Extract roll engines and log helpers

README.md

@@ -29,6 +29,7 @@ Backend:
 - `RpgRoller/Services/GameUserAdministrationService.cs`: username reads, admin user listing, role updates, and account deletion
 - `RpgRoller/Services/GameStateStore.cs`, `GameStateCloneFactory.cs`, and `GamePersistenceService.cs`: in-memory runtime state, campaign-state version tracking, and SQLite load/save boundaries
 - `RpgRoller/Services/GameAuthorization.cs`, `GameContextResolver.cs`, and `GameDtoMapper.cs`: shared authorization, session/campaign resolution, and backend read-model mapping
+- `RpgRoller/Services/RollEngine.cs`, `StandardRollEngine.cs`, `D6RollEngine.cs`, `RolemasterRollEngine.cs`, `RollBreakdownFormatter.cs`, and `CampaignLogSummaryBuilder.cs`: ruleset-specific dice execution, breakdown formatting, and compact campaign-log summaries
 - `RpgRoller/Services/SkillDefinitionValidator.cs`, `RoleSerializer.cs`, `RollVisibilityParser.cs`, and `CustomRollOptionsResolver.cs`: shared rules and parsing helpers
 
 Frontend:
@@ -48,7 +49,7 @@ Frontend:
 
 Current repo note:
 
-- `TASKS.md` tracks the remaining roll-engine extraction and Workspace cleanup work.
+- `TASKS.md` tracks the remaining Workspace cleanup work.
 - This README describes the code as it exists today. It does not treat blueprint items in `TASKS.md` as finished unless they are already present in the repo.
 
 ## Runtime and Persistence

RpgRoller.Tests/Services/ServiceRollHelperTests.cs

@@ -0,0 +1,80 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+using RpgRoller.Services;
+
+namespace RpgRoller.Tests;
+
+public sealed class ServiceRollHelperTests
+{
+    [Fact]
+    public void RollBreakdownFormatter_FormatsStandardAndRolemasterOpenEndedBreakdowns()
+    {
+        Assert.Equal("4+5+2=11", RollBreakdownFormatter.BuildBreakdown([4, 5], 2, 11));
+        Assert.Equal("0=0", RollBreakdownFormatter.BuildBreakdown([], 0, 0));
+        Assert.Equal("97+96+45+85=323", RollBreakdownFormatter.BuildRolemasterOpenEndedBreakdown(97, [96, 45], false, 85, 323));
+        Assert.Equal("(05) -97 -100 -12 +85 = -124", RollBreakdownFormatter.BuildRolemasterOpenEndedBreakdown(5, [97, 100, 12], true, 85, -124));
+        Assert.Equal("05", RollBreakdownFormatter.FormatRolemasterTriggerRoll(5));
+    }
+
+    [Fact]
+    public void CampaignLogSummaryBuilder_ExtractsExpressionsAndBuildsBadgesAndSummaries()
+    {
+        var d6Dice = new[]
+        {
+            new RollDieResult(6, true, false, true, false, false),
+            new RollDieResult(1, false, true, true, false, false)
+        };
+        var rolemasterDice = new[]
+        {
+            new RollDieResult(5, false, false, false, false, false, 1, RollDieKinds.RolemasterOpenEndedInitial, null),
+            new RollDieResult(97, false, false, false, false, false, 2, RollDieKinds.RolemasterOpenEndedLowSubtract, -97),
+            new RollDieResult(100, false, false, false, false, false, 3, RollDieKinds.RolemasterOpenEndedLowSubtract, -100)
+        };
+
+        Assert.Equal("1d20+5", CampaignLogSummaryBuilder.ExtractCustomRollExpression("1d20+5 => 20+5=25", " => "));
+        Assert.Null(CampaignLogSummaryBuilder.ExtractCustomRollExpression("20+5=25", " => "));
+        Assert.Equal("6, 1", CampaignLogSummaryBuilder.BuildCompactLogSummary(d6Dice));
+        Assert.Equal("(05) -97 -100 | open-ended low", CampaignLogSummaryBuilder.BuildCompactLogSummary(rolemasterDice));
+        Assert.Equal("No detail available.", CampaignLogSummaryBuilder.BuildCompactLogSummary([]));
+        Assert.Equal(["w6", "w1"], Assert.IsType<string[]>(CampaignLogSummaryBuilder.BuildCompactLogEventBadges(RulesetKind.D6, null, d6Dice)));
+        Assert.Equal(["n20"], Assert.IsType<string[]>(CampaignLogSummaryBuilder.BuildCompactLogEventBadges(RulesetKind.Dnd5e, "1d20+5", [new RollDieResult(20, false, false, false, false, false)])));
+        Assert.Equal(["rf", "r100"], Assert.IsType<string[]>(CampaignLogSummaryBuilder.BuildCompactLogEventBadges(RulesetKind.Rolemaster, "d100!+85", rolemasterDice)));
+    }
+
+    [Fact]
+    public void RollEngine_DelegatesToRulesetSpecificEngines()
+    {
+        var engine = new RollEngine(
+            new StandardRollEngine(new FixedDiceRoller([7, 10])),
+            new D6RollEngine(new FixedDiceRoller([6, 4, 2])),
+            new RolemasterRollEngine(new FixedDiceRoller([97, 96, 45])));
+
+        var d6Roll = engine.Roll(RulesetKind.D6, new DiceExpression(2, 6, 1, "2D+1"), 1, true, null);
+        Assert.Equal(13, d6Roll.Total);
+        Assert.Equal("6+4+2+1=13", d6Roll.Breakdown);
+
+        var standardRoll = engine.Roll(RulesetKind.Dnd5e, new DiceExpression(2, 10, 3, "2d10+3"), 0, false, null);
+        Assert.Equal(20, standardRoll.Total);
+        Assert.Equal("7+10+3=20", standardRoll.Breakdown);
+
+        var rolemasterRoll = engine.Roll(RulesetKind.Rolemaster, new DiceExpression(1, 100, 85, "d100!+85", DiceExpressionKind.RolemasterOpenEndedPercentile), 0, false, 5);
+        Assert.Equal(323, rolemasterRoll.Total);
+        Assert.Equal("97+96+45+85=323", rolemasterRoll.Breakdown);
+    }
+
+    private sealed class FixedDiceRoller : IDiceRoller
+    {
+        public FixedDiceRoller(IEnumerable<int> values)
+        {
+            m_Values = new(values);
+        }
+
+        public int Roll(int sides)
+        {
+            var next = m_Values.Count > 0 ? m_Values.Dequeue() : 1;
+            return Math.Clamp(next, 1, sides);
+        }
+
+        private readonly Queue<int> m_Values;
+    }
+}

