diff --git a/CLAUDE.md b/CLAUDE.md
index 9313dd2..f2a7b3e 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        # 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, ~34 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 7a0a128..8c5cf17 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -52,7 +52,10 @@ 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
                            the rule that pending migrations mean unhealthy. Pure, so it is tested
 Services/
@@ -68,13 +71,16 @@ 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
-                            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 (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
@@ -104,7 +110,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)
@@ -117,6 +126,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/known_issues.md b/docs/known_issues.md
index d9ec2c7..67e6fd8 100644
--- a/docs/known_issues.md
+++ b/docs/known_issues.md
@@ -286,6 +286,31 @@ 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.
+
+## 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`.
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 ec06d3d..49d2b94 100644
--- a/docs/ui_components.md
+++ b/docs/ui_components.md
@@ -107,14 +107,50 @@ 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. 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
+  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`:
+  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. 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
+  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.Core/Models/Game.cs b/src/FootballFormation.Core/Models/Game.cs
index d541965..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));
@@ -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..e37a768 100644
--- a/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
+++ b/src/FootballFormation.Core/Reporting/GameMinutesReport.cs
@@ -46,9 +46,14 @@ 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. 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/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/MatchClockService.cs b/src/FootballFormation.Core/Services/MatchClockService.cs
index 930e09b..cf743e7 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",
@@ -181,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 eea0d1d..b697dc6 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,53 @@ 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.
+    /// <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) =>
+        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.
@@ -136,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;
@@ -144,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/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 38a0d9f..bd69f09 100644
--- a/src/FootballFormation.UI/Pages/LiveMatch.razor
+++ b/src/FootballFormation.UI/Pages/LiveMatch.razor
@@ -61,20 +61,6 @@
                 <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
-                        {
-                            <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)
@@ -88,7 +74,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 +119,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 +128,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>
 
@@ -177,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>
@@ -266,6 +237,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..3393f51 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.
@@ -158,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"
     };
@@ -227,7 +239,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
@@ -263,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;
@@ -302,20 +319,25 @@ 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);
-
-    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);
 
     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()
     {
@@ -353,27 +375,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;
+
+        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, playerOffId, playerOnId.Value);
+        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..851db8b 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;
 }
@@ -109,24 +106,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;
@@ -165,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;
@@ -301,6 +206,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/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/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..2e48d39 100644
--- a/src/FootballFormation.UI/Strings.nl.resx
+++ b/src/FootballFormation.UI/Strings.nl.resx
@@ -187,25 +187,25 @@
   <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="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="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>
   <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,8 +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>
   <data name="Match finished" xml:space="preserve"><value>Wedstrijd afgesloten</value></data>
@@ -233,6 +231,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 +443,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>
@@ -459,12 +464,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>
@@ -513,16 +515,15 @@
   <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>
+  <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/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/LiveMatchNotificationTests.cs b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
index 03259f1..be2e351 100644
--- a/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
+++ b/tests/FootballFormation.Core.Tests/LiveMatchNotificationTests.cs
@@ -32,15 +32,15 @@ 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);
         Assert.True((await MatchClock.EndPeriodAsync(game.Id)).IsSuccess);
         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);
+        // Ten writes, ten announcements, each naming this match.
+        Assert.Equal(10, _announced.Count);
         Assert.All(_announced, id => Assert.Equal(game.Id, id));
     }
 
@@ -52,10 +52,11 @@ 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);
+        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/MatchClockServiceTests.cs b/tests/FootballFormation.Core.Tests/MatchClockServiceTests.cs
index eff00fa..cbda286 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 ---------------------------------------------------------------------------
@@ -193,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 b1d7ccc..f7cd2a8 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()
     {
@@ -124,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()
     {
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/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 d979ab6..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]);
@@ -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,107 @@ 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('"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);
+
+  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..d7c9155 100644
--- a/tests/ui/specs/selectors.spec.js
+++ b/tests/ui/specs/selectors.spec.js
@@ -30,7 +30,9 @@ 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',
+                      'planned-row'],
   'the phone layout': ['dialog-sheet', 'stacked-table', 'topbar-nav'],
   'the squad': ['badge-archived'],
 };