From 18aaa9dbe3c0e6b4bd0b417773ebe87866909611 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 11 Aug 2026 16:00:14 +0000
Subject: [PATCH 1/4] Trim the live controls, and let the screen say more about
 the match
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Six things asked for from the touchline, all on /games/{id}/live.

The pause button is gone: a youth match is not paused, and it was one more
thing to hit by accident. PauseClockAsync stays in the service, and "Resume"
now appears only for a live period whose clock is somehow stopped — without
it, a match paused before this change could never be run to full time.

Every goal on the timeline now carries the score it made it, in the
scoreboard's order. ScoreProgressionReport counts forwards over the whole
match and the page looks each goal up by id, because the timeline runs newest
first and a total accumulated while rendering would count down. The rule for
which end a goal lands on moves onto GameGoal.CountsForUs, so the running
total and Game.CountOurGoals cannot disagree.

Tapping a player now offers two changes, one dropdown each: someone comes on
for them, or they trade positions with a team-mate who stays on. Choosing in
either list clears the other, so the single button always has exactly one
change to make and says which. The swap is a new MatchSubstitutionService
method that writes no GameSubstitution — nobody left the pitch, and a row
there would say they did.

"Opstelling wisselen" is now "Volgende opstelling": it brings the next
quarter's planned line-up on without stopping the clock, which is what the
"Changes at half-way" card above it is listing.

The control buttons fill their panel again. `.live-control-row > *` was in
the page's scoped CSS and matched nothing — every child is a MudButton, and
the <button> MudBlazor renders carries no scope attribute. It moves to
app.css as a two-column grid, with the odd one out spanning the row.

And a "Show subs" checkbox folds the bench strip away.
---
 CLAUDE.md                                     |  6 +-
 docs/architecture.md                          |  5 +-
 docs/known_issues.md                          |  8 ++
 docs/ui_components.md                         | 33 ++++++-
 src/FootballFormation.Core/Models/Game.cs     |  4 +-
 src/FootballFormation.Core/Models/GameGoal.cs |  7 ++
 .../Reporting/GameMinutesReport.cs            |  9 +-
 .../Reporting/ScoreProgressionReport.cs       | 45 +++++++++
 .../Services/MatchSubstitutionService.cs      | 48 +++++++++-
 .../Pages/LiveMatch.razor                     | 68 ++++++++------
 .../Pages/LiveMatch.razor.cs                  | 75 ++++++++++++---
 .../Pages/LiveMatch.razor.css                 | 29 +++---
 .../Pages/LiveSubDialog.razor                 | 59 +++++++-----
 .../Pages/LiveSubDialog.razor.cs              | 71 +++++++++++---
 .../Pages/LiveSubDialog.razor.css             |  7 ++
 src/FootballFormation.UI/Strings.nl.resx      | 15 ++-
 src/FootballFormation.Web/wwwroot/app.css     | 34 ++++++-
 .../LiveMatchNotificationTests.cs             |  7 +-
 .../MatchSubstitutionServiceTests.cs          | 82 ++++++++++++++++
 .../ScoreProgressionReportTests.cs            | 93 +++++++++++++++++++
 tests/ui/specs/match-day.spec.js              | 52 +++++++++++
 tests/ui/specs/selectors.spec.js              |  3 +-
 22 files changed, 645 insertions(+), 115 deletions(-)
 create mode 100644 src/FootballFormation.Core/Reporting/ScoreProgressionReport.cs
 create mode 100644 tests/FootballFormation.Core.Tests/ScoreProgressionReportTests.cs

diff --git a/CLAUDE.md b/CLAUDE.md
index 9313dd2..0732d48 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -16,9 +16,9 @@ as in the markup. The UI is Dutch by default with English available.
 
 ```bash
 dotnet build -c Release        # what CI builds — warnings are errors here (see below)
-dotnet test                    # 374 tests, xUnit v3, real SQLite
+dotnet test                    # 389 tests, xUnit v3, real SQLite
 cd src/FootballFormation.Web && dotnet run     # http://localhost:5228
-cd tests/ui && npm test        # 34 Playwright tests in a browser, ~1 min (npm install first)
+cd tests/ui && npm test        # 36 Playwright tests in a browser, ~1 min (npm install first)
 scripts/visual-check.sh        # screenshots every page, then measures every touch target
 scripts/coverage.sh            # coverage of the lines this branch changed, 80% floor
 ```
@@ -166,7 +166,7 @@ Test names are sentences:
 There are **no component tests** (no bUnit). The UI is checked by driving the real app in a real
 browser, in two places, both against a throwaway database:
 
-- **`cd tests/ui && npm test`** — Playwright, ~34 tests, about a minute. Runs on every pull request
+- **`cd tests/ui && npm test`** — Playwright, ~36 tests, about a minute. Runs on every pull request
   as a job in `ci.yml`, advisory rather than the merge gate. Behaviour: the public/admin
   split, the squad and match dialogs, the whole match-day journey from dragging a lineup to blowing
   the final whistle, both languages, and the phone layout. Read
diff --git a/docs/architecture.md b/docs/architecture.md
index 7a0a128..475b9c8 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -53,6 +53,8 @@ Reporting/
   PositionFitHelper.cs    — 5-tier position fit: Preferred, NaturalFit, Alternative, Compatible, OutOfPosition
   MatchClockReport.cs     — Derives the live clock and period state from the stored anchor + banked total
   PlannedChangesReport.cs — What the next period changes versus the one on the pitch
+  ScoreProgressionReport.cs — The score after each goal (MatchScore), for the live timeline —
+                           counted forwards because that list runs newest first
   HealthReport.cs         — Whether a booted container is actually serving: the /health payload and
                            the rule that pending migrations mean unhealthy. Pure, so it is tested
 Services/
@@ -74,7 +76,8 @@ Services/
   MatchGoalService.cs     — Goals logged live: storage delegated to GameService, the live minute
                             and the recomputed scoreline added here
   MatchSubstitutionService.cs — The slot swap and the record of it, in one SaveChanges, plus undoing