RpgRoller/Services/CampaignLogSummaryBuilder.cs

@@ -0,0 +1,115 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+
+namespace RpgRoller.Services;
+
+public static class CampaignLogSummaryBuilder
+{
+    public static string BuildCompactLogSummary(IReadOnlyList<RollDieResult> dice)
+    {
+        if (dice.Count == 0)
+            return "No detail available.";
+
+        if (dice.Any(die => IsRolemasterDieKind(die.Kind)))
+            return BuildRolemasterCompactLogSummary(dice);
+
+        return string.Join(", ", dice.Select(die => die.Roll.ToString()));
+    }
+
+    public static string[]? BuildCompactLogEventBadges(RulesetKind ruleset, string? expression, IReadOnlyList<RollDieResult> dice)
+    {
+        var badges = new List<string>();
+
+        switch (ruleset)
+        {
+            case RulesetKind.D6:
+                AddBadgeIfMissing(badges, dice.Any(die => die.Wild && die.Roll == 6), "w6");
+                AddBadgeIfMissing(badges, dice.Any(die => die.Wild && die.Roll == 1), "w1");
+                break;
+            case RulesetKind.Dnd5e:
+                if (!string.IsNullOrWhiteSpace(expression) && IsSingleD20Expression(expression))
+                {
+                    AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 20), "n20");
+                    AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 1), "n1");
+                }
+
+                break;
+            case RulesetKind.Rolemaster:
+                AddBadgeIfMissing(
+                    badges,
+                    dice.Any(die =>
+                        string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedInitial, StringComparison.Ordinal) &&
+                        !die.SignedContribution.HasValue),
+                    "rf");
+                AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 100), "r100");
+                AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 66), "r66");
+                break;
+        }
+
+        return badges.Count == 0 ? null : badges.ToArray();
+    }
+
+    public static string? ExtractCustomRollExpression(string breakdown, string separator)
+    {
+        var separatorIndex = breakdown.IndexOf(separator, StringComparison.Ordinal);
+        if (separatorIndex <= 0)
+            return null;
+
+        return breakdown[..separatorIndex];
+    }
+
+    private static string BuildRolemasterCompactLogSummary(IReadOnlyList<RollDieResult> dice)
+    {
+        var openEndedInitial = dice.FirstOrDefault(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedInitial, StringComparison.Ordinal));
+        if (openEndedInitial is not null)
+        {
+            var highFollowUps = dice
+                .Where(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedHigh, StringComparison.Ordinal))
+                .Select(die => die.Roll.ToString())
+                .ToArray();
+            if (highFollowUps.Length > 0)
+                return $"{openEndedInitial.Roll} + {string.Join(" + ", highFollowUps)} | open-ended high";
+
+            var lowFollowUps = dice
+                .Where(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedLowSubtract, StringComparison.Ordinal))
+                .Select(die => die.Roll.ToString())
+                .ToArray();
+            if (lowFollowUps.Length > 0)
+                return $"({RollBreakdownFormatter.FormatRolemasterTriggerRoll(openEndedInitial.Roll)}) {string.Join(" ", lowFollowUps.Select(roll => $"-{roll}"))} | open-ended low";
+
+            return $"{openEndedInitial.Roll} | open-ended";
+        }
+
+        if (dice.Any(die => string.Equals(die.Kind, RollDieKinds.RolemasterStandard, StringComparison.Ordinal)))
+        {
+            var preview = string.Join(" + ", dice.Select(die => die.Roll.ToString()));
+            return $"{preview} | rolemaster";
+        }
+
+        return string.Join(", ", dice.Select(die => die.Roll.ToString()));
+    }
+
+    private static bool IsRolemasterDieKind(string? kind)
+    {
+        return kind is RollDieKinds.RolemasterStandard or
+            RollDieKinds.RolemasterOpenEndedInitial or
+            RollDieKinds.RolemasterOpenEndedHigh or
+            RollDieKinds.RolemasterOpenEndedLowSubtract;
+    }
+
+    private static void AddBadgeIfMissing(List<string> badges, bool condition, string code)
+    {
+        if (!condition || badges.Any(badge => string.Equals(badge, code, StringComparison.Ordinal)))
+            return;
+
+        badges.Add(code);
+    }
+
+    private static bool IsSingleD20Expression(string expression)
+    {
+        var parsedExpression = DiceRules.ParseExpression(RulesetKind.Dnd5e, expression);
+        return parsedExpression.Succeeded &&
+               parsedExpression.Value!.DiceCount == 1 &&
+               parsedExpression.Value.Sides == 20;
+    }
+}

RpgRoller/Services/D6RollEngine.cs

@@ -0,0 +1,94 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+
+namespace RpgRoller.Services;
+
+public sealed class D6RollEngine
+{
+    public D6RollEngine(IDiceRoller diceRoller)
+    {
+        m_DiceRoller = diceRoller;
+    }
+
+    public (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) Roll(DiceExpression expression, int wildDice, bool allowFumble)
+    {
+        var initialDice = expression.DiceCount;
+        var currentDice = initialDice;
+        var pendingExplodingDice = 0;
+        var pendingFumbles = 0;
+        var dieResults = new List<RollDieResult>(initialDice);
+
+        for (var i = 0; i < currentDice; i += 1)
+        {
+            var roll = m_DiceRoller.Roll(expression.Sides);
+            var isWild = i < wildDice;
+            var isCrit = false;
+            var isFumble = false;
+            var isAdded = false;
+
+            if (isWild)
+            {
+                if (roll == expression.Sides)
+                {
+                    pendingExplodingDice += 1;
+                    currentDice += 1;
+                    isCrit = true;
+                }
+                else if (allowFumble && roll == 1)
+                {
+                    pendingFumbles += 1;
+                    isFumble = true;
+                }
+            }
+
+            if (pendingExplodingDice > 0 && i >= initialDice)
+            {
+                pendingExplodingDice -= 1;
+                isAdded = true;
+                if (roll == expression.Sides)
+                {
+                    pendingExplodingDice += 1;
+                    currentDice += 1;
+                }
+            }
+
+            dieResults.Add(new(roll, isCrit, isFumble, isWild, false, isAdded));
+        }
+
+        for (var roll = expression.Sides; roll >= 1 && pendingFumbles > 0; roll -= 1)
+        for (var i = currentDice - 1; i >= 0 && pendingFumbles > 0; i -= 1)
+        {
+            if (dieResults[i].Roll != roll)
+                continue;
+
+            dieResults[i] = dieResults[i] with
+            {
+                Removed = true,
+                Added = false,
+                Crit = false,
+                Fumble = false
+            };
+            pendingFumbles -= 1;
+        }
+
+        var total = expression.Modifier;
+        var includedDice = new List<int>(dieResults.Count);
+        foreach (var die in dieResults)
+        {
+            if (die.Fumble)
+            {
+                total += 1;
+                includedDice.Add(1);
+            }
+            else if (!die.Removed)
+            {
+                total += die.Roll;
+                includedDice.Add(die.Roll);
+            }
+        }
+
+        return (total, RollBreakdownFormatter.BuildBreakdown(includedDice, expression.Modifier, total), dieResults);
+    }
+
+    private readonly IDiceRoller m_DiceRoller;
+}

RpgRoller/Services/GameRollService.cs

@@ -11,6 +11,10 @@ public sealed class GameRollService
         m_StateStore = stateStore;
         m_PersistenceService = persistenceService;
         m_DiceRoller = diceRoller;
+        m_RollEngine = new(
+            new StandardRollEngine(diceRoller),
+            new D6RollEngine(diceRoller),
+            new RolemasterRollEngine(diceRoller));
     }
 
     public ServiceResult<RollResult> RollSkill(string sessionToken, Guid skillId, string visibility)
@@ -39,7 +43,7 @@ public sealed class GameRollService
             if (!parsedVisibility.Succeeded)
                 return ServiceResult<RollResult>.Failure(parsedVisibility.Error!.Code, parsedVisibility.Error.Message);
 
-            var roll = ComputeRoll(campaign.Ruleset, parsedExpression.Value!, skill.WildDice, skill.AllowFumble, skill.FumbleRange);
+            var roll = m_RollEngine.Roll(campaign.Ruleset, parsedExpression.Value!, skill.WildDice, skill.AllowFumble, skill.FumbleRange);
             return RecordRollLocked(user, campaign, character, skill.Id, parsedVisibility.Value, roll, parsedExpression.Value!.Canonical);
         }
     }
@@ -70,7 +74,7 @@ public sealed class GameRollService
                 return ServiceResult<RollResult>.Failure(parsedVisibility.Error!.Code, parsedVisibility.Error.Message);
 
             var (wildDice, allowFumble, fumbleRange) = CustomRollOptionsResolver.Resolve(campaign.Ruleset);
-            var roll = ComputeRoll(campaign.Ruleset, parsedExpression.Value!, wildDice, allowFumble, fumbleRange);
+            var roll = m_RollEngine.Roll(campaign.Ruleset, parsedExpression.Value!, wildDice, allowFumble, fumbleRange);
             return RecordRollLocked(user, campaign, character, CustomRollSkillId, parsedVisibility.Value, roll, parsedExpression.Value!.Canonical);
         }
     }
@@ -164,240 +168,6 @@ public sealed class GameRollService
         }
     }
 