-                            the most recent one of a period
+                            the most recent one of a period, plus SwapPositionsAsync — two players
+                            already on trading slots, which writes no substitution row
   LiveMatchOperation.cs   — The write shape those three share: RunAdminAsync plus, on success, one
                             LiveMatchNotifier call naming the game that changed
   LiveMatchQueries.cs     — The tracked load they all start from (the game with its periods, via
diff --git a/docs/known_issues.md b/docs/known_issues.md
index d9ec2c7..439796f 100644
--- a/docs/known_issues.md
+++ b/docs/known_issues.md
@@ -286,6 +286,14 @@ Avoid repeating these mistakes:
   the identical markup on `/settings` — those buttons rendered as native browser chrome for as
   long as nobody looked. There is no warning. Anything more than one page uses goes in `app.css`;
   `.action-btn`, `.badge-*`, `.stat-tile*` and `.stacked-table` are there for this reason.
+- **The same trap catches a rule that never leaves its own page: a child component's root element
+  has no scope attribute either.** `.live-control-row > *` sat in `LiveMatch.razor.css` and matched
+  nothing, because every child of that row is a `MudButton` and the `<button>` MudBlazor renders
+  carries no `b-<hash>`. The row looked deliberate and read as flex — the buttons simply never took
+  the width or the height it asked for, which is what "the buttons don't fill the box" turned out
+  to be. The tell: the *container* is styled and the *children* are not. Anything selecting past a
+  MudBlazor component's root goes in `app.css`, next to `.live-scoreboard` and `.live-action-btn`,
+  which are there for the same reason.
 
 ## General
 - **Port already in use**: Kill orphaned process with `taskkill //PID <pid> //F`.
diff --git a/docs/ui_components.md b/docs/ui_components.md
index ec06d3d..5fafb20 100644
--- a/docs/ui_components.md
+++ b/docs/ui_components.md
@@ -107,12 +107,35 @@ watches the same URL read-only. Every control sits in an `<AuthorizeView Roles="
   the score, clock and state from its first load while newly inserted goals appear alongside them —
   a live screen stuck at the old scoreline. Identity resolution keeps shared `Player` rows single.
 - Controls are context-sensitive, and **only half time is a break**. A quarters game is still two
-  halves: Q1→Q2 and Q3→Q4 offer "Start Q2"/"Start Q4", which call `AdvancePeriodAsync` and roll
-  the lineup over *without stopping the clock*. Only after the first half or Q2 does the screen
-  offer "Half time" (`EndPeriodAsync`, which does stop it) followed by "Start Q3". The rule lives
-  in `PeriodTypeExtensions.IsFollowedByBreak`, not in the page.
+  halves: mid-half the screen offers **"Next line-up"**, which calls `AdvancePeriodAsync` and rolls
+  the *next quarter's planned lineup* onto the pitch without stopping the clock — the changes it is
+  about to make are the ones listed in the "Changes at half-way" card above it. Only after the first
+  half or Q2 does the screen offer "Half time" (`EndPeriodAsync`, which does stop it) followed by
+  "Start 2nd half". The rule lives in `PeriodTypeExtensions.IsFollowedByBreak`, not in the page.
+- **There is no pause button.** Nothing on the screen stops a running clock any more: a youth match
+  is not paused at the touchline, and the button was one more thing to hit by accident.
+  `PauseClockAsync` survives in `MatchClockService` (a match paused before it went has to be
+  resumable, which is the only thing "Resume" now appears for — a live period whose clock is
+  stopped), but nothing renders a control that calls it.
+- **The controls are a two-column grid, laid out in `app.css`.** How many buttons the panel holds
+  depends on where the match is, so equal columns keep them the same size whichever set is showing,
+  and `:last-child:nth-child(odd)` spans the odd one out across the row. It has to be `app.css`:
+  the children are `MudButton`s, and the old scoped `.live-control-row > *` rule never matched
+  them — the classic CSS-isolation miss, and why they used not to fill the panel.
 - The pitch shows the live period; at the break and after full time the last one played, and before
-  kick-off the first — so it is never blank when a lineup exists.
+  kick-off the first — so it is never blank when a lineup exists. A **"Show subs" checkbox** folds
+  the bench strip under it away; the state is per circuit and deliberately not stored.
+- **Tapping a player offers two changes, one dropdown each** (`LiveSubDialog`): someone comes on for
+  them (`SubstituteAsync`), or they trade positions with a team-mate who stays on
+  (`SwapPositionsAsync`). Choosing in either list clears the other, so the single action button
+  always has exactly one change to make and says which — "Make substitution" or "Swap positions".
+  A position swap writes no `GameSubstitution`: nobody's minutes changed, and a row there would say
+  they did. Each select's `Placeholder` is set **only** when its list is empty — MudSelect shows a
+  placeholder whenever nothing is chosen, so a standing "nobody is on the bench" greets a full bench.
+- **Every goal on the timeline carries the score it made it** (`ScoreProgressionReport`), in the
+  scoreboard's order — home side first. It is counted forwards over the whole match and looked up
+  by goal id, because the timeline itself runs newest first and a total accumulated while rendering
+  would count down.
 - Finishing asks for confirmation via `DialogPrompts.ConfirmAsync` (not `ConfirmDeleteAsync`,
   whose button says "Delete").
 - **Minutes played is admin-only** (`LiveMinutesReport`), and shows exact time on the pitch rather
diff --git a/src/FootballFormation.Core/Models/Game.cs b/src/FootballFormation.Core/Models/Game.cs
index d541965..215b893 100644
--- a/src/FootballFormation.Core/Models/Game.cs
+++ b/src/FootballFormation.Core/Models/Game.cs
@@ -174,11 +174,11 @@ public int ElapsedSecondsAt(DateTime utcNow) => ClockAccumulatedSeconds +
     /// so it is excluded here and included in <see cref="CountTheirGoals"/>.
     /// </summary>
     public static int CountOurGoals(IEnumerable<GameGoal> goals) =>
-        goals.Count(g => !g.IsOwnGoal && !g.IsOpponentGoal);
+        goals.Count(g => g.CountsForUs);
 
     /// <summary>Their goals: everything the opponent scored, plus our own goals.</summary>
     public static int CountTheirGoals(IEnumerable<GameGoal> goals) =>
-        goals.Count(g => g.IsOwnGoal || g.IsOpponentGoal);
+        goals.Count(g => !g.CountsForUs);
 }
 
 /// <summary>
diff --git a/src/FootballFormation.Core/Models/GameGoal.cs b/src/FootballFormation.Core/Models/GameGoal.cs
index 66c633d..0a0da03 100644
--- a/src/FootballFormation.Core/Models/GameGoal.cs
+++ b/src/FootballFormation.Core/Models/GameGoal.cs
@@ -28,4 +28,11 @@ public class GameGoal
     /// moment they were typed, which is the best available answer and never reorders a live match.
     /// </summary>
     public DateTime RecordedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Which end of the scoreline this goal lands on. The rule is stated once here because two
+    /// places count goals: <see cref="Game.CountOurGoals"/> totals a finished match, and
+    /// <c>ScoreProgressionReport</c> walks them one at a time for the live timeline.
+    /// </summary>
+    public bool CountsForUs => !IsOwnGoal && !IsOpponentGoal;
 }
diff --git a/src/FootballFormation.Core/Reporting/GameMinutesReport.cs b/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
index 8356a1d..85d6245 100644
--- a/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
+++ b/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
@@ -46,9 +46,12 @@ public int SecondsFor(int playerId) =>
 /// its lineup a full period's minutes would invent playing time.
 /// </para>
 /// <para>
-/// Known limitation: the live screen only records a position change as part of a substitution, so
-/// a player who shifts from one position to another mid-period without a swap keeps the earlier
-/// position for those minutes. That is a gap in what gets recorded, not in this calculation.
+/// Known limitation: only a substitution records a position change, so a player who shifts
+/// position mid-period without one keeps the earlier position for those minutes. The live screen's
+/// position swap (<c>MatchSubstitutionService.SwapPositionsAsync</c>) is exactly that case: it
+/// rewrites the lineup and writes nothing down, because a <see cref="GameSubstitution"/> would say
+/// someone left the pitch. Totals stay right; the per-position split lags a swap. That is a gap in
+/// what gets recorded, not in this calculation.
 /// </para>
 /// </summary>
 public static class GameMinutesReport
diff --git a/src/FootballFormation.Core/Reporting/ScoreProgressionReport.cs b/src/FootballFormation.Core/Reporting/ScoreProgressionReport.cs
new file mode 100644
index 0000000..c3b2f4c
--- /dev/null
+++ b/src/FootballFormation.Core/Reporting/ScoreProgressionReport.cs
@@ -0,0 +1,45 @@
+using FootballFormation.Core.Models;
+
+namespace FootballFormation.Core.Reporting;
+
+/// <summary>
+/// A scoreline, always ours first. Only the display decides whether the home side goes on the
+/// left — see the live screen's scoreboard, which reads the venue and this record does not.
+/// </summary>
+public readonly record struct MatchScore(int Us, int Them);
+
+/// <summary>
+/// The score as it stood immediately after each goal, keyed by goal id.
+/// <para>
+/// The timeline lists events newest first, so a running total cannot be accumulated as the list
+/// renders — it has to be counted in the order the goals were actually scored, which is what this
+/// does once for the whole match.
+/// </para>
+/// </summary>
+public static class ScoreProgressionReport
+{
+    /// <param name="goals">Every goal in the match, in any order.</param>
+    public static IReadOnlyDictionary<int, MatchScore> Build(IEnumerable<GameGoal> goals)
+    {
+        var progression = new Dictionary<int, MatchScore>();
+        var us = 0;
+        var them = 0;
+
+        // The order the live screen shows events in, read forwards: the match minute first, then
+        // the moment it was entered, then the id — see LiveMatch.Timeline for why all three.
+        var chronological = goals
+            .OrderBy(g => g.Minute ?? 0)
+            .ThenBy(g => g.RecordedAt)
+            .ThenBy(g => g.Id);
+
+        foreach (var goal in chronological)
+        {
+            if (goal.CountsForUs) us++;
+            else them++;
+
+            progression[goal.Id] = new MatchScore(us, them);
+        }
+
+        return progression;
+    }
+}
diff --git a/src/FootballFormation.Core/Services/MatchSubstitutionService.cs b/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
index eea0d1d..5c6a39e 100644
--- a/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
+++ b/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
@@ -7,8 +7,9 @@
 namespace FootballFormation.Core.Services;
 
 /// <summary>
-/// Substitutions during a match: a slot and a position change hands between two players, and the
-/// swap is written down with the minute it happened.
+/// Who stands where once a match is under way: a substitution, where a slot and a position change
+/// hands between the pitch and the bench and the swap is written down with the minute it happened,
+/// and a straight position swap between two players already on.
 /// <para>
 /// The most intricate write in the app, and the reason it sits on its own: the lineup and the
 /// record of the change go in with one <c>SaveChanges</c>, because every minutes report is built
@@ -105,6 +106,49 @@ public Task<Result<GameSubstitution>> SubstituteAsync(
             return Result.Success(sub);
         });
 
+    /// <summary>
+    /// Swaps the pitch slots — and with them the positions — of two players who are both already
+    /// on. Nobody enters or leaves the match, so this writes no <see cref="GameSubstitution"/>:
+    /// the rows exist to say who was on the pitch when, and a shuffle changes none of that. What
+    /// it does cost is the position half of the minutes report, which keeps crediting both players
+    /// the position they started the period in (see <c>GameMinutesReport</c>).
+    /// </summary>
+    public Task<Result> SwapPositionsAsync(
+        int gameId, int playerAId, int playerBId, CancellationToken cancellationToken = default) =>
+        LiveMatchOperation.RunAdminAsync(notifier, currentUser, logger, "swap the positions",
+            cancellationToken, async () =>
+        {
+            await using var db = await dbFactory.CreateDbContextAsync(cancellationToken);
+
+            if (playerAId == playerBId)
+                return Result.Failure<int>("A player cannot swap positions with themselves");
+
+            var game = await db.LoadWithPeriodsAsync(gameId, cancellationToken);
+            if (game is null) return LiveMatchQueries.GameNotFound<int>(gameId);
+
+            var period = game.LivePeriod();
+            if (period is null)
+                return Result.Failure<int>("No period is currently being played");
+
+            await db.Entry(period).Collection(p => p.PlayerPositions).LoadAsync(cancellationToken);
+
+            var a = period.PlayerPositions.FirstOrDefault(pp => pp.PlayerId == playerAId);
+            var b = period.PlayerPositions.FirstOrDefault(pp => pp.PlayerId == playerBId);
+
+            if (a is null || a.IsSubstitute || b is null || b.IsSubstitute)
+                return Result.Failure<int>("Both players have to be on the pitch to swap positions");
+
+            (a.SlotIndex, b.SlotIndex) = (b.SlotIndex, a.SlotIndex);
+            (a.Position, b.Position) = (b.Position, a.Position);
+
+            await db.SaveChangesAsync(cancellationToken);
+
+            logger.LogInformation("Game {GameId}: {A} and {B} swapped positions in period {PeriodId}",
+                gameId, playerAId, playerBId, period.Id);
+
+            return Result.Success(gameId);
+        });
+
     /// <summary>
     /// Undoes a substitution. Only the most recent one in its period can go, because reversing an
     /// older swap would fight every change made on that slot since.
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor b/src/FootballFormation.UI/Pages/LiveMatch.razor
index 38a0d9f..6d6976a 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor
@@ -61,14 +61,9 @@
                 <div class="live-control-row">
                     @if (IsLivePeriod)
                     {
-                        @if (GameData.IsClockRunning)
-                        {
-                            <MudButton Variant="Variant.Outlined" Class="btn-ghost"
-                                       StartIcon="@Icons.Material.Filled.Pause" OnClick="PauseClock">
-                                @L["Pause"]
-                            </MudButton>
-                        }
-                        else
+                        @* Nothing here stops the clock any more, so this only appears for a match
+                           paused by the button that used to. See ResumeClock. *@
+                        @if (!GameData.IsClockRunning)
                         {
                             <MudButton Variant="Variant.Outlined" Class="btn-ghost"
                                        StartIcon="@Icons.Material.Filled.PlayArrow" OnClick="ResumeClock">
@@ -88,7 +83,7 @@
                         {
                             <MudButton Variant="Variant.Filled" Class="btn-gold"
                                        StartIcon="@Icons.Material.Filled.SwapHoriz" OnClick="AdvancePeriod">
-                                @L["Change line-up"]
+                                @L["Next line-up"]
                             </MudButton>
                         }
                     }
@@ -133,7 +128,7 @@
             @if (CanSubstitute)
             {
                 <MudText Typo="Typo.caption" Class="live-pitch-hint">
-                    @L["Tap a player to substitute them."]
+                    @L["Tap a player to substitute them or change their position."]
                 </MudText>
             }
 
@@ -142,26 +137,37 @@
                    HidePositionFit="!_isAdmin"
                    OnPlayerClicked="@(CanSubstitute ? EventCallback.Factory.Create<int>(this, OpenSubDialog) : default)" />
 
-            <div class="live-bench">
-                <span class="live-bench-label">@L["Subs"]:</span>
-                @if (OnBench.Count == 0)
-                {
-                    <span class="live-bench-empty">@L["No subs"]</span>
-                }
-                else
-                {
-                    @foreach (var sub in OnBench)
+            @* The bench is reference material, not something to act on, so it can be folded away
+               to keep the pitch and the controls on one phone screen. *@
+            <div class="live-bench-toggle">
+                <MudCheckBox T="bool" @bind-Value="ShowSubs" Dense="true" Size="Size.Small" Color="Color.Primary">
+                    @L["Show subs"]
+                </MudCheckBox>
+            </div>
+
+            @if (ShowSubs)
+            {
+                <div class="live-bench">
+                    <span class="live-bench-label">@L["Subs"]:</span>
+                    @if (OnBench.Count == 0)
                     {
-                        <span class="live-bench-chip">
-                            @if (sub.Player?.ShirtNumber is not null)
-                            {
-                                <span class="live-bench-number">#@sub.Player.ShirtNumber</span>
-                            }
-                            @PlayerLabel(sub.PlayerId)
-                        </span>
+                        <span class="live-bench-empty">@L["No subs"]</span>
                     }
-                }
-            </div>
+                    else
+                    {
+                        @foreach (var sub in OnBench)
+                        {
+                            <span class="live-bench-chip">
+                                @if (sub.Player?.ShirtNumber is not null)
+                                {
+                                    <span class="live-bench-number">#@sub.Player.ShirtNumber</span>
+                                }
+                                @PlayerLabel(sub.PlayerId)
+                            </span>
+                        }
+                    }
+                </div>
+            }
         }
     </MudPaper>
 
@@ -266,6 +272,12 @@
                                 <div class="live-event-sub">↔ @PlayerLabel(sub.PlayerOffId)</div>
                             }
                         </div>
+                        @* The score the goal made it, in the scoreboard's order. Reading it off the
+                           list is otherwise impossible: the list runs backwards. *@
+                        @if (entry.Score is { } score)
+                        {
+                            <span class="live-event-score">@ScoreText(score)</span>
+                        }
                         <AuthorizeView Roles="@AppRoles.Admin" Context="auth">
                             @if (entry.Goal is { } goalToRemove)
                             {
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
index a76845c..9901b10 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
@@ -18,8 +18,11 @@ namespace FootballFormation.UI.Pages;
 /// share a <paramref name="RecordedAt"/>, and rows older than that column all read
 /// <c>0001-01-01</c>. Across the two kinds the ids come from different tables, so a tie there is
 /// arbitrary — but it is stable, which is what the list needs.
+/// <paramref name="Score"/> is the scoreline as it stood after a goal, and null for a substitution.
 /// </summary>
-public record MatchEvent(int Minute, DateTime RecordedAt, int Id, bool IsGoal, GameGoal? Goal, GameSubstitution? Substitution);
+public record MatchEvent(
+    int Minute, DateTime RecordedAt, int Id, bool IsGoal, GameGoal? Goal, GameSubstitution? Substitution,
+    MatchScore? Score = null);
 
 /// <summary>
 /// The sideline screen. An admin runs the clock and records what happens; everyone else sees the
@@ -51,6 +54,13 @@ public partial class LiveMatch
     private SeasonSquad Squad { get; set; } = SeasonSquad.Empty;
     private bool _isAdmin;
 
+    /// <summary>
+    /// Whether the bench strip under the pitch is drawn. Per circuit and not stored: it is a
+    /// glance-vs-space choice made in the moment, and it survives the live reloads because those
+    /// replace the data rather than the component.
+    /// </summary>
+    private bool ShowSubs { get; set; } = true;
+
     /// <summary>
     /// Drives the clock display only. The elapsed value is derived from the anchor the server
     /// stored, so a tick never talks to the server and every viewer shows the same time.
@@ -227,7 +237,12 @@ private List<MatchEvent> Timeline
         {
             if (GameData is null) return [];
 
-            var goals = GameData.Goals.Select(g => new MatchEvent(g.Minute ?? 0, g.RecordedAt, g.Id, true, g, null));
+            // Counted forwards over the whole match, then looked up per goal: this list runs
+            // newest first, so a total accumulated while rendering it would count down.
+            var progression = ScoreProgressionReport.Build(GameData.Goals);
+
+            var goals = GameData.Goals.Select(g =>
+                new MatchEvent(g.Minute ?? 0, g.RecordedAt, g.Id, true, g, null, progression[g.Id]));
             var subs = GameData.Substitutions.Select(s => new MatchEvent(s.Minute, s.RecordedAt, s.Id, false, null, s));
 
             // A goal and the sub that followed it commonly share a minute; the entry time keeps
@@ -302,9 +317,11 @@ private async Task<bool> ReloadAsync()
     private async Task StartMatch() =>
         Snackbar.Report(L, await ClockService.StartMatchAsync(GameId), L["Match started"]);
 
-    private async Task PauseClock() =>
-        Snackbar.Report(L, await ClockService.PauseClockAsync(GameId), L["Clock paused"], Severity.Info);
-
+    /// <summary>
+    /// Only offered when a period is live and its clock is somehow stopped, which nothing on this
+    /// screen can now cause — the pause button is gone. It stays as the way out for a match that
+    /// was paused before it went, since without it that match could never be run to full time.
+    /// </summary>
     private async Task ResumeClock() =>
         Snackbar.Report(L, await ClockService.ResumeClockAsync(GameId), L["Clock running"], Severity.Info);
 
@@ -353,27 +370,59 @@ private async Task RemoveSubstitution(GameSubstitution sub) =>
         Snackbar.Report(L, await SubService.RemoveSubstitutionAsync(sub.Id),
             L["Substitution undone"], Severity.Warning);
 
-    /// <summary>Tapping a player on the pitch asks who replaces them.</summary>
-    private async Task OpenSubDialog(int playerOffId)
+    /// <summary>
+    /// Tapping a player on the pitch asks what happens to them: someone comes on for them, or they
+    /// trade positions with a team-mate who stays on.
+    /// </summary>
+    private async Task OpenSubDialog(int playerId)
     {
         if (!CanSubstitute) return;
 
-        var playerOff = FindPlayer(playerOffId);
-        if (playerOff is null) return;
+        var tapped = OnPitch.FirstOrDefault(p => p.PlayerId == playerId);
+        if (tapped is null || FindPlayer(playerId) is not { } player) return;
 
-        var playerOnId = await DialogService.PromptValueAsync<LiveSubDialog, int>(
+        var choice = await DialogService.PromptAsync<LiveSubDialog, LiveSubChoice>(
             L["Substitution"],
             p =>
             {
-                p.Add(x => x.PlayerOff, playerOff);
+                p.Add(x => x.Player, player);
+                p.Add(x => x.Position, tapped.Position);
                 p.Add(x => x.Bench, SubCandidates);
+                p.Add(x => x.OnPitch, SwapCandidates(playerId));
             });
-        if (playerOnId is null) return;
+        if (choice is null) return;
 
-        var sub = await SubService.SubstituteAsync(GameId, playerOffId, playerOnId.Value);
+        if (choice.IsPositionSwap)
+        {
+            var swap = await SubService.SwapPositionsAsync(GameId, playerId, choice.PlayerId);
+            Snackbar.Report(L, swap, L["Positions swapped"]);
+            return;
+        }
+
+        var sub = await SubService.SubstituteAsync(GameId, playerId, choice.PlayerId);
         Snackbar.Report(L, sub, L["Substitution made"]);
     }
 
+    /// <summary>
+    /// Who the tapped player can trade positions with: the rest of the pitch, in slot order so the
+    /// list reads like a team sheet rather than in whatever order the lineup rows were stored.
+    /// </summary>
+    private List<PitchPlayer> SwapCandidates(int playerId) =>
+        [.. OnPitch
+            .Where(p => p.PlayerId != playerId)
+            .OrderBy(p => p.SlotIndex)
+            .Select(p => (Entry: p, Player: FindPlayer(p.PlayerId)))
+            .Where(x => x.Player is not null)
+            .Select(x => new PitchPlayer(x.Player!, x.Entry.Position))];
+
+    /// <summary>
+    /// A scoreline for the timeline, in the same order as the scoreboard above it — the home side
+    /// on the left, whoever that is. <see cref="MatchScore"/> itself is always ours first.
+    /// </summary>
+    private string ScoreText(MatchScore score) => GameData?.IsHomeGame == false
+        ? $"{score.Them}–{score.Us}"
+        : $"{score.Us}–{score.Them}";
+
     private Player? FindPlayer(int playerId) => AllPlayers.FirstOrDefault(p => p.Id == playerId);
 
     private string PlayerLabel(int playerId) =>
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.css b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
index b8c6a3c..c307e7e 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.css
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
@@ -109,24 +109,20 @@
     color: #fff;
 }
 
-/* Clock controls */
-.live-control-row {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px;
-}
-
-.live-control-row > * {
-    flex: 1 1 45%;
-}
-
+/* The clock controls (.live-control-row) are laid out in app.css: every child is a MudButton,
+   and scoped CSS never reaches a child component's root element. */
 .live-pitch-hint {
     display: block;
     margin-bottom: 6px;
     color: var(--ink-subtle);
 }
 
-/* Bench strip under the pitch */
+/* Bench strip under the pitch, and the checkbox that folds it away. The checkbox's own touch
+   target is sized in app.css — this rule reaches the wrapper, not the MudBlazor component in it. */
+.live-bench-toggle {
+    margin-top: 6px;
+}
+
 .live-bench {
     display: flex;
     flex-wrap: wrap;
@@ -301,6 +297,15 @@
     color: var(--ink-muted);
 }
 
+/* The scoreline a goal produced, parked on the right where every row lines its digits up. */
+.live-event-score {
+    flex: none;
+    font-size: 0.85rem;
+    font-weight: 800;
+    font-variant-numeric: tabular-nums;
+    color: var(--ink-muted);
+}
+
 .live-event-tag {
     font-size: 0.7rem;
     font-weight: 700;
diff --git a/src/FootballFormation.UI/Pages/LiveSubDialog.razor b/src/FootballFormation.UI/Pages/LiveSubDialog.razor
index 3d8aec1..d3b052d 100644
--- a/src/FootballFormation.UI/Pages/LiveSubDialog.razor
+++ b/src/FootballFormation.UI/Pages/LiveSubDialog.razor
@@ -3,38 +3,47 @@
 <MudDialog>
     <DialogContent>
         <div class="sub-off-line">
-            <MudIcon Icon="@Icons.Material.Filled.ArrowDownward" Size="Size.Small" Color="Color.Error" />
+            <MudIcon Icon="@Icons.Material.Filled.PersonPin" Size="Size.Small" Color="Color.Primary" />
             <span class="sub-off-name">
-                <PlayerLabel Player="PlayerOff" />
+                <PlayerLabel Player="Player" />
             </span>
+            <span class="sub-off-pos">@Position.ToString()</span>
         </div>
 
-        @if (Bench.Count == 0)
-        {
-            <MudText Typo="Typo.body2" Style="color: var(--ink-muted);">
-                @L["Nobody is on the bench for this period."]
-            </MudText>
-        }
-        else
-        {
-            <MudForm @ref="Form">
-                <MudSelect T="int" @bind-Value="PlayerOnId" Label="@L["Comes on"]" Class="mt-3"
-                           Required="true" RequiredError="@L["Please select a player"]">
-                    @foreach (var player in Bench)
-                    {
-                        <MudSelectItem T="int" Value="player.Id">
-                            <PlayerLabel Player="player" />
-                        </MudSelectItem>
-                    }
-                </MudSelect>
-            </MudForm>
-        }
+        @* Two lists, never both: picking in one clears the other, so the button below always has
+           exactly one change to make. *@
+        @* The placeholder only ever explains an empty list. MudSelect shows it whenever nothing is
+           chosen, so a standing "nobody is on the bench" would greet a full bench too. *@
+        <MudSelect T="int?" @bind-Value="PlayerOnId" Label="@L["Comes on"]" Class="mt-4" Clearable="true"
+                   Placeholder="@(Bench.Count == 0 ? L["Nobody is on the bench for this period."].Value : null)"
+                   Disabled="@(Bench.Count == 0)">
+            @foreach (var player in Bench)
+            {
+                <MudSelectItem T="int?" Value="player.Id">
+                    <PlayerLabel Player="player" />
+                </MudSelectItem>
+            }
+        </MudSelect>
+
+        <MudSelect T="int?" @bind-Value="SwapWithId" Label="@L["Swaps position with"]" Class="mt-4" Clearable="true"
+                   Placeholder="@(OnPitch.Count == 0 ? L["Nobody else is on the pitch."].Value : null)"
+                   Disabled="@(OnPitch.Count == 0)">
+            @foreach (var other in OnPitch)
+            {
+                <MudSelectItem T="int?" Value="other.Player.Id">
+                    <PlayerLabel Player="other.Player" /> — @other.Position.ToString()
+                </MudSelectItem>
+            }
+        </MudSelect>
+
+        <MudText Typo="Typo.caption" Class="mt-2" Style="color: var(--ink-muted); display: block;">
+            @L["A position swap keeps both players on the pitch and is not a substitution."]
+        </MudText>
     </DialogContent>
     <DialogActions>
         <MudButton OnClick="Cancel">@L["Cancel"]</MudButton>
-        <MudButton Color="Color.Primary" Variant="Variant.Filled" Disabled="@(Bench.Count == 0)"
-                   OnClick="Submit">
-            @L["Make substitution"]
+        <MudButton Color="Color.Primary" Variant="Variant.Filled" Disabled="@(!HasChoice)" OnClick="Submit">
+            @(IsPositionSwap ? L["Swap positions"] : L["Make substitution"])
         </MudButton>
     </DialogActions>
 </MudDialog>
diff --git a/src/FootballFormation.UI/Pages/LiveSubDialog.razor.cs b/src/FootballFormation.UI/Pages/LiveSubDialog.razor.cs
index 67b4bb8..3c42809 100644
--- a/src/FootballFormation.UI/Pages/LiveSubDialog.razor.cs
+++ b/src/FootballFormation.UI/Pages/LiveSubDialog.razor.cs
@@ -4,34 +4,83 @@
 
 namespace FootballFormation.UI.Pages;
 
+/// <summary>A player standing on the pitch right now, with the position they are holding.</summary>
+public record PitchPlayer(Player Player, PlayerPosition Position);
+
+/// <summary>
+/// What the touchline decided about the player who was tapped: either someone comes on for them,
+/// or they trade positions with a team-mate who stays on.
+/// </summary>
+public record LiveSubChoice(int PlayerId, bool IsPositionSwap);
+
 /// <summary>
-/// Picks the replacement for a player already chosen on the pitch. Like every dialog here it
-/// never calls a service — the page persists the choice.
+/// The two things that can happen to a player already on the pitch. Both are one dropdown and one
+/// button, and choosing in either clears the other — the dialog answers with exactly one change.
+/// Like every dialog here it never calls a service; the page persists the choice.
 /// </summary>
 public partial class LiveSubDialog
 {
     [CascadingParameter]
     private IMudDialogInstance MudDialog { get; set; } = null!;
 
+    /// <summary>The player who was tapped on the pitch.</summary>
     [Parameter, EditorRequired]
-    public Player PlayerOff { get; set; } = null!;
+    public Player Player { get; set; } = null!;
+
+    /// <summary>The position they are holding, shown so the swap list reads against something.</summary>
+    [Parameter]
+    public PlayerPosition Position { get; set; }
 
     /// <summary>Everyone available to come on for the period currently being played.</summary>
     [Parameter, EditorRequired]
     public List<Player> Bench { get; set; } = [];
 
-    private MudForm Form { get; set; } = null!;
-    private int PlayerOnId { get; set; }
+    /// <summary>The rest of the pitch — who this player can trade positions with.</summary>
+    [Parameter, EditorRequired]
+    public List<PitchPlayer> OnPitch { get; set; } = [];
+
+    private int? _playerOnId;
+    private int? _swapWithId;
+
+    /// <summary>
+    /// Nullable so the select opens genuinely empty: an int binds to 0, which is nobody's id but
+    /// still renders as a chosen value — the same trap LiveGoalDialog documents.
+    /// </summary>
+    private int? PlayerOnId
+    {
+        get => _playerOnId;
+        set
+        {
+            _playerOnId = value;
+            if (value is not null) _swapWithId = null;
+        }
+    }
+
+    private int? SwapWithId
+    {
+        get => _swapWithId;
+        set
+        {
+            _swapWithId = value;
+            if (value is not null) _playerOnId = null;
+        }
+    }
+
+    /// <summary>The one button says what it is about to do, which is whichever list was used.</summary>
+    private bool IsPositionSwap => _swapWithId is not null;
 
-    protected override void OnParametersSet() =>
-        PlayerOnId = PlayerOnId == 0 ? Bench.FirstOrDefault()?.Id ?? 0 : PlayerOnId;
+    private bool HasChoice => _playerOnId is not null || _swapWithId is not null;
 
-    private async Task Submit()
+    private void Submit()
     {
-        await Form.ValidateAsync();
-        if (!Form.IsValid || PlayerOnId == 0) return;
+        if (_swapWithId is { } swapWith)
+        {
+            MudDialog.Close(DialogResult.Ok(new LiveSubChoice(swapWith, IsPositionSwap: true)));
+            return;
+        }
 
-        MudDialog.Close(DialogResult.Ok(PlayerOnId));
+        if (_playerOnId is { } playerOn)
+            MudDialog.Close(DialogResult.Ok(new LiveSubChoice(playerOn, IsPositionSwap: false)));
     }
 
     private void Cancel() => MudDialog.Cancel();
diff --git a/src/FootballFormation.UI/Pages/LiveSubDialog.razor.css b/src/FootballFormation.UI/Pages/LiveSubDialog.razor.css
index f6601d9..63b5c6b 100644
--- a/src/FootballFormation.UI/Pages/LiveSubDialog.razor.css
+++ b/src/FootballFormation.UI/Pages/LiveSubDialog.razor.css
@@ -8,3 +8,10 @@
     font-weight: 700;
     color: var(--ink);
 }
+
+.sub-off-pos {
+    font-size: 0.7rem;
+    font-weight: 800;
+    letter-spacing: 0.04em;
+    color: var(--ink-muted);
+}
diff --git a/src/FootballFormation.UI/Strings.nl.resx b/src/FootballFormation.UI/Strings.nl.resx
index d808b10..0a34fb5 100644
--- a/src/FootballFormation.UI/Strings.nl.resx
+++ b/src/FootballFormation.UI/Strings.nl.resx
@@ -191,21 +191,21 @@
   <data name="Additional time" xml:space="preserve"><value>Extra tijd</value></data>
   <data name="Full time" xml:space="preserve"><value>Einde wedstrijd</value></data>
   <data name="Start match" xml:space="preserve"><value>Wedstrijd starten</value></data>
-  <data name="Pause" xml:space="preserve"><value>Pauzeren</value></data>
   <data name="Resume" xml:space="preserve"><value>Hervatten</value></data>
   <data name="Half time" xml:space="preserve"><value>Rust</value></data>
   <data name="Start {0}" xml:space="preserve"><value>{0} starten</value></data>
-  <data name="Change line-up" xml:space="preserve"><value>Opstelling wisselen</value></data>
+  <data name="Next line-up" xml:space="preserve"><value>Volgende opstelling</value></data>
   <data name="Changes at half-way" xml:space="preserve"><value>Wissels halverwege</value></data>
   <data name="Position changes" xml:space="preserve"><value>Positiewissels</value></data>
   <data name="Finish match" xml:space="preserve"><value>Wedstrijd afsluiten</value></data>
   <data name="Edit result" xml:space="preserve"><value>Uitslag aanpassen</value></data>
   <data name="Line-up" xml:space="preserve"><value>Opstelling</value></data>
   <data name="No line-up for this period yet — build one first." xml:space="preserve"><value>Nog geen opstelling voor dit deel — maak er eerst een.</value></data>
-  <data name="Tap a player to substitute them." xml:space="preserve"><value>Tik op een speler om te wisselen.</value></data>
+  <data name="Tap a player to substitute them or change their position." xml:space="preserve"><value>Tik op een speler om te wisselen of van positie te veranderen.</value></data>
   <data name="Goal against" xml:space="preserve"><value>Tegen doelpunt</value></data>
   <data name="Timeline" xml:space="preserve"><value>Tijdlijn</value></data>
   <data name="Nothing has happened yet" xml:space="preserve"><value>Er is nog niets gebeurd</value></data>
+  <data name="Show subs" xml:space="preserve"><value>Wissels tonen</value></data>
   <data name="Minutes played" xml:space="preserve"><value>Gespeelde minuten</value></data>
   <data name="On the pitch" xml:space="preserve"><value>In het veld</value></data>
   <data name="Live now" xml:space="preserve"><value>Nu live</value></data>
@@ -214,7 +214,6 @@
   <data name="Remove" xml:space="preserve"><value>Verwijderen</value></data>
   <data name="Undo" xml:space="preserve"><value>Ongedaan maken</value></data>
   <data name="Match started" xml:space="preserve"><value>Wedstrijd gestart</value></data>
-  <data name="Clock paused" xml:space="preserve"><value>Klok gepauzeerd</value></data>
   <data name="Clock running" xml:space="preserve"><value>Klok loopt</value></data>
   <data name="Period ended" xml:space="preserve"><value>Speeldeel beëindigd</value></data>
   <data name="Next period started" xml:space="preserve"><value>Volgend speeldeel gestart</value></data>
@@ -233,6 +232,11 @@
   <data name="Make substitution" xml:space="preserve"><value>Wissel doorvoeren</value></data>
   <data name="Comes on" xml:space="preserve"><value>Komt erin</value></data>
   <data name="Nobody is on the bench for this period." xml:space="preserve"><value>Er zit niemand op de bank voor dit speeldeel.</value></data>
+  <data name="Swaps position with" xml:space="preserve"><value>Wisselt van positie met</value></data>
+  <data name="Nobody else is on the pitch." xml:space="preserve"><value>Er staat niemand anders op het veld.</value></data>
+  <data name="A position swap keeps both players on the pitch and is not a substitution." xml:space="preserve"><value>Bij een positiewissel blijven beide spelers op het veld; het is geen wissel.</value></data>
+  <data name="Swap positions" xml:space="preserve"><value>Posities wisselen</value></data>
+  <data name="Positions swapped" xml:space="preserve"><value>Posities gewisseld</value></data>
 
   <!-- Player stats -->
   <data name="Player Stats" xml:space="preserve"><value>Spelersstatistieken</value></data>
@@ -440,7 +444,9 @@
   <data name="Failed to {0}" xml:space="preserve"><value>Actie mislukt: {0}</value></data>
   <data name="You are not signed in to {0}" xml:space="preserve"><value>Je bent niet aangemeld om te {0}</value></data>
   <data name="A goal for us needs a scorer" xml:space="preserve"><value>Een doelpunt voor ons heeft een maker nodig</value></data>
+  <data name="A player cannot swap positions with themselves" xml:space="preserve"><value>Een speler kan niet met zichzelf van positie wisselen</value></data>
   <data name="A player cannot be substituted for themselves" xml:space="preserve"><value>Een speler kan niet voor zichzelf gewisseld worden</value></data>
+  <data name="Both players have to be on the pitch to swap positions" xml:space="preserve"><value>Beide spelers moeten op het veld staan om van positie te wisselen</value></data>
   <data name="Cannot copy a squad onto itself" xml:space="preserve"><value>Een selectie kan niet naar zichzelf gekopieerd worden</value></data>
   <data name="Comment not found" xml:space="preserve"><value>Opmerking niet gevonden</value></data>
   <data name="End the current period first" xml:space="preserve"><value>Beëindig eerst de huidige periode</value></data>
@@ -523,6 +529,7 @@
   <data name="save lineup" xml:space="preserve"><value>opstelling opslaan</value></data>
   <data name="set the password" xml:space="preserve"><value>wachtwoord instellen</value></data>
   <data name="start the next period" xml:space="preserve"><value>volgende periode starten</value></data>
+  <data name="swap the positions" xml:space="preserve"><value>posities wisselen</value></data>
   <data name="switch season" xml:space="preserve"><value>van seizoen wisselen</value></data>
   <data name="undo the substitution" xml:space="preserve"><value>wissel ongedaan maken</value></data>
   <data name="update comment" xml:space="preserve"><value>opmerking bijwerken</value></data>
diff --git a/src/FootballFormation.Web/wwwroot/app.css b/src/FootballFormation.Web/wwwroot/app.css
index 06c6444..3f31684 100644
--- a/src/FootballFormation.Web/wwwroot/app.css
+++ b/src/FootballFormation.Web/wwwroot/app.css
@@ -728,9 +728,9 @@ html, body {
 }
 
 /* --- Live match ---
-   These three sit here rather than in LiveMatch.razor.css because they target MudBlazor
-   components (two MudPapers and a MudButton), and scoped CSS never reaches a child
-   component's root element. The rest of that page's styling is scoped as normal. */
+   These sit here rather than in LiveMatch.razor.css because they target MudBlazor components
+   (two MudPapers and the buttons inside them), and scoped CSS never reaches a child component's
+   root element. The rest of that page's styling is scoped as normal. */
 .live-scoreboard,
 .live-controls {
     border-radius: 16px;
@@ -746,6 +746,34 @@ html, body {
     min-height: 56px;
 }
 
+/* The clock controls. A grid rather than a wrapping flex row: how many buttons the panel holds
+   depends on where the match is, and equal columns keep them the same width and the same height
+   whichever set is showing. The odd one out spans the row instead of sitting half-width beside a
+   gap — which is every case with a single button, and the third of three. */
+.live-control-row {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 8px;
+}
+
+.live-control-row > * {
+    width: 100%;
+    /* Not as tall as a scoring button: those are the ones pressed without looking. */
+    min-height: 48px;
+}
+
+.live-control-row > *:last-child:nth-child(odd) {
+    grid-column: 1 / -1;
+}
+
+/* The "Show subs" checkbox is dense, which is right on a desktop and under the 44px floor on the
+   phone this screen is actually used on. Its label is the target, so the height goes there. */
+@media (pointer: coarse) {
+    .live-bench-toggle .mud-checkbox {
+        min-height: 44px;
+    }
+}
+
 /* On a phone what just happened matters more than where everyone stands, so the line-up card
    drops below the timeline, taking the minutes table with it. Every other child of .live-layout
    keeps the default order of 0 and so stays in source order above them. */
diff --git a/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
index 03259f1..59ee2b4 100644
--- a/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
+++ b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
@@ -32,6 +32,8 @@ public async Task Every_touchline_write_names_the_game_it_changed()
         // Asked for by the substitution's own id, so this one names the game only after doing it.
         Assert.True((await Subs.RemoveSubstitutionAsync(sub.Value!.Id)).IsSuccess);
 
+        Assert.True((await Subs.SwapPositionsAsync(game.Id, players[0].Id, players[1].Id)).IsSuccess);
+
         Assert.True((await MatchClock.AdvancePeriodAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.PauseClockAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.ResumeClockAsync(game.Id)).IsSuccess);
@@ -39,8 +41,8 @@ public async Task Every_touchline_write_names_the_game_it_changed()
         Assert.True((await MatchClock.StartNextPeriodAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.FinishMatchAsync(game.Id)).IsSuccess);
 
-        // Eleven writes, eleven announcements, each naming this match.
-        Assert.Equal(11, _announced.Count);
+        // Twelve writes, twelve announcements, each naming this match.
+        Assert.Equal(12, _announced.Count);
         Assert.All(_announced, id => Assert.Equal(game.Id, id));
     }
 
@@ -56,6 +58,7 @@ public async Task A_refused_write_says_nothing()
         Assert.True((await Goals.LogGoalAsync(game.Id, null, null, false, false)).IsFailure);
         Assert.True((await Goals.RemoveGoalAsync(game.Id, 999)).IsFailure);
         Assert.True((await Subs.SubstituteAsync(game.Id, 999, 998)).IsFailure);
+        Assert.True((await Subs.SwapPositionsAsync(game.Id, 999, 998)).IsFailure);
         Assert.True((await Subs.RemoveSubstitutionAsync(999)).IsFailure);
 
         Assert.Empty(_announced);
diff --git a/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs b/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
index b1d7ccc..85be83e 100644
--- a/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
+++ b/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
@@ -95,6 +95,88 @@ public async Task A_substitution_needs_a_period_to_be_running()
         Assert.Equal("No period is currently being played", result.Error);
     }
 
+    [Fact]
+    public async Task Two_players_on_the_pitch_trade_their_slots_and_their_positions()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        var players = await PlayersAsync();
+
+        Time.Advance(TimeSpan.FromMinutes(12));
+        var result = await Subs.SwapPositionsAsync(game.Id, players[0].Id, players[1].Id);
+
+        Assert.True(result.IsSuccess);
+
+        var live = await ReloadAsync(game.Id);
+        var period = await Db.GamePeriods
+            .Include(p => p.PlayerPositions)
+            .FirstAsync(p => p.Id == live.LivePeriodId);
+
+        var keeper = period.PlayerPositions.Single(p => p.PlayerId == players[0].Id);
+        var midfielder = period.PlayerPositions.Single(p => p.PlayerId == players[1].Id);
+
+        Assert.Equal(5, keeper.SlotIndex);
+        Assert.Equal(PlayerPosition.CM, keeper.Position);
+        Assert.Equal(0, midfielder.SlotIndex);
+        Assert.Equal(PlayerPosition.GK, midfielder.Position);
+        Assert.False(keeper.IsSubstitute);
+        Assert.False(midfielder.IsSubstitute);
+    }
+
+    [Fact]
+    public async Task A_position_swap_is_not_a_substitution_and_is_never_written_down_as_one()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        var players = await PlayersAsync();
+
+        Assert.True((await Subs.SwapPositionsAsync(game.Id, players[0].Id, players[1].Id)).IsSuccess);
+
+        // Nobody left the pitch, so nobody's minutes changed — and a row here would say they did.
+        Assert.Empty(await Db.GameSubstitutions.ToListAsync());
+    }
+
+    [Fact]
+    public async Task Only_two_players_who_are_both_on_can_swap_positions()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        var players = await PlayersAsync();
+
+        // players[2] is on the bench; bringing them on is a substitution, not a swap.
+        var result = await Subs.SwapPositionsAsync(game.Id, players[1].Id, players[2].Id);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal("Both players have to be on the pitch to swap positions", result.Error);
+    }
+
+    [Fact]
+    public async Task A_player_cannot_swap_positions_with_themselves()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        var players = await PlayersAsync();
+
+        var result = await Subs.SwapPositionsAsync(game.Id, players[1].Id, players[1].Id);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal("A player cannot swap positions with themselves", result.Error);
+    }
+
+    [Fact]
+    public async Task A_position_swap_needs_a_period_to_be_running()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        await MatchClock.EndPeriodAsync(game.Id);
+        var players = await PlayersAsync();
+
+        var result = await Subs.SwapPositionsAsync(game.Id, players[0].Id, players[1].Id);
+
+        Assert.True(result.IsFailure);
+        Assert.Equal("No period is currently being played", result.Error);
+    }
+
     [Fact]
     public async Task Undoing_the_most_recent_substitution_restores_the_slot()
     {
diff --git a/tests/FootballFormation.Core.Tests/ScoreProgressionReportTests.cs b/tests/FootballFormation.Core.Tests/ScoreProgressionReportTests.cs
new file mode 100644
index 0000000..d058119
--- /dev/null
+++ b/tests/FootballFormation.Core.Tests/ScoreProgressionReportTests.cs
@@ -0,0 +1,93 @@
+using FootballFormation.Core.Models;
+using FootballFormation.Core.Reporting;
+
+namespace FootballFormation.Core.Tests;
+
+/// <summary>
+/// The score each goal made it. The live timeline lists events newest first, so the totals cannot
+/// be counted off the list as it renders — they have to be walked forwards, in the same order the
+/// timeline puts events in backwards.
+/// </summary>
+public class ScoreProgressionReportTests
+{
+    private static GameGoal Goal(int id, int minute, bool ownGoal = false, bool opponentGoal = false) =>
+        new()
+        {
+            Id = id,
+            Minute = minute,
+            IsOwnGoal = ownGoal,
+            IsOpponentGoal = opponentGoal,
+            RecordedAt = new DateTime(2026, 8, 11, 14, 0, minute, DateTimeKind.Utc)
+        };
+
+    [Fact]
+    public void Each_goal_carries_the_score_it_made_it()
+    {
+        var goals = new List<GameGoal>
+        {
+            Goal(1, 5),
+            Goal(2, 12, opponentGoal: true),
+            Goal(3, 30)
+        };
+
+        var progression = ScoreProgressionReport.Build(goals);
+
+        Assert.Equal(new MatchScore(1, 0), progression[1]);
+        Assert.Equal(new MatchScore(1, 1), progression[2]);
+        Assert.Equal(new MatchScore(2, 1), progression[3]);
+    }
+
+    [Fact]
+    public void An_own_goal_climbs_the_opponents_half_of_the_scoreline()
+    {
+        var goals = new List<GameGoal> { Goal(1, 20, ownGoal: true) };
+
+        var progression = ScoreProgressionReport.Build(goals);
+
+        Assert.Equal(new MatchScore(0, 1), progression[1]);
+    }
+
+    [Fact]
+    public void The_goals_are_counted_in_the_order_they_were_scored_not_the_order_they_arrived()
+    {
+        var goals = new List<GameGoal> { Goal(2, 40), Goal(1, 10, opponentGoal: true) };
+
+        var progression = ScoreProgressionReport.Build(goals);
+
+        Assert.Equal(new MatchScore(0, 1), progression[1]);
+        Assert.Equal(new MatchScore(1, 1), progression[2]);
+    }
+
+    [Fact]
+    public void Two_goals_in_the_same_minute_are_separated_by_when_they_were_entered()
+    {
+        // Typed in seconds apart, both logged as the 20th minute — the minute alone cannot say
+        // which was the equaliser and which put us ahead.
+        var first = Goal(7, 20, opponentGoal: true);
+        var second = Goal(4, 20);
+        second.RecordedAt = first.RecordedAt.AddSeconds(20);
+
+        var progression = ScoreProgressionReport.Build([second, first]);
+
+        Assert.Equal(new MatchScore(0, 1), progression[7]);
+        Assert.Equal(new MatchScore(1, 1), progression[4]);
+    }
+
+    [Fact]
+    public void The_last_goals_score_is_the_final_score()
+    {
+        var goals = new List<GameGoal> { Goal(1, 5), Goal(2, 25), Goal(3, 50, ownGoal: true) };
+
+        var progression = ScoreProgressionReport.Build(goals);
+        var final = progression[3];
+
+        Assert.Equal(Game.CountOurGoals(goals), final.Us);
+        Assert.Equal(Game.CountTheirGoals(goals), final.Them);
+    }
+
+    [Fact]
+    public void A_match_with_no_goals_has_nothing_to_report()
+    {
+        Assert.Empty(ScoreProgressionReport.Build([]));
+    }
+}
diff --git a/tests/ui/specs/match-day.spec.js b/tests/ui/specs/match-day.spec.js
index d979ab6..27a30d8 100644
--- a/tests/ui/specs/match-day.spec.js
+++ b/tests/ui/specs/match-day.spec.js
@@ -95,6 +95,11 @@ test('a match is run from the live screen and its score reaches the result', asy
     () => expect(theirScore).toHaveText('1'),
   );
 
+  // Each goal carries the score it made it, newest first — so the equaliser reads 1–1 above the
+  // opener's 1–0. Counted forwards over the match, which is the only way to get that off a list
+  // that runs backwards.
+  await expect(page.locator('.live-event .live-event-score')).toHaveText(['1–1', '1–0']);
+
   // The final whistle asks first, and its confirming button carries the same words as the one that
   // opened it — so the click has to be scoped to the control panel, or the locator matches both.
   await clickFor(
@@ -111,6 +116,53 @@ test('a match is run from the live screen and its score reaches the result', asy
   await expect(gameRow(page, 'FC Uitslag').locator('.game-score')).toHaveText(/1\s*.\s*1/);
 });
 
+test('tapping a player on the pitch offers a substitution and a position swap', async ({ page }) => {
+  const id = await matchWithId(page, 'FC Wisselen');
+  await fillLineup(page, 2);
+
+  await goto(page, `/games/${id}/live`);
+  await clickFor(
+    page.getByRole('button', { name: 'Start match' }),
+    () => expect(page.getByRole('button', { name: 'Finish match' })).toBeVisible(),
+  );
+
+  const chips = page.locator('.live-lineup .pitch-player');
+  const first = chips.first();
+  const before = await first.textContent();
+
+  await clickFor(first, () => expect(page.locator('.mud-dialog')).toBeVisible());
+  const dialog = await openDialog(page);
+
+  // Two lists, and the button names whichever one was used.
+  await expect(dialog.getByRole('button', { name: 'Make substitution' })).toBeDisabled();
+  await chooseOption(page, dialog, 'Swaps position with', '#');
+  await submitDialog(page, 'Swap positions');
+  await expect(page.getByText('Positions swapped', { exact: false })).toBeVisible();
+
+  // Both are still on — a swap is not a substitution — and they have changed places, so the chip
+  // that was first now names the other player. Nothing reaches the timeline.
+  await expect(chips).toHaveCount(2);
+  await expect(first).not.toHaveText(before);
+  await expect(page.locator('.live-event')).toHaveCount(0);
+});
+
+test('the bench strip can be folded away while the match is being run', async ({ page }) => {
+  const id = await matchWithId(page, 'FC Bank');
+  await fillLineup(page, 2);
+
+  await goto(page, `/games/${id}/live`);
+  await clickFor(
+    page.getByRole('button', { name: 'Start match' }),
+    () => expect(page.getByRole('button', { name: 'Finish match' })).toBeVisible(),
+  );
+
+  await expect(page.locator('.live-bench')).toBeVisible();
+  await clickFor(
+    page.locator('.live-bench-toggle input[type=checkbox]'),
+    () => expect(page.locator('.live-bench')).toHaveCount(0),
+  );
+});
+
 test('the playing-time table drops its estimate once the match has been run', async ({ page }) => {
   const id = await matchWithId(page, 'FC Speeltijd');
   await fillLineup(page, 2);
diff --git a/tests/ui/specs/selectors.spec.js b/tests/ui/specs/selectors.spec.js
index 66201a2..16fe476 100644
--- a/tests/ui/specs/selectors.spec.js
+++ b/tests/ui/specs/selectors.spec.js
@@ -30,7 +30,8 @@ const SELECTORS = {
   'a match still missing its lineup': ['nolineup-icon', 'action-needs-lineup'],
   'the formation builder': ['pitch', 'pitch-empty', 'pitch-player', 'draggable-player'],
   'the playing-time table': ['playtime-table', 'pt-total', 'playtime-note'],
-  'the live screen': ['live-lineup', 'live-controls', 'live-score-value', 'live-score-away'],
+  'the live screen': ['live-lineup', 'live-controls', 'live-score-value', 'live-score-away',
+                      'live-event', 'live-event-score', 'live-bench', 'live-bench-toggle'],
   'the phone layout': ['dialog-sheet', 'stacked-table', 'topbar-nav'],
   'the squad': ['badge-archived'],
 };

From 2f2929c907cfd684c2bf14dd6f57804789130233 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 11 Aug 2026 16:09:20 +0000
Subject: [PATCH 2/4] Take the pause out of the clock entirely, not just off
 the screen
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

No game is ever paused, so PauseClockAsync and ResumeClockAsync go with the
buttons — service, tests, error messages and resource keys. The clock now
runs from kick-off until the period is whistled off, and only a period
boundary stops it, which is one fewer way for the seconds a season's minutes
are built from to be wrong.

That makes "a live period" and "a running clock" the same thing, so the
status chip's paused state was only ever the break between two periods.
Renamed to .live-status-break, and the unreachable "Paused" label is gone.

The one clock test left in that section now says what the rule is rather
than testing a stoppage that cannot happen; ending a period and starting the
next already cover BankClock's arithmetic.
---
 CLAUDE.md                                     |  2 +-
 docs/architecture.md                          |  7 +--
 docs/patterns.md                              |  2 +-
 docs/ui_components.md                         | 11 ++--
 src/FootballFormation.Core/Models/Game.cs     |  6 +--
 .../Services/MatchClockService.cs             | 49 +++--------------
 .../Pages/LiveMatch.razor                     |  9 ----
 .../Pages/LiveMatch.razor.cs                  | 18 +++----
 .../Pages/LiveMatch.razor.css                 | 11 ++--
 src/FootballFormation.UI/Strings.nl.resx      |  8 ---
 .../LiveMatchNotificationTests.cs             |  8 ++-
 .../MatchClockServiceTests.cs                 | 54 +++----------------
 12 files changed, 40 insertions(+), 145 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 0732d48..edee77c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -16,7 +16,7 @@ as in the markup. The UI is Dutch by default with English available.
 
 ```bash
 dotnet build -c Release        # what CI builds — warnings are errors here (see below)
-dotnet test                    # 389 tests, xUnit v3, real SQLite
+dotnet test                    # 386 tests, xUnit v3, real SQLite
 cd src/FootballFormation.Web && dotnet run     # http://localhost:5228
 cd tests/ui && npm test        # 36 Playwright tests in a browser, ~1 min (npm install first)
 scripts/visual-check.sh        # screenshots every page, then measures every touch target
diff --git a/docs/architecture.md b/docs/architecture.md
index 475b9c8..77d748b 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -70,9 +70,10 @@ Services/
                             renders, GetTodaysMatchAsync for the home-page banner (in-progress
                             first, else today's fixture, upcoming or finished). Writing to one is
                             the three services below, split by what happens on the touchline
-  MatchClockService.cs    — The clock and the run of play: kick-off, pause/resume, ending a period,
-                            starting or rolling into the next one, the final whistle. The
-                            arithmetic a season's statistics are built from
+  MatchClockService.cs    — The clock and the run of play: kick-off, ending a period, starting or
+                            rolling into the next one, the final whistle. The arithmetic a
+                            season's statistics are built from. There is no pause — the clock
+                            runs from kick-off to the whistle and only a period boundary stops it
   MatchGoalService.cs     — Goals logged live: storage delegated to GameService, the live minute
                             and the recomputed scoreline added here
   MatchSubstitutionService.cs — The slot swap and the record of it, in one SaveChanges, plus undoing
diff --git a/docs/patterns.md b/docs/patterns.md
index c055c26..bdad826 100644
--- a/docs/patterns.md
+++ b/docs/patterns.md
@@ -108,7 +108,7 @@ is actually happening at the touchline rather than along a data-access seam:
 | Service | Owns |
 | --- | --- |
 | `LiveMatchService` | Reading: `GetLiveAsync` for the live screen, `GetTodaysMatchAsync` for the home banner. Both public, like every other read |
-| `MatchClockService` | Kick-off, pause/resume, ending a period, starting or rolling into the next, the final whistle — and `BankClock`, the only thing that moves seconds about |
+| `MatchClockService` | Kick-off, ending a period, starting or rolling into the next, the final whistle — and `BankClock`, the only thing that moves seconds about. No pause: only a period boundary stops the clock |
 | `MatchGoalService` | The live minute a goal is stamped with and the scoreline recomputed from the goals on file. Storage itself still delegates to `GameService` |
 | `MatchSubstitutionService` | The slot swap and the record of it, in one `SaveChanges`, and undoing the most recent one of a period |
 
diff --git a/docs/ui_components.md b/docs/ui_components.md
index 5fafb20..24d7c89 100644
--- a/docs/ui_components.md
+++ b/docs/ui_components.md
@@ -112,11 +112,12 @@ watches the same URL read-only. Every control sits in an `<AuthorizeView Roles="
   about to make are the ones listed in the "Changes at half-way" card above it. Only after the first
   half or Q2 does the screen offer "Half time" (`EndPeriodAsync`, which does stop it) followed by
   "Start 2nd half". The rule lives in `PeriodTypeExtensions.IsFollowedByBreak`, not in the page.
-- **There is no pause button.** Nothing on the screen stops a running clock any more: a youth match
-  is not paused at the touchline, and the button was one more thing to hit by accident.
-  `PauseClockAsync` survives in `MatchClockService` (a match paused before it went has to be
-  resumable, which is the only thing "Resume" now appears for — a live period whose clock is
-  stopped), but nothing renders a control that calls it.
+- **There is no pause.** The clock runs from kick-off until the period is whistled off, and only
+  a period boundary stops it — `PauseClockAsync`/`ResumeClockAsync` are gone from
+  `MatchClockService` too, not just from the screen. A youth match is not paused at the touchline,
+  and a clock a stray tap can stop is a clock the season's minutes cannot be trusted from. So a
+  live period always has a running clock, which is why the status chip's third state is the break
+  between two periods (`.live-status-break`) rather than a paused one.
 - **The controls are a two-column grid, laid out in `app.css`.** How many buttons the panel holds
   depends on where the match is, so equal columns keep them the same size whichever set is showing,
   and `:last-child:nth-child(odd)` spans the odd one out across the row. It has to be `app.css`:
diff --git a/src/FootballFormation.Core/Models/Game.cs b/src/FootballFormation.Core/Models/Game.cs
index 215b893..ccdacab 100644
--- a/src/FootballFormation.Core/Models/Game.cs
+++ b/src/FootballFormation.Core/Models/Game.cs
@@ -42,8 +42,8 @@ public class Game
     public MatchState MatchState { get; set; } = MatchState.NotStarted;
 
     /// <summary>
-    /// UTC instant the match clock was last started or resumed; null whenever the clock is not
-    /// running. The clock is stored as an anchor rather than a ticking value so every viewer
+    /// UTC instant the match clock was last started — at kick-off, or when a period took over from
+    /// a break; null whenever the clock is not running. The clock is stored as an anchor rather than a ticking value so every viewer
     /// derives the same elapsed time without the server having to push each second.
     /// </summary>
     public DateTime? ClockRunningSince { get; set; }
@@ -164,7 +164,7 @@ public List<Player> SelectRoster(IEnumerable<Player> allPlayers, SeasonSquad squ
 
     /// <summary>
     /// The match clock in seconds at <paramref name="utcNow"/>. Callers that only need a settled
-    /// value (a paused clock, a finished match) can pass any instant.
+    /// value (a stopped clock, a finished match) can pass any instant.
     /// </summary>
     public int ElapsedSecondsAt(DateTime utcNow) => ClockAccumulatedSeconds +
         (ClockRunningSince is null ? 0 : Math.Max(0, (int)(utcNow - ClockRunningSince.Value).TotalSeconds));
diff --git a/src/FootballFormation.Core/Services/MatchClockService.cs b/src/FootballFormation.Core/Services/MatchClockService.cs
index 930e09b..b9e0bf0 100644
--- a/src/FootballFormation.Core/Services/MatchClockService.cs
+++ b/src/FootballFormation.Core/Services/MatchClockService.cs
@@ -7,7 +7,12 @@
 namespace FootballFormation.Core.Services;
 
 /// <summary>
-/// The clock and the run of play: kick-off, the pauses, the period changes and the final whistle.
+/// The clock and the run of play: kick-off, the period changes and the final whistle.
+/// <para>
+/// There is no pause: the clock runs from kick-off until the period is whistled off, and only a
+/// period boundary stops it. A youth match is not paused at the touchline, and a clock that could
+/// be stopped by a stray tap is a clock the season's minutes cannot be trusted from.
+/// </para>
 /// <para>
 /// This is where the arithmetic a season's statistics are built on lives — the banked seconds and
 /// the started/ended marks on each period are what <c>GameMinutesReport</c> later credits players
@@ -57,48 +62,6 @@ public Task<Result<Game>> StartMatchAsync(int gameId, CancellationToken cancella
             return Result.Success(game);
         });
 
-    public Task<Result<Game>> PauseClockAsync(int gameId, CancellationToken cancellationToken = default) =>
-        LiveMatchOperation.RunAdminAsync(notifier, gameId, currentUser, logger, "pause the clock",
-            cancellationToken, async () =>
-        {
-            await using var db = await dbFactory.CreateDbContextAsync(cancellationToken);
-
-            var game = await db.LoadWithPeriodsAsync(gameId, cancellationToken);
-            if (game is null) return NotFound(gameId);
-
-            if (!game.IsClockRunning) return Result.Failure<Game>("The clock is not running");
-
-            BankClock(game);
-            await db.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Paused clock for game {GameId} at {Seconds}s",
-                gameId, game.ClockAccumulatedSeconds);
-            return Result.Success(game);
-        });
-
-    public Task<Result<Game>> ResumeClockAsync(int gameId, CancellationToken cancellationToken = default) =>
-        LiveMatchOperation.RunAdminAsync(notifier, gameId, currentUser, logger, "resume the clock",
-            cancellationToken, async () =>
-        {
-            await using var db = await dbFactory.CreateDbContextAsync(cancellationToken);
-
-            var game = await db.LoadWithPeriodsAsync(gameId, cancellationToken);
-            if (game is null) return NotFound(gameId);
-
-            if (game.MatchState != MatchState.InProgress)
-                return Result.Failure<Game>("This match is not in progress");
-            if (game.IsClockRunning) return Result.Failure<Game>("The clock is already running");
-            if (game.LivePeriodId is null)
-                return Result.Failure<Game>("Start the next period before resuming the clock");
-
-            game.ClockRunningSince = UtcNow;
-            await db.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("Resumed clock for game {GameId} at {Seconds}s",
-                gameId, game.ClockAccumulatedSeconds);
-            return Result.Success(game);
-        });
-
     /// <summary>Whistles the current period off. The clock stops and no period is live until the next one starts.</summary>
     public Task<Result<Game>> EndPeriodAsync(int gameId, CancellationToken cancellationToken = default) =>
         LiveMatchOperation.RunAdminAsync(notifier, gameId, currentUser, logger, "end the period",
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor b/src/FootballFormation.UI/Pages/LiveMatch.razor
index 6d6976a..e3bfd68 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor
@@ -61,15 +61,6 @@
                 <div class="live-control-row">
                     @if (IsLivePeriod)
                     {
-                        @* Nothing here stops the clock any more, so this only appears for a match
-                           paused by the button that used to. See ResumeClock. *@
-                        @if (!GameData.IsClockRunning)
-                        {
-                            <MudButton Variant="Variant.Outlined" Class="btn-ghost"
-                                       StartIcon="@Icons.Material.Filled.PlayArrow" OnClick="ResumeClock">
-                                @L["Resume"]
-                            </MudButton>
-                        }
                         @* A quarter boundary is not a stoppage, it is the planned line-up change
                            partway through the half — so it is named after what it does. *@
                         @if (BreakFollowsCurrentPeriod)
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
index 9901b10..01624a9 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
@@ -168,19 +168,21 @@ DisplayPeriod is { } current && MidHalfSuccessor is { } next
         null or MatchState.NotStarted => L["Not started"],
         MatchState.Finished => L["Full time"],
         _ when !IsLivePeriod => L["Break"],
-        _ when !GameData.IsClockRunning => L["Paused"],
         // The half is played out and play has not stopped — the thing to say is how much longer.
         _ when Clock.IsInAdditionalTime => L["Additional time"],
         _ => L[DisplayHalfLabel ?? "In progress"]
     };
 
-    /// <summary>Drives the colour of the status chip: only a running clock counts as live.</summary>
+    /// <summary>
+    /// Drives the colour of the status chip. A live period always has a running clock — nothing
+    /// stops one short of the whistle — so the third arm here is the break between two periods.
+    /// </summary>
     private string StatusCssClass => GameData?.MatchState switch
     {
         MatchState.InProgress when GameData.IsClockRunning && Clock.IsInAdditionalTime =>
             "live-status live-status-extra",
         MatchState.InProgress when GameData.IsClockRunning => "live-status live-status-running",
-        MatchState.InProgress => "live-status live-status-paused",
+        MatchState.InProgress => "live-status live-status-break",
         MatchState.Finished => "live-status live-status-done",
         _ => "live-status"
     };
@@ -278,7 +280,7 @@ protected override async Task OnInitializedAsync()
         _tick.Start();
     }
 
-    /// <summary>Only repaints while the clock is actually moving — a paused screen has nothing to redraw.</summary>
+    /// <summary>Only repaints while the clock is actually moving — at a break there is nothing to redraw.</summary>
     private void OnTick(object? sender, ElapsedEventArgs e)
     {
         if (GameData?.IsClockRunning != true) return;
@@ -317,14 +319,6 @@ private async Task<bool> ReloadAsync()
     private async Task StartMatch() =>
         Snackbar.Report(L, await ClockService.StartMatchAsync(GameId), L["Match started"]);
 
-    /// <summary>
-    /// Only offered when a period is live and its clock is somehow stopped, which nothing on this
-    /// screen can now cause — the pause button is gone. It stays as the way out for a match that
-    /// was paused before it went, since without it that match could never be run to full time.
-    /// </summary>
-    private async Task ResumeClock() =>
-        Snackbar.Report(L, await ClockService.ResumeClockAsync(GameId), L["Clock running"], Severity.Info);
-
     private async Task EndPeriod() =>
         Snackbar.Report(L, await ClockService.EndPeriodAsync(GameId), L["Period ended"], Severity.Info);
 
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.css b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
index c307e7e..ee28273 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.css
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
@@ -93,13 +93,10 @@
     color: #fff;
 }
 
-/* Still being played, but past the end of the half — not the same green as a half in hand. */
-.live-status-extra {
-    background: var(--color-warning);
-    color: #fff;
-}
-
-.live-status-paused {
+/* Still being played, but past the end of the half — not the same green as a half in hand. And
+   the break between two periods, which is the only other time the clock is not moving. */
+.live-status-extra,
+.live-status-break {
     background: var(--color-warning);
     color: #fff;
 }
diff --git a/src/FootballFormation.UI/Strings.nl.resx b/src/FootballFormation.UI/Strings.nl.resx
index 0a34fb5..b0805a8 100644
--- a/src/FootballFormation.UI/Strings.nl.resx
+++ b/src/FootballFormation.UI/Strings.nl.resx
@@ -187,11 +187,9 @@
   <data name="Not started" xml:space="preserve"><value>Nog niet begonnen</value></data>
   <data name="In progress" xml:space="preserve"><value>Bezig</value></data>
   <data name="Break" xml:space="preserve"><value>Rust</value></data>
-  <data name="Paused" xml:space="preserve"><value>Gepauzeerd</value></data>
   <data name="Additional time" xml:space="preserve"><value>Extra tijd</value></data>
   <data name="Full time" xml:space="preserve"><value>Einde wedstrijd</value></data>
   <data name="Start match" xml:space="preserve"><value>Wedstrijd starten</value></data>
-  <data name="Resume" xml:space="preserve"><value>Hervatten</value></data>
   <data name="Half time" xml:space="preserve"><value>Rust</value></data>
   <data name="Start {0}" xml:space="preserve"><value>{0} starten</value></data>
   <data name="Next line-up" xml:space="preserve"><value>Volgende opstelling</value></data>
@@ -214,7 +212,6 @@
   <data name="Remove" xml:space="preserve"><value>Verwijderen</value></data>
   <data name="Undo" xml:space="preserve"><value>Ongedaan maken</value></data>
   <data name="Match started" xml:space="preserve"><value>Wedstrijd gestart</value></data>
-  <data name="Clock running" xml:space="preserve"><value>Klok loopt</value></data>
   <data name="Period ended" xml:space="preserve"><value>Speeldeel beëindigd</value></data>
   <data name="Next period started" xml:space="preserve"><value>Volgend speeldeel gestart</value></data>
   <data name="Match finished" xml:space="preserve"><value>Wedstrijd afgesloten</value></data>
@@ -465,12 +462,9 @@
   <data name="Season {0} has no squad to copy" xml:space="preserve"><value>Seizoen {0} heeft geen selectie om te kopiëren</value></data>
   <data name="Season {0} is the current season" xml:space="preserve"><value>Seizoen {0} is het huidige seizoen</value></data>
   <data name="Season {0} still has {1} games" xml:space="preserve"><value>Seizoen {0} heeft nog {1} wedstrijden</value></data>
-  <data name="Start the next period before resuming the clock" xml:space="preserve"><value>Start de volgende periode voordat je de klok hervat</value></data>
   <data name="Substitution not found" xml:space="preserve"><value>Wissel niet gevonden</value></data>
   <data name="That player is already on the pitch" xml:space="preserve"><value>Die speler staat al op het veld</value></data>
   <data name="That player is not on the pitch" xml:space="preserve"><value>Die speler staat niet op het veld</value></data>
-  <data name="The clock is already running" xml:space="preserve"><value>De klok loopt al</value></data>
-  <data name="The clock is not running" xml:space="preserve"><value>De klok loopt niet</value></data>
   <data name="The end date must be after the start date" xml:space="preserve"><value>De einddatum moet na de startdatum liggen</value></data>
   <data name="These dates overlap season {0}" xml:space="preserve"><value>Deze datums overlappen seizoen {0}</value></data>
   <data name="This game has no periods to play" xml:space="preserve"><value>Deze wedstrijd heeft geen periodes om te spelen</value></data>
@@ -519,13 +513,11 @@
   <data name="log the goal" xml:space="preserve"><value>doelpunt vastleggen</value></data>
   <data name="look up the season for that date" xml:space="preserve"><value>seizoen bij die datum opzoeken</value></data>
   <data name="make the substitution" xml:space="preserve"><value>wissel doorvoeren</value></data>
-  <data name="pause the clock" xml:space="preserve"><value>klok pauzeren</value></data>
   <data name="prepare seasons" xml:space="preserve"><value>seizoenen voorbereiden</value></data>
   <data name="remove comment" xml:space="preserve"><value>opmerking verwijderen</value></data>
   <data name="remove goal" xml:space="preserve"><value>doelpunt verwijderen</value></data>
   <data name="remove the goal" xml:space="preserve"><value>doelpunt verwijderen</value></data>
   <data name="remove the player from the squad" xml:space="preserve"><value>speler uit de selectie verwijderen</value></data>
-  <data name="resume the clock" xml:space="preserve"><value>klok hervatten</value></data>
   <data name="save lineup" xml:space="preserve"><value>opstelling opslaan</value></data>
   <data name="set the password" xml:space="preserve"><value>wachtwoord instellen</value></data>
   <data name="start the next period" xml:space="preserve"><value>volgende periode starten</value></data>
diff --git a/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
index 59ee2b4..be2e351 100644
--- a/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
+++ b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
@@ -35,14 +35,12 @@ public async Task Every_touchline_write_names_the_game_it_changed()
         Assert.True((await Subs.SwapPositionsAsync(game.Id, players[0].Id, players[1].Id)).IsSuccess);
 
         Assert.True((await MatchClock.AdvancePeriodAsync(game.Id)).IsSuccess);
-        Assert.True((await MatchClock.PauseClockAsync(game.Id)).IsSuccess);
-        Assert.True((await MatchClock.ResumeClockAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.EndPeriodAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.StartNextPeriodAsync(game.Id)).IsSuccess);
         Assert.True((await MatchClock.FinishMatchAsync(game.Id)).IsSuccess);
 
-        // Twelve writes, twelve announcements, each naming this match.
-        Assert.Equal(12, _announced.Count);
+        // Ten writes, ten announcements, each naming this match.
+        Assert.Equal(10, _announced.Count);
         Assert.All(_announced, id => Assert.Equal(game.Id, id));
     }
 
@@ -54,7 +52,7 @@ public async Task A_refused_write_says_nothing()
         _announced.Clear();
 
         // A rule broken and an unknown row, across all three services.
-        Assert.True((await MatchClock.PauseClockAsync(999)).IsFailure);
+        Assert.True((await MatchClock.StartNextPeriodAsync(game.Id)).IsFailure);
         Assert.True((await Goals.LogGoalAsync(game.Id, null, null, false, false)).IsFailure);
         Assert.True((await Goals.RemoveGoalAsync(game.Id, 999)).IsFailure);
         Assert.True((await Subs.SubstituteAsync(game.Id, 999, 998)).IsFailure);
diff --git a/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs b/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
index eff00fa..ab46b06 100644
--- a/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
+++ b/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
@@ -67,60 +67,18 @@ public async Task An_unknown_game_fails_rather_than_throwing()
     // ---- The clock -------------------------------------------------------------------------
 
     [Fact]
-    public async Task Pausing_banks_the_time_run_so_far_and_stops_the_anchor()
+    public async Task The_clock_runs_from_kick_off_until_the_period_is_whistled_off()
     {
         var game = await SeedGameAsync();
         await MatchClock.StartMatchAsync(game.Id);
 
+        // There is nothing that stops it in between: no pause, no resume. Whatever the touchline
+        // does with the screen, the seconds the season's minutes are built from keep counting.
         Time.Advance(TimeSpan.FromMinutes(7));
-        await MatchClock.PauseClockAsync(game.Id);
 
-        var paused = await ReloadAsync(game.Id);
-        Assert.Equal(420, paused.ClockAccumulatedSeconds);
-        Assert.False(paused.IsClockRunning);
-    }
-
-    [Fact]
-    public async Task Time_spent_paused_is_not_counted()
-    {
-        var game = await SeedGameAsync();
-        await MatchClock.StartMatchAsync(game.Id);
-
-        Time.Advance(TimeSpan.FromMinutes(7));
-        await MatchClock.PauseClockAsync(game.Id);
-
-        Time.Advance(TimeSpan.FromMinutes(30));      // a long injury stoppage
-        await MatchClock.ResumeClockAsync(game.Id);
-
-        Time.Advance(TimeSpan.FromMinutes(3));
-
-        var resumed = await ReloadAsync(game.Id);
-        Assert.Equal(600, resumed.ElapsedSecondsAt(Time.GetUtcNow().UtcDateTime));
-    }
-
-    [Fact]
-    public async Task Pausing_a_stopped_clock_is_refused()
-    {
-        var game = await SeedGameAsync();
-        await MatchClock.StartMatchAsync(game.Id);
-        await MatchClock.PauseClockAsync(game.Id);
-
-        var result = await MatchClock.PauseClockAsync(game.Id);
-
-        Assert.True(result.IsFailure);
-        Assert.Equal("The clock is not running", result.Error);
-    }
-
-    [Fact]
-    public async Task Resuming_a_running_clock_is_refused()
-    {
-        var game = await SeedGameAsync();
-        await MatchClock.StartMatchAsync(game.Id);
-
-        var result = await MatchClock.ResumeClockAsync(game.Id);
-
-        Assert.True(result.IsFailure);
-        Assert.Equal("The clock is already running", result.Error);
+        var running = await ReloadAsync(game.Id);
+        Assert.True(running.IsClockRunning);
+        Assert.Equal(420, running.ElapsedSecondsAt(Time.GetUtcNow().UtcDateTime));
     }
 
     // ---- Periods ---------------------------------------------------------------------------

From 1a2f451ed6f9329a9934b82f97dbc76cdd214c90 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 11 Aug 2026 16:17:41 +0000
Subject: [PATCH 3/4] Ask before rolling on to the next line-up, and show what
 it changes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Advancing a period is the one control on the live screen with no way back —
it rewrites who is on the pitch and no timeline event records it — and what
it was about to do could only be read off a card further down the screen. It
now opens a dialog that lists the swaps and the position moves, says the
clock keeps running, and offers Cancel or Next line-up.

The card and the dialog show the same thing, so the markup moves into
PlannedChangesList and takes its styling with it. Scoped CSS follows the file
that owns the elements: leaving the .live-planned-* rules in LiveMatch.razor.css
would have left both callers unstyled, which is the trap this repository has
walked into twice.

createMatch can pick the game split, because quarters is the only shape whose
live screen offers this at all.
---
 CLAUDE.md                                     |  4 +-
 docs/architecture.md                          | 10 ++-
 docs/ui_components.md                         | 13 ++-
 .../Components/PlannedChangesList.razor       | 40 +++++++++
 .../Components/PlannedChangesList.razor.css   | 88 +++++++++++++++++++
 .../Pages/LiveMatch.razor                     | 28 +-----
 .../Pages/LiveMatch.razor.cs                  | 13 ++-
 .../Pages/LiveMatch.razor.css                 | 88 -------------------
 .../Pages/LiveNextLineupDialog.razor          | 28 ++++++
 .../Pages/LiveNextLineupDialog.razor.cs       | 24 +++++
 .../Pages/LiveNextLineupDialog.razor.css      |  5 ++
 src/FootballFormation.UI/Strings.nl.resx      |  2 +
 tests/ui/helpers.js                           |  5 +-
 tests/ui/specs/match-day.spec.js              | 58 +++++++++++-
 tests/ui/specs/selectors.spec.js              |  3 +-
 15 files changed, 282 insertions(+), 127 deletions(-)
 create mode 100644 src/FootballFormation.UI/Components/PlannedChangesList.razor
 create mode 100644 src/FootballFormation.UI/Components/PlannedChangesList.razor.css
 create mode 100644 src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor
 create mode 100644 src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.cs
 create mode 100644 src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.css

diff --git a/CLAUDE.md b/CLAUDE.md
index edee77c..7c1aa3e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,7 +18,7 @@ as in the markup. The UI is Dutch by default with English available.
 dotnet build -c Release        # what CI builds — warnings are errors here (see below)
 dotnet test                    # 386 tests, xUnit v3, real SQLite
 cd src/FootballFormation.Web && dotnet run     # http://localhost:5228
-cd tests/ui && npm test        # 36 Playwright tests in a browser, ~1 min (npm install first)
+cd tests/ui && npm test        # 37 Playwright tests in a browser, ~1 min (npm install first)
 scripts/visual-check.sh        # screenshots every page, then measures every touch target
 scripts/coverage.sh            # coverage of the lines this branch changed, 80% floor
 ```
@@ -166,7 +166,7 @@ Test names are sentences:
 There are **no component tests** (no bUnit). The UI is checked by driving the real app in a real
 browser, in two places, both against a throwaway database:
 
-- **`cd tests/ui && npm test`** — Playwright, ~36 tests, about a minute. Runs on every pull request
+- **`cd tests/ui && npm test`** — Playwright, ~37 tests, about a minute. Runs on every pull request
   as a job in `ci.yml`, advisory rather than the merge gate. Behaviour: the public/admin
   split, the squad and match dialogs, the whole match-day journey from dragging a lineup to blowing
   the final whistle, both languages, and the phone layout. Read
diff --git a/docs/architecture.md b/docs/architecture.md
index 77d748b..0f76327 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -52,7 +52,8 @@ Reporting/
   PlayerStatsReport.cs    — Per-player aggregates (PlayerStats, PositionStat, PlayerGameStat)
   PositionFitHelper.cs    — 5-tier position fit: Preferred, NaturalFit, Alternative, Compatible, OutOfPosition
   MatchClockReport.cs     — Derives the live clock and period state from the stored anchor + banked total
-  PlannedChangesReport.cs — What the next period changes versus the one on the pitch
+  PlannedChangesReport.cs — What the next period changes versus the one on the pitch (rendered by
+                           UI/Components/PlannedChangesList, shared by the live card and its dialog)
   ScoreProgressionReport.cs — The score after each goal (MatchScore), for the live timeline —
                            counted forwards because that list runs newest first
   HealthReport.cs         — Whether a booted container is actually serving: the /health payload and
@@ -108,7 +109,10 @@ Pages/
   MatchResult.razor(.cs)(.css)— /games/{id}/result — Score and goal entry
   LiveMatch.razor(.cs)(.css)  — /games/{id}/live — Sideline screen: clock, subs, goals; admin drives, others watch
   LiveGoalDialog.razor(.cs)   — Dialog: scorer, assister, own-goal toggle
-  LiveSubDialog.razor(.cs)(.css) — Dialog: pick the replacement for a player tapped on the pitch
+  LiveSubDialog.razor(.cs)(.css) — Dialog: for a player tapped on the pitch, either a replacement
+                                from the bench or a position swap with someone already on
+  LiveNextLineupDialog.razor(.cs)(.css) — Dialog: what rolling on to the next line-up will change,
+                                asked before it is done — advancing a period has no undo
   SeasonDialog.razor(.cs)     — Dialog: season name, start date, end date
   Settings.razor(.cs)         — /settings — Match preferences, own password, season management
   Users.razor(.cs)            — /users — Accounts: add, edit, reset password, delete (Admin only)
@@ -121,6 +125,8 @@ Components/
   Pitch.razor(.cs)(.css)            — The pitch. Read-only by default; Draggable for the builder,
                                       OnPlayerClicked for the live screen, Size for chip scale
   PlayerLabel.razor                 — A player as one line of text: "#7 Jasper"
+  PlannedChangesList.razor(.css)    — What the next line-up does, as a team sheet; shared by the live
+                                      screen's card and the dialog that asks before applying it
   CancellableComponent.cs           — Base for any component that reads: owns the CancellationToken its
                                       service reads take, tripped when the component is disposed
   SeasonAwarePage.cs                — Base for pages that follow the season picker (a CancellableComponent)
diff --git a/docs/ui_components.md b/docs/ui_components.md
index 24d7c89..f77a7e5 100644
--- a/docs/ui_components.md
+++ b/docs/ui_components.md
@@ -108,8 +108,10 @@ watches the same URL read-only. Every control sits in an `<AuthorizeView Roles="
   a live screen stuck at the old scoreline. Identity resolution keeps shared `Player` rows single.
 - Controls are context-sensitive, and **only half time is a break**. A quarters game is still two
   halves: mid-half the screen offers **"Next line-up"**, which calls `AdvancePeriodAsync` and rolls
-  the *next quarter's planned lineup* onto the pitch without stopping the clock — the changes it is
-  about to make are the ones listed in the "Changes at half-way" card above it. Only after the first
+  the *next quarter's planned lineup* onto the pitch without stopping the clock. It **asks first**
+  (`LiveNextLineupDialog`), listing the swaps and moves it is about to make: advancing a period has
+  no undo — no timeline event records it — and the changes used to be readable only from a card
+  further down the screen. Only after the first
   half or Q2 does the screen offer "Half time" (`EndPeriodAsync`, which does stop it) followed by
   "Start 2nd half". The rule lives in `PeriodTypeExtensions.IsFollowedByBreak`, not in the page.
 - **There is no pause.** The clock runs from kick-off until the period is whistled off, and only
@@ -138,7 +140,12 @@ watches the same URL read-only. Every control sits in an `<AuthorizeView Roles="
   by goal id, because the timeline itself runs newest first and a total accumulated while rendering
   would count down.
 - Finishing asks for confirmation via `DialogPrompts.ConfirmAsync` (not `ConfirmDeleteAsync`,
-  whose button says "Delete").
+  whose button says "Delete"). "Next line-up" needs a list rather than a sentence, so it has its own
+  dialog and goes through `PromptValueAsync<…, bool>` instead.
+- **`PlannedChangesList` is the one rendering of what the next line-up does.** The card and the
+  dialog show the same thing, so the markup and its `.planned-*` styling live in the component —
+  scoped CSS follows the file that owns the elements, so moving the markup and leaving the CSS
+  behind would have left both callers unstyled.
 - **Minutes played is admin-only** (`LiveMinutesReport`), and shows exact time on the pitch rather
   than the `periodsPlaying × periodDuration` estimate the planning screens use. It is a computed
   property, so the running player's total climbs with the clock tick.
diff --git a/src/FootballFormation.UI/Components/PlannedChangesList.razor b/src/FootballFormation.UI/Components/PlannedChangesList.razor
new file mode 100644
index 0000000..ea16f0d
--- /dev/null
+++ b/src/FootballFormation.UI/Components/PlannedChangesList.razor
@@ -0,0 +1,40 @@
+@*
+    What the next line-up does, as a team sheet: who is swapped, and underneath, who only moves.
+
+    Two places show exactly this — the live screen's "Changes at half-way" card and the dialog that
+    asks before the same changes are carried out — so the markup and its styling live here once.
+*@
+@inject IStringLocalizer<Strings> L
+
+<div class="planned">
+    @foreach (var change in Changes.Substitutions)
+    {
+        <div class="planned-row">
+            <span class="planned-pos">@change.Position.ToString()</span>
+            <span class="planned-off">@(change.PlayerOff?.ShortName ?? "—")</span>
+            @* Plain text, not a MudIcon: scoped CSS never reaches a child component's root element. *@
+            <span class="planned-arrow">→</span>
+            <span class="planned-on">@(change.PlayerOn?.ShortName ?? "—")</span>
+        </div>
+    }
+</div>
+
+@* Secondary: nobody leaves the pitch, so this never competes with the swaps above. *@
+@if (Changes.Moves.Count > 0)
+{
+    <div class="planned-moves">
+        <span class="planned-moves-label">@L["Position changes"]</span>
+        @foreach (var move in Changes.Moves)
+        {
+            <span class="planned-move">
+                @move.Player.ShortName
+                <span class="planned-move-pos">@move.From.ToString() → @move.To.ToString()</span>
+            </span>
+        }
+    </div>
+}
+
+@code {
+    [Parameter, EditorRequired]
+    public PlannedChanges Changes { get; set; } = PlannedChanges.None;
+}
diff --git a/src/FootballFormation.UI/Components/PlannedChangesList.razor.css b/src/FootballFormation.UI/Components/PlannedChangesList.razor.css
new file mode 100644
index 0000000..65b3ed6
--- /dev/null
+++ b/src/FootballFormation.UI/Components/PlannedChangesList.razor.css
@@ -0,0 +1,88 @@
+/* Moved here with the markup from LiveMatch.razor.css — scoped CSS follows the file that owns
+   the elements, so leaving these behind would have left both callers unstyled. */
+.planned {
+    display: flex;
+    flex-direction: column;
+}
+
+.planned-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 0;
+    font-size: 0.85rem;
+    border-bottom: 1px solid color-mix(in srgb, var(--ink) 8%, transparent);
+}
+
+.planned-row:last-child {
+    border-bottom: none;
+}
+
+.planned-pos {
+    min-width: 42px;
+    font-size: 0.7rem;
+    font-weight: 800;
+    letter-spacing: 0.04em;
+    color: var(--ink-muted);
+}
+
+/* Who leaves is settled information; who arrives is the thing to act on. */
+.planned-off {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--ink-muted);
+    text-decoration: line-through;
+}
+
+.planned-arrow {
+    flex: none;
+    color: var(--ink-faint);
+}
+
+.planned-on {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-weight: 700;
+    color: var(--ink);
+}
+
+/* Position shuffles, listed as chips under the swaps so they read as a footnote to them */
+.planned-moves {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 6px;
+    margin-top: 10px;
+}
+
+.planned-moves-label {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    color: var(--ink-muted);
+}
+
+.planned-move {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 2px 10px;
+    border-radius: 999px;
+    font-size: 0.8rem;
+    font-weight: 600;
+    background: color-mix(in srgb, var(--ink) 7%, transparent);
+    color: var(--ink);
+}
+
+.planned-move-pos {
+    font-size: 0.7rem;
+    font-weight: 800;
+    color: var(--ink-muted);
+}
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor b/src/FootballFormation.UI/Pages/LiveMatch.razor
index e3bfd68..bd69f09 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor
@@ -174,33 +174,7 @@
         {
             <MudPaper Class="pa-4" Elevation="2" Style="border-radius: 16px;">
                 <div class="card-label">@L["Changes at half-way"]</div>
-                <div class="live-planned">
-                    @foreach (var change in planned.Substitutions)
-                    {
-                        <div class="live-planned-row">
-                            <span class="live-planned-pos">@change.Position.ToString()</span>
-                            <span class="live-planned-off">@(change.PlayerOff?.ShortName ?? "—")</span>
-                            @* Plain text, not a MudIcon: scoped CSS never reaches a child component's root element. *@
-                            <span class="live-planned-arrow">→</span>
-                            <span class="live-planned-on">@(change.PlayerOn?.ShortName ?? "—")</span>
-                        </div>
-                    }
-                </div>
-
-                @* Secondary: nobody leaves the pitch, so this never competes with the swaps above. *@
-                @if (planned.Moves.Count > 0)
-                {
-                    <div class="live-planned-moves">
-                        <span class="live-planned-moves-label">@L["Position changes"]</span>
-                        @foreach (var move in planned.Moves)
-                        {
-                            <span class="live-planned-move">
-                                @move.Player.ShortName
-                                <span class="live-planned-move-pos">@move.From.ToString() → @move.To.ToString()</span>
-                            </span>
-                        }
-                    </div>
-                }
+                <PlannedChangesList Changes="planned" />
             </MudPaper>
         }
     </AuthorizeView>
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
index 01624a9..3393f51 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.cs
@@ -325,8 +325,19 @@ private async Task EndPeriod() =>
     private async Task StartNextPeriod() =>
         Snackbar.Report(L, await ClockService.StartNextPeriodAsync(GameId), L["Next period started"]);
 