-    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) ComputeRoll(RulesetKind ruleset, DiceExpression expression, int wildDice, bool allowFumble, int? fumbleRange)
-    {
-        if (ruleset == RulesetKind.D6)
-            return ComputeD6Roll(expression, wildDice, allowFumble);
-
-        if (ruleset == RulesetKind.Rolemaster)
-        {
-            return expression.Kind switch
-            {
-                DiceExpressionKind.RolemasterOpenEndedPercentile => ComputeRolemasterOpenEndedRoll(expression, fumbleRange.GetValueOrDefault()),
-                _                                               => ComputeRolemasterStandardRoll(expression)
-            };
-        }
-
-        return ComputeStandardRoll(expression);
-    }
-
-    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) ComputeStandardRoll(DiceExpression expression)
-    {
-        var diceValues = new int[expression.DiceCount];
-        var dice = new RollDieResult[expression.DiceCount];
-        var total = expression.Modifier;
-        for (var i = 0; i < expression.DiceCount; i += 1)
-        {
-            var value = m_DiceRoller.Roll(expression.Sides);
-            diceValues[i] = value;
-            dice[i] = new(value, false, false, false, false, false);
-            total += value;
-        }
-
-        return (total, BuildBreakdown(diceValues, expression.Modifier, total), dice);
-    }
-
-    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) ComputeRolemasterStandardRoll(DiceExpression expression)
-    {
-        var diceValues = new int[expression.DiceCount];
-        var dice = new RollDieResult[expression.DiceCount];
-        var total = expression.Modifier;
-        for (var i = 0; i < expression.DiceCount; i += 1)
-        {
-            var value = m_DiceRoller.Roll(expression.Sides);
-            diceValues[i] = value;
-            dice[i] = CreateRolemasterDie(value, i + 1, RollDieKinds.RolemasterStandard, value);
-            total += value;
-        }
-
-        return (total, BuildBreakdown(diceValues, expression.Modifier, total), dice);
-    }
-
-    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) ComputeRolemasterOpenEndedRoll(DiceExpression expression, int fumbleRange)
-    {
-        var initialRoll = m_DiceRoller.Roll(expression.Sides);
-        var followUpRolls = new List<int>();
-        int? initialContribution = initialRoll <= fumbleRange ? null : initialRoll;
-        var dice = new List<RollDieResult>
-        {
-            CreateRolemasterDie(initialRoll, 1, RollDieKinds.RolemasterOpenEndedInitial, initialContribution)
-        };
-
-        var baseTotal = initialRoll <= fumbleRange ? 0 : initialRoll;
-        var subtractFollowUps = false;
-        if (initialRoll >= 96)
-        {
-            followUpRolls.AddRange(RollRolemasterHighOpenEndedChain(dice, sequenceStart: 2, subtract: false));
-            baseTotal += followUpRolls.Sum();
-        }
-        else if (initialRoll <= fumbleRange)
-        {
-            subtractFollowUps = true;
-            followUpRolls.AddRange(RollRolemasterHighOpenEndedChain(dice, sequenceStart: 2, subtract: true));
-            baseTotal -= followUpRolls.Sum();
-        }
-
-        var total = baseTotal + expression.Modifier;
-        var breakdown = BuildRolemasterOpenEndedBreakdown(initialRoll, followUpRolls, subtractFollowUps, expression.Modifier, total);
-        return (total, breakdown, dice);
-    }
-
-    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) ComputeD6Roll(DiceExpression expression, int wildDice, bool allowFumble)
-    {
-        var initialDice = expression.DiceCount;
-        var currentDice = initialDice;
-        var pendingExplodingDice = 0;
-        var pendingFumbles = 0;
-        var dieResults = new List<RollDieResult>(initialDice);
-
-        for (var i = 0; i < currentDice; i += 1)
-        {
-            var roll = m_DiceRoller.Roll(expression.Sides);
-            var isWild = i < wildDice;
-            var isCrit = false;
-            var isFumble = false;
-            var isAdded = false;
-
-            if (isWild)
-            {
-                if (roll == expression.Sides)
-                {
-                    pendingExplodingDice += 1;
-                    currentDice += 1;
-                    isCrit = true;
-                }
-                else if (allowFumble && roll == 1)
-                {
-                    pendingFumbles += 1;
-                    isFumble = true;
-                }
-            }
-
-            if (pendingExplodingDice > 0 && i >= initialDice)
-            {
-                pendingExplodingDice -= 1;
-                isAdded = true;
-                if (roll == expression.Sides)
-                {
-                    pendingExplodingDice += 1;
-                    currentDice += 1;
-                }
-            }
-
-            dieResults.Add(new(roll, isCrit, isFumble, isWild, false, isAdded));
-        }
-
-        for (var roll = expression.Sides; roll >= 1 && pendingFumbles > 0; roll -= 1)
-        for (var i = currentDice - 1; i >= 0 && pendingFumbles > 0; i -= 1)
-        {
-            if (dieResults[i].Roll != roll)
-                continue;
-
-            dieResults[i] = dieResults[i] with
-            {
-                Removed = true,
-                Added = false,
-                Crit = false,
-                Fumble = false
-            };
-            pendingFumbles -= 1;
-        }
-
-        var total = expression.Modifier;
-        var includedDice = new List<int>(dieResults.Count);
-        foreach (var die in dieResults)
-        {
-            if (die.Fumble)
-            {
-                total += 1;
-                includedDice.Add(1);
-            }
-            else if (!die.Removed)
-            {
-                total += die.Roll;
-                includedDice.Add(die.Roll);
-            }
-        }
-
-        return (total, BuildBreakdown(includedDice, expression.Modifier, total), dieResults);
-    }
-
-    private IEnumerable<int> RollRolemasterHighOpenEndedChain(List<RollDieResult> dice, int sequenceStart, bool subtract)
-    {
-        var followUpRolls = new List<int>();
-        var sequence = sequenceStart;
-
-        while (true)
-        {
-            var roll = m_DiceRoller.Roll(100);
-            followUpRolls.Add(roll);
-            dice.Add(CreateRolemasterDie(
-                roll,
-                sequence,
-                subtract ? RollDieKinds.RolemasterOpenEndedLowSubtract : RollDieKinds.RolemasterOpenEndedHigh,
-                subtract ? -roll : roll));
-
-            sequence += 1;
-            if (roll < 96)
-                break;
-        }
-
-        return followUpRolls;
-    }
-
-    private static RollDieResult CreateRolemasterDie(int roll, int sequence, string kind, int? signedContribution)
-    {
-        return new(roll, false, false, false, false, kind == RollDieKinds.RolemasterOpenEndedHigh, sequence, kind, signedContribution);
-    }
-
-    private static string BuildBreakdown(IEnumerable<int> diceValues, int modifier, int total)
-    {
-        var dicePart = string.Join("+", diceValues);
-        if (string.IsNullOrWhiteSpace(dicePart))
-            dicePart = "0";
-
-        return BuildModifierBreakdown(dicePart, modifier, total);
-    }
-
-    private static string BuildRolemasterOpenEndedBreakdown(int initialRoll, IReadOnlyList<int> followUpRolls, bool subtractFollowUps, int modifier, int total)
-    {
-        if (subtractFollowUps)
-        {
-            var segments = new List<string> { $"({FormatRolemasterTriggerRoll(initialRoll)})" };
-            segments.AddRange(followUpRolls.Select(roll => $"-{roll}"));
-            if (modifier > 0)
-                segments.Add($"+{modifier}");
-            else if (modifier < 0)
-                segments.Add(modifier.ToString());
-
-            return $"{string.Join(" ", segments)} = {total}";
-        }
-
-        var core = initialRoll.ToString();
-        if (followUpRolls.Count > 0)
-        {
-            var followUpBreakdown = string.Join("+", followUpRolls);
-            core = subtractFollowUps ? $"{core}-({followUpBreakdown})" : $"{core}+{followUpBreakdown}";
-        }
-
-        return BuildModifierBreakdown(core, modifier, total);
-    }
-
-    private static string FormatRolemasterTriggerRoll(int roll)
-    {
-        return roll.ToString("00");
-    }
-
-    private static string BuildModifierBreakdown(string core, int modifier, int total)
-    {
-        return modifier switch
-        {
-            > 0 => $"{core}+{modifier}={total}",
-            < 0 => $"{core}{modifier}={total}",
-            _   => $"{core}={total}"
-        };
-    }
-
     private ServiceResult<RollResult> RecordRollLocked(
         UserAccount user,
         Campaign campaign,
@@ -460,7 +230,7 @@ public sealed class GameRollService
         var characterName = m_StateStore.CharactersById.TryGetValue(entry.CharacterId, out var character) ? character.Name : "Unknown character";
         var skillName = ResolveLoggedSkillName(entry);
         var loggedExpression = ResolveLoggedExpression(entry);
-        var eventBadges = BuildCompactLogEventBadges(campaign, loggedExpression, dice);
+        var eventBadges = CampaignLogSummaryBuilder.BuildCompactLogEventBadges(campaign.Ruleset, loggedExpression, dice);
 
         return GameDtoMapper.ToCampaignLogListEntry(
             entry,
@@ -469,7 +239,7 @@ public sealed class GameRollService
             ResolveLogRollerLabel(user, campaign, entry),
             ResolveLogVisibilityLabel(user, campaign, entry),
             ResolveLogVisibilityStyle(user, campaign, entry),
-            BuildCompactLogSummary(dice),
+            CampaignLogSummaryBuilder.BuildCompactLogSummary(dice),
             eventBadges);
     }
 
@@ -478,56 +248,6 @@ public sealed class GameRollService
         return JsonSerializer.Serialize(dice, DiceJsonOptions);
     }
 
-    private static string BuildCompactLogSummary(IReadOnlyList<RollDieResult> dice)
-    {
-        if (dice.Count == 0)
-            return "No detail available.";
-
-        if (dice.Any(die => IsRolemasterDieKind(die.Kind)))
-            return BuildRolemasterCompactLogSummary(dice);
-
-        return string.Join(", ", dice.Select(die => die.Roll.ToString()));
-    }
-
-    private static string BuildRolemasterCompactLogSummary(IReadOnlyList<RollDieResult> dice)
-    {
-        var openEndedInitial = dice.FirstOrDefault(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedInitial, StringComparison.Ordinal));
-        if (openEndedInitial is not null)
-        {
-            var highFollowUps = dice
-                .Where(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedHigh, StringComparison.Ordinal))
-                .Select(die => die.Roll.ToString())
-                .ToArray();
-            if (highFollowUps.Length > 0)
-                return $"{openEndedInitial.Roll} + {string.Join(" + ", highFollowUps)} | open-ended high";
-
-            var lowFollowUps = dice
-                .Where(die => string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedLowSubtract, StringComparison.Ordinal))
-                .Select(die => die.Roll.ToString())
-                .ToArray();
-            if (lowFollowUps.Length > 0)
-                return $"({FormatRolemasterTriggerRoll(openEndedInitial.Roll)}) {string.Join(" ", lowFollowUps.Select(roll => $"-{roll}"))} | open-ended low";
-
-            return $"{openEndedInitial.Roll} | open-ended";
-        }
-
-        if (dice.Any(die => string.Equals(die.Kind, RollDieKinds.RolemasterStandard, StringComparison.Ordinal)))
-        {
-            var preview = string.Join(" + ", dice.Select(die => die.Roll.ToString()));
-            return $"{preview} | rolemaster";
-        }
-
-        return string.Join(", ", dice.Select(die => die.Roll.ToString()));
-    }
-
-    private static bool IsRolemasterDieKind(string? kind)
-    {
-        return kind is RollDieKinds.RolemasterStandard or
-            RollDieKinds.RolemasterOpenEndedInitial or
-            RollDieKinds.RolemasterOpenEndedHigh or
-            RollDieKinds.RolemasterOpenEndedLowSubtract;
-    }
-
     private string ResolveLoggedSkillName(RollLogEntry entry)
     {
         if (entry.SkillId == CustomRollSkillId)
@@ -539,69 +259,11 @@ public sealed class GameRollService
     private string? ResolveLoggedExpression(RollLogEntry entry)
     {
         if (entry.SkillId == CustomRollSkillId)
-            return ExtractCustomRollExpression(entry.Breakdown);
+            return CampaignLogSummaryBuilder.ExtractCustomRollExpression(entry.Breakdown, CustomRollBreakdownSeparator);
 
         return m_StateStore.SkillsById.TryGetValue(entry.SkillId, out var skill) ? skill.DiceRollDefinition : null;
     }
 
-    private static string? ExtractCustomRollExpression(string breakdown)
-    {
-        var separatorIndex = breakdown.IndexOf(CustomRollBreakdownSeparator, StringComparison.Ordinal);
-        if (separatorIndex <= 0)
-            return null;
-
-        return breakdown[..separatorIndex];
-    }
-
-    private static string[]? BuildCompactLogEventBadges(Campaign campaign, string? expression, IReadOnlyList<RollDieResult> dice)
-    {
-        var badges = new List<string>();
-
-        switch (campaign.Ruleset)
-        {
-            case RulesetKind.D6:
-                AddBadgeIfMissing(badges, dice.Any(die => die.Wild && die.Roll == 6), "w6");
-                AddBadgeIfMissing(badges, dice.Any(die => die.Wild && die.Roll == 1), "w1");
-                break;
-            case RulesetKind.Dnd5e:
-                if (!string.IsNullOrWhiteSpace(expression) && IsSingleD20Expression(expression))
-                {
-                    AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 20), "n20");
-                    AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 1), "n1");
-                }
-
-                break;
-            case RulesetKind.Rolemaster:
-                AddBadgeIfMissing(
-                    badges,
-                    dice.Any(die =>
-                        string.Equals(die.Kind, RollDieKinds.RolemasterOpenEndedInitial, StringComparison.Ordinal) &&
-                        !die.SignedContribution.HasValue),
-                    "rf");
-                AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 100), "r100");
-                AddBadgeIfMissing(badges, dice.Any(die => die.Roll == 66), "r66");
-                break;
-        }
-
-        return badges.Count == 0 ? null : badges.ToArray();
-    }
-
-    private static void AddBadgeIfMissing(List<string> badges, bool condition, string code)
-    {
-        if (!condition || badges.Any(badge => string.Equals(badge, code, StringComparison.Ordinal)))
-            return;
-
-        badges.Add(code);
-    }
-
-    private static bool IsSingleD20Expression(string expression)
-    {
-        var parsedExpression = DiceRules.ParseExpression(RulesetKind.Dnd5e, expression);
-        return parsedExpression.Succeeded &&
-               parsedExpression.Value!.DiceCount == 1 &&
-               parsedExpression.Value.Sides == 20;
-    }
-
     private string ResolveLogRollerLabel(UserAccount user, Campaign campaign, RollLogEntry entry)
     {
         if (entry.RollerUserId == user.Id)
@@ -666,5 +328,6 @@ public sealed class GameRollService
     private static readonly JsonSerializerOptions DiceJsonOptions = RpgRollerJson.CreateSerializerOptions();
     private readonly IDiceRoller m_DiceRoller;
     private readonly GamePersistenceService m_PersistenceService;
+    private readonly RollEngine m_RollEngine;
     private readonly GameStateStore m_StateStore;
 }

RpgRoller/Services/RolemasterRollEngine.cs