-    private async Task AdvancePeriod() =>
+    /// <summary>
+    /// Rolls the next planned line-up onto the pitch, after showing what that changes. Confirmed
+    /// rather than immediate because it is the one control here with no way back: advancing a
+    /// period rewrites who is on, and the timeline records no such event to undo.
+    /// </summary>
+    private async Task AdvancePeriod()
+    {
+        var confirmed = await DialogService.PromptValueAsync<LiveNextLineupDialog, bool>(
+            L["Next line-up"], p => p.Add(x => x.Changes, PlannedChanges));
+        if (confirmed is null) return;
+
         Snackbar.Report(L, await ClockService.AdvancePeriodAsync(GameId), L["Next period started"]);
+    }
 
     private async Task FinishMatch()
     {
diff --git a/src/FootballFormation.UI/Pages/LiveMatch.razor.css b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
index ee28273..851db8b 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor.css
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor.css
@@ -158,94 +158,6 @@
     color: var(--ink-muted);
 }
 
-/* Changes due halfway through the half, read off the planned line-ups */
-.live-planned {
-    display: flex;
-    flex-direction: column;
-}
-
-.live-planned-row {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    padding: 6px 0;
-    font-size: 0.85rem;
-    border-bottom: 1px solid color-mix(in srgb, var(--ink) 8%, transparent);
-}
-
-.live-planned-row:last-child {
-    border-bottom: none;
-}
-
-.live-planned-pos {
-    min-width: 42px;
-    font-size: 0.7rem;
-    font-weight: 800;
-    letter-spacing: 0.04em;
-    color: var(--ink-muted);
-}
-
-/* Who leaves is settled information; who arrives is the thing to act on. */
-.live-planned-off {
-    flex: 1;
-    min-width: 0;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    color: var(--ink-muted);
-    text-decoration: line-through;
-}
-
-.live-planned-arrow {
-    flex: none;
-    color: var(--ink-faint);
-}
-
-.live-planned-on {
-    flex: 1;
-    min-width: 0;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    font-weight: 700;
-    color: var(--ink);
-}
-
-/* Position shuffles, listed as chips under the swaps so they read as a footnote to them */
-.live-planned-moves {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: center;
-    gap: 6px;
-    margin-top: 10px;
-}
-
-.live-planned-moves-label {
-    font-size: 0.7rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    letter-spacing: 0.04em;
-    color: var(--ink-muted);
-}
-
-.live-planned-move {
-    display: inline-flex;
-    align-items: center;
-    gap: 4px;
-    padding: 2px 10px;
-    border-radius: 999px;
-    font-size: 0.8rem;
-    font-weight: 600;
-    background: color-mix(in srgb, var(--ink) 7%, transparent);
-    color: var(--ink);
-}
-
-.live-planned-move-pos {
-    font-size: 0.7rem;
-    font-weight: 800;
-    color: var(--ink-muted);
-}
-
 /* The two big scoring buttons */
 .live-actions {
     display: flex;
diff --git a/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor
new file mode 100644
index 0000000..cbf521b
--- /dev/null
+++ b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor
@@ -0,0 +1,28 @@
+@inject IStringLocalizer<Strings> L
+
+<MudDialog>
+    <DialogContent>
+        <MudText Typo="Typo.body2">
+            @L["The line-up planned for the rest of this half takes over. The clock keeps running."]
+        </MudText>
+
+        @if (Changes.IsEmpty)
+        {
+            <MudText Typo="Typo.body2" Class="mt-3" Style="color: var(--ink-muted);">
+                @L["Nobody changes — the next line-up is the one already on the pitch."]
+            </MudText>
+        }
+        else
+        {
+            <div class="next-lineup-changes">
+                <PlannedChangesList Changes="Changes" />
+            </div>
+        }
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="Cancel">@L["Cancel"]</MudButton>
+        <MudButton Color="Color.Primary" Variant="Variant.Filled" OnClick="Accept">
+            @L["Next line-up"]
+        </MudButton>
+    </DialogActions>
+</MudDialog>
diff --git a/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.cs b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.cs
new file mode 100644
index 0000000..bd07888
--- /dev/null
+++ b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.cs
@@ -0,0 +1,24 @@
+using FootballFormation.Core.Reporting;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+
+namespace FootballFormation.UI.Pages;
+
+/// <summary>
+/// Shows what rolling on to the next line-up will actually do, and asks first. The button used to
+/// carry it out on the tap, which meant reading the card further down the screen to find out what
+/// was about to change — and there is no undo for a period that has been advanced.
+/// </summary>
+public partial class LiveNextLineupDialog
+{
+    [CascadingParameter]
+    private IMudDialogInstance MudDialog { get; set; } = null!;
+
+    /// <summary>The swaps and moves the next period's line-up implies, measured against the pitch.</summary>
+    [Parameter, EditorRequired]
+    public PlannedChanges Changes { get; set; } = PlannedChanges.None;
+
+    private void Accept() => MudDialog.Close(DialogResult.Ok(true));
+
+    private void Cancel() => MudDialog.Cancel();
+}
diff --git a/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.css b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.css
new file mode 100644
index 0000000..c5dac38
--- /dev/null
+++ b/src/FootballFormation.UI/Pages/LiveNextLineupDialog.razor.css
@@ -0,0 +1,5 @@
+/* The list is a child component, so only its wrapper can be reached from here — which is all the
+   spacing this dialog needs. */
+.next-lineup-changes {
+    margin-top: 12px;
+}
diff --git a/src/FootballFormation.UI/Strings.nl.resx b/src/FootballFormation.UI/Strings.nl.resx
index b0805a8..2e48d39 100644
--- a/src/FootballFormation.UI/Strings.nl.resx
+++ b/src/FootballFormation.UI/Strings.nl.resx
@@ -194,6 +194,8 @@
   <data name="Start {0}" xml:space="preserve"><value>{0} starten</value></data>
   <data name="Next line-up" xml:space="preserve"><value>Volgende opstelling</value></data>
   <data name="Changes at half-way" xml:space="preserve"><value>Wissels halverwege</value></data>
+  <data name="The line-up planned for the rest of this half takes over. The clock keeps running." xml:space="preserve"><value>De opstelling die voor de rest van deze helft gepland staat neemt het over. De klok loopt door.</value></data>
+  <data name="Nobody changes — the next line-up is the one already on the pitch." xml:space="preserve"><value>Er verandert niemand — de volgende opstelling is die al in het veld staat.</value></data>
   <data name="Position changes" xml:space="preserve"><value>Positiewissels</value></data>
   <data name="Finish match" xml:space="preserve"><value>Wedstrijd afsluiten</value></data>
   <data name="Edit result" xml:space="preserve"><value>Uitslag aanpassen</value></data>
diff --git a/tests/ui/helpers.js b/tests/ui/helpers.js
index f0c9a5f..9314465 100644
--- a/tests/ui/helpers.js
+++ b/tests/ui/helpers.js
@@ -160,7 +160,7 @@ export async function playerMenuItem(page, name, item) {
  * list is keyed on visually. Only the opponent is required; the rest of the form is already filled
  * in from the season's preferences, which is the point of those defaults.
  */
-export async function createMatch(page, { opponent, venue, matchType } = {}) {
+export async function createMatch(page, { opponent, venue, matchType, split } = {}) {
   await goto(page, '/games');
   const panel = page.locator('.mud-dialog');
   await clickFor(page.getByRole('button', { name: 'Add' }).first(), () => expect(panel).toBeVisible());
@@ -168,6 +168,9 @@ export async function createMatch(page, { opponent, venue, matchType } = {}) {
   await fillField(panel, 'Opponent', opponent);
   if (venue) await chooseOption(page, panel, 'Venue', venue);
   if (matchType) await chooseOption(page, panel, 'Match Type', matchType);
+  // "Quarters" is the split that gives a half two line-ups, and so the only one whose live screen
+  // ever offers "Next line-up".
+  if (split) await chooseOption(page, panel, 'Game Split', split);
   await submitDialog(page);
 
   await expect(gameRow(page, opponent)).toBeVisible();
diff --git a/tests/ui/specs/match-day.spec.js b/tests/ui/specs/match-day.spec.js
index 27a30d8..30a3406 100644
--- a/tests/ui/specs/match-day.spec.js
+++ b/tests/ui/specs/match-day.spec.js
@@ -8,8 +8,8 @@ import { test, expect } from '../fixtures.js';
 import { chooseOption, clickFor, createMatch, gameRow, goto, openDialog, submitDialog } from '../helpers.js';
 
 /** Creates a match and returns its id, read from the URL its own formation button navigates to. */
-async function matchWithId(page, opponent) {
-  await createMatch(page, { opponent });
+async function matchWithId(page, opponent, options = {}) {
+  await createMatch(page, { opponent, ...options });
   await gameRow(page, opponent).getByTitle(/Formation|Add lineup/).click();
   await page.waitForURL(/\/games\/\d+\/formation/);
   return Number(page.url().match(/\/games\/(\d+)\//)[1]);
@@ -146,6 +146,60 @@ test('tapping a player on the pitch offers a substitution and a position swap',
   await expect(page.locator('.live-event')).toHaveCount(0);
 });
 
+test('"Next line-up" says what it is about to change, and cancelling changes nothing', async ({ page }) => {
+  // Quarters, so the first half is planned as two line-ups and the mid-half control appears.
+  const id = await matchWithId(page, 'FC Kwarten', { split: 'Quarters' });
+
+  const available = page.locator('.draggable-player');
+  const emptySlots = page.locator('.pitch .pitch-empty');
+  const chips = page.locator('.pitch .pitch-player');
+
+  // Q1 takes the front of the squad list and Q2 the back, so the two line-ups genuinely differ and
+  // the dialog has changes to list.
+  await expect(available.first()).toBeVisible();
+  for (let i = 0; i < 3; i++) {
+    await available.first().dragTo(emptySlots.first());
+    await expect(chips).toHaveCount(i + 1);
+  }
+  await clickFor(page.getByRole('tab').nth(1), () => expect(chips).toHaveCount(0));
+  for (let i = 0; i < 3; i++) {
+    await available.last().dragTo(emptySlots.first());
+    await expect(chips).toHaveCount(i + 1);
+  }
+  await clickFor(
+    page.getByRole('button', { name: /^Save( All Lineups)?$/ }).first(),
+    () => expect(page.getByText('All lineups saved', { exact: false })).toBeVisible(),
+    { settle: 10_000 },
+  );
+
+  await goto(page, `/games/${id}/live`);
+  const nextLineup = page.locator('.live-controls').getByRole('button', { name: 'Next line-up' });
+  await clickFor(
+    page.getByRole('button', { name: 'Start match' }),
+    () => expect(nextLineup).toBeVisible(),
+  );
+
+  await clickFor(nextLineup, () => expect(page.locator('.mud-dialog')).toBeVisible());
+  const dialog = await openDialog(page);
+
+  // The point of the dialog: the changes are in it, not on a card further down the screen.
+  await expect(dialog.locator('.planned-row').first()).toBeVisible();
+
+  await clickFor(
+    dialog.getByRole('button', { name: 'Cancel' }),
+    () => expect(page.locator('.mud-dialog')).toHaveCount(0),
+  );
+  // Still the first quarter — cancelling a change with no undo has to actually cancel it.
+  await expect(nextLineup).toBeVisible();
+
+  await clickFor(nextLineup, () => expect(page.locator('.mud-dialog')).toBeVisible());
+  await submitDialog(page, 'Next line-up');
+  await expect(page.getByText('Next period started', { exact: false })).toBeVisible();
+
+  // The second quarter is the last of the half, so the control it now offers is half time.
+  await expect(page.locator('.live-controls').getByRole('button', { name: 'Half time' })).toBeVisible();
+});
+
 test('the bench strip can be folded away while the match is being run', async ({ page }) => {
   const id = await matchWithId(page, 'FC Bank');
   await fillLineup(page, 2);
diff --git a/tests/ui/specs/selectors.spec.js b/tests/ui/specs/selectors.spec.js
index 16fe476..d7c9155 100644
--- a/tests/ui/specs/selectors.spec.js
+++ b/tests/ui/specs/selectors.spec.js
@@ -31,7 +31,8 @@ const SELECTORS = {
   'the formation builder': ['pitch', 'pitch-empty', 'pitch-player', 'draggable-player'],
   'the playing-time table': ['playtime-table', 'pt-total', 'playtime-note'],
   'the live screen': ['live-lineup', 'live-controls', 'live-score-value', 'live-score-away',
-                      'live-event', 'live-event-score', 'live-bench', 'live-bench-toggle'],
+                      'live-event', 'live-event-score', 'live-bench', 'live-bench-toggle',
+                      'planned-row'],
   'the phone layout': ['dialog-sheet', 'stacked-table', 'topbar-nav'],
   'the squad': ['badge-archived'],
 };

From 496a609305fdc8faa640ed89a066b2b67089bf61 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 11 Aug 2026 19:47:33 +0000
Subject: [PATCH 4/4] Fix what a position swap breaks in the two places that
 read substitution rows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A swap moves two players between slots and writes nothing down, which is
right — nobody left the pitch. But two readers took the rows for the whole
story.

RemoveSubstitutionAsync handed back the slot the substitution recorded. Sub
into slot 5, swap that player to slot 0, then undo, and two players ended up
in slot 5 with slot 0 empty — the exact "an older swap fights every change
made on that slot since" the guard above it exists to prevent, arriving by a
route the guard cannot see. It now reads the slot and position off the player
coming off, which is a no-op when nothing moved them.

GameMinutesReport seeds from the lineup as it finally stands, so a swap
credits the position moved *into* for the whole period, earlier minutes
included. Both comments claimed the opposite. Corrected, and pinned with a
test so the claim and the behaviour cannot drift apart again.

AdvancePeriodAsync leaves the clock anchor alone on purpose, which was safe
while pause existed to set it back. A row an older build left paused would
now roll on to the next line-up with the clock frozen — banking no minutes
for the rest of the half, while the new dialog promises it keeps running. It
restarts a stopped anchor, and does nothing to a game that was never paused.
---
 CLAUDE.md                                     |  2 +-
 docs/architecture.md                          |  3 +-
 docs/known_issues.md                          | 17 ++++++++++
 docs/ui_components.md                         |  7 +++-
 .../Reporting/GameMinutesReport.cs            | 14 ++++----
 .../Services/MatchClockService.cs             |  7 ++++
 .../Services/MatchSubstitutionService.cs      | 21 +++++++++---
 .../GameMinutesReportTests.cs                 | 27 ++++++++++++++++
 .../MatchClockServiceTests.cs                 | 29 +++++++++++++++++
 .../MatchSubstitutionServiceTests.cs          | 32 +++++++++++++++++++
 10 files changed, 145 insertions(+), 14 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 7c1aa3e..f2a7b3e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -16,7 +16,7 @@ as in the markup. The UI is Dutch by default with English available.
 
 ```bash
 dotnet build -c Release        # what CI builds — warnings are errors here (see below)
-dotnet test                    # 386 tests, xUnit v3, real SQLite
+dotnet test                    # 389 tests, xUnit v3, real SQLite
 cd src/FootballFormation.Web && dotnet run     # http://localhost:5228
 cd tests/ui && npm test        # 37 Playwright tests in a browser, ~1 min (npm install first)
 scripts/visual-check.sh        # screenshots every page, then measures every touch target
diff --git a/docs/architecture.md b/docs/architecture.md
index 0f76327..8c5cf17 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -79,7 +79,8 @@ Services/
                             and the recomputed scoreline added here
   MatchSubstitutionService.cs — The slot swap and the record of it, in one SaveChanges, plus undoing
                             the most recent one of a period, plus SwapPositionsAsync — two players
-                            already on trading slots, which writes no substitution row
+                            already on trading slots, which writes no substitution row (so the undo
+                            reads the slot back off the pitch, not off the row)
   LiveMatchOperation.cs   — The write shape those three share: RunAdminAsync plus, on success, one
                             LiveMatchNotifier call naming the game that changed
   LiveMatchQueries.cs     — The tracked load they all start from (the game with its periods, via
diff --git a/docs/known_issues.md b/docs/known_issues.md
index 439796f..67e6fd8 100644
--- a/docs/known_issues.md
+++ b/docs/known_issues.md
@@ -295,6 +295,23 @@ Avoid repeating these mistakes:
   MudBlazor component's root goes in `app.css`, next to `.live-scoreboard` and `.live-action-btn`,
   which are there for the same reason.
 
+## Live match
+- **A change to the pitch that writes no row is invisible to everything that reads the rows.**
+  `SwapPositionsAsync` moves two players between slots without a `GameSubstitution`, which is right
+  — nobody left the pitch — but two readers assumed the rows were the whole story.
+  `RemoveSubstitutionAsync` handed back the slot the *substitution* recorded, so subbing into slot
+  5, swapping that player to slot 0 and then undoing seated two players in slot 5 and emptied
+  slot 0; it now reads the slot off the player coming off instead. And `GameMinutesReport` seeds
+  from the lineup as it finally stands, so a swap credits **the position moved into** for the whole
+  period, earlier minutes included — the opposite of what its comment used to claim. Totals are
+  right either way; only the split by position is affected, and a test pins it.
+- **Removing a control does not remove the state it could leave behind.** Deleting pause/resume
+  left `MatchState=InProgress` + a live period + `ClockRunningSince=null` unreachable going
+  forward, but still storable by a row an older build wrote. `AdvancePeriodAsync` deliberately
+  leaves the anchor alone — so on such a row it would roll on to the next line-up with the clock
+  still frozen, banking no minutes for the rest of the half while the dialog promised the opposite.
+  It now restarts a stopped anchor, which is a no-op for every game that was never paused.
+
 ## General
 - **Port already in use**: Kill orphaned process with `taskkill //PID <pid> //F`.
 - **File locked during build**: Stop the running app before rebuilding.
diff --git a/docs/ui_components.md b/docs/ui_components.md
index f77a7e5..49d2b94 100644
--- a/docs/ui_components.md
+++ b/docs/ui_components.md
@@ -133,7 +133,12 @@ watches the same URL read-only. Every control sits in an `<AuthorizeView Roles="
   (`SwapPositionsAsync`). Choosing in either list clears the other, so the single action button
   always has exactly one change to make and says which — "Make substitution" or "Swap positions".
   A position swap writes no `GameSubstitution`: nobody's minutes changed, and a row there would say
-  they did. Each select's `Placeholder` is set **only** when its list is empty — MudSelect shows a
+  they did. The price is the *split by position* — `GameMinutesReport` reads the lineup as it finally
+  stands, so after a swap the whole period is credited to the position each player moved **into**
+  (pinned by `A_position_change_with_no_substitution_credits_the_position_it_ended_in`). Totals are
+  unaffected. Undoing a substitution therefore follows the slot rather than the recorded one: a swap
+  can have moved it since, and handing the recorded slot back would seat two players in it.
+  Each select's `Placeholder` is set **only** when its list is empty — MudSelect shows a
   placeholder whenever nothing is chosen, so a standing "nobody is on the bench" greets a full bench.
 - **Every goal on the timeline carries the score it made it** (`ScoreProgressionReport`), in the
   scoreboard's order — home side first. It is counted forwards over the whole match and looked up
diff --git a/src/FootballFormation.Core/Reporting/GameMinutesReport.cs b/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
index 85d6245..e37a768 100644
--- a/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
+++ b/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
@@ -46,12 +46,14 @@ public int SecondsFor(int playerId) =>
 /// its lineup a full period's minutes would invent playing time.
 /// </para>
 /// <para>
-/// Known limitation: only a substitution records a position change, so a player who shifts
-/// position mid-period without one keeps the earlier position for those minutes. The live screen's
-/// position swap (<c>MatchSubstitutionService.SwapPositionsAsync</c>) is exactly that case: it
-/// rewrites the lineup and writes nothing down, because a <see cref="GameSubstitution"/> would say
-/// someone left the pitch. Totals stay right; the per-position split lags a swap. That is a gap in
-/// what gets recorded, not in this calculation.
+/// Known limitation: only a substitution records a position change. The walk below starts from the
+/// lineup as it <em>finally</em> stands and rewinds substitution rows, so a player who shifts
+/// position mid-period without one is credited the position they ended in for the whole period,
+/// the minutes before the shift included. The live screen's position swap
+/// (<c>MatchSubstitutionService.SwapPositionsAsync</c>) is exactly that case: it rewrites the
+/// lineup and writes nothing down, because a <see cref="GameSubstitution"/> would say someone left
+/// the pitch. Totals stay right; only the split by position does. That is a gap in what gets
+/// recorded, not in this calculation.
 /// </para>
 /// </summary>
 public static class GameMinutesReport
diff --git a/src/FootballFormation.Core/Services/MatchClockService.cs b/src/FootballFormation.Core/Services/MatchClockService.cs
index b9e0bf0..cf743e7 100644
--- a/src/FootballFormation.Core/Services/MatchClockService.cs
+++ b/src/FootballFormation.Core/Services/MatchClockService.cs
@@ -144,6 +144,13 @@ public Task<Result<Game>> AdvancePeriodAsync(int gameId, CancellationToken cance
             next.EndedAtSeconds = null;
             game.LivePeriodId = next.Id;
 
+            // Nothing this app still does can stop a live period's clock, but a row stored by a
+            // build that had a pause button can be in exactly that state — and rolling on to the
+            // next line-up while the clock stayed frozen would bank no minutes for the rest of the
+            // half. Restarting the anchor from the banked total is what "the clock keeps running"
+            // means, and it is a no-op for every game that was not left paused.
+            game.ClockRunningSince ??= UtcNow;
+
             await db.SaveChangesAsync(cancellationToken);
             logger.LogInformation("Game {GameId} rolled from period {From} into {To} at {Seconds}s",
                 gameId, current.Id, next.Id, elapsed);
diff --git a/src/FootballFormation.Core/Services/MatchSubstitutionService.cs b/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
index 5c6a39e..b697dc6 100644
--- a/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
+++ b/src/FootballFormation.Core/Services/MatchSubstitutionService.cs
@@ -109,9 +109,13 @@ public Task<Result<GameSubstitution>> SubstituteAsync(
     /// <summary>
     /// Swaps the pitch slots — and with them the positions — of two players who are both already
     /// on. Nobody enters or leaves the match, so this writes no <see cref="GameSubstitution"/>:
-    /// the rows exist to say who was on the pitch when, and a shuffle changes none of that. What
-    /// it does cost is the position half of the minutes report, which keeps crediting both players
-    /// the position they started the period in (see <c>GameMinutesReport</c>).
+    /// the rows exist to say who was on the pitch when, and a shuffle changes none of that.
+    /// <para>
+    /// What it costs is the position half of the minutes report. <c>GameMinutesReport</c> reads the
+    /// lineup as it finally stands and rewinds only substitution rows, so after a swap each player
+    /// is credited the position they moved <em>into</em> for the whole period — including the
+    /// minutes before the swap. Totals are unaffected; only the split by position is.
+    /// </para>
     /// </summary>
     public Task<Result> SwapPositionsAsync(
         int gameId, int playerAId, int playerBId, CancellationToken cancellationToken = default) =>
@@ -180,6 +184,13 @@ public Task<Result> RemoveSubstitutionAsync(int subId, CancellationToken cancell
             var on = positions.FirstOrDefault(pp => pp.PlayerId == sub.PlayerOnId);
             var off = positions.FirstOrDefault(pp => pp.PlayerId == sub.PlayerOffId);
 
+            // Where the incoming player is standing *now*, not where they came on. A position swap
+            // moves a slot without writing a row here, so the slot this substitution recorded may
+            // belong to somebody else by now — handing it back would put two players in it and
+            // leave another empty. The recorded slot is only the fallback for a missing row.
+            var slot = on?.SlotIndex ?? sub.SlotIndex;
+            var position = on is { IsSubstitute: false } ? on.Position : sub.Position;
+
             if (on is not null)
             {
                 on.SlotIndex = null;
@@ -188,8 +199,8 @@ public Task<Result> RemoveSubstitutionAsync(int subId, CancellationToken cancell
 
             if (off is not null)
             {
-                off.SlotIndex = sub.SlotIndex;
-                off.Position = sub.Position;
+                off.SlotIndex = slot;
+                off.Position = position;
                 off.IsSubstitute = false;
             }
 
diff --git a/tests/FootballFormation.Core.Tests/GameMinutesReportTests.cs b/tests/FootballFormation.Core.Tests/GameMinutesReportTests.cs
index acf4810..5eed6d6 100644
--- a/tests/FootballFormation.Core.Tests/GameMinutesReportTests.cs
+++ b/tests/FootballFormation.Core.Tests/GameMinutesReportTests.cs
@@ -104,6 +104,33 @@ public void Minutes_are_attributed_to_the_position_actually_held()
         Assert.Equal(1200, minutes.PositionsFor(2)[PlayerPosition.ST]);
     }
 
+    [Fact]
+    public void A_position_change_with_no_substitution_credits_the_position_it_ended_in()
+    {
+        // The known limitation this report documents, pinned so it cannot change unnoticed. The
+        // live screen's position swap rewrites the lineup and records nothing, and the walk below
+        // starts from the lineup as it finally stands — so the whole period is credited to the
+        // position each player *moved into*, the minutes before the swap included.
+        var game = TestData.Game();
+        var period = game.AddPeriod(PeriodType.FirstHalf,
+            TestData.Starter(1, PlayerPosition.CM, 5),      // started in goal, swapped at half-way
+            TestData.Starter(2, PlayerPosition.GK, 0));     // and the other way round
+
+        period.StartedAtSeconds = 0;
+        period.EndedAtSeconds = 1200;
+
+        var minutes = GameMinutesReport.Build(game);
+
+        Assert.Equal(new Dictionary<PlayerPosition, int> { [PlayerPosition.CM] = 1200 },
+            minutes.PositionsFor(1));
+        Assert.Equal(new Dictionary<PlayerPosition, int> { [PlayerPosition.GK] = 1200 },
+            minutes.PositionsFor(2));
+
+        // The totals — what the season's statistics are actually built from — are untouched.
+        Assert.Equal(1200, minutes.SecondsFor(1));
+        Assert.Equal(1200, minutes.SecondsFor(2));
+    }
+
     [Fact]
     public void Two_substitutions_in_the_same_second_subtract_no_time()
     {
diff --git a/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs b/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
index ab46b06..cbda286 100644
--- a/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
+++ b/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
@@ -151,6 +151,35 @@ public async Task Advancing_between_quarters_loses_no_seconds()
         Assert.True(advanced.IsClockRunning);
     }
 
+    [Fact]
+    public async Task Advancing_restarts_a_clock_that_an_older_build_left_stopped()
+    {
+        // Nothing here can stop a live period's clock any more, but a row written while there was
+        // a pause button can be in exactly that state. Rolling on to the next line-up while the
+        // anchor stayed null would bank no minutes for the rest of the half.
+        var game = await SeedGameAsync(GameSplitType.Quarters);
+        await MatchClock.StartMatchAsync(game.Id);
+
+        Time.Advance(TimeSpan.FromMinutes(15));
+
+        // Through ReloadAsync, which clears the change tracker first: the copy this context has
+        // held since the seed still reads ClockRunningSince = null, so assigning null to *that*
+        // is not a change EF would detect, and the anchor the service wrote would survive.
+        var paused = await ReloadAsync(game.Id);
+        paused.ClockAccumulatedSeconds = 900;
+        paused.ClockRunningSince = null;
+        await Db.SaveChangesAsync();
+
+        Assert.True((await MatchClock.AdvancePeriodAsync(game.Id)).IsSuccess);
+
+        var advanced = await ReloadAsync(game.Id);
+        Assert.True(advanced.IsClockRunning);
+        Assert.Equal(900, advanced.Periods.OrderBy(p => p.PeriodType).ToList()[1].StartedAtSeconds);
+
+        Time.Advance(TimeSpan.FromMinutes(5));
+        Assert.Equal(1200, advanced.ElapsedSecondsAt(Time.GetUtcNow().UtcDateTime));
+    }
+
     [Fact]
     public async Task Advancing_past_the_last_period_is_refused()
     {
diff --git a/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs b/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
index 85be83e..f7cd2a8 100644
--- a/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
+++ b/tests/FootballFormation.Core.Tests/MatchSubstitutionServiceTests.cs
@@ -206,6 +206,38 @@ public async Task Undoing_the_most_recent_substitution_restores_the_slot()
         Assert.Empty(await Db.GameSubstitutions.ToListAsync());
     }
 
+    [Fact]
+    public async Task Undoing_a_substitution_follows_the_slot_a_later_position_swap_moved_it_to()
+    {
+        var game = await SeedGameAsync();
+        await MatchClock.StartMatchAsync(game.Id);
+        var players = await PlayersAsync();
+
+        // players[1] holds slot 5, players[0] slot 0. Bring players[2] on for players[1], then let
+        // them swap with the keeper — so the slot the substitution recorded is somebody else's now.
+        Time.Advance(TimeSpan.FromMinutes(10));
+        var sub = await Subs.SubstituteAsync(game.Id, players[1].Id, players[2].Id);
+        Assert.True((await Subs.SwapPositionsAsync(game.Id, players[2].Id, players[0].Id)).IsSuccess);
+
+        Assert.True((await Subs.RemoveSubstitutionAsync(sub.Value!.Id)).IsSuccess);
+
+        Db.ChangeTracker.Clear();
+        var live = await ReloadAsync(game.Id);
+        var period = await Db.GamePeriods
+            .Include(p => p.PlayerPositions)
+            .FirstAsync(p => p.Id == live.LivePeriodId);
+
+        var starters = period.PlayerPositions.Where(p => !p.IsSubstitute).ToList();
+
+        // Handing back the recorded slot would have put players[1] into slot 5 alongside players[0]
+        // and left slot 0 empty. They take over where the player coming off was actually standing.
+        Assert.Equal(starters.Count, starters.Select(p => p.SlotIndex).Distinct().Count());
+        Assert.Equal(0, starters.Single(p => p.PlayerId == players[1].Id).SlotIndex);
+        Assert.Equal(PlayerPosition.GK, starters.Single(p => p.PlayerId == players[1].Id).Position);
+        Assert.Equal(5, starters.Single(p => p.PlayerId == players[0].Id).SlotIndex);
+        Assert.True(period.PlayerPositions.Single(p => p.PlayerId == players[2].Id).IsSubstitute);
+    }
+
     [Fact]
     public async Task Only_the_most_recent_substitution_of_a_period_can_be_undone()
     {