@@ -0,0 +1,96 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+
+namespace RpgRoller.Services;
+
+public sealed class RolemasterRollEngine
+{
+    public RolemasterRollEngine(IDiceRoller diceRoller)
+    {
+        m_DiceRoller = diceRoller;
+    }
+
+    public (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) Roll(DiceExpression expression, int? fumbleRange)
+    {
+        return expression.Kind switch
+        {
+            DiceExpressionKind.RolemasterOpenEndedPercentile => RollOpenEnded(expression, fumbleRange.GetValueOrDefault()),
+            _                                               => RollStandard(expression)
+        };
+    }
+
+    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) RollStandard(DiceExpression expression)
+    {
+        var diceValues = new int[expression.DiceCount];
+        var dice = new RollDieResult[expression.DiceCount];
+        var total = expression.Modifier;
+        for (var i = 0; i < expression.DiceCount; i += 1)
+        {
+            var value = m_DiceRoller.Roll(expression.Sides);
+            diceValues[i] = value;
+            dice[i] = CreateRolemasterDie(value, i + 1, RollDieKinds.RolemasterStandard, value);
+            total += value;
+        }
+
+        return (total, RollBreakdownFormatter.BuildBreakdown(diceValues, expression.Modifier, total), dice);
+    }
+
+    private (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) RollOpenEnded(DiceExpression expression, int fumbleRange)
+    {
+        var initialRoll = m_DiceRoller.Roll(expression.Sides);
+        var followUpRolls = new List<int>();
+        int? initialContribution = initialRoll <= fumbleRange ? null : initialRoll;
+        var dice = new List<RollDieResult>
+        {
+            CreateRolemasterDie(initialRoll, 1, RollDieKinds.RolemasterOpenEndedInitial, initialContribution)
+        };
+
+        var baseTotal = initialRoll <= fumbleRange ? 0 : initialRoll;
+        var subtractFollowUps = false;
+        if (initialRoll >= 96)
+        {
+            followUpRolls.AddRange(RollHighOpenEndedChain(dice, sequenceStart: 2, subtract: false));
+            baseTotal += followUpRolls.Sum();
+        }
+        else if (initialRoll <= fumbleRange)
+        {
+            subtractFollowUps = true;
+            followUpRolls.AddRange(RollHighOpenEndedChain(dice, sequenceStart: 2, subtract: true));
+            baseTotal -= followUpRolls.Sum();
+        }
+
+        var total = baseTotal + expression.Modifier;
+        var breakdown = RollBreakdownFormatter.BuildRolemasterOpenEndedBreakdown(initialRoll, followUpRolls, subtractFollowUps, expression.Modifier, total);
+        return (total, breakdown, dice);
+    }
+
+    private IEnumerable<int> RollHighOpenEndedChain(List<RollDieResult> dice, int sequenceStart, bool subtract)
+    {
+        var followUpRolls = new List<int>();
+        var sequence = sequenceStart;
+
+        while (true)
+        {
+            var roll = m_DiceRoller.Roll(100);
+            followUpRolls.Add(roll);
+            dice.Add(CreateRolemasterDie(
+                roll,
+                sequence,
+                subtract ? RollDieKinds.RolemasterOpenEndedLowSubtract : RollDieKinds.RolemasterOpenEndedHigh,
+                subtract ? -roll : roll));
+
+            sequence += 1;
+            if (roll < 96)
+                break;
+        }
+
+        return followUpRolls;
+    }
+
+    private static RollDieResult CreateRolemasterDie(int roll, int sequence, string kind, int? signedContribution)
+    {
+        return new(roll, false, false, false, false, kind == RollDieKinds.RolemasterOpenEndedHigh, sequence, kind, signedContribution);
+    }
+
+    private readonly IDiceRoller m_DiceRoller;
+}

RpgRoller/Services/RollBreakdownFormatter.cs

@@ -0,0 +1,52 @@
+namespace RpgRoller.Services;
+
+public static class RollBreakdownFormatter
+{
+    public static string BuildBreakdown(IEnumerable<int> diceValues, int modifier, int total)
+    {
+        var dicePart = string.Join("+", diceValues);
+        if (string.IsNullOrWhiteSpace(dicePart))
+            dicePart = "0";
+
+        return BuildModifierBreakdown(dicePart, modifier, total);
+    }
+
+    public static string BuildRolemasterOpenEndedBreakdown(int initialRoll, IReadOnlyList<int> followUpRolls, bool subtractFollowUps, int modifier, int total)
+    {
+        if (subtractFollowUps)
+        {
+            var segments = new List<string> { $"({FormatRolemasterTriggerRoll(initialRoll)})" };
+            segments.AddRange(followUpRolls.Select(roll => $"-{roll}"));
+            if (modifier > 0)
+                segments.Add($"+{modifier}");
+            else if (modifier < 0)
+                segments.Add(modifier.ToString());
+
+            return $"{string.Join(" ", segments)} = {total}";
+        }
+
+        var core = initialRoll.ToString();
+        if (followUpRolls.Count > 0)
+        {
+            var followUpBreakdown = string.Join("+", followUpRolls);
+            core = $"{core}+{followUpBreakdown}";
+        }
+
+        return BuildModifierBreakdown(core, modifier, total);
+    }
+
+    public static string FormatRolemasterTriggerRoll(int roll)
+    {
+        return roll.ToString("00");
+    }
+
+    public static string BuildModifierBreakdown(string core, int modifier, int total)
+    {
+        return modifier switch
+        {
+            > 0 => $"{core}+{modifier}={total}",
+            < 0 => $"{core}{modifier}={total}",
+            _   => $"{core}={total}"
+        };
+    }
+}

RpgRoller/Services/RollEngine.cs

@@ -0,0 +1,29 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+
+namespace RpgRoller.Services;
+
+public sealed class RollEngine
+{
+    public RollEngine(StandardRollEngine standardRollEngine, D6RollEngine d6RollEngine, RolemasterRollEngine rolemasterRollEngine)
+    {
+        m_StandardRollEngine = standardRollEngine;
+        m_D6RollEngine = d6RollEngine;
+        m_RolemasterRollEngine = rolemasterRollEngine;
+    }
+
+    public (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) Roll(RulesetKind ruleset, DiceExpression expression, int wildDice, bool allowFumble, int? fumbleRange)
+    {
+        if (ruleset == RulesetKind.D6)
+            return m_D6RollEngine.Roll(expression, wildDice, allowFumble);
+
+        if (ruleset == RulesetKind.Rolemaster)
+            return m_RolemasterRollEngine.Roll(expression, fumbleRange);
+
+        return m_StandardRollEngine.Roll(expression);
+    }
+
+    private readonly D6RollEngine m_D6RollEngine;
+    private readonly RolemasterRollEngine m_RolemasterRollEngine;
+    private readonly StandardRollEngine m_StandardRollEngine;
+}

RpgRoller/Services/StandardRollEngine.cs

@@ -0,0 +1,30 @@
+using RpgRoller.Contracts;
+using RpgRoller.Domain;
+
+namespace RpgRoller.Services;
+
+public sealed class StandardRollEngine
+{
+    public StandardRollEngine(IDiceRoller diceRoller)
+    {
+        m_DiceRoller = diceRoller;
+    }
+
+    public (int Total, string Breakdown, IReadOnlyList<RollDieResult> Dice) Roll(DiceExpression expression)
+    {
+        var diceValues = new int[expression.DiceCount];
+        var dice = new RollDieResult[expression.DiceCount];
+        var total = expression.Modifier;
+        for (var i = 0; i < expression.DiceCount; i += 1)
+        {
+            var value = m_DiceRoller.Roll(expression.Sides);
+            diceValues[i] = value;
+            dice[i] = new(value, false, false, false, false, false);
+            total += value;
+        }
+
+        return (total, RollBreakdownFormatter.BuildBreakdown(diceValues, expression.Modifier, total), dice);
+    }
+
+    private readonly IDiceRoller m_DiceRoller;
+}

TASKS.md

@@ -17,7 +17,7 @@ The user-visible proof is intentionally boring: after starting the app, logging
 - [x] (2026-04-04 22:46Z) Inspected the current frontend state. `RpgRoller/Components/Pages/WorkspaceState.cs`, `WorkspaceSessionCoordinator.cs`, `WorkspaceCampaignCoordinator.cs`, `WorkspaceCampaignScopeCoordinator.cs`, `WorkspacePlayCoordinator.cs`, `WorkspaceAdminCoordinator.cs`, `WorkspaceLiveStateController.cs`, `WorkspaceFeedbackService.cs`, and `WorkspaceToast.cs` already exist.
 - [x] (2026-04-04 22:46Z) Marked the large structural extractions as already done in this plan instead of treating the repository as pre-refactor.
 - [x] (2026-04-04 23:03Z) Completed backend shared-helper consolidation. `GameStateStore` now owns campaign-state version mutations, `GameAuthorization`, `GameContextResolver`, and `GameDtoMapper` now own the shared helper seams, and the domain services delegate to them instead of keeping private copies.
-- [ ] Complete backend roll decomposition. Remaining work: extract the dice engines, breakdown formatting, and compact log summary logic out of `RpgRoller/Services/GameRollService.cs` while preserving all existing roll behavior.
+- [x] (2026-04-04 23:20Z) Completed backend roll decomposition. Dice execution now lives in `RollEngine`, `StandardRollEngine`, `D6RollEngine`, and `RolemasterRollEngine`, while `RollBreakdownFormatter` and `CampaignLogSummaryBuilder` own the extracted formatting and compact-log helpers.
 - [x] (2026-04-04 23:03Z) Finished thinning `RpgRoller/Services/GameService.cs` for startup and campaign-state bootstrap. The constructor now loads persistence and rebuilds campaign-state versions through `GameStateStore` without keeping private helper methods.
 - [ ] Finish thinning `RpgRoller/Components/Pages/Workspace.razor.cs`. Remaining work: remove the large mirror of `WorkspaceState` properties and the excess pass-through wrappers so the file acts as a composition root plus lifecycle and JS-invokable bridge.
 - [ ] Update `README.md` and this ExecPlan after the remaining code changes land so the documentation reflects the final, not intermediate, structure. Completed in this iteration: backend helper descriptions and current remaining scope.
@@ -33,6 +33,9 @@ The user-visible proof is intentionally boring: after starting the app, logging
 - Observation: `GameRollService` is now the main backend monolith.
   Evidence: `RpgRoller/Services/GameRollService.cs` still owns D6 logic, Rolemaster logic, log summary formatting, event badge generation, and JSON dice serialization in one file.
 
+- Observation: the roll split preserved behavior cleanly because the extracted helper boundaries were already pure and ruleset-scoped.
+  Evidence: after moving dice execution into ruleset engines and moving summary text into `CampaignLogSummaryBuilder`, the existing D6, Rolemaster, log paging, detail, custom-roll, and Playwright smoke tests passed without contract changes.
+
 - Observation: the frontend refactor introduced one extra collaborator that was not named in the original blueprint, and that collaborator is worth keeping.
   Evidence: `RpgRoller/Components/Pages/WorkspaceCampaignScopeCoordinator.cs` now owns selected-campaign reload, selected-character synchronization, log reset, and unauthorized-session handling. Those behaviors are cohesive and should not be pushed back into `Workspace.razor.cs`.
 
@@ -60,6 +63,10 @@ The user-visible proof is intentionally boring: after starting the app, logging
   Rationale: the extracted logic is pure over `GameStateStore` plus method inputs, so static helpers keep wiring simple while still removing the duplication that was obscuring the domain services.
   Date/Author: 2026-04-04 / Codex
 
+- Decision: Instantiate the extracted roll engines inside `GameRollService` instead of pushing more constructor parameters through `GameService`.
+  Rationale: the new engines depend only on `IDiceRoller`, so local construction keeps the facade wiring small while still carving the algorithmic work out of the service orchestration path.
+  Date/Author: 2026-04-04 / Codex
+
 - Decision: Keep validation instructions in this ExecPlan even though this revision is documentation-only.
   Rationale: `PLANS.md` requires executable validation guidance, but the user explicitly requested no CI or test work for this pass. The commands remain here for the implementation pass that follows later.
   Date/Author: 2026-04-04 / Codex
@@ -68,7 +75,7 @@ The user-visible proof is intentionally boring: after starting the app, logging
 
 The repository now has the shared backend seams that the earlier rewrite described as missing. `GameStateStore` owns campaign-state version mutation, `GameAuthorization` owns shared access checks, `GameContextResolver` owns session and campaign resolution, and `GameDtoMapper` owns the backend read-model construction that had been repeated across services.
 
-The remaining work is narrower than before. The repository now needs second-wave cleanup focused mainly on `GameRollService` algorithm extraction and the final `Workspace` binding cleanup. `GameService` is already at the intended facade shape, so later iterations can stay smaller and more reviewable.
+The remaining work is narrower than before. The repository now needs the final `Workspace` binding cleanup. `GameService` is already at the intended facade shape, and `GameRollService` is now primarily orchestration plus persistence-facing log record handling.
 
 ## Context and Orientation
 
@@ -78,7 +85,7 @@ A "thin facade" in this plan means a class that mainly wires collaborators and f
 
 The current backend state is better than the old monolith. `RpgRoller/Services/GameService.cs` already delegates its public methods to `GameAuthService`, `GameCampaignService`, `GameCharacterService`, `GameSkillService`, `GameRollService`, and `GameUserAdministrationService`. `RpgRoller/Services/GamePersistenceService.cs` already owns SQLite loading and saving. `RpgRoller/Services/SkillDefinitionValidator.cs`, `RoleSerializer.cs`, `RollVisibilityParser.cs`, `CustomRollOptionsResolver.cs`, and `GameStateCloneFactory.cs` already exist as helper files.
 
-The backend shared-helper duplication is now resolved. `RpgRoller/Services/GameStateStore.cs` owns campaign-state version mutations. `RpgRoller/Services/GameAuthorization.cs` owns shared access checks. `RpgRoller/Services/GameContextResolver.cs` owns session-token and campaign resolution. `RpgRoller/Services/GameDtoMapper.cs` owns the backend read models returned by the services. The main backend target that remains is `RpgRoller/Services/GameRollService.cs`, which still combines dice algorithms, compact log formatting, event badges, and dice serialization in one file.
+The backend shared-helper duplication is now resolved. `RpgRoller/Services/GameStateStore.cs` owns campaign-state version mutations. `RpgRoller/Services/GameAuthorization.cs` owns shared access checks. `RpgRoller/Services/GameContextResolver.cs` owns session-token and campaign resolution. `RpgRoller/Services/GameDtoMapper.cs` owns the backend read models returned by the services. Roll execution is now split across `RpgRoller/Services/RollEngine.cs`, `StandardRollEngine.cs`, `D6RollEngine.cs`, `RolemasterRollEngine.cs`, `RollBreakdownFormatter.cs`, and `CampaignLogSummaryBuilder.cs`, leaving `RpgRoller/Services/GameRollService.cs` as a smaller workflow coordinator.
 
 The current frontend state is also better than the old monolith. `RpgRoller/Components/Pages/WorkspaceState.cs` holds most UI state and many computed projections. Session/bootstrap behavior lives in `WorkspaceSessionCoordinator.cs`. Campaign management and modal flows live in `WorkspaceCampaignCoordinator.cs`. Selected campaign scope refresh lives in `WorkspaceCampaignScopeCoordinator.cs`. Play/log behavior lives in `WorkspacePlayCoordinator.cs`. Admin behavior lives in `WorkspaceAdminCoordinator.cs`. Live event reconciliation lives in `WorkspaceLiveStateController.cs`. Toast and announcement behavior lives in `WorkspaceFeedbackService.cs`.
 
@@ -127,16 +134,15 @@ Start every future implementation pass by re-reading the plan and checking the c
     git status --short
     rg --files RpgRoller/Services RpgRoller/Components/Pages
 
-Shared backend helper consolidation is complete in the current tree. The next backend pass should begin by inspecting the remaining roll-service concentration before editing:
+The remaining implementation pass is frontend-focused. Begin by inspecting the `Workspace` composition surface before editing:
 
-    Get-Content RpgRoller\Services\GameService.cs
-    Get-Content RpgRoller\Services\GameRollService.cs
-    Get-Content RpgRoller\Services\GameAuthorization.cs
-    Get-Content RpgRoller\Services\GameContextResolver.cs
-    Get-Content RpgRoller\Services\GameDtoMapper.cs
-    Get-Content RpgRoller\Services\GameStateStore.cs
+    Get-Content RpgRoller\Components\Pages\Workspace.razor.cs
+    Get-Content RpgRoller\Components\Pages\Workspace.razor
+    Get-Content RpgRoller\Components\Pages\WorkspaceState.cs
+    Get-Content RpgRoller\Components\Pages\WorkspaceCampaignScopeCoordinator.cs
+    Get-Content RpgRoller\Components\Pages\WorkspacePlayCoordinator.cs
 
-Keep the next extraction small. Move one cohesive cluster at a time out of `GameRollService` so tests can prove that dice totals, breakdown strings, and compact log responses stayed unchanged.
+Keep the next extraction small. Remove one block of mirrored state or pass-through wrappers at a time so component behavior can stay stable and the Playwright smoke flow can keep proving the result.
 
 When beginning frontend cleanup, inspect the current composition surface before editing:
 
@@ -157,7 +163,7 @@ The expected result is simple: no failing tests, no coverage regression, and the
 
 ## Validation and Acceptance
 
-This implementation revision ran targeted helper tests during extraction. Full repo validation through `pwsh ./scripts/ci-local.ps1` remains mandatory before considering the iteration complete.
+This implementation revision ran targeted helper tests during extraction and later full repo validation through `pwsh ./scripts/ci-local.ps1`. The same full validation remains mandatory after the frontend pass.
 
 The backend is accepted when `RpgRoller/Services/GameService.cs` contains only collaborator wiring, ruleset enumeration, and public delegation; when shared authorization, context, mapping, and campaign-state helper logic each live in one place; and when `RpgRoller/Services/GameRollService.cs` no longer embeds the dice engines or compact log summary builders.
 
@@ -267,3 +273,5 @@ In `RpgRoller/Components/Pages/WorkspaceState.cs`, keep all plain state plus pur
 Revision note (2026-04-04): Replaced the old blueprint with an ExecPlan, reconciled it against the code already present in the repository, and marked completed versus remaining refactor work after direct file inspection. The reason for this rewrite is that `AGENTS.md` now requires complex refactors to be tracked as ExecPlans maintained under `PLANS.md`.
 
 Revision note (2026-04-04 23:03Z): Marked backend shared-helper consolidation and `GameService` facade thinning as complete after implementing `GameAuthorization`, `GameContextResolver`, `GameDtoMapper`, and `GameStateStore` tracker methods. Updated the remaining scope so the next pass starts with `GameRollService` decomposition and later `Workspace` cleanup.
+
+Revision note (2026-04-04 23:20Z): Marked backend roll decomposition as complete after extracting `RollEngine`, the ruleset-specific engines, `RollBreakdownFormatter`, and `CampaignLogSummaryBuilder`. Updated the remaining scope so the next pass can focus entirely on `Workspace` cleanup.