diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 5a2938d96..db5d93b19 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -18,7 +18,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v7
         with:
-          go-version: "1.27.1"
+          go-version: "1.27.2"
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v7
         with:
diff --git a/.github/workflows/validate.yaml b/.github/workflows/validate.yaml
index d245d41e5..8f9755bef 100644
--- a/.github/workflows/validate.yaml
+++ b/.github/workflows/validate.yaml
@@ -22,7 +22,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v7
         with:
-          go-version: "1.27.1"
+          go-version: "1.27.2"
 
       - name: Init project
         run: |
@@ -62,7 +62,7 @@ jobs:
           # (the Makefile's pin, used by `make go/lint` locally) did not.
           # Keep this in lockstep with the `go install` version in
           # Makefile's go/lint target so a local green run predicts CI.
-          version: v2.13.1
+          version: v2.14.0
 
       #   ____             _
       #  |  _ \  ___   ___| | _____ _ __
@@ -111,7 +111,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v7
         with:
-          go-version: "1.27.1"
+          go-version: "1.27.2"
           cache: true
 
       - name: Init project
@@ -193,7 +193,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v7
         with:
-          go-version: "1.27.1"
+          go-version: "1.27.2"
           cache: true
 
       - name: Install LibreOffice headless
diff --git a/CLAUDE.md b/CLAUDE.md
index d9a481365..3eb098791 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -169,14 +169,15 @@ tournament-data/
 - **Tie-marking Rule**: A match (individual or sub-match) is a tie when the operator enters **'X'** (or 'x') in the "vs" column or when both sides finish with the same total score (equal character-count after stripping spaces/zeros/dashes). For auto-detection, at least one score cell in that row must be non-empty. A team match is automatically a draw (T=1) when both IV and PW totals are equal.
 - **Match Colors**: White (Shiro) is always the left column and Red (Aka) is always the right column (this is fixed and not configurable). In the Excel export, `helper.WhiteLeft` (`internal/helper/excel.go`) is the one Go owner of that side-to-column order; no mirror setting exists, and every side-ordered pair (entrant formulas and names, scores, fouls, result marks, header labels and styles, standings side records, a team summary's IV/PW) routes through it rather than restating the order. In pool matches the first-listed player (SideA) is Red; in elimination matches the upper-bracket player (`node.Left`) is Red. **A TINTED surface does not carry a SHIRO/AKA badge as well** (operator ruling 2026-09-20, bc-sccl, which SUPERSEDES bc-dnst's "named once in text, by the header badge"): where a side has a background tint, the tint plus Shiro's 45° hatch carry it, and the badge is redundant. Every side badge in the app went with that ruling: the score editors' header pill (`.sb-side__badge`), the engi card's (`.engi-side__badge`), the scores list and court console's (`.se-color-badge`) and the compact schedule's 14×14 `A`/`S` squares (`.tw-match__badge`). Bout rows and foul counters were already tint-only, so do not re-add per-bout SHIRO/AKA chips or "SHIRO Fouls" prefixes either. A tinted surface still names the side in TEXT for a screen reader — that is the one thing that must never be dropped with a badge (DESIGN.md §4: colour is never the only signal). The list of surfaces that carry no such text is short and closed: the TV board and the bracket card (both below, each by its own ruling), plus the watchlist hero, which names it VISIBLY instead. **`SideCell` (side_cell.jsx) owns this: a surface passes `side` and gets the fill class AND the `sr-only` label together, so the tint cannot arrive without its text; `SideLabel` is the label alone, for a surface that paints its own tint; `sideFillClass` is the class alone, for the watchlist hero only, which names the side visibly and so must not carry the span as well.** Do not hand-type either the class or the span -- that is how `"Shiro: "` and `"Shiro:"` came to coexist. **Use an `sr-only` span**, via that owner. An `aria-label` only works on an element whose role permits naming, and the cells this rule governs are bare `<div>`s, i.e. role `generic`, where ARIA PROHIBITS it: the court console carried `aria-label={`Shiro: …`}` on four such cells and the side was announced by nothing. An `aria-label` on an interactive wrapper is worse than useless here, because role=button has presentational children, so it REPLACES the side word, the competitor numbers and the dojos inside it — that is how the watchlist hero lost all of them. ONE exception, and it is about SIZE, not colour: the watchlist hero (`.wl-hero__side-lbl`) keeps a visible `Aka`/`Shiro` word (operator decision 2026-09-20). It is a large personal card read at arm's length, not a dense row, so the word costs it nothing -- which is the whole reason the ruling removed the badge from dense rows. Do not copy it onto a row. The exception this REPLACES was `.bc-color-badge`, justified by that card being dark navy; bc-wlhc made the card light and deleted the class, so the old wording named a surface that no longer existed. Controls that PICK a side (the "SHIRO wins"/"AKA wins" buttons, the decision side picker, the team summary band) keep naming it, as does the OBS lower third's heading. The TV board does NOT: its SHIRO/AKA headings went with the same ruling (position plus each name's colour carry it there, and a projector has no screen-reader audience), pinned by `side_is_carried_by_tint.test.jsx`'s "the TV board names no side". Aria-labels and titles may always say the side. The competitor number sits on the OUTER side of the name on every surface, Shiro's before it and Aka's after (operator ruling 2026-09-14, bc-dnst); `NumberedName` (numbered_name.jsx) owns it for JSX and `withNumber` (match_scoreboard.jsx) for strings, so a new surface calls one of those two and never restates the before/after choice. **Which of the two depends on one thing: does the cell CLIP?** A cell with `text-overflow: ellipsis` truncates the END of its run, which on Aka is the number, so the string form silently loses it there while Shiro's leading number survives. A clipping cell therefore passes `clip` to `NumberedName` (or, on the display surfaces, takes `sideLabelParts` from display_helpers.jsx), which makes the chip its own flex child so only the name ellipsises; a wrapping or unconstrained cell keeps the string. Both forms read the same `numberedParts`, so they cannot disagree about a side's name and number. The OBS lower third is MIXED on exactly this basis, not string-only (bc-rvfx): its team lines clip and chip, its individual lines do not clip and keep the string. The TV board WAS mixed on the same basis and is now chip-only (operator decision 2026-09-19, bc-lbty): its `NextPair` rows (the NEXT line and the UP NEXT pool bout list) still do not clip, but they render the non-clip `NumberedName` anyway, because a chipped row directly above a bare-string row read as an oversight rather than a choice. Clipping still decides `clip` vs plain; it no longer decides chip vs string, so do NOT infer from that exception that every non-clipping cell must chip -- the overlay's individual lines are the standing counter-example. **A chip takes the COLOUR of the name it rides beside** (operator decision 2026-09-19, bc-lbty): `.num-prefix` is `color: inherit` with its tint mixed from `currentColor` toward `transparent`, so Shiro's chip is dark and Aka's is red, and the chip never introduces colour the adjacent name does not already carry. The mix must stay transparency-based, never toward a solid light colour: the OBS lower third paints on `rgba(0,0,0,0.85)` with white and pale-pink text, where a white-mixed chip would be invisible. This supersedes the earlier mp-938b neutral-chip note, which the `.num-prefix` comment in styles.css no longer carries and which survives in git history only. Where the two sides STACK vertically instead of sitting left/right (the bracket card, the admin and public schedule rows) there is no outer side: the number sits before the name on both so the numbers align in a column, and the bracket card names no side in text, its leading colour bar and tint carry it (operator ruling 2026-09-14, bc-dnst).
 - **Excel Layout**: Uses an **8-column per court** layout. Columns A and G (and their court-shifted counterparts) are 30 units wide; others are 5 units wide. A blank row separates pools vertically.
-- **Team block bout rows** (`state.Competition.TeamBoutRows`, with `domain.KachinukiMaxBouts`): the ONE owner of how many numbered bout rows a team match's block has in any workbook: 0 for an individual competition, TeamSize for a team match, 2 x TeamSize - 1 for kachinuki (the most bouts a winner-stays-on encounter can take). `RenderCompetitionWorkbook` passes it to the renderers (the Pool Matches and Elimination Matches blocks, the 3rd-place block, their IV/PW formula ranges and page heights) and `BuildResultsWorkbook` to the overlays, which skip a bout Position past it rather than write into the next block. **The app's "Download blank template" is NOT `ExportCompetitionXlsx`**: `buildXlsxBody` (admin_schedule_export.jsx) posts the roster to the stateless `POST /create` (cmd), which re-draws it (mp-x0u9), sending `teamMatchType=kachinuki` for a kachinuki competition, `teamMatches` as the team size and `format=league` for a league (one pool and no knockout, which `/create` cannot tell from a pools competition that formed a single pool; any other `format` is a 400); cmd builds a `state.Competition` from them to ask the same owners (`TeamBoutRows`, `IsKnockoutEnabled`). An encounter with more bouts (reserves fielded) keeps them all on the Kachinuki Detail sheet, which lists a match's recorded bouts, or that many empty numbered rows for one with none, in every workbook (`helper.BlankKachinukiSections` for `/create`'s own draw, which leaves that sheet unprotected), so it can be filled in by hand (operator decision 2026-09-27, bc-kdsc). Before the draw, a knockout-only competition's detail sheet lists the skeleton the Elimination Matches sheet printed (the same rounds, through `helper.BlankKachinukiSections`), so the two sheets have one source. `helper.breakBeforeEliminationBlock` is the one page rule for every block on the Elimination Matches sheet, the 3rd-place block included, so a block that fits on one page never prints across two. A block taller than a page (a team of 17 or more, which only the CLI or API allows; the app caps teams at 9) still does. Never restate 2n-1 for a workbook, in Go or JS; the one other use is the score editor's own cap on manually added kachinuki bouts (`kachinukiMaxBouts`, admin_scoring_team.jsx), which is taken from `MAX_TEAM_SIZE`, not from a team's size. `TestCreateHandler_WithoutTeamMatchTypeMatchesTheExamples` reproduces four committed example workbooks byte for byte through `/create`, so a rendering change must regenerate them (`make examples`).
-- **Workbook owners.** `engine.AttachPoolMatches` is the ONE Pool Matches source for both engine exports (the results workbook, and the stored-draw export `ExportCompetitionXlsx` behind `GET /api/competitions/:id/export` and the Export PDFs prints): never rely on a cached `pool.Matches`, since pools.csv records membership only and a restart empties it (the stored-draw export printed no match block after a restart until bc-kdsc). `engine.PrintedBracket` is how those exports name a stored bracket match: its block title (`helper.EliminationMatchTitle`, or `helper.ThirdPlaceLabel` for the bronze) and its sides, a side not decided yet as `helper.MatchRefLabel`'s "M n", never an internal id such as "Winner of r2-m1". The results overlay and the Kachinuki Detail sheet both name through it, so a detail section and the "M n" that points at it read alike. `/create` has no stored bracket; `helper.BlankKachinukiSections` names its draw's matches through the same owners (`helper.EliminationMatchTitle`, `helper.MatchRefLabel`, `helper.ThirdPlaceLabel`, `helper.PoolMatchLabel`).
+- **Team block bout rows** (`state.Competition.TeamBoutRows`, with `domain.KachinukiMaxBouts`): the ONE owner of how many numbered bout rows a team match's block has in any workbook: 0 for an individual competition, TeamSize for a team match, 2 x TeamSize - 1 for kachinuki (the most bouts a winner-stays-on encounter can take). `RenderCompetitionWorkbook` passes it to the renderers (the Pool Matches and Elimination Matches blocks, the 3rd-place block, their IV/PW formula ranges and page heights) and `BuildResultsWorkbook` to the overlays, which skip a bout Position past it rather than write into the next block. **The app's "Download blank template" is NOT `ExportCompetitionXlsx`**: `buildXlsxBody` (admin_schedule_export.jsx) posts the roster to the stateless `POST /create` (cmd), which re-draws it (mp-x0u9), sending `teamMatchType=kachinuki` for a kachinuki competition, `teamMatches` as the team size and `format=league` for a league (one pool and no knockout, which `/create` cannot tell from a pools competition that formed a single pool; any other `format` is a 400); cmd builds a `state.Competition` from them to ask the same owners (`TeamBoutRows`, `IsKnockoutEnabled`). The main sheets' team block skips the representative bout (position -1), so its height and IV/PW ranges stay `TeamBoutRows`' alone; that bout is on the Representative Bouts sheet (see Workbook owners). An encounter with more bouts (reserves fielded) keeps them all on the Kachinuki Detail sheet, which lists a match's recorded bouts, or that many empty numbered rows for one with none, in every workbook (`helper.BlankKachinukiSections` for `/create`'s own draw, which leaves that sheet unprotected), so it can be filled in by hand (operator decision 2026-09-27, bc-kdsc). Before the draw, a knockout-only competition's detail sheet lists the skeleton the Elimination Matches sheet printed (the same rounds, through `helper.BlankKachinukiSections`), so the two sheets have one source. `helper.breakBeforeEliminationBlock` is the one page rule for every block on the Elimination Matches sheet, the 3rd-place block included, so a block that fits on one page never prints across two. A block taller than a page (a team of 17 or more, which only the CLI or API allows; the app caps teams at 9) still does. Never restate 2n-1 for a workbook, in Go or JS; the one other use is the score editor's own cap on manually added kachinuki bouts (`kachinukiMaxBouts`, admin_scoring_team.jsx), which is taken from `MAX_TEAM_SIZE`, not from a team's size. `TestCreateHandler_WithoutTeamMatchTypeMatchesTheExamples` reproduces four committed example workbooks byte for byte through `/create`, so a rendering change must regenerate them (`make examples`).
+- **Workbook owners.** `engine.AttachPoolMatches` is the ONE Pool Matches source for both engine exports (the results workbook, and the stored-draw export `ExportCompetitionXlsx` behind `GET /api/competitions/:id/export` and the Export PDFs prints): never rely on a cached `pool.Matches`, since pools.csv records membership only and a restart empties it (the stored-draw export printed no match block after a restart until bc-kdsc). `engine.PrintedBracket` is how those exports name a stored bracket match: its block title (`helper.EliminationMatchTitle`, or `helper.ThirdPlaceLabel` for the bronze) and its sides, a side not decided yet as `helper.MatchRefLabel`'s "M n", never an internal id such as "Winner of r2-m1". The results overlay, the Kachinuki Detail sheet and the Representative Bouts sheet all name through it, so a detail section and the "M n" that points at it read alike. `/create` has no stored bracket; `helper.BlankKachinukiSections` names its draw's matches through the same owners (`helper.EliminationMatchTitle`, `helper.MatchRefLabel`, `helper.ThirdPlaceLabel`, `helper.PoolMatchLabel`).
+- **Representative Bouts sheet** (`helper.WriteRepresentativeBoutsSheet`, `helper.SheetRepresentativeBouts`): a fixed-order team competition's workbook carries it exactly when a stored match holds a representative bout (a -1 row); kachinuki never has one. `engine.RepresentativeBoutMatches`/`collectRepresentativeBouts` (representative_export.go) walk the draw in the Kachinuki Detail sheet's order (`detailDraw.sections`) and take each bout's score, marks and centre from that sheet's own `boutFigures`, so the two sheets cannot disagree on a bout; the row is labelled `helper.RepresentativeBoutRowLabel` ("DH"). Both engine exports carry it (the stored-draw export and the results workbook); `/create`, the four committed examples and the Export PDFs prints do not (the PDF groups select sheets by name and list neither detail sheet). The row keeps the TEAM names by rule, so a representative is printed only from a member id that resolves in that side's team (`representativeOf`), never from the stored name; otherwise the bout prints its label alone.
 - **Clearing a scored mark is a tap on the mark, and each editor says so ONCE** (operator ruling 2026-09-16, bc-dnst). The individual board puts the line under its slot groups; the TEAM sheet puts it after the team names and BEFORE the first bout, never per bout, because the sheet repeats a row per bout. Both use the same words and the same `.sb-hint` owner (`.sb-hint--encounter` only adds the spacing a line between two blocks needs), and both show it only while a mark exists to clear. The team sheet keeps the line's space while it is hidden (`.holds-space`, the one owner of `visibility: hidden` for this, operator ruling 2026-10-06), because it sits above every bout row: appearing at a bout's first point (in kachinuki at every bout, since a recorded bout's marks no longer count) it moved every row 28 px down, and a quick second tap on M opened the fighter list. The individual board's line sits below what a scoring tap aims at, so it still comes and goes. A hantei mark does not raise it: `realIppons` drops it and it undoes through its own "click to undo" control.
 - **Team Match Labels**: Summaries use **"IV"** (Individual Victories) and **"PW"** (Points Won).
 - **Court limit**: `--courts` is hard-capped at 16 (`helper.MaxCourts`, derived from the court label alphabet A–P) and any value over that returns an error rather than silently truncating. 16 is the largest allocation any one competition can legally hold, so a venue beyond it could never give all its shiaijo to a single competition.
-- **Competitor Eligibility** (`internal/state/competitor_status.go`, `internal/engine/eligibility.go`): a kiken/fusenpai decision auto-writes a `CompetitorStatus{Eligible: false}` for the loser; `engine.StartMatch(compID, matchID)` is the pre-flight gate that returns `*IneligibleCompetitorError` (matches `errors.Is(err, ErrIneligibleCompetitor)`). Maps to HTTP 409, with `reasonHuman` (`reasonHumanForBarredCompetitor`/`barredCompetitorSentence`, `mobileapp/errors.go`) composing one operator sentence naming the competitor, the match (`engine.OperatorMatchLabel`), and what to do, e.g. "Alice withdrew in Pool A · Match 1 and cannot fight again. Record the fusensho for Carol." (kiken-injury: "...Reinstate Alice if they can fight again, or record the fusensho for Carol."). Kiken-injury (FIK Art. 30) sets `CompetitorStatus.Reinstateable: true`; the admin can call `POST /api/competitions/:cid/competitors/:pid/reinstate` to restore eligibility. Kiken-voluntary (Art. 31) and fusenpai are not reinstateable. A withdrawal decision against a competitor ANOTHER match already barred is decided by ONE rule, `engine.alreadyBarredRefusal` (bc-kfup), asked by both T105 halves (`checkConcurrentIneligibility` before the write, the K2 check-and-set in `recordIneligibilityFromDecision`): a kiken is refused with `already_ineligible` (a competitor withdraws once), while a fusenpai is their default loss on a remaining match and records NO new `CompetitorStatus`, so the existing one keeps naming the match where they withdrew. Do not re-add a fusenpai refusal there: StartMatchTx refuses to start that match, so the fusenpai is the operator's exit. Clearing the match that DID record the bar moves it onto such a chained fusenpai rather than lifting it (`standingWithdrawalOf`, fusenpai only: a kiken still on record beside a later bar was lifted by a reinstatement before that bar existed, since a second kiken is refused), and a reopen that clears it lands `scheduled` because `reopenTargetStatusTx` judges the bars the restore will leave (`restoredStatus`, shared with the restore). Accepted as it is (operator decision 2026-09-26): a fusenpai recorded before a reinstatement still carries the bar on, so a competitor who withdrew injured, had a no-show recorded on another match, was reinstated, and then has a later withdrawal cleared as a mistake is barred again by that earlier no-show; the editor names the no-show match, where clearing the fusenpai lifts it. Telling the two apart needs the time of each reinstatement, which is not worth storing for this. Do not report it as a new defect. `engine.BarredSides(statuses, matchID, sideAID, sideBID)` is the ONE extraction point for "is this side barred by a match OTHER than the one being checked" (the `st.MatchID != matchID` undo-path exemption lets a match always be re-scored past its own prior kiken/fusenpai); it replaced three hand-copied loops (`StartMatchTx`, `checkEligibilityExcludingMatch`, `annotateEligibility`). A SCHEDULED match with a barred side carries a READ-ONLY `ineligibleSides` stamp (`state.IneligibleSidesAnnotation{A, B string}`, both `omitempty` decision-code strings) on `MatchResult`/`BracketMatch`, computed at REQUEST TIME ONLY by `mobileapp.annotateEligibility` (`handlers_match.go`; never persisted, `yaml:"-"` on the pool side); a stamped match also has its `queuePosition` zeroed and so omitted from the wire (`state.DeriveQueuePositions`/`annotateBracketQueuePositions`), so it is skipped exactly like an unqueued match. `web-mobile/js/ineligible_match.jsx` is the ONE JS owner reading this stamp: `isBarredMatch`/`awaitedDefaultWin` skip such a match from Up next, Finish + Start Next, the TV next line, the lobby, and on-deck alerts, and drive the operator's one-tap `Record fusensho for <opponent>` (`POST /decision {decision: "fusensho", decisionBy: <barred side>}`, which does not touch the barred competitor's own `CompetitorStatus`) and, for a kiken-injury, `Reinstate <name>`. The same request-time pass stamps a COMPLETED match a kiken, fusenpai or fusensho decided with `withdrawnStatus` (`state.WithdrawnStatusAnnotation`: the withdrawn side's status now, eligible / the match that bars it / reinstateable), which `RecordedWithdrawal` words its clear from instead of fetching statuses. The viewer payloads load statuses whenever a match needs either stamp (`anyMatchToAnnotate`), and the `/decision`, `/score` and bulk-score writes stamp the result they push (`stampWithdrawnStatus`), so a pushed row and its refetch read the same. **Recording a withdrawal changes only that match** (operator ruling 2026-09-26, "do not cascade"): the post-kiken Remaining matches panel that offered to close the competitor's other matches was removed, and each of them is closed from its own notice when it comes up. Do not re-add a cascade from one match's editor. Recording one still starts the court's next match in the same competition (mp-nwds item 7, the operator's request), on the court console and the Scores tab alike; both skip the withdrawn competitor's matches through `sideBarredByDecision`/`involvesCompetitor` (`ineligible_match.jsx`), because the list shows them barred only after it refreshes.
+- **Competitor Eligibility** (`internal/state/competitor_status.go`, `internal/engine/eligibility.go`): a kiken/fusenpai decision auto-writes a `CompetitorStatus{Eligible: false}` for the loser; `engine.StartMatch(compID, matchID)` is the pre-flight gate that returns `*IneligibleCompetitorError` (matches `errors.Is(err, ErrIneligibleCompetitor)`). Maps to HTTP 409, with `reasonHuman` (`reasonHumanForBarredCompetitor`/`barredCompetitorSentence`, `mobileapp/errors.go`) composing one operator sentence naming the competitor, the match (`engine.OperatorMatchLabel`), and what to do, e.g. "Alice withdrew in Pool A · Match 1 and cannot fight again. Record the fusensho for Carol." (kiken-injury: "...Reinstate Alice if they can fight again, or record the fusensho for Carol."). Kiken-injury (FIK Art. 30) sets `CompetitorStatus.Reinstateable: true`; the admin can call `POST /api/competitions/:cid/competitors/:pid/reinstate` to restore eligibility. Kiken-voluntary (Art. 31) and fusenpai are not reinstateable. A withdrawal decision against a competitor ANOTHER match already barred is decided by ONE rule, `engine.alreadyBarredRefusal` (bc-kfup), asked by both T105 halves (`checkConcurrentIneligibility` before the write, the K2 check-and-set in `recordIneligibilityFromDecision`): a kiken is refused with `already_ineligible` (a competitor withdraws once), while a fusenpai is their default loss on a remaining match and records NO new `CompetitorStatus`, so the existing one keeps naming the match where they withdrew. Do not re-add a fusenpai refusal there: StartMatchTx refuses to start that match, so the fusenpai is the operator's exit. Clearing the match that DID record the bar moves it onto such a chained fusenpai rather than lifting it (`standingWithdrawalOf`, fusenpai only: a kiken still on record beside a later bar was lifted by a reinstatement before that bar existed, since a second kiken is refused), and a reopen that clears it lands `scheduled` because `reopenTargetStatusTx` judges the bars the restore will leave (`restoredStatus`, shared with the restore). Accepted as it is (operator decision 2026-09-26): a fusenpai recorded before a reinstatement still carries the bar on, so a competitor who withdrew injured, had a no-show recorded on another match, was reinstated, and then has a later withdrawal cleared as a mistake is barred again by that earlier no-show; the editor names the no-show match, where clearing the fusenpai lifts it. Telling the two apart needs the time of each reinstatement, which is not worth storing for this. Do not report it as a new defect. `engine.BarredSides(statuses, matchID, sideAID, sideBID)` is the ONE extraction point for "is this side barred by a match OTHER than the one being checked" (the `st.MatchID != matchID` undo-path exemption lets a match always be re-scored past its own prior kiken/fusenpai); it replaced three hand-copied loops (`StartMatchTx`, `checkEligibilityExcludingMatch`, `annotateEligibility`). A SCHEDULED match with a barred side carries a READ-ONLY `ineligibleSides` stamp (`state.IneligibleSidesAnnotation{A, B string}`, both `omitempty` decision-code strings) on `MatchResult`/`BracketMatch`, computed at REQUEST TIME ONLY by `mobileapp.annotateEligibility` (`handlers_match.go`; never persisted, `yaml:"-"` on the pool side); a stamped match also has its `queuePosition` zeroed and so omitted from the wire (`state.DeriveQueuePositions`/`annotateBracketQueuePositions`), so it is skipped exactly like an unqueued match. `web-mobile/js/ineligible_match.jsx` is the ONE JS owner reading this stamp: `isBarredMatch`/`awaitedDefaultWin` skip such a match from Up next, Finish + Start Next, the TV next line, the lobby, and on-deck alerts, and drive the operator's one-tap `Record fusensho for <opponent>` (`POST /decision {decision: "fusensho", decisionBy: <barred side>}`, which does not touch the barred competitor's own `CompetitorStatus`) and, for a kiken-injury, `Reinstate <name>`. The same request-time pass stamps a COMPLETED match a kiken, fusenpai or fusensho decided with `withdrawnStatus` (`state.WithdrawnStatusAnnotation`: the withdrawn side's status now, eligible / the match that bars it / reinstateable), which `RecordedWithdrawal` words its clear from instead of fetching statuses. The viewer payloads load statuses whenever a match needs either stamp (`anyMatchToAnnotate`), and the `/decision`, `/score` and bulk-score writes stamp the result they push (`stampWithdrawnStatus`), so a pushed row and its refetch read the same. **Recording a withdrawal changes only that match** (operator ruling 2026-09-26, "do not cascade"): the post-kiken Remaining matches panel that offered to close the competitor's other matches was removed, and each of them is closed from its own notice when it comes up. Do not re-add a cascade from one match's editor. Recording one still starts the court's next match in the same competition (mp-nwds item 7, the operator's request), on the court console and the Scores tab alike, both through `start_match.jsx` (one start at a time; a refused start is shown on the refused match, on the console's Up next or queue row and on the Scores tab's row, with one toast: an error `editMatchScore` already toasted is marked (`markToasted`, write_result.jsx) and the host does not toast it again. The notice is bound to the refused match, not to Up next, by one rule both hosts ask (`startRefusalStands`, start_match.jsx): it stays while that match is `scheduled` on the court, and across an empty list, which says nothing about the match and goes when it leaves `scheduled`, when a non-empty court list no longer holds it, when the operator starts a match, or when an eligibility change in its competition is broadcast; Up next moving on does not drop it. A refusal because another start was still out is kept, in the past tense (`startWasBlockedByStartMessage`), on the refused match once that start has gone out: `landed` on the start's record, set by the console's `startMatch` for a start that landed or was queued offline, never for a pick whose deferral of the running bout failed, nor for a start the server refused: a `clock_skew` answer, or a superseded one that holds the `result` group (`heldGroups` non-empty: a different result is stored and nothing of the start was written). A superseded start with NO `heldGroups` is an echo-hold (a start names only `result`, and the server lists a held group only when it differs from the stored one, `reportHeld`/`HeldEcho`): another device's start of the same match landed first and the match is running, so `classifyStartOutcome` answers it `{ok: true}` like a landed start: no sentence, no toast, a pick pins the panel, and a refusal waiting on it is worded in the past tense. The two refusals answer `{ok: false, msg}`, so both hosts take them as refused starts: the sentence (`START_CLOCK_SKEW_MESSAGE`, or `START_SUPERSEDED_MESSAGE`, composed by `notSavedText` from `SUPERSEDED_REASON` and `SUPERSEDED_ADVICE` under the "Not started" lead, which never invites a retry, start_match.jsx) is stored on the refused match and toasted once, and a pick does not pin the panel on that match; after a pick the court is idle, the running bout already sent back to the queue. The refused match is never started on its own; if the blocking start fails instead, its own refusal stays. On the Scores tab `refuseStart` replaces the single waiting refusal and clears `waitingOn`, so its `finally` has nothing to rewrite, and a superseded start that holds its result group, after a decision, lands on that match with its notice. Accepted: the `result` group's projection also holds `CorrectionReason`/`ResultSource`, so a start over a match running under a different source or reason answers `heldGroups: ["result"]` and shows the refused sentence on a running match; the notice drops once live data shows it running (`startRefusalStands`), the toast stays. The console reads `startPatch`, `winnerSideLR` and `teamMatchMarks` by ES import (`start_match.jsx`, `side_marks.jsx`), and admin_shiaijo.jsx still must not import bracket.jsx); both skip the withdrawn competitor's matches through `sideBarredByDecision`/`involvesCompetitor` (`ineligible_match.jsx`), because the list shows them barred only after it refreshes.
 - **Send back to queue keeps the score** (operator ruling 2026-09-26, bc-sbq). `RevertMatchToQueue`/`requeueBracketMatch` clear only the verdict and the audit notes; points, penalties, overtime, bouts, flags and rep-bout fighters stay, the operator removes a wrong mark themselves, and the button is always offered (picking another bout sends a scored one back the same way). Starting the match again keeps them: the SPA's `startPatch` sends the request-only `startOnly` flag and `engine.keepQueuedScore` copies the stored score onto that write, because the wire cannot say "no score sent" (the start's empty arrays are the bytes of an operator clearing every mark, which must still clear, so the editors' own Start stays unflagged; `startOnly` with any status but `running` is a 400, since the stored score is swapped in after validation). The start's representative-bout winner is derived AFTER that swap (`deriveDaihyosenWinner`, scoring_tx.go), so it comes from the bouts the start keeps, never from rows it discards. While queued, every display shows the match as NOT STARTED through `matchShowsScore` (match_shows_score.jsx, a leaf every display ES-imports), which `IndividualScore`/`TeamScoreboard` apply to themselves; the score editors are the one exception. A queued knockout match's kept points do not make it "fought" (`bracketMatchStartedOrDecided` reads status and winner only), so correcting or reopening the match that feeds it re-seats it with its points and asks nothing when it starts. A FINISHED later match that a confirmed correction reopens keeps its points, bouts and flags too, only its verdict goes (`reopenDisplacedBracketMatch` through `reopenBracketMatchKeepingTheFight`, both the knockout and the pool-requalification doors). Engi flags are saved as they are entered: a running engi write is not judged on the flag total (`engiRunningWrite`, scoring_tx.go) and the bracket write carries flags, so a send-back or switch keeps them.
-- **A fixed-order team bout row records NO fighter name, never the team's** (operator ruling 2026-09-17, bc-dnst: "the storage is the main source of truth"). The bout settles at the MATCH level, so when no lineup names a fighter the row knows no per-fighter identity and `buildPatch` writes `sideA`/`sideB` EMPTY. It used to write the team name there, which is not a person: every display then had to filter it back out, and the ones that did not showed the team's name where the competitor goes. Nothing needed the copy, because attribution reads the MATCH-level name first (`state.SubBoutWinnerSide`, whose `sub.SideA` arm is guarded against `"" == ""`; the JS `teamIVScore` fallback mirrors it) and the server's own quick-score path already wrote this shape. **The DAIHYOSEN row is the exception and keeps the team names**: the hantei mark is placed on the winner's side by comparing the winner against THAT row's `sideA`/`sideB` (`placeHt`), so blanking them drops the mark from the wire. `resolveBoutSideName`'s `teamNameA`/`teamNameB` filter stays for rows written BEFORE this rule; it is legacy handling, not a live guard.
+- **A fixed-order team bout row records NO fighter name, never the team's** (operator ruling 2026-09-17, bc-dnst: "the storage is the main source of truth"). The bout settles at the MATCH level, so when no lineup names a fighter the row knows no per-fighter identity and `buildPatch` writes `sideA`/`sideB` EMPTY. It used to write the team name there, which is not a person: every display then had to filter it back out, and the ones that did not showed the team's name where the competitor goes. Nothing needed the copy, because attribution reads the MATCH-level name first (`state.SubBoutWinnerSide`, whose `sub.SideA` arm is guarded against `"" == ""`; the JS `teamIVScore` fallback mirrors it) and the server's own quick-score path already wrote this shape. **The DAIHYOSEN row is the exception and keeps the team names**: the hantei mark is placed on the winner's side by comparing the winner against THAT row's `sideA`/`sideB` (`placeHt`), so blanking them drops the mark from the wire. The server keeps them too: `engine.AddDaihyosen` stores the match's team names on the row when the bout is added, and `seatBracketSide` (bracket_seat.go, the ONE owner of seating a knockout side) keeps the row's `sideA`/`sideB` equal to the match's on every seat, and carries the row's `Winner` to the new name when the side keeps its team and the Winner names the side by its old name, the row's own or the match's (a rename: `nameRepBoutRow` with `another` false and `matchOld` the match's name before the seat, since a row's side name can be blank or stale; the carry also runs when the row already reads the new name; `ReplaceParticipantInDraw` seats a side matched by id through it, `renameBracketSide`, and renames an id-less side's row name without clearing a pick), judging "another team" by id when both sides carry one and by name otherwise; a side given another team loses its representative pick there, dated after the pick it clears. `resolveBoutSideName`'s `teamNameA`/`teamNameB` filter stays for rows written BEFORE this rule; it is legacy handling, not a live guard.
 - **A lineup vacancy is never flagged on the score sheet** (operator ruling 2026-09-16, bc-dnst). Team sizes are unregulated and a vacancy is legitimate play, so the sheet must not tell the operator to complete a lineup. The "SHIRO/AKA: Lineup incomplete, add the remaining players" notice was REMOVED with its predicate and its CSS; it never blocked anything, but it read as a requirement. Pinned by `team_editor_vacancy_not_flagged.render.test.jsx`, which exists because a removed warning otherwise leaves no failing test behind. Do not re-add it in any form.
 - **Team Lineups & Kachinuki** (`internal/domain/team_lineup.go`, `internal/engine/kachinuki.go`): TeamLineup pins position→player for a round or a specific match (mp-825). Team sizes are unregulated and vacancies are never enforced: `TeamLineup.Validate`/`validateFive` (the FIK 5-person back-fill/DQ rule) were REMOVED (mp-gmcg); only the key-only `ValidatePositions` check remains. Kachinuki ("winner-stays-on") is operator-led: `engine.MaybeAdvanceKachinuki` is append-only (adds the next pairing; NEVER auto-finalizes; the roster snapshot is advisory) and the encounter ends only on an explicit `status: completed` score write, which strips trailing unscored auto-appended bouts. Both win rules, exhaustion and taisho-defeated, record `decision: "kachinuki-exhaustion"`; a drawn pool/league encounter is `hikiwake`. Whether a tied pair fights on in encho is the operator's call, on ANY bout and in ANY phase: the app records what happens and never decides how a match is run (operator ruling 2026-09-26). A taisho-only rule (bc-kten: the editor withheld Encho from any pair but the two taisho, and the server refused a new encho on such a pair) was built on 2026-09-25 and reversed the next day; do NOT re-add a pairing gate or a server refusal for encho. Whether a tied pairing must produce a result (e.g. the taisho must be defeated) is likewise OPERATOR DISCRETION, never derived from pool-vs-bracket (the phase-independence rule lives in `allowNumberedEnchoFromStore` (`handlers_match.go`) and `subBoutNeedsNumberedEnchoAllowance` (`validation.go`); do NOT re-scope numbered-bout encho by match-ID phase; that was tried and reverted). Only the knockout END stays blocked while tied (the bracket needs a winner, `validateBracketCompletion`). A kachinuki encounter never carries a match-level encho (operator ruling 2026-09-24, bc-kheb): one bout fought on in encho does not put the encounter in overtime, so (E) lives on that bout's row only. `state.Competition.ClearKachinukiEncounterEncho(matchID, ...)` is the one owner, and it leaves a pool representative bout or tie-break bout (`Pool X-DH-N`, `Pool X-TB-N`, the `state.IsPoolDaihyosenMatchID`/`IsTiebreakerMatchID` grammar) alone at all three sites below: that match IS one individual bout, whose overtime lives at match level: `applyKachinukiMerge` strips the field on every score write (logged, never refused, since an older client's queued write inherits it), the engine's decision write (`recordDecisionTx`) drops it before the decision's circles are counted, and the load repair `upgradeKachinukiEncounterEnchoLocked` clears what older releases stored, gated on the config.md marker `kachinuki_encounter_encho_cleared`, which `POST /competitions` sets on a competition created as kachinuki (it has nothing to repair) and which a match file the repair cannot read leaves unset, so a later start retries. The team editor sends none (`encounterEnchoCount`) and offers no match-level overtime stepper on a kachinuki encounter. Daihyosen does not exist in kachinuki → `POST .../daihyosen` returns 400. Mistakes: `POST /api/competitions/:id/matches/:mid/reopen` (a kachinuki match, or any match a kiken, kiken-injury, fusenpai or fusensho decided; a 400 otherwise) flips a completed match back to running, clearing winner/decision but keeping the bout log -- EXCEPT a kiken, fusenpai or fusensho whose `decisionBy` side is STILL barred by a withdrawal recorded on a DIFFERENT match: `engine.reopenTargetStatus` (`kachinuki.go`) sends that one to `scheduled` instead of `running`, because going straight to `running` would strand the operator behind the eligibility gate with no way to start it (clearing the match that recorded a bar moves that bar onto a chained fusenpai rather than lifting it); once the bar is gone, the competitor reinstated or the match that recorded it cleared, the identical reopen goes to `running` like any other decision; a reopen that lands `scheduled` takes no court, so neither court gate applies to it (the target status is decided before either gate runs); in a knockout, when the winner of the match being reopened or corrected went straight through a bye (a hidden, unnumbered match the draw leaves with one empty side, so nobody can open or reopen it directly), the write takes that winner back out of it (or re-seats the new one) and answers for the first real match past it (`propagatedDownstreamOf`), rather than refusing; a POOL reopen in a mixed competition is never refused for a seated knockout, because the write that finishes it runs the pool requalification check (`engine/pool_requalify.go`); `POST .../matches/:mid/requeue-blocker-and-reopen` atomically frees the target's court (requeuing the blocking match) and reopens under one court-lock hold; `DELETE .../matches/:mid/kachinuki-bout` removes the current trailing unscored auto-appended pairing. Every numbered bout row of a team match shows the fighter's squad number and, when the position is unnamed, a typeable name box (operator ruling 2026-09-15, bc-dnst). The number belongs to the squad member, not the row: team order can change between matches, so picking a different member into a position moves that member's number onto the row. A fresh team's seeded blank slots are members with a number and no name, so an unnamed fixed-order position shows the number of the blank member seeded for it, and a name typed there names that member through `resolveMemberIdsForPositions` (rename, never a new mint while a blank slot with that number exists), so the name stays attached to the number it was shown with. A team's squad is seeded with team size + 2 numbered slots (`SquadReserveSlots`, two reserves), and the row's list shows every slot with its number, blank ones by number alone, so any number the team can field can be picked and then named; a picked slot is written by id (`buildInlineLineupWrite` with a member) and a name typed into it renames that member (operator ruling 2026-09-15, bc-dnst). That makes a picked-but-unnamed slot a real placement everywhere: every lineup writer (the score sheet row, the Up Next "Enter lineup" panel, the Lineups page) sends the position with an empty name and the member id rather than dropping it; `TeamLineup.OrderedMembers` counts a position occupied when it carries a name OR an id, so such a fighter is on the kachinuki roster; and `AdvanceKachinuki` decides which side stayed on through `domain.SubBoutAttribution`/`AttributeWinnerSide` (ids first), because the client records a nameless winner as its TEAM name plus the member id and a name comparison alone can never see it stay on. A lineup may not place one member id at two positions: `memberPlacedElsewhere` (lineup_resolver.jsx) is the ONE client predicate, asked by every writer before it writes (`buildInlineLineupWrite`, the panel's save, the Lineups page's add path) and rendered as the list filter `rosterWithoutPlacedElsewhere` on every picker, so the offer and the refusal ("<name> is already at <position>", worded once by `alreadyPlacedNote`, the position named by `lineupPositionLabel` on every surface; a change to a position takes a refusal down) never disagree; `ErrLineupDuplicateMember` from `ValidatePositions` (a 400 naming the two positions) is the server backstop. A lineup that already held a duplicate before this guard existed is repaired by clearing one of the two rows. Under kachinuki only the FIRST row is a lineup position; every later row's pick rides the bout itself (`pickManual` with the member id, never a lineup PUT), the list there is unfiltered because the fighter who stayed on legitimately repeats, and a name typed over a picked blank member renames that member and keeps its id. Which side stayed on is decided through `domain.AttributeWinnerSide`, whose id tier names a side when the winner id equals THAT side's id even if the other side carries none (JS mirror `attributeWinnerSide`, result_slot.jsx), with the same name-only residue `RetiredPlayersFromBoutLog` keeps for a row no id can settle. Before the draw a team has no number, so the Lineups page, the one operator surface for a team's people, labels a slot through `squadSlotLabel` ("Slot 3"), a sibling of `squadMemberLabel` in the same owner; spectator surfaces keep `squadMemberLabel` and stay bare before the draw. The competition Settings page's Squad members section was REMOVED on 2026-09-15 by operator decision (bc-dnst): the Lineups page is the one home for a team's people, and its "Team members" list's "Clear name" control (beside Rename) is where clearing a member's name now lives. The Lineups page's "+ Add" confirm is derived from the resolver's own three outcomes (an existing member is selected with no confirm, a blank slot is named, else a member is minted). A rename or a clear reaches every stored lineup: `RenameTeamMember`/`ClearTeamMemberName` rewrite the name of every lineup position holding that member by id (`renameMemberInLineupsLocked`), because the score sheet and the export read the lineup's stored name; fought bouts keep their frozen names. The Excel export indexes lineup positions by member id as well as by name (`memberKey`, `resolveKachinukiBoutPosition`) so a nameless fighter still gets its position label. Positions are ordered in ONE way, `domain.ComparePositions` (the FIK names in fighting order, then numbered positions by number, then any other by name), which the roster walk (`OrderedMembers`), the export and the member-id load repair share; a text sort put Chuken before Senpo and "10" before "2".
 - **A team carries the lineup of its previous team match** (operator ruling 2026-10-05: "by default, a team carries the previous team match lineup. You can have a different team lineup in every team match"). `engine.LineupInForce` (`internal/engine/lineup_in_force.go`) is the ONE owner: the match's own lineup (read whole, even one that holds no position), else the latest lineup the team had before it in match order (an earlier match's, or its starting lineup, which comes before every match); a match the draw does not hold gets its own lineup or the starting lineup. A lineup saved for a later round is never read (see the migration bullet below). A lineup is matched by the team's participant id only, never by its name; an id-less side has none. Discarding a draw removes the lineups saved for its matches. Match order is the pool-match number, then the knockout by round and position, the 3rd-place match last; `state.TeamMatches` is the one list of a draw's team matches (a bye, a pool daihyosen or tie-break bout, and a league's or Swiss competition's vestigial bracket are none), for the rule and the migration alike. The kachinuki roster, the Kachinuki Detail export and every client surface (through `GET .../lineup-in-force/:matchId` and `resolveMatchLineup`) ask it; no surface derives a round to read a lineup. The Lineups page edits each team's starting lineup (stored as its round-0 entry) and any match's own lineup; **Use the previous match's lineup** removes a match's own lineup so it inherits again. **Copy from previous match** was removed because carrying over is the default; do not re-add it. A match the Lineups page has chosen that the team is no longer in (a correction seated another team) stays chosen, locked, Use the previous match's lineup included, with a notice naming it (`notInMatch`), rather than the page silently editing the starting lineup. The at-court lineup panel follows the match it was opened for: its host keeps the match's key and reads the row every render, so a side given another team gets that team's editor and a match that leaves the data closes the panel.
@@ -200,7 +201,7 @@ The rules below were settled by operator rulings and are pinned by tests. Each h
 
 #### The middle is a closed set
 
-Visual marks follow the score sheet's layout, split into two kinds. MIDDLE marks occupy the centre "vs" cell (the score-string centre): exactly one of `X` (tie), `(E)` (overtime, always bare: `periodCount` is recorded but never displayed), `(DH)` (rep bout). They are mutually exclusive by rule: a match that went to encho cannot end tied, so X beats (E); a daihyosen is one-point sudden death, so DH bouts have no encho. RESULT marks ride beside the competitor they name: `Ht` (hantei winner), `Kiken` (withdrawer), `Fus.` (no-show, and also the winner of a match-level fusensho; `sideMarks` in bracket.jsx and `domain.SideMarks` (placed on the sheet by `SideMarksLR`, internal/export/suffix.go) agree on this, so a fusensho match reads identically on every surface and in the exported workbook).
+Visual marks follow the score sheet's layout, split into two kinds. MIDDLE marks occupy the centre "vs" cell (the score-string centre): exactly one of `X` (tie), `(E)` (overtime, always bare: `periodCount` is recorded but never displayed), `(DH)` (rep bout). They are mutually exclusive by rule: a match that went to encho cannot end tied, so X beats (E); a daihyosen is one-point sudden death, so DH bouts have no encho. RESULT marks ride beside the competitor they name: `Ht` (hantei winner), `Kiken` (withdrawer), `Fus.` (no-show, and also the winner of a match-level fusensho; `sideMarks` (side_marks.jsx, re-exported by bracket.jsx) and `domain.SideMarks` (placed on the sheet by `SideMarksLR`, internal/export/suffix.go) agree on this, so a fusensho match reads identically on every surface and in the exported workbook).
 
 Web score strings read `[left cell] [middle] [right cell]` with `vs` as the plain middle and `–` (or empty) meaning no points. Never digits: ippon renders as waza letters only, e.g. `M vs –`, `M (E) K`, `M Ht (E) K`. The dash is a CELL value only. The middle never shows a dash, so unplayed and pending match rows read `vs` too.
 
@@ -240,7 +241,7 @@ The slot rule has ONE owner, `resultSlot` in web-mobile/js/result_slot.jsx (a sm
 
 Score strings TRAIL loose marks as an unattributable-winner degradation, but the scoreboard has no centre-`Ht` equivalent: an unattributable winner gets no mark rather than one in the shared centre cell. ACCEPTED no-mark classes (all drifted/legacy data; the centre is forbidden by the operator ruling and no side is attributable): (i) same-name-no-id pairs; (ii) rename-drifted winner names (note the old centre fallback DID fire for these whenever the middle was empty, which a no-encho hantei makes normal, so this IS a regression there, accepted); (iii) winner-less legacy `decidedByHantei` rows (previously centre `Ht`); (iv) untied legacy `decidedByHantei` rows written before the tied-scoreline validation existed (letters still convey the winner; the judges'-decision marker is dropped).
 
-Two related deliberate divergences. Score strings (`sideMarks`) and the Excel export (`SideMarksLR`, over `domain.SideMarks`) still mark `Ht` UNCONDITIONALLY: the mirrored pair stays consistent with itself and gains no tie gate. And a winner naming BOTH sides resolves defensively to AKA everywhere in JS (`subWinnerSides`, aka-first) to match Go's `isWinForSide`/`SideMarksLR` order, so rows, summaries, standings and the export agree on the same arbitrary side. That aka-first rule is scoped to the MATCH level, where a team name is unique by rule and a winner naming both sides is therefore drifted or hand-edited data. It does NOT hold for a SUB-BOUT, where two opposing fighters may legally share a display name and the same order would be a coin flip on ordinary valid data: such a bout is attributed by the row's MEMBER IDS and counts for NEITHER side when no id can decide. A team bout row that names no fighter settles at the match level: `domain.SubBoutAttributionForTeamRow` puts the team names in AFTER that same-name blank, so even a legacy same-named team pair is attributed side A first, as the app and the standings do. **`domain.SubBoutAttribution` owns that rule** and its doc comment is the statement of it; every consumer builds its attribution there, and the JS mirror is `subBoutAttribution` (result_slot.jsx). Do not re-add a name tier that runs when `SideA == SideB`, and do not restate the mechanism here: an earlier copy of it named a function by its unexported name and went stale one commit after that function was exported. Stored sub names stay frozen after a rename (nothing rewrites `SubMatchResult.SideA`/`SideB` on disk or on the wire): every DISPLAY instead resolves the CURRENT name by member id at render time, through `resolveBoutSideDisplayName` (web-mobile/js/lineup_resolver.jsx) and its Go twin `resolveKachinukiDisplayName` (internal/engine/kachinuki_export.go) for the Excel export (bc-dnst), so a rename shows on bouts already fought, on every surface, without touching the stored record. Mirrored helpers: `middleMark`/`sideMarks`/`enchoLabel` (bracket.jsx) ↔ `domain.MiddleMark`/`domain.SideMarks`/`domain.EnchoLabel` (internal/domain/result_marks.go, with `domain.SideMarksAB`, and `domain.IpponsScore` beside IsScoringIppon in ippon.go), moved there (bc-kdsc) so the Kachinuki Detail sheet (internal/helper/excel_kachinuki.go, fed by internal/engine/kachinuki_export.go, which cannot import internal/export without a cycle) reads the SAME closed-set rule rather than restating it. internal/export keeps only what adapts them: `MiddleMark` (from `*state.EnchoMetadata`) and `SideMarksLR` (places the marks White-left). The overtime marker is pinned in both languages via `internal/export/testdata/encho_labels.json` (Go side: `domain.EnchoLabel`).
+Two related deliberate divergences. Score strings (`sideMarks`) and the Excel export (`SideMarksLR`, over `domain.SideMarks`) still mark `Ht` UNCONDITIONALLY: the mirrored pair stays consistent with itself and gains no tie gate. And a winner naming BOTH sides resolves defensively to AKA everywhere in JS (`subWinnerSides`, aka-first) to match Go's `isWinForSide`/`SideMarksLR` order, so rows, summaries, standings and the export agree on the same arbitrary side. That aka-first rule is scoped to the MATCH level, where a team name is unique by rule and a winner naming both sides is therefore drifted or hand-edited data. It does NOT hold for a SUB-BOUT, where two opposing fighters may legally share a display name and the same order would be a coin flip on ordinary valid data: such a bout is attributed by the row's MEMBER IDS and counts for NEITHER side when no id can decide. A team bout row that names no fighter settles at the match level: `domain.SubBoutAttributionForTeamRow` puts the team names in AFTER that same-name blank, so even a legacy same-named team pair is attributed side A first, as the app and the standings do. **`domain.SubBoutAttribution` owns that rule** and its doc comment is the statement of it; every consumer builds its attribution there, and the JS mirror is `subBoutAttribution` (result_slot.jsx). Do not re-add a name tier that runs when `SideA == SideB`, and do not restate the mechanism here: an earlier copy of it named a function by its unexported name and went stale one commit after that function was exported. Stored sub names stay frozen after a rename (nothing rewrites `SubMatchResult.SideA`/`SideB` on disk or on the wire): every DISPLAY instead resolves the CURRENT name by member id at render time, through `resolveBoutSideDisplayName` (web-mobile/js/lineup_resolver.jsx) and its Go twin `resolveKachinukiDisplayName` (internal/engine/kachinuki_export.go) for the Excel export (bc-dnst), so a rename shows on bouts already fought, on every surface, without touching the stored record. Mirrored helpers: `middleMark`/`enchoLabel` (bracket.jsx) and `sideMarks` (side_marks.jsx, the leaf that also holds `placeMarks`, `winnerSideLR` and `teamMatchMarks`; bracket.jsx re-exports them) ↔ `domain.MiddleMark`/`domain.SideMarks`/`domain.EnchoLabel` (internal/domain/result_marks.go, with `domain.SideMarksAB`, and `domain.IpponsScore` beside IsScoringIppon in ippon.go), moved there (bc-kdsc) so the Kachinuki Detail sheet (internal/helper/excel_kachinuki.go, fed by internal/engine/kachinuki_export.go, which cannot import internal/export without a cycle) reads the SAME closed-set rule rather than restating it. internal/export keeps only what adapts them: `MiddleMark` (from `*state.EnchoMetadata`) and `SideMarksLR` (places the marks White-left). The overtime marker is pinned in both languages via `internal/export/testdata/encho_labels.json` (Go side: `domain.EnchoLabel`).
 
 #### Writing `SubResults`
 
@@ -284,18 +285,18 @@ The engine-side contradiction guard is `stripInvalidHantei` (replaced `preserveM
 
 Operator ruling 2026-10-03: "Nothing should be dropped. All events must be ordered." A match write is merged GROUP BY GROUP onto the stored match, ordered by the stamp of when the change was made (`modifiedAt`, server-relative, never arrival order), and what does not apply is kept in the match's history. Each rule below has one owner; change the owner, never a call site.
 
-- **The groups** (`internal/state/match_groups.go`, the ONE owner of which fields each holds): `points` (IpponsA/B, HansokuA/B), `result` (Status, Winner/WinnerID, Decision/DecisionBy/DecisionReason, and the CorrectionReason/ResultSource that describe it), `encho`, `flags` (engi), `rep` (pool rep players), and `bout:<position>` per SubResults row (1..n, -1). Sides and ids, court, schedule, round, ReopenPending, IsOverridden and the bracket structure are NOT groups: their own writers keep them. `CopyGroup` moves a group, `GroupDiffers` compares one, `GroupValue` projects one for the history; nothing hand-copies a field list.
+- **The groups** (`internal/state/match_groups.go`, the ONE owner of which fields each holds): `points` (IpponsA/B, HansokuA/B), `result` (Status, Winner/WinnerID, Decision/DecisionBy/DecisionReason, and the CorrectionReason/ResultSource that describe it), `encho`, `flags` (engi), `rep` (pool rep players), `repPickA` and `repPickB` (each side's representative picked for a team match's representative bout, SideAMemberID and SideBMemberID of the -1 row: each dated apart from the other side's and from `bout:-1`, so two captains picking at the same moment both land, a point on that bout never erases a pick and a pick never erases a point; the row's WinnerMemberID stays with the bout and the merge re-derives it when the two disagree, `ReconcileWinnerMemberID`), and `bout:<position>` per SubResults row (1..n, -1). Sides and ids, court, schedule, round, ReopenPending, IsOverridden and the bracket structure are NOT groups: their own writers keep them. `CopyGroup` moves a group, `GroupDiffers` compares one, `GroupValue` projects one for the history; nothing hand-copies a field list.
 - **The stamps**: `GroupStamps map[string]int64` on `MatchResult` and `BracketMatch` (pool-matches.csv: the `GroupStamps` column, index 29, JSON, appended after `ModifiedAt`; bracket.json: `groupStamps`). A match with NO map reads every group as stamped at its `ModifiedAt` (legacy files behave exactly as the whole-match guard did); once a map exists, a group with no entry was never written (0). `ModifiedAt` stays the newest group stamp (recency and `keepNewerMatches` read it). A bout whose row is gone keeps its stamp: a TOMBSTONE, so an older write still carrying the row cannot resurrect it. `stampGroups` (`MatchResult.StampGroups`/`BracketMatch.StampGroups`) is the ONE stamper: it materializes a legacy match's implicit stamps before stamping one group, or every other group would start reading the new `ModifiedAt`, and it never LOWERS a group's stamp (a caller that already holds a later one for a group -- an engi finish let through as a HeldEcho under an older stamp -- must not drag it backwards, or a change genuinely made between the two would wrongly read as applying after a group it never actually followed; mirrors `ModifiedAt`'s own never-lower rule); a stamp the MERGE decided, which may be lower (S2's displacement moves a newer invalid recount out and gives the group the finish's own stamp), is written as decided through `ApplyMergedGroupStamps`, never through `stampGroups`. Every writer that changes a group outside the merge stamps it through it: the reopen (`reopenPoolMatch`/`reopenBracketMatch`, server now), the requeue (`RevertMatchToQueue`/`requeueBracketMatch`: the verdict only, the kept score keeps its stamps), override-winner (`result`, and its own comparison is on that group), the engi finish (`result`+`flags`, at the client's stamp once the merge has ordered it, `engiFinishHeld`; server now only for an unstamped writer), the kachinuki advance (the appended `bout:n` + `result`, at the server's time and never older than the match, as `writeStamp` stamps every server-built write; the Record-bout answer echoes the bout log AND the stamps the advance left, `engine.KachinukiAdvance`, and the team editor adopts the stamp with the log, so its next tap on the new bout is floored by it, bc-hlck), `RemoveTrailingKachinukiBout` (the removed bout's tombstone), and a downstream reopen (`reopenDisplacedBracketMatch`, `bout:-1` with it). Byes auto-completed at draw time carry no stamp, which is right.
-- **The wire**: `MatchResult.Changed` (`json:"-"`, request-only, beside `ClearsWithdrawal`) is read from `/score`'s and each bulk entry's `changed`; a name that is not a group is a 400. ABSENT means every group the payload carries (`defaultChangedGroups`; on the pool branch a nil SubResults still names the stored rows, the whole-struct write's old meaning), EXCEPT that a client's running or scheduled write over a COMPLETED match never carries `result` (`effectiveChangedGroups`). Every server-built write names its groups: decision `result`+`points`+`encho` (`decisionChangedGroups`), both-barred hikiwake `result`, daihyosen add `bout:-1`+`result` and remove `bout:-1`+`result`+`encho` (+`points` when clearing the verdict took a hantei mark out, `daihyosenChangedGroups`), quick-score every group and every stored row (`WholeMatchChangedGroups`), a start (`startOnly`) `result` alone. The rows the server itself changes after the writer sent them (kachinuki merge, the padding a match-level decision adds) are added by `noteServerBoutChanges`; in a kachinuki write, which merges its bout log by position, a stored row the writer left out counts too, so the finish's strip of a trailing unscored pairing is named and not copied back. It and `daihyosenChangedGroups` (mobileapp, the representative-bout add and remove, built from the stored match under the same lock) are the two places the server diffs, each its own values under the write's lock; a CLIENT payload is never diffed against the store, or an echoed stale group with a newer stamp would read as an edit. A server-built door reaching the merge with `Changed` nil is logged as a BUG (`serverBuiltWithoutGroups`). `MatchResult.WriteDoor` names the door for the history.
+- **The wire**: `MatchResult.Changed` (`json:"-"`, request-only, beside `ClearsWithdrawal`) is read from `/score`'s and each bulk entry's `changed`; a name that is not a group is a 400. ABSENT means every group the payload carries (`defaultChangedGroups`; on the pool branch a nil SubResults still names the stored rows, the whole-struct write's old meaning), EXCEPT that a client's running or scheduled write over a COMPLETED match never carries `result` (`effectiveChangedGroups`). Every server-built write names its groups: decision `result`+`points`+`encho` (`decisionChangedGroups`), both-barred hikiwake `result`, daihyosen add `bout:-1`+`result`+`repPickA`+`repPickB` and remove `bout:-1`+`result`+`encho`+`repPickA`+`repPickB` (both date both sides' picks, so a pick made on the previous representative bout is held, never landed on the new one; +`points` when clearing the verdict took a hantei mark out, `daihyosenChangedGroups`), quick-score every group and every stored row (`WholeMatchChangedGroups`), a start (`startOnly`) `result` alone. The rows the server itself changes after the writer sent them (kachinuki merge, the padding a match-level decision adds) are added by `noteServerBoutChanges`; in a kachinuki write, which merges its bout log by position, a stored row the writer left out counts too, so the finish's strip of a trailing unscored pairing is named and not copied back. It and `daihyosenChangedGroups` (mobileapp, the representative-bout add and remove, built from the stored match under the same lock) are the two places the server diffs, each its own values under the write's lock; a CLIENT payload is never diffed against the store, or an echoed stale group with a newer stamp would read as an edit. A server-built door reaching the merge with `Changed` nil is logged as a BUG (`serverBuiltWithoutGroups`). A bracket door that gives a side another team without reopening that match records a `reseat` history line naming the cleared pick group (`recordRepPickClears`, bracket_seat_audit.go: a snapshot of every match's picks before the door's write, diffed after, in the same transaction; `ResolveQualifiedPools`, the resolver run after a pool write or a `DELETE .../overrides`, is such a door, in its own `WithTransaction`); a reopened match's `downstream-reopen` line names the pick instead, and a refused write's restore records nothing. `MatchResult.WriteDoor` names the door for the history.
 - **The merge owner**: `mergeMatchWrite` (engine/match_merge.go), called by BOTH branches before anything else judges the write (`applyPoolWrite`; `applyBracketResultIn` for rounds and bronze, ahead of `preserveWithdrawalRuling` and the downstream guard), each after folding the stored pairing into the write (`reconcileSides`; on the bracket branch `sidesBeforeMerge`), so a winner worked out again reads the stored sides, never a payload's omitted ones. An UNSTAMPED write the server orders itself (a completing write, or any write a server door builds: quick-score, an engine caller, a decision with no stamp) takes the server's time there, never older than the stored `ModifiedAt` (`writeStamp`), so it leaves a fence a later stale replay is ordered against; only a client's unstamped running or scheduled write keeps the unstamped bypass. A changed group applies when `domain.ApplyByTimestamp(stamp, storedGroupStamp)` (0 on either side applies) and takes the write's stamp; otherwise the stored value is copied in and the group is HELD (its incoming value goes to `MergeReport.HeldValues`). A group the write does not change always takes the stored value. An applied group whose value equals the stored one is `Unchanged` (an echo); for a write that NAMES NO groups at all (`Changed` nil: bulk-score, an older client, which cannot tell an echo from a change) it keeps the stamp it already had rather than taking the write's, and `ModifiedAt` moves only when some applied group actually changed, so a whole-match echo can never fence out a real, older change made on another device in the gap. A write that NAMES a group takes the write's stamp there even when the group echoes: naming it is a real action taken at that time (an operator re-sends the value their screen showed, or a replayed decision), not a re-send of everything the write happened to carry, and `ModifiedAt` moves with it. A HELD group whose value equals the stored one is no loss (`HeldEcho`, bc-mrgc phase 3: a decision's "no overtime" over a match with none): it is neither listed in `heldGroups` nor kept in `HeldValues`, and its history outcome is `unchanged`. The write is SUPERSEDED only when something is held (or echo-held) and every applied group is an echo (`MergeReport.Superseded`): then nothing is written to the match file, exactly as before. The report rides on `MatchResult.Merge`; `ResultChanged` false (the verdict did not move: held, or applied as an echo of the stored one, e.g. the same withdrawal sent again under a later stamp) skips the eligibility record, since re-recording a stored withdrawal would rewrite its status and undo a reinstatement made since. Corrections get no exemption: a stale correction is held like any other change.
 - **R2** (operator: "points scored means the withdrawal was a mistake"): a kiken, fusenpai or fusensho is ATOMIC with what it changes and is held whole when any of its groups is held or ANY stored points or bout stamp is newer than it (`withdrawalOutranked`); `recordDecisionTx` asks the same merge on a copy first (`decisionHeldByMerge`), so a stale decision is superseded before its refusals judge it. A scoring change (points, a bout, the engi flags, with a different value) in a RUNNING write stamped after a stored withdrawal clears it (`ClearsWithdrawal` set, the cleared result kept in history as `clearedWithdrawal`); `restoreIfWithdrawalRemoved` restores eligibility. That clear needs an actual SCORING change against a withdrawal of the match itself -- an overtime toggle alone says nothing about whether the withdrawal was a mistake -- and it must give the match its winner: a clear that would leave a knockout tied is abandoned and the decision stands, held as below, never answered `needs_winner`. Overtime enters this rule only when its value actually changes (an echoed (E) is a plain no-op), and a hold records a reason only when it held something that is not an echo. A kiken, fusenpai or fusensho (a fusensho is awarded for a bar recorded on ANOTHER match: the other side cannot fight) already decided who won, and neither a point, a bout, nor an (E) tap the board still sends says otherwise, so the decision stands and the whole scoring side of the write -- points and overtime alike -- is held together instead (`holdDefaultWinScoring`; the history reason names the decision, `defaultWinStandsReason`, e.g. "a fusensho closed this match"), answered with its own code, `heldReason: "default_win_stands"`, and the decision, `heldDecision` (`MergeReport.DefaultWinStands`/`StandingDecision`; the message from `messageForHeldReason`, worded through `domain.DecisionWord`; the client's `writeDefaultWinStands`/`writeHeldDecision` and `decisionWord` in write_result.jsx; `HeldDecision()` is non-empty exactly when `HeldReason()` is `default_win_stands`, so every answer carries the two together), so the operator is told which decision closed the match and to correct it from the match's score editor (the copy names no button: a kachinuki editor offers no Remove), rather than told a newer change exists or to correct the result with a winner. A COMPLETED correction keeps a stored withdrawal exactly as before (`KeepsWithdrawalRuling`, the `clearWithdrawal` flag).
 - **R3** (operator: "stay finished, add the point"): a running write's scoring change stamped AFTER a finished match's `result` stamp applies to the finished match, which stays finished; `deriveWinnerAfterMerge` works the winner out again through the existing owners (engi flags, `deriveKachinukiWinner`, `TeamResult` IV then PW then `deriveDaihyosenWinner`, `CountScoringIppons` with the Ht mark breaking a tie). An engi match is never a draw: a winner only on a valid flag total (`engiValidTotal`), pool and knockout alike (bc-mrgc phase 3; a pool recount to an even total used to become a hikiwake). One stamped before it, or unstamped, is held whole. A points change whose write does not apply `result` keeps a stored hantei mark (`carryHantei`, through `domain.AppendHantei`): the judges' decision is the result's, so a late foul or a board that never showed the mark cannot erase it; `stripInvalidHantei` still drops it if the new scoreline is not tied. The score handler treats such a write as a correction: no court gate, no StartMatchTx (`writesOverFinished`), and the old `staleAfterComplete` `{stale:true}` drop is gone. A server-built write that names `result` on purpose (the daihyosen add to a finished knockout match) is not R3's shape.
 - **R4** (operator ruling 2026-10-04, replacing the implementer's back-to-running edge: "It needs a winner if the match is finished and is being corrected"): a scoring change that would leave a FINISHED knockout match tied, or an engi match (pool or knockout) with no valid flag count, is NOT applied. `deriveWinnerAfterMerge` reports false and changes nothing, and `mergeHold` (the one place a group is taken back out of a write) holds the scoring groups: the match keeps its recorded finish, winner and advanced winner, never goes back to running, and the change is in the history with `HoldReasonKnockoutNeedsWinner`/`HoldReasonEngiNeedsValidCount`. `MergeReport.NeedsWinner` reaches the answer as `heldReason: "needs_winner"` (`state.HeldReasonNeedsWinner`) beside `heldGroups`, with `NeedsWinnerMessage` on a fully held write, so the operator is told to correct the result with a winner. A pool or league tie becomes a completed draw (`hikiwake`). Nothing on the bracket write retracts a winner for it any more.
-- **S2, the other arrival order**: a finish whose `result` applies over scoring stored NEWER than it (a point made after the finish on a board that never saw it, arriving first) gets the verdict that scoring gives, through the same `deriveWinnerAfterMerge`, so both arrival orders end in the same state (status, winner, scoreline, stamps); the result is stamped with that newer scoring's stamp when the verdict moved (`verdictMoved`), as R3 stamps it. The finish's own hantei mark is carried onto the newer scoreline first (`carryHantei`, the S3 rule the other way round). A withdrawal is excluded (R2's `withdrawalOutranked` owns it). When the newer scoring would leave the match without the winner it needs (a knockout tie, an engi count that is not valid), stamp order says that scoring came after the finish and could not apply (R4), so the finish is APPLIED on its own scoreline and each newer scoring group is moved out of the match into the history as held (`mergeHold.displaceNewerScoring`, `MergeReport.Displaced`, one entry per stamp with door `displaced` and the R4 reason, written by `recordDisplacedHistory`, also from the engi branch); `ModifiedAt` falls back to the newest stamp left. Both arrival orders then reach the same state (status, winner, scoreline, stamps, next round) and both histories hold the tying change; the answer is applied and carries `displacedGroups` with `heldReason: "needs_winner"`. Only a finish whose payload does not carry the scoring it stood on (it names `result` alone and sends no scoreline) cannot be replayed: it is held (`needs_winner`) and the match stays as stored. Winners worked out again take a side's id from the stored match when the payload omits it (`mergeCtx.storedAID`/`storedBID`), since ids are backfilled only after the merge.
+- **S2, the other arrival order**: a finish whose `result` applies over scoring stored NEWER than it (a point made after the finish on a board that never saw it, arriving first) gets the verdict that scoring gives, through the same `deriveWinnerAfterMerge`, so both arrival orders end in the same state (status, winner, scoreline, stamps); the result is stamped with that newer scoring's stamp when the verdict moved (`verdictMoved`), as R3 stamps it. The finish's own hantei mark is carried onto the newer scoreline first (`carryHantei`, the S3 rule the other way round). A withdrawal is excluded (R2's `withdrawalOutranked` owns it). When the newer scoring would leave the match without the winner it needs (a knockout tie, an engi count that is not valid), stamp order says that scoring came after the finish and could not apply (R4), so the finish is APPLIED on its own scoreline and each newer scoring group is moved out of the match into the history as held (`mergeHold.displaceNewerScoring`, `MergeReport.Displaced`, one entry per stamp with door `displaced` and the R4 reason, written by `recordDisplacedHistory`, also from the engi branch); `ModifiedAt` falls back to the newest stamp left. Both arrival orders then reach the same state (status, winner, scoreline, stamps, next round) and both histories hold the tying change; the answer is applied and carries `displacedGroups` with `heldReason: "needs_winner"`. The same displacement covers a representative pick stamped after a representative-bout removal: when the removal applies, the pick is moved to the history (reason `HoldReasonRepBoutRemoved`, "the representative bout was removed"), and that answer carries `displacedGroups` with NO `heldReason`; the client asks `writeDisplacedForWinner` (write_result.jsx) before saying a displacement left a match without a winner. Only a finish whose payload does not carry the scoring it stood on (it names `result` alone and sends no scoreline) cannot be replayed: it is held (`needs_winner`) and the match stays as stored. Winners worked out again take a side's id from the stored match when the payload omits it (`mergeCtx.storedAID`/`storedBID`), since ids are backfilled only after the merge.
 - **The history** (internal/state/match_history.go): one append-only file per match, `competitions/<id>/history/<url.PathEscape(matchID)>.jsonl`, one JSON line per write that reached the merge: stamp, server `receivedAt`, door, session, changed groups, per-group outcome (`applied`/`unchanged`/`held`), the held groups' incoming values, any cleared withdrawal, and the `reason` when one rule held the write's groups rather than their stamps (`MergeReport.HoldReason`: `HoldReasonOlderRevision`, `HoldReasonEngiAtomic`, `HoldReasonFinishAtomic`, `HoldReasonKnockoutNeedsWinner`, `HoldReasonEngiNeedsValidCount`; the History view shows it as "Not applied: <reason>"). `StoreTx.AppendMatchHistory` stages the whole small file in the SAME transaction as the write (`LoadMatchHistory` reads it, read-your-own-writes), so an aborted transaction leaves no entry. Written at the point the write can no longer be rolled back (`recordWriteHistory`: after K3/requalification in `RecordMatchResultWithIneligibilityTx`, in `writeMatchResult`, and on the superseded paths), so a write refused by validation, a side mismatch or K3 leaves none; every direct writer above appends its own (`recordDirectHistory`) INSIDE the transaction that makes its write: the doors already in one (the reopens, the kachinuki bout remove, the downstream reopen) pass their `tx`, and the kachinuki advance, `OverrideBracketWinner` and `RevertMatchToQueue` each open a `WithTransaction` for the write and the entry together (`withBracketMatch` takes the store handle, as `withPoolMatch` does), so a process dying between the two leaves no match change without its line; a held override writes nothing and appends on its own. `recordDirectHistory` logs a failed append rather than returning it, so a failure of the append alone still lets the write commit without its entry (accepted). The history directory is created only under an existing competition directory (`ensureMatchHistoryDirLocked`), so a write after `DeleteCompetition` fails rather than resurrecting it; `DiscardDraw` deletes it (`DeleteMatchHistory`), since a regenerated draw reuses the match ids. A fully-held write must COMMIT its transaction for its entry to land: every door returns nil from its closure on `ErrMatchSuperseded` and answers after (the score/decision handlers always did; bulk-score, both daihyosen paths and `RecordMatchResult` were changed to).
-- **The answers**: a write applied in part answers applied (the merged result) plus `heldGroups` (`scoreResponseWithReopened`, `withHeldGroups`, bulk-score's top-level `heldGroups`); a fully-held one keeps the 200 `{applied:false, reason:"superseded"}` shape the SPA keys on, plus `heldGroups` (`respondSuperseded`, `SupersededMessage`: "kept in the match's history"). Either answer adds `heldReason: "needs_winner"` when R4/S2 held them (`MergeReport.HeldReason`; a fully held one then carries `NeedsWinnerMessage`; bulk-score puts it on the entry), and an applied finish that moved stored newer scoring to the history adds `displacedGroups` (`MergeReport.DisplacedGroups`) with the same `heldReason` (score, daihyosen, bulk-score's `heldGroups[]` items). `ErrMatchSuperseded` is returned as `*SupersededError` carrying the held groups and that code (`errors.Is` still matches; `HeldGroupsOf`/`HeldReasonOf` read them). A completed write stamped OLDER than the stored `result` group over a finished match is not asked for a correction reason (`applyCorrectionReasonUnderTx`, `matchSnapshot.ResultStamp`): a write that completes the match is atomic with everything else it changes (`HoldReasonFinishAtomic`, mirroring `HoldReasonEngiAtomic`), so a stale finish is held WHOLE and kept in the history rather than landing its scoreline beside a verdict it never declared; an equal stamp is an exact replay and still needs one. The request-only fields (`Changed`, `WriteDoor`, `Merge`, `ClearsWithdrawal`) never ride on a stored copy: `MatchResult.ClearRequestFields` is the one list, called on the pool write's overwrite and on every pool-match copy the store hands out.
+- **The answers**: a write applied in part answers applied (the merged result) plus `heldGroups` (`scoreResponseWithReopened`, `withHeldGroups`, bulk-score's top-level `heldGroups`); a fully-held one keeps the 200 `{applied:false, reason:"superseded"}` shape the SPA keys on, plus `heldGroups` (`respondSuperseded`, `SupersededMessage`: "kept in the match's history"). Either answer adds `heldReason: "needs_winner"` when R4/S2 held them (`MergeReport.HeldReason`; a fully held one then carries `NeedsWinnerMessage`; bulk-score puts it on the entry), and an applied finish that moved stored newer scoring to the history adds `displacedGroups` (`MergeReport.DisplacedGroups`) with the same `heldReason` (score, daihyosen, bulk-score's `heldGroups[]` items). `ErrMatchSuperseded` is returned as `*SupersededError` carrying the held groups and that code (`errors.Is` still matches; `HeldGroupsOf`/`HeldReasonOf` read them). A completed write stamped OLDER than the stored `result` group over a finished match is not asked for a correction reason (`applyCorrectionReason`, `matchSnapshot.ResultStamp`): a write that completes the match is atomic with everything else it changes (`HoldReasonFinishAtomic`, mirroring `HoldReasonEngiAtomic`), so a stale finish is held WHOLE and kept in the history rather than landing its scoreline beside a verdict it never declared; an equal stamp is an exact replay and still needs one. The request-only fields (`Changed`, `WriteDoor`, `Merge`, `ClearsWithdrawal`) never ride on a stored copy: `MatchResult.ClearRequestFields` is the one list, called on the pool write's overwrite and on every pool-match copy the store hands out.
 
-- **The client (phase 2)**: every score write names its groups. `web-mobile/js/match_groups.jsx` is the ONE client owner of the names (pinned against `state.ScalarGroups`/`BoutGroup` by the shared table `internal/state/testdata/match_groups.json`: `TestMatchGroups_SharedTable` and `match_groups_table.test.jsx`), of the comparison (`changedGroups`, on WIRE shapes only: both sides go through `toBackendMatchResult`, the adopted copy via `matchWire` in api_serializers.jsx, so a placeholder slot, an Ht placement or a winner object never reads as a change; a field the write leaves out, e.g. an omitted correction reason or a silent representative bout's ippons, is not compared, and a bout row the write does not carry is never a change), of the union (`unionChanged`: no list on either side means every group and stays so) and of a group's words (`groupLabel`). `useChangedGroups(m)` (admin_scoring_autosave.jsx) is the one hook the three editors call; every patch goes through its `claim` (the individual and team `buildPatch`, a hantei included since bc-htsd, the engi save and autosave builder). A group counts against TWO baselines: the server value the editor last AGREED with for that group (seeded at mount, moved on at each build where local equals the prop), NOT the latest prop, or an edit held while another device changed a group the editor kept its own value for would put the old value back; and the last write the editor built, or a tap taken back before the first write's echo would name nothing. A reopen is a write the server makes, not a build, so when the match the editor renders leaves `completed` (a reopen, or a send back to the queue) the editor takes the result it now holds as agreed, that group alone (`useChangedGroups`): without it, ending a reopened match again with the verdict it had named nothing, and the server kept the match running with no error. It keys on the status, not on `reopenPending`: a reopen without a reason carries that stamp, but one a correction's reason comes with (a downstream reopen, a requalification, a pool-rank override) leaves the match scheduled with its points and no stamp, and an editor that watched only the stamp named no result for it. `startPatch` names `result` alone. The outbox keeps `changed` verbatim (persist, cross-tab, rehydrate, replay); a score write that takes a queued one's place claims the union (`_claimingQueuedGroups` in `_placeWrite`, and the absorb in `recordScore`, both against the one entry `_coalesceTarget` names); `_broadcastPatch` strips it. Answers: `writeHeldGroups`/`writePartlyHeld` (write_result.jsx) for a partial apply, which the editors answer with a quiet note (`useKeptInHistoryNote`/`KeptInHistoryNote`, worded by `heldGroupsNote`) and `editMatchScore` with a toast when the write closes the editor; a superseded write leads "Not applied", never "Not saved" (`SUPERSEDED_LEAD`, `notSavedText`'s `lead`, `supersededAlertText`). The editors' closed-by-default **History** disclosure (`MatchHistoryDisclosure`, match_history_view.jsx, `data-testid="match-history"`, hidden under `selfReport`) reads `GET /api/competitions/:id/matches/:mid/history` (`RegisterMatchHistoryHandler`, stamp order with an unstamped entry at its `receivedAt`, `[]` when none, 404 for an unknown competition or match, main-gated in self-run), readable values through `formatIpponsScore`/`withdrawalLabel`/`sideWord`.
+- **The client (phase 2)**: every score write names its groups. `web-mobile/js/match_groups.jsx` is the ONE client owner of the names (pinned against `state.ScalarGroups`/`BoutGroup` by the shared table `internal/state/testdata/match_groups.json`: `TestMatchGroups_SharedTable` and `match_groups_table.test.jsx`), of the comparison (`changedGroups`, on WIRE shapes only: both sides go through `toBackendMatchResult`, the adopted copy via `matchWire` in api_serializers.jsx, so a placeholder slot, an Ht placement or a winner object never reads as a change; a field the write leaves out, e.g. an omitted correction reason or a silent representative bout's ippons, is not compared, and a bout row the write does not carry is never a change), of the union (`unionChanged`: no list on either side means every group and stays so) and of a group's words (`groupLabel`). `useChangedGroups(m)` (admin_scoring_autosave.jsx) is the one hook the three editors call; every patch goes through its `claim` (the individual and team `buildPatch`, a hantei included since bc-htsd, the engi save and autosave builder). A group counts against TWO baselines: the server value the editor last AGREED with for that group (seeded at mount, moved on at each build where local equals the prop, and by `claim.agree(group)` when an editor's adopt TAKES the server's value for that group, or when the team editor's withdrawal-removal Undo puts the whole board back to the server's (every bout group and both pick groups); an adopt that takes only PART of a group agrees it only when the editor's whole group then equals the server's (the individual editor's hantei adopt skips `points` while a point of its own is unsaved; a representative-side adopt agrees `rep` only when both sides then hold the server's picks); both baselines are kept per group), NOT the latest prop, or an edit held while another device changed a group the editor kept its own value for would put the old value back; and the last write the editor built, or a tap taken back before the first write's echo would name nothing. A reopen is a write the server makes, not a build, so when the match the editor renders leaves `completed` (a reopen, or a send back to the queue) the editor takes the result it now holds as agreed, that group alone (`useChangedGroups`): without it, ending a reopened match again with the verdict it had named nothing, and the server kept the match running with no error. It keys on the status, not on `reopenPending`: a reopen without a reason carries that stamp, but one a correction's reason comes with (a downstream reopen, a requalification, a pool-rank override) leaves the match scheduled with its points and no stamp, and an editor that watched only the stamp named no result for it. `startPatch` names `result` alone. The outbox keeps `changed` verbatim (persist, cross-tab, rehydrate, replay); a score write that takes a queued one's place claims the union (`_claimingQueuedGroups` in `_placeWrite`, and the absorb in `recordScore`, both against the one entry `_coalesceTarget` names); `_broadcastPatch` strips it. Answers: `writeHeldGroups`/`writePartlyHeld` (write_result.jsx) for a partial apply, which the editors answer with a quiet note (`useKeptInHistoryNote`/`KeptInHistoryNote`, worded by `heldGroupsNote`) and `editMatchScore` with a toast when the write closes the editor; a superseded write leads "Not applied", never "Not saved" (`SUPERSEDED_LEAD`, `notSavedText`'s `lead`, `supersededAlertText`). The editors' closed-by-default **History** disclosure (`MatchHistoryDisclosure`, match_history_view.jsx, `data-testid="match-history"`, hidden under `selfReport`) reads `GET /api/competitions/:id/matches/:mid/history` (`RegisterMatchHistoryHandler`, stamp order with an unstamped entry at its `receivedAt`, `[]` when none, 404 for an unknown competition or match, main-gated in self-run), readable values through `formatIpponsScore`/`withdrawalLabel`/`sideWord`.
 
 - **Phase 3, the remaining drop sites, each with one owner:**
   - **The running rev guard holds, never drops.** A running write with a lower `rev` than the same `revSession` already sent is answered by `holdOlderRevision` (handlers_match.go): one bare transaction, no court lock, no start gate, no correction check, and the high-water mark left alone. It calls `RecordMatchResultWithIneligibilityTx` with `engine.ForceOptions{HoldReason: engine.HoldReasonOlderRevision}`, whose `holdWriteTx` asks the merge owner on a copy with `mergeCtx.holdAll` (every changed group held, echoes excepted), records the history entry with the reason, and returns the superseded error; the answer is `respondSuperseded` with `heldGroups`. `{stale:true}` no longer exists anywhere (server, openapi, client: `_handleOkBody` and the admin toast that read it are gone).
@@ -330,9 +331,9 @@ Two distinctions that look like details and are not:
 
 **Self-run participants run the representative bout; a hantei stays the organiser's** (operator decisions 2026-09-28, bc-dhas). An anonymous self-run `PUT /score` may carry the representative-bout row (position -1, sub decision `daihyosen`) and score it like any bout. `POST`/`DELETE .../daihyosen` are public, but an anonymous caller adds or removes only on a RUNNING match (`selfRunDaihyosenRefusal`, handlers_daihyosen.go: 409 `result_finalized` with the `/score` sentence once it has finished, 409 `match_not_running` before it starts). The organiser keeps no status rule there, since an add to a finished fixed-order knockout match may be their correction (no `/reopen` exists for one). The add keeps a recorded kiken, fusenpai or fusensho; the organiser's remove of an unscored representative bout does not: it clears the match's decision and puts it back to running (`clearMatchVerdict`), while the competitor's bar stays recorded. Accepted as it is (operator decision 2026-10-02); do not report it as a new defect. An encounter holds ONE representative bout: a second add is 409 `daihyosen_exists` for every caller, and the add refuses engi, kachinuki and individual competitions and pool matches. `state.DaihyosenSubIndex` is the one finder of that row (the first -1 row).
 
-ONE judge, `holdSelfReportedWriteUnderTx` (handlers_match.go), decides everything a participant's score write is refused or rewritten for that depends on the stored match. The decision allowlist and the Rev/RevSession reset run before the lock, in `enforceSelfRunPolicy`. The judge runs under the write's lock and reads the stored match once (`matchSnapshot`, whose `Pairing` holds the stored sides and ids), and each refusal is a `selfRunRefusal` carrying its own status, code and sentence.
+ONE judge, `holdSelfReportedWriteUnderTx` (handlers_match.go), decides everything a participant's score write is refused or rewritten for that depends on the stored match. The decision allowlist and the Rev/RevSession reset run before the lock, in `enforceSelfRunPolicy`. The judge runs under the write's lock over the stored match the `/score` handler reads ONCE per write for every guard (`matchSnapshot`, whose `Pairing` holds the stored sides and ids; `applyCorrectionReason` reads the same one, and the member judge takes it as the pre-write baseline), and each refusal is a `selfRunRefusal` carrying its own status, code and sentence. Who a write seats is judged on what it LANDS, after the engine write, in the same transaction (`landedMembersRefusal`): the handler reads the match back through `stx`, which sees its own staged bytes, and compares it with the snapshot read before the write. A side member id the stored row now holds and did not hold before must be on that side's team (400 `team_member_not_in_team`: `errBoutFighterNotInTeam` on a participant's numbered row, `errRepMemberNotInTeam` on a representative pick, anyone's), and a winner member id that changed on a participant's numbered row must be one of the row's two fighters (400 `winner_member_not_in_bout`, `errWinnerMemberNotInBout`); the organiser's numbered rows are not judged. A refusal is RETURNED from the transaction closure as a `*landedWriteRefusal`, which ABORTS the transaction (no match write, no history line, no eligibility record), and is unwrapped into `engErr` after `WithTransaction` returns. It is judged only for a write the engine accepted (a superseded or rolled-back write still commits its history and restore) and only when the write, as the earlier judges leave it, INTRODUCES a member id on a judged row against the match as it stood before the write (`introducesJudgedMember`, a pure predicate over the payload rows and the pre-write snapshot; it and the judge, `membersOutsideTeams`, read ONE selection of rows, `judgedRows`: every representative-bout row against the stored one and, for a participant's write, each numbered row against the stored row at its position, `state.SubResultAt`, so a row or field added to one is added to the other): an echo of the stored ids, which the team editor stamps on every row that has a lineup, reads nothing back, because the engine never lands a member id the judge would refuse that the payload did not introduce (pinned from the engine's side by `TestEngineLandsNoMemberIDThePayloadDidNotIntroduce`, over kachinuki bouts on both store branches and a fixed-order team match's representative bout on the bracket, with stamped writes (one older than the group it rewrites, so that group is held and copied back) and both teams' starting lineups and team members saved, whose minted ids no row carries: every member id the write itself lands that the payload did not carry is a STORED one at the same position (`preserveKachinukiMemberIDs`; the merge's copies of the groups it does not apply, held or unnamed, through `CopyGroup`/`SetRepPick`; `keepQueuedScore` on a start, which that test does not send) or a winner id derived from the row's own landed side ids (`ResolveMemberWinnerID`/`ReconcileWinnerMemberID`), and an id taken from those lineups or members inside the write would be a foreign one it refuses; `MaybeAdvanceKachinuki`'s lineup ids are added after the transaction, in the handler, which the test does not reach). It judges the landed match, not the payload, because the engine rewrites a write before its merge (`applyKachinukiMerge` merges stored rows by position and fills member ids; `noteServerBoutChanges` adds the `bout:N` groups it rewrote): a pre-write probe of the payload (`engine.AppliedGroups`, removed) let a participant land another team's member on a kachinuki bout the write left out of `changed`. A group the merge does not land is the stored one in the landed match and is never judged: a stale NAMED group is in `heldGroups` and the history, an unnamed one in neither. Every member-id check (the landed rows, and the lineup PUT's `memberIDsOutsideTeam`) goes through one `memberJudge`, which reads team-members.yaml at most once and only when an id is introduced, and builds each team's member-id set once (`memberJudge.ids`); a file it cannot read refuses the write with 409 `team_members_unreadable` (`errTeamMembersUnreadable`), never a 500 the offline queue would retry forever, and since a refusal is an abort, nothing is written.
 
-A participant's score write never creates a representative bout. A -1 row on a match that has none is one the write INHERITED, from a sheet a moment behind a remove made elsewhere or from a queued write replayed after it. The judge DROPS that row, logs the drop, and writes the rest through the timestamp guard, which decides a stale one. A write that FINISHES the match on such a row is refused instead, 409 `no_daihyosen` (`errRepBoutRemoved`), and nothing is written, since a finish may take its winner from that row. Nor does it ever remove one (only `DELETE .../daihyosen` does): a write listing the bouts without the -1 row the match has comes from a sheet a moment behind an ADD, so the judge KEEPS the stored row, scored or not, and a finish is refused, 409 `daihyosen_added` (`errRepBoutAdded`). Two rows are 400 `duplicate_daihyosen`. The organiser's write is not judged here. Once the organiser records the judges' decision on it, a participant's write may send the row back (`sameHanteiVerdict`: same winner, same side names, mark in the same array) or leave its ippons out. The silence test is `engine.KeepsStoredDaihyosenVerdict`, the one `preserveSubHantei` restores by; a row with two or more outstanding fouls is never silent, because the fold would give it an array. Either way the judge REPLACES that row with a deep copy of the stored one, so the write lands with the decided bout exactly as recorded, whatever else the row said. Any of these is 409 `hantei_organiser_only`:
+A participant's score write never creates a representative bout. A -1 row on a match that has none is one the write INHERITED, from a sheet a moment behind a remove made elsewhere or from a queued write replayed after it. The judge DROPS that row, logs the drop, and writes the rest through the timestamp guard, which decides a stale one. A write that FINISHES the match on such a row is refused instead, 409 `no_daihyosen` (`errRepBoutRemoved`), and nothing is written, since a finish may take its winner from that row. Nor does it ever remove one (only `DELETE .../daihyosen` does): a write listing the bouts without the -1 row the match has comes from a sheet a moment behind an ADD, so the judge KEEPS the stored row, scored or not, and a finish is refused, 409 `daihyosen_added` (`errRepBoutAdded`). Two rows are 400 `duplicate_daihyosen`. The organiser's write is not judged here, except its representative picks, which `landedMembersRefusal` judges on what the write lands, exactly as a participant's (same 400 `team_member_not_in_team` and sentence); a pick the merge holds (stamped older than the stored pick, or carried by a write held whole) is kept in the history and answered in `heldGroups`, never refused (a pick names a SIDE, whose team a correction can change under an open editor), and the match's status is never asked. Once the organiser records the judges' decision on it, a participant's write may send the row back (`sameHanteiVerdict`: same winner, same side names, mark in the same array) or leave its ippons out. The silence test is `engine.KeepsStoredDaihyosenVerdict`, the one `preserveSubHantei` restores by; a row with two or more outstanding fouls is never silent, because the fold would give it an array. Either way the judge REPLACES that row with a deep copy of the stored one, so the write lands with the decided bout exactly as recorded, whatever else the row said. Any of these is 409 `hantei_organiser_only`:
 - recording, moving or clearing the decision;
 - dropping the row;
 - naming a match `winner`/`winnerId` other than the decided side, read id-first against the STORED sides through `domain.AttributeWinnerSide`.
@@ -345,7 +346,7 @@ The public editor matches:
 - once a hantei is recorded, the representative bout is read-only (`repBoutDecidedForParticipant`, overtime stepper included) with the refusal's sentence, and every save sends the verdict back;
 - the individual editor hides its whole decision place.
 
-`POST .../bulk-score` and `PUT .../quick-score` write without these checks, so they are main-gated in self-run.
+`POST .../bulk-score` and `PUT .../quick-score` write without the participant's checks, so they are main-gated in self-run; bulk-score does judge each entry's representative picks on what the entry lands, in the entry's own transaction (a refused entry stores nothing and reports `reason: team_member_not_in_team`), and quick-score builds its rows server-side.
 
 **A representative-bout add or remove holds the team editor's autosave** (bc-dhas). The add and remove go through `_daihyosenRequest` (api_client.jsx) on `_fetchJson`, which keeps one AbortController armed, on a timer rather than the wall clock, until the body is read. So a request the server never answers, or answers with a body that never completes, fails with the not-added/not-removed sentence instead of holding the write forever. The add and the remove are one sequence, `runRepBoutChange` (admin_scoring_team.jsx). It takes `hold()` before its pre-save. The pre-save is bounded by the same `FETCH_TIMEOUT_MS` (write_result.jsx), past which the change is reported as not answered, nothing is sent and the hold is released. Add and Remove both stay disabled while that save is still out (`submitting`), so no second change starts beside a pre-save given up on. The admin hosts' refetch after a write is bounded too (`refreshCompsBestEffort` asks `fetchCompetitions({ bounded: true })`), and one given up on at that deadline says nothing: `_fetchJson` rejects past its deadline with the one `timedOut` error however the abort surfaced, and `refreshFailureToast` (admin.jsx) returns no toast for it, because the hosts refresh after every autosave and on a slow link the toast would follow every few taps while the write reaches the page by push anyway. Any other refresh failure keeps the reload hint. `recordScore`, `recordDecision`, `overrideBracketWinner` and the queue's replay (`_flushQueue`, single-flight, so one stalled replay stopped every later flush) read their answers through `_fetchJson` too, so a body that stalls past the deadline is a network failure: the write comes back `{queued: true}` (the editor stays open, `writeKeepsEditorOpen`) and is replayed with the stamp it was sent with, safe if the server did store it because the write guard is last-write-wins and an equal stamp re-applies. The add saves the sheet first unless the match has finished, so a queued match starts through the score path's gates; the remove saves first only a running sheet with an edit owed. A debounce that fires while held defers its write, and the mounted editor calls `release()` from an effect on `daihyosenBusy`'s true-to-false edge, after the render that adopted the result. The adopt keeps the answer in the override, `{ match, at }`: a stamped answer the prop does not hold yet (`holdsAnswer`) becomes the match the sheet shows, with the answer's bout log, status and team-match overtime (the prop's winner and decision stay, since the client reshapes those), and it goes once the prop's bout log changes or its stamp reaches `at`; a change of the prop's STATUS re-judges it too (an effect on `match.status`, which releases it when the prop holds the same bout log and is not older than the answer), so a finish or reopen made elsewhere is not hidden behind it. `hold()` returns `settle(transform)`, called on every exit (`withServerDaihyosenRow` over the answer's row once landed, or over the last prop's when that prop already holds the answer; bare in `finally`): an edit owed when the editor UNMOUNTS during the request waits for it and is written with the outcome applied (the added row as returned, a removed one left out, unchanged on failure or refusal). A page going away (`pagehide`) meanwhile writes it at once, durably, as it stands, since nothing can wait for it; a tab merely hidden (`visibilitychange`) waits for the request like the unmount does and then writes durably with the outcome applied, since a write at once would put back a removed representative bout or wipe an added one. Accepted residual: a hidden page the system discards before the request answers, with no `pagehide`, loses that one tap. The pre-save (`saveRunningSheet`) repeats while a tap made during it is owed, reading the sheet through the autosave refs: the request is stamped when it is sent, so an edit made before it and written after it would lose the guard silently.
 
@@ -367,6 +368,8 @@ A picker that FILTERS A LIST by what the reader typed asks ONE rule for the comp
 
 The workbook is built entirely from code in `internal/excel/template.go` (`NewFileFromScratch`). Each sheet (data, Time Estimator, Pool Draw, Pool Matches, Elimination Matches, Names to Print, Tree) is created and styled programmatically. Layout constants (rows-per-page, spacing, max bracket size) and sheet name constants (`SheetData`, `SheetPoolDraw`, etc.) live in `internal/helper/constants.go`. Use these constants everywhere rather than string literals.
 
+**excelize is pinned to a master commit, not a release** (`v2.11.1-0.20261010030226-066c84b8f7de`, operator decision 2026-10-10, PR #463): v2.11.0 carries fifteen advisories that fail CI's Anchore image scan (`validate`, severity medium and up), each fixed only on excelize's master, and no release after v2.11.0 existed. Move to the first tagged release that contains those fixes. `govulncheck` does not see them (it counts reachable code); to reproduce the scan, run grype on the built binary (`docker run --rm -v <dir>:/scan:ro anchore/grype:latest dir:/scan --fail-on medium`; the image is `FROM scratch`, so the binary is all it scans). An excelize version change rewrites the bytes of the committed example workbooks (this one changed only font property order and numbers written to 15 significant digits), so `TestCreateHandler_WithoutTeamMatchTypeMatchesTheExamples` fails: regenerate them with `make examples` and compare the workbooks' XML (cells, formulas, styles, page breaks), not their bytes, before committing.
+
 ### Resource Embedding
 
 `main.go` embeds `web/*` via `//go:embed`. The global var `helper.WebFs` exists for backward compatibility with code paths that still reference it directly. Must rebuild after changing embedded files.
@@ -444,7 +447,7 @@ Name[, Zekken/DisplayName], Dojo[, DanGrade][, source]
 
 ## Common Pitfalls
 
-- **A team's people are its "team members", never its "squad"** in UI strings, in `docs/`, and on disk (operator ruling 2026-09-16, bc-dnst). The store file is `team-members.yaml`, renamed from `squads.yaml` (root key `squads` -> `members`). **A storage change carries a migration path on load covering the last TWO releases** (operator rule 2026-09-17): `upgradeTeamMembersFilenameLocked` (legacy_upgrade.go) adopts v2.0.0's file on first load and removes it once the new one is written, so a tournament recorded by that release keeps its members. v1.1.0 and earlier stored none, so that is the whole history. It converges rather than dual-reading, so only one shape stays live. The route is `GET /api/competitions/:id/team-members` and its payload key is `teamMembers`; both were renamed with the file, with no compatibility shim, because client and server ship in one binary. Three team writes are deliberately PUBLIC in self-run (operator decision 2026-09-27, bc-dhas, "Open lineups to participants"): the ones the public score sheet makes when a competitor names a bout's fighter, `PUT .../teams/:tid/match-lineups/:matchId`, `POST .../teams/:tid/members` and `PUT .../teams/:tid/members/:memberId`. They are NOT in `isSelfRunMainGatedConfigRoute`; their handlers hold a caller with an EMPTY password (`selfRunAnonymous`, middleware.go, shared with `/score`'s `enforceSelfRunPolicy` and the representative bout's add and remove) to the score path's rule. A password sent but wrong is an organiser with a stale one: it gets 401 with AuthMiddleware's body (`respondInvalidPassword`), never a participant's sentence. That is why the member POST asks `selfRunAnonymous` too. The rule has these parts: no lineup change once the match has finished (409 `result_finalized`, from the `resultFinalized` helper the score path and the representative bout's add and remove use, with the lineup's own sentence; an unknown match is 404) or for a team the match does not hold by id (404 `team_not_in_match`); no renaming a member who already has a name (409 `member_already_named`, a `selfRunRefusal`); no adding or naming a member once the competition has finished (409 `competition_finished`); and no add past `selfRunMemberLimit` (2 x team size + `SquadReserveSlots`, 409 `team_member_limit`), because a member can never be removed; the count and the add are ONE step under the store lock (`AddTeamMemberUpTo`, reached through the `deps.go` interface), since a count taken before the add let concurrent anonymous adds pass it together. The finished-competition refusal is judged there too, and in `NameUnnamedTeamMember`, under the lock the competition's completion takes (`state.ErrCompetitionFinished`), never from the handler's earlier read, which a finish could land after. The match-lineup PUT also refuses an anonymous caller's member id the named team does not hold among the positions the save writes (the changed ones when it names them, `LineupRequest.memberIDsRead`) (400 `team_member_not_in_team`, `memberIDsOutsideTeam`, read through `StoreTx.LoadSquads`), so a participant cannot seat another team's member, or an invented id, in a lineup; the organiser is not judged by it. Every member write answers with the member as stored, stamped (`TeamMember.ModifiedAt`, `Store.stampMember`: the server's time in ms, or one more than the member's previous stamp, so one member's stamps only grow): POST 201, PUT and DELETE 200 (they were 204), and all three announce the change (`lineup-updated` naming the team), POST included. A member name longer than `MaxLenPlayerName` is 400 for every caller. Each of these handlers resolves the caller before reading the body. The organiser, sending the password, keeps mp-q722's always-editable rule. Every other lineup or member route (`GET team-members`, `DELETE members/:memberId`, the round lineups PUT/DELETE, `DELETE match-lineups`) MUST stay in that list or it becomes publicly reachable in self-run; pinned by `self_run_team_writes_test.go`. When you add a route here, decide which side it is on and pin it there. The public page sends an EMPTY `X-Tournament-Password`, never omits it. A public surface reads a team's members from the viewer payload, never from `GET team-members`: the self-run score editor gets them through `MatchViewerModal`'s `teamMembers` prop, and `TeamScoreEditorModal` calls `fetchSquads` only when no host passed them. "Squad" survives as a code name only, in identifiers such as `squadMemberLabel`, `squadSlotLabel` and `squadRosterEntries`, and in the client-side `squads` property that `normalizeViewerCompItem` maps the wire key onto (note `normalizeCompetitionDetail` SPREADS the payload instead, so that shape carries `teamMembers`: two shapes, two names, one concept). The Lineups page heading reads "Team members"; write the same in any new operator copy or docs page.
+- **A team's people are its "team members", never its "squad"** in UI strings, in `docs/`, and on disk (operator ruling 2026-09-16, bc-dnst). The store file is `team-members.yaml`, renamed from `squads.yaml` (root key `squads` -> `members`). **A storage change carries a migration path on load covering the last TWO releases** (operator rule 2026-09-17): `upgradeTeamMembersFilenameLocked` (legacy_upgrade.go) adopts v2.0.0's file on first load and removes it once the new one is written, so a tournament recorded by that release keeps its members. v1.1.0 and earlier stored none, so that is the whole history. It converges rather than dual-reading, so only one shape stays live. The route is `GET /api/competitions/:id/team-members` and its payload key is `teamMembers`; both were renamed with the file, with no compatibility shim, because client and server ship in one binary. Three team writes are deliberately PUBLIC in self-run (operator decision 2026-09-27, bc-dhas, "Open lineups to participants"): the ones the public score sheet makes when a competitor names a bout's fighter, `PUT .../teams/:tid/match-lineups/:matchId`, `POST .../teams/:tid/members` and `PUT .../teams/:tid/members/:memberId`. They are NOT in `isSelfRunMainGatedConfigRoute`; their handlers hold a caller with an EMPTY password (`selfRunAnonymous`, middleware.go, shared with `/score`'s `enforceSelfRunPolicy` and the representative bout's add and remove) to the score path's rule. A password sent but wrong is an organiser with a stale one: it gets 401 with AuthMiddleware's body (`respondInvalidPassword`), never a participant's sentence. That is why the member POST asks `selfRunAnonymous` too. The rule has these parts: no lineup change once the match has finished (409 `result_finalized`, from the `resultFinalized` helper the score path and the representative bout's add and remove use, with the lineup's own sentence; an unknown match is 404) or for a team the match does not hold by id (404 `team_not_in_match`); no renaming a member who already has a name (409 `member_already_named`, a `selfRunRefusal`); no adding or naming a member once the competition has finished (409 `competition_finished`); and no add past `selfRunMemberLimit` (2 x team size + `SquadReserveSlots`, 409 `team_member_limit`), because a member can never be removed; the count and the add are ONE step under the store lock (`AddTeamMemberUpTo`, reached through the `deps.go` interface), since a count taken before the add let concurrent anonymous adds pass it together. The finished-competition refusal is judged there too, and in `NameUnnamedTeamMember`, under the lock the competition's completion takes (`state.ErrCompetitionFinished`), never from the handler's earlier read, which a finish could land after. The match-lineup PUT also refuses an anonymous caller's member id the named team does not hold among the positions the save writes (the changed ones when it names them, `LineupRequest.memberIDsRead`) (400 `team_member_not_in_team`, `memberIDsOutsideTeam`, through the score judge's `memberJudge`: a save naming no member id reads no file, and a team-members.yaml that cannot be read is 409 `team_members_unreadable`), so a participant cannot seat another team's member, or an invented id, in a lineup; the organiser is not judged by it. Every member write answers with the member as stored, stamped (`TeamMember.ModifiedAt`, `Store.stampMember`: the server's time in ms, or one more than the member's previous stamp, so one member's stamps only grow): POST 201, PUT and DELETE 200 (they were 204), and all three announce the change (`lineup-updated` naming the team), POST included. A member name longer than `MaxLenPlayerName` is 400 for every caller. Each of these handlers resolves the caller before reading the body. The organiser, sending the password, keeps mp-q722's always-editable rule. Every other lineup or member route (`GET team-members`, `DELETE members/:memberId`, the round lineups PUT/DELETE, `DELETE match-lineups`) MUST stay in that list or it becomes publicly reachable in self-run; pinned by `self_run_team_writes_test.go`. When you add a route here, decide which side it is on and pin it there. The public page sends an EMPTY `X-Tournament-Password`, never omits it. A public surface reads a team's members from the viewer payload, never from `GET team-members`: the self-run score editor gets them through `MatchViewerModal`'s `teamMembers` prop, and `TeamScoreEditorModal` calls `fetchSquads` only when no host passed them. "Squad" survives as a code name only, in identifiers such as `squadMemberLabel`, `squadSlotLabel` and `squadRosterEntries`, and in the client-side `squads` property that `normalizeViewerCompItem` maps the wire key onto (note `normalizeCompetitionDetail` SPREADS the payload instead, so that shape carries `teamMembers`: two shapes, two names, one concept). The Lineups page heading reads "Team members"; write the same in any new operator copy or docs page.
 - **Never write "default win"** in anything a person reads: a UI string, a docs page, an API message, a commit or PR (operator ruling 2026-10-04: "such thing does not exist"). Every finished match has a result: a scoreline, or a registered decision that names the winner (kiken, fusenpai, fusensho, hantei). Name the decision (`domain.DecisionWord` in Go, `decisionWord` in write_result.jsx); say "decision" only where several kinds are meant together. Internal identifiers keep the old name (`IsDefaultWinDecisionStr`, `DefaultWinIppons`, the wire code `default_win_stands`), since no person reads them. The other forms are the same concept and banned with it: "default loss", "default winner", and a side that wins, won (never the contraction "won't"), loses or is winning "by default". Enforced by three gates sharing three patterns, pinned by one shared case table (`internal/mobileapp/testdata/default_win_cases.json`, read by the Go and JS gate tests): "default" then win(s) or loss(es) with at least one separator (any space, a hyphen, `{}`, quotes or `+`, and a word boundary after, so a camelCase identifier or `variant="default" winner` passes); "default", whitespace, winner(s); and wins, won, winning or loses followed within 40 characters by "by", whitespace, "default" (crossing line breaks, stopping at a full stop or a table-cell `|`). The words "winners", "lost" and "losing" are deliberately left out of the last pattern: they refused ordinary settings and connection prose ("Winners per pool is 2 by default"). The gates: `TestNoDefaultWinInStringLiterals` (every Go string literal under internal/ and cmd/, `+`-joined literals checked as one) with `TestNoDefaultWinInPersonReadText` (every git-tracked person-read text file outside docs/: `specs/openapi.yaml`, tracked `specs/**/*.md`, and the root `*.md` except CLAUDE.md and AGENTS.md), a FORBIDDEN rule in `web-mobile/check-write-result.mjs` (the comment-stripped WHOLE file; also index.html and styles.css) and `docs/check_prose.py` (paragraph-wide, on tag- and emphasis-stripped text; a fenced block or comment ends a paragraph).
 - **Kendo uses NO MATS. Never write "mat" or "mats"** in code, comments, tests, UI strings, docs or commit messages. The fighting area is a **shiaijo** (in prose, a **court**); "shiai-jo" hyphenated on the public `docs/` site. "Mat" is judo/wrestling vocabulary and is simply wrong for this sport. Reaching for it to avoid repeating "court" is how it gets in. (The only legitimate `mat` in the tree is a QR bitmap variable in `web-mobile/js/qr.jsx`, plus the rule's own name inside `docs/check_prose.py`.)
 - Excel coordinates matter: changing match generation requires updating cell references and formula links across sheets
@@ -458,6 +461,7 @@ Name[, Zekken/DisplayName], Dojo[, DanGrade][, source]
 - Chained match navigation in the admin score editor (Prev/Next buttons, Finish + Start Next, ←/→ keys) must stay on the current match's shiaijo, and the AUTOMATIC advance (Finish + Start Next, the start after a withdrawal or no-show) also stays in the current match's competition (operator ruling 2026-09-26: one operator per court, scoring from the court view; an operator view never switches competition or court by itself). The tournament-wide Scores page lists every competition, so its `nextActiveFrom` filters on the open match's `compId`; the court console's `nextActiveAfter` always did. Prev/Next, which the operator taps, still move along the whole court. Operators run matches per-court, so hopping courts mid-flow breaks the workflow. See `AdminScoreEditor` in `web-mobile/js/admin_schedule_score_editor.jsx` (`admin_schedule.jsx` only re-exports it): filter to `(m.court || "") === (openMatch.court || "")` so empty/undefined courts share one "unassigned" bucket.
 - Docs under `docs/` are PUBLIC-facing: no beads (`mp-xxxx`)/`bd`, no internal-tooling or `CLAUDE.md` references, and NO em-dashes. The PR template gates `make docs/build`; run it before pushing docs changes.
 - `mkdocs build --strict` fails on broken cross-file links (WARNING) but only logs missing same-page anchors as INFO (build still passes), so verify anchors by hand. Anchors use pymdownx slugs: lowercase, punctuation dropped, `--`/parens collapsed to single hyphens (e.g. `### Locked mode (--lock-password)` becomes `#locked-mode-lock-password`). Note TWO files named `mobile-app.md` exist (`docs/user-guide/mobile-app.md` guide vs `docs/user-guide/commands/mobile-app.md` reference); a relative link from `commands/` resolves to the sibling, so confirm the target file before trusting a flagged anchor.
+- **A court call is the console's, and withdrawing one that is already gone is not a failure** (bc-cdbl, operator decisions 2026-10-08 Q1 (a) and Q2 3A). The console that called a match keeps the announcement id per match and withdraws it once that match leaves scheduled; the server never tags an announcement with a match. `AnnouncementStore.Add` replaces an active announcement with the identical message (new id, fresh duration), and the id it replaced still withdraws the one that replaced it (`replaced`; an alias whose announcement has gone is dropped at the next add or removal, `dropOrphanAliasesLocked`), so a console holding the older id can take the call down. When two consoles called the same match, the second withdrawal finds it gone: `API.deleteAnnouncement` reads a 404 as the outcome the caller asked for (the banner is gone), on the console and the organiser's Dismiss alike. The browser still logs the 404 response itself; that line is not the app's.
 - **A lineup read never answers 404 for "nothing saved"** (bc-k404, operator decision 2026-09-27: "there either is one or there isn't and it's empty"). All three public lineup GETs (`lineups/:round`, `match-lineups/:matchId`, `lineup-in-force/:matchId`) in `internal/mobileapp/handlers_lineup.go` answer 200 with `saved: false` and an empty lineup instead; `api_client.jsx`'s `lineupOrNull`, used by `fetchTeamLineup` and `fetchLineupInForce`, is the ONE place that turns `saved: false` into `null`, and a 404 there means the competition itself does not exist. Do not re-add a not-found answer for an unsaved lineup.
 
 ## PR Workflow
diff --git a/Dockerfile b/Dockerfile
index 4499dfb42..26d9c3079 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,5 @@
 # Build stage
-ARG GO_VERSION=1.27.1
+ARG GO_VERSION=1.27.2
 
 # Build stage
 FROM golang:${GO_VERSION} AS builder
diff --git a/Dockerfile.mobile b/Dockerfile.mobile
index 370e8d48b..f09d7826f 100644
--- a/Dockerfile.mobile
+++ b/Dockerfile.mobile
@@ -1,5 +1,5 @@
 # Build stage
-ARG GO_VERSION=1.27.1
+ARG GO_VERSION=1.27.2
 
 # Build stage
 FROM golang:${GO_VERSION} AS builder
diff --git a/Dockerfile.mobile-pdf b/Dockerfile.mobile-pdf
index 33abe49e3..84fb72ba1 100644
--- a/Dockerfile.mobile-pdf
+++ b/Dockerfile.mobile-pdf
@@ -11,7 +11,7 @@
 # libreoffice-nogui). The Go binary's LocateSoffice() probes $PATH first, so no
 # additional env vars are required.
 
-ARG GO_VERSION=1.27.1
+ARG GO_VERSION=1.27.2
 
 # ---------------------------------------------------------------------------
 # Build stage, identical to Dockerfile.mobile
diff --git a/GEMINI.md b/GEMINI.md
index 3d799d52c..6f3202d48 100644
--- a/GEMINI.md
+++ b/GEMINI.md
@@ -84,7 +84,7 @@ On tree and knockout brackets, the player/team on the top of the bracket is alwa
 ## Building and Running
 
 ### Prerequisites
-- Go 1.27.1+
+- Go 1.27.2+
 - Make
 
 ### Key Commands
diff --git a/Makefile b/Makefile
index a09c2832a..f026f24fc 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@ BIN_NAME := bracket-creator
 GH_REPOSITORY ?= gitrgoliveira/bracket-creator
 IMAGE_NAME := ghcr.io/$(GH_REPOSITORY)
 BIN_PATH := ./bin
-GO_VERSION := 1.27.1
+GO_VERSION := 1.27.2
 GO_SOURCES := $(shell find . -name "*.go" -type f)
 EMBEDDED_ASSETS := $(shell find ./web ./web-mobile -type f 2>/dev/null)
 
@@ -51,8 +51,14 @@ local/deps: hooks/install js/deps ## Install project dependencies
 	# golangci-lint is lower than the targeted Go version"). `go install pkg@ver`
 	# runs outside this module, so it would otherwise use whatever `go` is on
 	# PATH rather than the toolchain go.mod asks for.
-	GOTOOLCHAIN=go$(GO_VERSION) go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.13.1
-	GOTOOLCHAIN=go$(GO_VERSION) go install github.com/securego/gosec/v2/cmd/gosec@v2.29.0
+	# The version also matters on its own: each analyser reads the standard
+	# library's export data through its bundled golang.org/x/tools, and go1.27.2
+	# writes a newer export-data version than x/tools v0.49 can read ("export
+	# data version 5 is greater than maximum supported version 4"). golangci-lint
+	# v2.14.0 bundles x/tools v0.50. No gosec release does yet, so gosec is pinned
+	# to the master commit that does (x/tools v0.51); move it to the next tag.
+	GOTOOLCHAIN=go$(GO_VERSION) go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.14.0
+	GOTOOLCHAIN=go$(GO_VERSION) go install github.com/securego/gosec/v2/cmd/gosec@v2.29.1-0.20261009120814-7b1b5cebe007
 	GOTOOLCHAIN=go$(GO_VERSION) go install golang.org/x/vuln/cmd/govulncheck@latest
 	python3 -m pip install -r docs/requirements.txt
 
diff --git a/docs/architecture/data-model.md b/docs/architecture/data-model.md
index 31252eaa0..065b52822 100644
--- a/docs/architecture/data-model.md
+++ b/docs/architecture/data-model.md
@@ -383,7 +383,23 @@ That applies one level further down as well. A team bout carries its two fighter
 MEMBER ids beside their names, and the winner's id beside the winner's name. Without them
 a bout between two people who happen to share a display name could not be attributed at
 all, because the name identifies neither of them, and competitors are allowed to share
-one.
+one. The representative bout is the one row whose sides are the TEAM names: it keeps them
+and carries the two representatives' member ids beside them, the members picked for each
+side. Each side's id is a change of its own, ordered apart from the other side's and from
+the bout's score and result: a point struck on the representative bout never alters who was
+picked, a pick never alters the score, and a pick for one side never alters the other side's
+pick. So two captains picking at the same moment both land, and so do two boards doing one
+each. The winner's member id
+stays with the bout, and after a merge it always names one of the two picked members (or is
+empty): when a pick changes under it, it is worked out again from the side that won. A pick
+is a member of the team seated on its side, so when a knockout match is given another team on
+a side (a winner corrected upstream, a slot taken back to its placeholder, a qualifier
+repainted), that side's pick is cleared and dated at that moment, later than the pick had
+been. The write that made the old pick, replayed from a queue, is then kept in the match's
+history instead of seating the old team's member on the new team. A side whose team does not
+change (the same winner stored again, or the team only renamed) keeps its pick. A side taken
+back to its placeholder loses its pick, even when the match that feeds it is finished again
+with the same winner: the pick is picked again.
 
 Those are two different namespaces, and the field names keep them apart on purpose. A
 match side carries a PARTICIPANT id, which names a competitor or a whole team; a bout side
@@ -575,8 +591,9 @@ sequenceDiagram
 
 **Concurrent writes are merged, never dropped.** A match result is split into groups of
 fields that change together: the scoreline, the verdict (status, winner, decision and the
-notes that describe it), the overtime, the engi flags, the representative players, and each
-bout of a team match on its own. A write names the groups it changes, and each group records
+notes that describe it), the overtime, the engi flags, the representative players, each side's
+fighter picked for a representative bout (one group per side), and each bout of a team match on
+its own. A write names the groups it changes, and each group records
 the time of the last change applied to it. A change applies only when it was made no earlier
 than the stored change to the same group, so two operators changing different things (one
 records the overtime while another enters a point, or two bouts of a team match are scored on
diff --git a/docs/architecture/network-architecture.md b/docs/architecture/network-architecture.md
index 865fab618..be6b373d8 100644
--- a/docs/architecture/network-architecture.md
+++ b/docs/architecture/network-architecture.md
@@ -153,7 +153,7 @@ Key client mechanisms (all in `web-mobile/js/api_client.jsx` + consumers):
 | Half-open / stalled sockets | 12s write timeouts, 35s SSE silence watchdog (armed at connect, not only `onopen`) |
 | Reconnect storms | exponential backoff + jitter (vs. a fixed delay) |
 | Lost writes | durable outbox persisted to `localStorage`, retried until it lands, with no age limit; survives tab refresh. Each pending write is its own entry, and each is sent on its own. A flush pass sends the entries in the order they were made (their `modifiedAt`), but one that does not land (offline, or a 5xx that keeps coming back) holds back nothing after it, and a new write goes straight to the server whatever is queued, so holding it back would gain nothing (refer to **Order of writes** in this table) and would let one failing write stop every write after it. A later running update never takes the place of a queued Finish or decision, and a decision and a score for the same match are both kept; only a score write folds into the score write queued just before it (a running update into a running update, a Finish into either, as when the editor re-sends a held Finish), naming every group either changed. A lineup save is the other write that folds: it takes the place of a queued save of the same lineup, because a lineup save restates the whole lineup and carries no time the server could order it by. A refusal on replay is always reported, never taken as success. Every tab of the app shares the stored outbox. A tab saving its queue merges into it: it adds its own writes, keeps the newer copy where two tabs hold the same entry, and removes only the writes it settled. Each tab also takes up the writes another tab stores, so a write queued in a tab that then closes is still sent by a tab left open. A write two tabs hold can be sent by both, which is harmless, because the server orders writes by their stamps (refer to **Order of writes** in this table) |
-| Order of writes | nothing a device sends is thrown away, and changes are put in the order they were made (the write's `modifiedAt`), never the order they arrive. A device stamps a write with its estimate of the server's time, and never earlier than the match it was made against: two devices' estimates can differ by up to the 5 s the server accepts, so a change made a moment after a write stamped by a device running ahead would otherwise read as older than the write it changed. The stamp is therefore the later of the device's time and the stamp of the match as the operator saw it plus 1 ms (for an autosave, as it was at the tap), never more than 4 s past the device's time. A score write names the groups of the match it changes (`changed`: `points`, `result`, `encho`, `flags`, `rep`, or one bout row, `bout:<position>`). The score editor works this out by comparing what it sends with the match it was showing. The server applies each named group only if the write is not older than the last change applied to that group, and never touches a group the write does not name, so two devices changing different things both land whatever order they arrive in. A named group a newer change outranks is not applied: its value is kept in the match's history (`GET /api/competitions/:id/matches/:mid/history`), which the score editors show under **History**. A write applied in part answers with `heldGroups`; one none of which applied answers `{"applied": false, "reason": "superseded"}` with the same list, and the editor says "Not applied" rather than "Not saved". A change that would leave a finished match without the winner it needs (a knockout match left tied, an engi match with no valid flag count) is not applied either: the match keeps its recorded result, the change is kept in the history, and the answer adds `heldReason: "needs_winner"`, on which the editor tells the operator to correct the result with a winner. A change from a board still scoring a match, or its overtime, that a kiken, fusenpai, or fusensho (a withdrawal, or a win recorded for a competitor barred elsewhere) already closed is held as well: that decision stands, and the history gives the reason. The other arrival order is answered applied: an older finish that arrives after a newer scoring change which would leave it without a winner is recorded, that later change is moved to the history (an entry of its own, at its own time), and the answer names it in `displacedGroups` with the same `heldReason` and no `heldGroups`; the editor says "Saved" and what was moved, and a held finish replayed this way raises one information alert. Where the outbox folds a queued running update into a later one, the later one names every group either changed. The same holds for the writes that are not score sheets: an older save the same device had already followed with a newer one (an out-of-order delivery after a reconnect) is kept whole in the history as an "older revision of this board"; a winner set by hand that a newer result outranks is kept in the history with the winner it named, and answered like a held score; an engi result is ordered by when it was saved, its flags and the winner they decide kept together. A queued decision whose first send landed but whose answer was lost is answered as recorded when it is sent again |
+| Order of writes | nothing a device sends is thrown away, and changes are put in the order they were made (the write's `modifiedAt`), never the order they arrive. A device stamps a write with its estimate of the server's time, and never earlier than the match it was made against: two devices' estimates can differ by up to the 5 s the server accepts, so a change made a moment after a write stamped by a device running ahead would otherwise read as older than the write it changed. The stamp is therefore the later of the device's time and the stamp of the match as the operator saw it plus 1 ms (for an autosave, as it was at the tap), never more than 4 s past the device's time. A score write names the groups of the match it changes (`changed`: `points`, `result`, `encho`, `flags`, `rep`, each side's representative pick, `repPickA` and `repPickB`, or one bout row, `bout:<position>`). The score editor works this out by comparing what it sends with the match it was showing. The server applies each named group only if the write is not older than the last change applied to that group, and never touches a group the write does not name, so two devices changing different things both land whatever order they arrive in. A named group a newer change outranks is not applied: its value is kept in the match's history (`GET /api/competitions/:id/matches/:mid/history`), which the score editors show under **History**. A write applied in part answers with `heldGroups`; one none of which applied answers `{"applied": false, "reason": "superseded"}` with the same list, and the editor says "Not applied" rather than "Not saved". A change that would leave a finished match without the winner it needs (a knockout match left tied, an engi match with no valid flag count) is not applied either: the match keeps its recorded result, the change is kept in the history, and the answer adds `heldReason: "needs_winner"`, on which the editor tells the operator to correct the result with a winner. A change from a board still scoring a match, or its overtime, that a kiken, fusenpai, or fusensho (a withdrawal, or a win recorded for a competitor barred elsewhere) already closed is held as well: that decision stands, and the history gives the reason. The other arrival order is answered applied: an older finish that arrives after a newer scoring change which would leave it without a winner is recorded, that later change is moved to the history (an entry of its own, at its own time), and the answer names it in `displacedGroups` with `heldReason: "needs_winner"` and no `heldGroups`; the editor says "Saved" and what was moved, and a held finish replayed this way raises one information alert. A representative pick made after its representative bout was removed is moved to the history the same way when the removal arrives, and that answer names it in `displacedGroups` with no `heldReason`. Where the outbox folds a queued running update into a later one, the later one names every group either changed. The same holds for the writes that are not score sheets: an older save the same device had already followed with a newer one (an out-of-order delivery after a reconnect) is kept whole in the history as an "older revision of this board"; a winner set by hand that a newer result outranks is kept in the history with the winner it named, and answered like a held score; an engi result is ordered by when it was saved, its flags and the winner they decide kept together. A queued decision whose first send landed but whose answer was lost is answered as recorded when it is sent again |
 | Edits not yet sent | a score editor holds each edit for a short autosave window (300ms) before it writes it. The sync pill reads "Syncing…" from the first tap, not "Synced". If the editor goes away inside that window (closed, Prev/Next, another match picked, a court switch), the edit is written at once. If the tab is hidden or unloaded inside it, the edit is written straight into the outbox, so a reload does not lose it. An autosave carries the time of the tap, not the time it is sent, so it never outranks a result another device recorded after the tap. A running write already sent but not yet answered is also kept when the page goes away, which cancels its request; while the request is still open, that copy is not sent |
 | Server errors (5xx / 429), and 403 | write stays queued and keeps retrying until it lands, holding back no other write; after 10 consecutive rejections the operator gets a notice and the sync pill shows "Not saving", and the match's score editor offers **Discard held result**, which discards that write and nothing else after a confirm. The held-writes count in the admin topbar opens a list of every held write (score updates, results, decisions, winners set by hand, lineups), where any write that keeps failing can be discarded the same way, one at a time; a write only waiting for the connection cannot be discarded there. On this server 403 is never a bad credential (that is 401): it means the tournament is not configured yet, or is missing its password. Only an admin fixing the server state clears it, so signing in again cannot help and the write keeps retrying instead of parking |
 | Invalid credential (401) | the one 4xx a retry can fix: the write is parked, not discarded, stops retrying, and shows "Sign in to save"; signing in again re-sends it with the new credential, together with every other queued write still carrying the refused password (one queued after it, before its own 401 came back), so one sign-in is enough. A write queued without a password (a competitor's in a self-run event) is never given one |
diff --git a/docs/dev-guide/contributing.md b/docs/dev-guide/contributing.md
index 5f91985ab..b36a9d303 100644
--- a/docs/dev-guide/contributing.md
+++ b/docs/dev-guide/contributing.md
@@ -9,7 +9,7 @@ By participating in this project, you agree to abide by our
 
 Prerequisites:
 
-- [Go 1.27.1+](https://golang.org/doc/install)
+- [Go 1.27.2+](https://golang.org/doc/install)
 
 Other things you might need to run the tests:
 
diff --git a/docs/screenshots/console-correct-completed.png b/docs/screenshots/console-correct-completed.png
index 1538f92e6..37cd7bf04 100644
Binary files a/docs/screenshots/console-correct-completed.png and b/docs/screenshots/console-correct-completed.png differ
diff --git a/docs/screenshots/realtime-update.webm b/docs/screenshots/realtime-update.webm
index f9b8caad5..d6512b90b 100644
Binary files a/docs/screenshots/realtime-update.webm and b/docs/screenshots/realtime-update.webm differ
diff --git a/docs/screenshots/viewer-competition.png b/docs/screenshots/viewer-competition.png
index 0ec21102c..bf2927a80 100644
Binary files a/docs/screenshots/viewer-competition.png and b/docs/screenshots/viewer-competition.png differ
diff --git a/docs/screenshots/viewer-result-encho.png b/docs/screenshots/viewer-result-encho.png
index ab41967b2..730266086 100644
Binary files a/docs/screenshots/viewer-result-encho.png and b/docs/screenshots/viewer-result-encho.png differ
diff --git a/docs/user-guide/commands/version.md b/docs/user-guide/commands/version.md
index 80d06e9b1..c5bbeb820 100644
--- a/docs/user-guide/commands/version.md
+++ b/docs/user-guide/commands/version.md
@@ -8,6 +8,6 @@ bracket-creator - v1.1.0
 
 Git Commit: ee8538fa83f36ccf9910fe6fc0c42e56afaf07ca
 Build date: 2026-09-04 13:14:21 +0100
-Go version: go1.27.1
+Go version: go1.27.2
 OS / Arch: darwin arm64
 ```
diff --git a/docs/user-guide/court-operators/recording-decisions.md b/docs/user-guide/court-operators/recording-decisions.md
index 5e20fee6f..a40168504 100644
--- a/docs/user-guide/court-operators/recording-decisions.md
+++ b/docs/user-guide/court-operators/recording-decisions.md
@@ -67,6 +67,8 @@ A tie that does not affect advancement is left as a shared rank with no extra bo
 
 The bout is a single-point ippon-shobu with no time limit, between one representative from each tied team. Because it runs until someone scores, a daihyosen has no encho. The score editor lets you pick each team's representative from its roster. On the court console, the bout appears with a **(DH)** mark in the centre of the score. In pool and league standings, the team that won its daihyosen carries a **DH** badge.
 
+When a knockout team encounter is settled by a representative bout, the results workbook (**Export & print**, then **Download results (.xlsx)**) lists it on a **Representative Bouts** sheet, one section for each such encounter. A section is titled as that encounter is on the **Elimination Matches** sheet, followed by (Representative bout), with White (Shiro) on the left and Red (Aka) on the right. The bout's row shows **DH** where a numbered bout shows its number, then each team's representative with their number and name, the score, **(DH)** in the centre column, and the result mark (Ht, Kiken or Fus.) beside the side it names. A side whose representative was not picked shows no name. The sheet appears only when at least one encounter had a representative bout. The tie-break daihyosen of a team pool or league is not on it.
+
 ## Chusen (drawing lots)
 
 Chusen is the last resort when two or more tied teams have played a round of daihyosen and the bouts still do not produce a strict order. Examples are a cycle where each team beats another, an all-drawn round, or two teams finishing level on daihyosen wins.
diff --git a/docs/user-guide/court-operators/scoring-a-match.md b/docs/user-guide/court-operators/scoring-a-match.md
index 1fa107a18..b904fec41 100644
--- a/docs/user-guide/court-operators/scoring-a-match.md
+++ b/docs/user-guide/court-operators/scoring-a-match.md
@@ -15,6 +15,8 @@ On a laptop you can score without the mouse. When scoring an individual match or
 
 Everything you enter on a running match is saved as you go, so closing the editor or moving to another match keeps it, even straight after a tap. Two things are only kept when you press **Finish** or save a correction: a **Mark draw** on a running match, and changes to a finished match. If you close the editor or move to another match with one of those not yet saved, the app asks first: **Discard changes** drops it, and **Cancel** keeps you on the match.
 
+On the court console, **Finish + Start Next** records the result and starts the court's next match in the same competition. If that match cannot start, for example because one of its competitors is fighting on another shiai-jo, the **Up next** card says why.
+
 To take back a strike, tap the scored mark itself in the centre of the board. The editor says so while any mark is scored: under the marks on an individual match, and once above the first bout on a team match. Taking one back frees a cell, and the next strike you award fills it. Take both back and the next two strikes fill the cells in the order you award them, from the outside in.
 
 ### Match history
diff --git a/docs/user-guide/install/install.md b/docs/user-guide/install/install.md
index 77a91237e..8fbddfbc5 100644
--- a/docs/user-guide/install/install.md
+++ b/docs/user-guide/install/install.md
@@ -115,7 +115,7 @@ go install github.com/gitrgoliveira/bracket-creator@latest
 If you prefer to compile from source, `bracket-creator` is written in [Go](https://golang.org/).
 
 Prerequisites:
-- [Go 1.27.1+](https://golang.org/doc/install)
+- [Go 1.27.2+](https://golang.org/doc/install)
 - [Node.js](https://nodejs.org/) (`make go/build` runs `npx esbuild` to compile the web assets)
 - `curl` (used to fetch the vendored frontend runtime)
 
diff --git a/docs/user-guide/organisers/run-tournament.md b/docs/user-guide/organisers/run-tournament.md
index b48bf3b45..2c98a61f2 100644
--- a/docs/user-guide/organisers/run-tournament.md
+++ b/docs/user-guide/organisers/run-tournament.md
@@ -77,6 +77,10 @@ The same **Edit details** page also has branding and sponsor fields, below tourn
 
 Click **Announce** from the dashboard to broadcast a short message to every viewer. Choose a duration of 5, 10, 15, or 30 minutes; the message clears itself automatically when the time expires. It appears as an overlay on the viewer and display screens. Spectators who allow browser notifications can receive it in the background.
 
+Posting the same text again while it is still showing replaces the banner rather than adding a second one: viewers see one message, and its time starts again from the full duration.
+
+A court call, made with **Call to court** on the court console, is announced the same way. It disappears once the match starts, or is closed with a decision such as a fusensho, from any device, as long as the court console that made the call is still open, even if another console called the same match again meanwhile. If that console was closed or reloaded meanwhile, the call stays up until its five minutes run out.
+
 ## Registration desk
 
 Open **Registration desk** from the dashboard to access the check-in surface for the welcome table. Check-in exists only for competitions with **Check-in tracking** turned on in their Settings, and this desk is the one place to do it: it lists every competitor across those competitions so a registration helper can mark participants present as they arrive. A competition with the setting off does not appear here, and its Ordering & seeding panel carries no check-in controls either. Refer to the [Check-in workflow](#check-in-workflow).
diff --git a/docs/user-guide/organisers/team-tournaments.md b/docs/user-guide/organisers/team-tournaments.md
index d7288503b..e5bc19cb2 100644
--- a/docs/user-guide/organisers/team-tournaments.md
+++ b/docs/user-guide/organisers/team-tournaments.md
@@ -102,7 +102,7 @@ Individual bouts are scored first. Once all bouts are done, the encounter result
 
 1. The team with the highest number of individual wins (victories) wins the encounter.
 2. If wins are equal, the team with the highest points scored wins.
-3. If both wins and points are equal, the encounter is a draw in pools or league. In a knockout stage, the encounter goes to a representative bout (daihyosen). Refer to [Recording decisions](../court-operators/recording-decisions.md) for how daihyosen is handled.
+3. If both wins and points are equal, the encounter is a draw in pools or league. In a knockout stage, the encounter goes to a representative bout (daihyosen). Refer to [Recording decisions](../court-operators/recording-decisions.md) for how daihyosen is handled. The results workbook lists each representative bout on its own sheet, described under [Daihyosen](../court-operators/recording-decisions.md#daihyosen).
 
 When the encounter itself ends on a kiken, fusenpai, or fusensho, every bout that has no result yet is also credited to the other team, 2-0 each: one individual victory and two points, on top of whatever was already fought before the withdrawal. This feeds straight into the criteria above and into [Team standings and tie-breaks](#team-standings-and-tie-breaks). Refer to [Fusenpai and fusensho](../court-operators/recording-decisions.md#fusenpai-and-fusensho) for the full rule.
 
diff --git a/go.mod b/go.mod
index 04e92bc73..01e85f693 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/gitrgoliveira/bracket-creator
 
-go 1.27.1
+go 1.27.2
 
 require (
 	github.com/gin-gonic/gin v1.12.0
@@ -11,7 +11,7 @@ require (
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.12.1
-	github.com/xuri/excelize/v2 v2.11.0
+	github.com/xuri/excelize/v2 v2.11.1-0.20261010030226-066c84b8f7de
 	golang.org/x/crypto v0.57.0
 	golang.org/x/text v0.42.0
 	golang.org/x/time v0.16.0
@@ -51,13 +51,13 @@ require (
 	github.com/tiendc/go-deepcopy v1.7.2 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.2 // indirect
-	github.com/xuri/efp v0.0.1 // indirect
+	github.com/xuri/efp v0.0.2 // indirect
 	github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
 	go.mongodb.org/mongo-driver/v2 v2.8.2 // indirect
 	go.yaml.in/yaml/v3 v3.0.5 // indirect
 	golang.org/x/arch v0.30.0 // indirect
 	golang.org/x/image v0.46.0 // indirect
-	golang.org/x/net v0.58.0 // indirect
+	golang.org/x/net v0.60.0 // indirect
 	golang.org/x/sys v0.48.0 // indirect
 	google.golang.org/protobuf v1.36.12 // indirect
 )
diff --git a/go.sum b/go.sum
index 3d4c643db..f217062c3 100644
--- a/go.sum
+++ b/go.sum
@@ -104,10 +104,10 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.3.2 h1:zkEASHHyEClGeURfgNT9PJZVfAbs9oEX9QXggwWNJbc=
 github.com/ugorji/go/codec v1.3.2/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
-github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8=
-github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
-github.com/xuri/excelize/v2 v2.11.0 h1:HxaEFl6sRN2+8J5a8HaKq+0M4FsjBGMnWWtjOCPSG88=
-github.com/xuri/excelize/v2 v2.11.0/go.mod h1:jxFLbzaIwGQ5ufFNvYfUOHqXhfPaNmP14KWfmNz2Uak=
+github.com/xuri/efp v0.0.2 h1:74yhBh0nfIWLOrN76wtShYVse94pADGYS0/c86jOp8Q=
+github.com/xuri/efp v0.0.2/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
+github.com/xuri/excelize/v2 v2.11.1-0.20261010030226-066c84b8f7de h1:QRQGy38L8FOUwBEvBQarwtRqHVori7I0ryxhOiL8GjQ=
+github.com/xuri/excelize/v2 v2.11.1-0.20261010030226-066c84b8f7de/go.mod h1:d2KG/tW81cIhSeC3S7wENv3qRnOC3MDcrjDicKuZa6U=
 github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 h1:+C0TIdyyYmzadGaL/HBLbf3WdLgC29pgyhTjAT/0nuE=
 github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ=
 go.mongodb.org/mongo-driver/v2 v2.8.2 h1:b6o2m7zL8g2URuO8urBedAylxojybKXNZTxgkOcl+2w=
@@ -123,8 +123,8 @@ golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
 golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
 golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
 golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=
-golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To=
-golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU=
+golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
+golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
 golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
 golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
 golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
diff --git a/internal/engine/bracket_reseat_rep_picks_test.go b/internal/engine/bracket_reseat_rep_picks_test.go
new file mode 100644
index 000000000..cab505e7a
--- /dev/null
+++ b/internal/engine/bracket_reseat_rep_picks_test.go
@@ -0,0 +1,239 @@
+package engine
+
+// A team knockout match whose side is given ANOTHER team loses the
+// representative it held on that side: the pick is a member of the old team,
+// and the picker offers only the seated team's members (GroupRepPickA and
+// GroupRepPickB, state/match_groups.go). seatBracketSide is the one owner; these tests drive
+// it through the doors that re-seat a side with no store handle of their own
+// (a forced score correction, override-winner) and pin what must NOT change: a
+// correction that stores the same winner, and the side nobody re-seated.
+
+import (
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	rpPickA  = "pick-ryu"
+	rpPickC  = "pick-kuma"
+	rpNextID = "m-r2-0"
+)
+
+// rpRow is the representative bout of Ryu v Kuma with a pick on both sides.
+func rpRow() state.SubMatchResult {
+	return state.SubMatchResult{
+		Position: state.DaihyosenSubPosition, SideA: wrTeamA, SideB: wrTeamC,
+		SideAMemberID: rpPickA, SideBMemberID: rpPickC,
+		Decision: string(domain.DecisionDaihyosen),
+	}
+}
+
+// rpSetup stores a team knockout: m-r1-0 Ryu v Tora is played and Ryu advanced
+// into m-r2-0 side A, Kuma sits on side B (a bye through m-r1-1). m-r2-0 holds
+// a representative bout with both picks, dated mmT1 while the match itself was
+// last written at mmT2 (a point). played makes m-r2-0 a finished match whose
+// rep bout Ryu's pick won.
+func rpSetup(t *testing.T, played bool) (*Engine, *state.Store, string) {
+	t.Helper()
+	eng, store, _ := setupTestEngine(t)
+	const compID = "rp-reseat"
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Name: "rp", Kind: "team", TeamSize: 3, Status: state.CompStatusKnockout,
+	}))
+	wrSaveTeams(t, store, compID)
+	next := state.BracketMatch{
+		ID: rpNextID, MatchNumber: 3,
+		SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamC, SideBID: wrTeamCID,
+		Status:     state.MatchStatusScheduled,
+		SubResults: []state.SubMatchResult{rpRow()},
+		ModifiedAt: mmT2,
+		GroupStamps: map[string]int64{
+			state.GroupRepPickA:                         mmT1,
+			state.GroupRepPickB:                         mmT1,
+			state.BoutGroup(state.DaihyosenSubPosition): mmT1,
+			state.GroupPoints:                           mmT2,
+		},
+	}
+	if played {
+		next.Status = state.MatchStatusCompleted
+		next.Winner, next.WinnerID = wrTeamA, wrTeamAID
+		next.SubResults[0].Winner = wrTeamA
+		next.SubResults[0].WinnerMemberID = rpPickA
+		next.SubResults[0].IpponsA = []string{"M"}
+		next.GroupStamps[state.GroupResult] = mmT2
+	}
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{Rounds: [][]state.BracketMatch{
+		{
+			{ID: "m-r1-0", MatchNumber: 1, SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+				Status: state.MatchStatusCompleted, Winner: wrTeamA, WinnerID: wrTeamAID,
+				SubResults: []state.SubMatchResult{wrBout1("M")}},
+			{ID: "m-r1-1", MatchNumber: 2, SideA: wrTeamC, SideAID: wrTeamCID,
+				Status: state.MatchStatusCompleted, Winner: wrTeamC, WinnerID: wrTeamCID},
+		},
+		{next},
+	}}))
+	return eng, store, compID
+}
+
+// rpCorrect is the team editor's correction of m-r1-0 naming winner (Ryu or
+// Tora), with the bout that team's fighter won.
+func rpCorrect(winner string) *state.MatchResult {
+	id, bout := wrTeamAID, state.SubMatchResult{Position: 1, SideA: "r1", SideB: "t1", Winner: "r1", IpponsA: []string{"K"}}
+	if winner == wrTeamB {
+		id, bout = wrTeamBID, state.SubMatchResult{Position: 1, SideA: "r1", SideB: "t1", Winner: "t1", IpponsB: []string{"K"}}
+	}
+	return &state.MatchResult{
+		ID: "m-r1-0", SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+		Winner: winner, WinnerID: id, IpponsA: []string{}, IpponsB: []string{},
+		Status: state.MatchStatusCompleted, CorrectionReason: "Scoring error: wrong waza entered",
+		SubResults: []state.SubMatchResult{bout},
+	}
+}
+
+func rpNext(t *testing.T, store *state.Store, compID string) state.BracketMatch {
+	t.Helper()
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	m := b.MatchByID(rpNextID)
+	require.NotNil(t, m)
+	return *m
+}
+
+// rpOldPickReplay is the write that seated side A's pick, replayed: it names
+// that pick alone, at the stamp it was made at, and carries no sides (the stored
+// pairing fills them).
+func rpOldPickReplay() *state.MatchResult {
+	return &state.MatchResult{
+		ID: rpNextID, Status: state.MatchStatusScheduled, ModifiedAt: mmT1,
+		Changed: []string{state.GroupRepPickA}, WriteDoor: DoorScore,
+		SubResults: []state.SubMatchResult{rpRow()},
+	}
+}
+
+// assertSideAPickGone checks what every re-seat of side A must leave: side A is
+// Tora, its pick is gone, Kuma's pick stands, and the picks are dated after the
+// ones the old team's member was made at and not before the match itself.
+func assertSideAPickGone(t *testing.T, next state.BracketMatch, priorModifiedAt int64) {
+	t.Helper()
+	assert.Equal(t, wrTeamB, next.SideA)
+	assert.Equal(t, wrTeamBID, next.SideAID)
+	a, c := next.RepPicks()
+	assert.Empty(t, a, "side A was given another team: Ryu's member no longer stands for it")
+	assert.Equal(t, rpPickC, c, "side B was not re-seated: its pick stays")
+	assert.Greater(t, next.GroupStamp(state.GroupRepPickA), mmT1, "dated after the stamp the pick held")
+	assert.GreaterOrEqual(t, next.GroupStamp(state.GroupRepPickA), priorModifiedAt, "and never before the match")
+	assert.GreaterOrEqual(t, next.ModifiedAt, next.GroupStamp(state.GroupRepPickA))
+	assert.Equal(t, mmT1, next.GroupStamp(state.GroupRepPickB), "side B's pick keeps its date")
+}
+
+func TestReseat_ScheduledDownstreamLosesTheReseatedSidesPick(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	prior := rpNext(t, store, compID)
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB), ForceOptions{})
+		return err
+	}))
+	assertSideAPickGone(t, rpNext(t, store, compID), prior.ModifiedAt)
+
+	// The write that made the old pick, replayed from a queue, is older than the
+	// clear: it is kept in the history, not put back.
+	_, err := eng.RecordMatchResultWithIneligibility(compID, rpNextID, rpOldPickReplay())
+	require.ErrorIs(t, err, ErrMatchSuperseded)
+	assert.Equal(t, []string{state.GroupRepPickA}, HeldGroupsOf(err))
+	after := rpNext(t, store, compID)
+	a, c := after.RepPicks()
+	assert.Empty(t, a, "the replay did not seat Ryu's member on Tora's side")
+	assert.Equal(t, rpPickC, c)
+}
+
+func TestReseat_PlayedDownstreamLosesThePickAndItsReopenLineNamesIt(t *testing.T) {
+	eng, store, compID := rpSetup(t, true)
+	prior := rpNext(t, store, compID)
+
+	var reopened []ReopenedMatch
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB),
+			ForceOptions{Force: true, Reopened: &reopened})
+		return err
+	}))
+	require.Equal(t, []string{rpNextID}, reopenedIDs(reopened))
+	assert.Equal(t, []string{state.GroupRepPickA}, reopened[0].RepPicksCleared, "the reopened match is told its side A pick went with the team")
+
+	next := rpNext(t, store, compID)
+	assertSideAPickGone(t, next, prior.ModifiedAt)
+	assert.Equal(t, state.MatchStatusScheduled, next.Status, "its verdict went")
+	assert.Empty(t, next.Winner)
+	assert.Empty(t, next.SubResults[0].WinnerMemberID, "the rep bout's winner id went with the verdict and the pick")
+
+	entries, err := store.LoadMatchHistory(compID, rpNextID)
+	require.NoError(t, err)
+	var reopenLine *state.MatchHistoryEntry
+	for i := range entries {
+		if entries[i].Door == doorDownstreamReopen {
+			reopenLine = &entries[i]
+		}
+	}
+	require.NotNil(t, reopenLine, "the played match gets a line for its reopen")
+	assert.Contains(t, reopenLine.Changed, state.GroupRepPickA)
+	assert.NotContains(t, reopenLine.Changed, state.GroupRepPickB, "side B kept its pick")
+	assert.Contains(t, reopenLine.Changed, state.GroupResult)
+}
+
+func TestReseat_PlayedDownstreamReopenLineNamesNoPicksWhenNoneWentWithIt(t *testing.T) {
+	eng, store, compID := rpSetup(t, true)
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	m := b.MatchByID(rpNextID)
+	m.SubResults[0].SideAMemberID, m.SubResults[0].SideBMemberID = "", ""
+	require.NoError(t, store.SaveBracket(compID, b))
+
+	var reopened []ReopenedMatch
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB),
+			ForceOptions{Force: true, Reopened: &reopened})
+		return err
+	}))
+	require.Equal(t, []string{rpNextID}, reopenedIDs(reopened))
+	assert.Empty(t, reopened[0].RepPicksCleared)
+	entries, err := store.LoadMatchHistory(compID, rpNextID)
+	require.NoError(t, err)
+	for _, e := range entries {
+		assert.NotContains(t, e.Changed, state.GroupRepPickA, "there was no pick to clear")
+		assert.NotContains(t, e.Changed, state.GroupRepPickB, "there was no pick to clear")
+	}
+}
+
+func TestReseat_OverrideWinnerLosesTheReseatedSidesPick(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	prior := rpNext(t, store, compID)
+
+	applied, err := eng.OverrideBracketWinner(compID, "m-r1-0", wrTeamB, 0)
+	require.NoError(t, err)
+	require.True(t, applied)
+	assertSideAPickGone(t, rpNext(t, store, compID), prior.ModifiedAt)
+}
+
+// A correction that stores the winner already recorded re-propagates the same
+// team: nothing about the downstream match moves, its picks and their date
+// included. Green before the owner existed too; it is the no-op guard.
+func TestReseat_CorrectionStoringTheSameWinnerLeavesThePicksAlone(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	prior := rpNext(t, store, compID)
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamA), ForceOptions{})
+		return err
+	}))
+	next := rpNext(t, store, compID)
+	a, c := next.RepPicks()
+	assert.Equal(t, rpPickA, a)
+	assert.Equal(t, rpPickC, c)
+	assert.Equal(t, mmT1, next.GroupStamp(state.GroupRepPickA), "side A's pick keeps its date")
+	assert.Equal(t, mmT1, next.GroupStamp(state.GroupRepPickB), "and so does side B's")
+	assert.Equal(t, prior.ModifiedAt, next.ModifiedAt, "and the match is not touched")
+}
diff --git a/internal/engine/bracket_result.go b/internal/engine/bracket_result.go
index 4bf79cb85..8106b414b 100644
--- a/internal/engine/bracket_result.go
+++ b/internal/engine/bracket_result.go
@@ -92,6 +92,15 @@ func bracketMatchAsResult(bm *state.BracketMatch) *state.MatchResult {
 	}
 }
 
+// BracketMatchAsResult is a bracket match as the pool-shaped record every
+// write and merge reads (bracketMatchAsResult), for callers outside the engine
+// that read a stored bracket match the way they read a pool row (mobileapp's
+// matchSnapshot, before and after a score write). The result shares bm's bout
+// rows: a caller that changes it clones them first.
+func BracketMatchAsResult(bm *state.BracketMatch) *state.MatchResult {
+	return bracketMatchAsResult(bm)
+}
+
 // bracketMatchCourtAndSchedule returns the Court and ScheduledAt a bracket
 // match (a round match or the bronze/3rd-place match) currently holds,
 // bypassing bracketMatchAsResult's projection above, which deliberately
diff --git a/internal/engine/bracket_seat.go b/internal/engine/bracket_seat.go
new file mode 100644
index 000000000..fe9146d14
--- /dev/null
+++ b/internal/engine/bracket_seat.go
@@ -0,0 +1,202 @@
+package engine
+
+import (
+	"log"
+	"slices"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+// seatBracketSide is the ONE writer of a knockout match's side name and id
+// once the match exists: every re-seat of a side after the draw (a winner
+// propagated into the next round, a semifinal loser into the 3rd-place match,
+// a slot cleared back to its "Winner of ..." placeholder, a pool qualifier
+// painted over a placeholder) goes through it. It owns the one consequence a
+// plain assignment misses: the representative a team match's rep bout holds
+// for a side is a member of the team that was seated there
+// (SubMatchResult.SideAMemberID/SideBMemberID, the state.GroupRepPickA and
+// state.GroupRepPickB groups), so a side given ANOTHER team takes its pick away.
+//
+// ReplaceParticipantInDraw, which renames a team while the competition is
+// draw-ready, writes a side through here when the side carries the team's id
+// (the same id under a new name: the same team, so no pick is cleared). A
+// representative bout CAN exist in a draw-ready competition: the add commits
+// the running match in its own transaction and starts the competition after
+// it, and a failed start is only logged. A side with no id (a legacy row) is
+// renamed there directly, and only the row's name follows it (nameRepBoutRow),
+// since this function would read an id-less old name to a new one as another
+// team. The match's Winner is written directly in both cases; it is not a side.
+//
+// INVARIANT: after every call -- a winner propagated, a slot cleared back to
+// "" or a "Winner of ..." placeholder, a pool qualifier painted, a rename
+// re-propagated -- the representative bout row's SideA/SideB for THIS side
+// EQUALS the match's SideA/SideB for that side, whatever the string is (a
+// placeholder or empty included: one rule, no special case). The hantei mark
+// is placed on the winner's side by comparing the winner against that row's
+// names (placeHt), so a row still naming the team that was taken out would
+// attribute the verdict to nobody. The name is written on EVERY call, before
+// anything is judged, so it follows a rename as well as a re-seat; it dates
+// nothing on its own (no group stamp, no ModifiedAt: a name write is not a
+// change of the bout, which is what lets a draw-time caller produce exactly
+// the bracket it always did). A side that kept its team and only has a new name
+// takes the row's Winner along when it named the side by the old name, the
+// row's own or the match's (nameRepBoutRow). A match with no row has nothing to
+// write.
+//
+// Whether the side was given ANOTHER team is judged by id when both the side as
+// stored and the incoming one carry an id, and by name otherwise
+// (seatedAnotherTeam):
+//
+//   - Both ids set: another team exactly when they differ. A rename (the same
+//     id under a new name), or a correction that stores the winner already
+//     recorded and so re-propagates the same team, is not one: the name is
+//     written and the pick stays.
+//   - Either id empty: another team exactly when the names differ. That covers
+//     a slot going back to a placeholder or to "" (the name differs from any
+//     team's), a placeholder resolved to a team, and legacy id-less data,
+//     where the client resolves an id-less side's team by name and so a pick
+//     CAN sit on it. The same name with an id arriving (the side that carried
+//     only its team's name gaining the team's id) is the same team, and so is
+//     a writer that does not know the id (an incoming "" beside the name
+//     already seated): neither clears the pick, and the stored id is never
+//     thrown away for a writer that did not know it.
+//
+// This mirrors the client's rule (admin_scoring_team.jsx: a side is given
+// another team only when BOTH its lookup key and the team it resolves to
+// change; "a side that carried only its team's name gaining that team's id is
+// not one") and the carve-out BracketMatch has in CLAUDE.md (resolve by id when
+// present, fall back to the name only for an empty slot, an unresolved feeder
+// or a legacy row a repair has not reached).
+//
+// When the side was given another team, name and id are written, and a pick
+// held for THAT side is cleared. The other side's pick is never touched. With
+// no pick on that side, or no rep bout row at all, nothing else moves.
+//
+// The cleared pick is dated max(now, its previous stamp + 1, the match's
+// ModifiedAt) through StampGroups, which never lowers, and ONLY that side's
+// group is dated: the other side's pick keeps its date, so a pick made for it
+// on another device is still ordered by its own write. The date is strictly
+// above the date the pick held, so a replay of the write that made it is kept
+// in the match's history instead of seating the old team's member on the new
+// team's side, and never below the match. It is NOT the stamp of the correction
+// that caused the re-seat: that is a client stamp made against a different
+// match, and a pick written after the correction but before it arrived would
+// keep a stamp at or above it.
+//
+// It runs inside UpdateBracket callbacks, which hold no store handle, so it
+// writes the match in place and records no history line of its own (a played
+// downstream match gets one for its reopen, which names the group
+// (markRepPicksCleared, from the door's snapshot diff in bracket_seat_audit.go);
+// a scheduled one is logged here).
+func seatBracketSide(bm *state.BracketMatch, side domain.MatchSide, name, id string) {
+	var nameField, idField *string
+	switch side {
+	case domain.MatchSideA:
+		nameField, idField = &bm.SideA, &bm.SideAID
+	case domain.MatchSideB:
+		nameField, idField = &bm.SideB, &bm.SideBID
+	default:
+		log.Printf("engine: BUG: bracket match %s: seatBracketSide called with side %q; nothing written", bm.ID, side)
+		return
+	}
+	another := seatedAnotherTeam(*nameField, *idField, name, id)
+	matchOld := *nameField
+	*nameField = name
+	// An incoming "" beside the name already seated is a writer that did not
+	// know the id, not a removal: the id a repair resolved stays.
+	if id != "" || another {
+		*idField = id
+	}
+
+	row := state.DaihyosenSubIndex(bm.SubResults)
+	if row < 0 {
+		return
+	}
+	// The row's name follows the match's on every call, a rename included, and
+	// dates nothing (the invariant in the doc comment).
+	nameRepBoutRow(bm, row, side, name, matchOld, another)
+	if !another {
+		return
+	}
+	pickA, pickB := bm.RepPicks()
+	held := pickA
+	if side == domain.MatchSideB {
+		held = pickB
+	}
+	if held == "" {
+		return
+	}
+	bm.SetRepPick(side, "")
+	// The bout's winner id is derived from the picks and the winner's name, so
+	// it follows the pick that went.
+	bm.SubResults[row].ReconcileWinnerMemberID()
+	log.Printf("engine: bracket match %s: side %s was given another team, so its representative pick %q is cleared", bm.ID, side, held)
+	g := state.RepPickGroup(side)
+	bm.StampGroups(max(serverNowMs(), bm.GroupStamp(g)+1, bm.ModifiedAt), g)
+}
+
+// seatedAnotherTeam reports whether re-seating a side that is stored as
+// (storedName, storedID) to (name, id) gives it another team: by id when both
+// carry one, by name otherwise (the rule in seatBracketSide's doc comment).
+func seatedAnotherTeam(storedName, storedID, name, id string) bool {
+	if storedID != "" && id != "" {
+		return storedID != id
+	}
+	return storedName != name
+}
+
+// nameRepBoutRow writes name as side's name on the rep bout row at index row.
+// The list is replaced, never edited in place, so a row another copy of the
+// match shares is never written through (state.withRepPick does the same for a
+// pick); a name the row already has writes nothing and copies nothing, unless
+// its Winner still names the side by matchOld (the carry below). another
+// says the side was given another team: a side that kept its team (a rename)
+// also takes the row's Winner along when it names the side by the old name,
+// whether that is the row's own old side name or matchOld, the match's name for
+// the side before the rename. The match's counts because a row's side name can
+// be blank or stale while its Winner still reads as the match's: AddDaihyosen
+// stamps the names and adoptCurrentSideName only rewrites a row carrying the old
+// name, never fills a blank, but the merge lands a payload row's names as sent,
+// so a writer that does not restate them (rows written before the names rule,
+// the ones resolveBoutSideName's filter exists for; hand-edited data) leaves
+// them blank, and the rename would otherwise leave the Winner on the old team
+// name and the hantei credited to nobody.
+func nameRepBoutRow(bm *state.BracketMatch, row int, side domain.MatchSide, name, matchOld string, another bool) {
+	field := func(r *state.SubMatchResult) *string {
+		if side == domain.MatchSideA {
+			return &r.SideA
+		}
+		return &r.SideB
+	}
+	old := *field(&bm.SubResults[row])
+	// A side that kept its team and only has a new name keeps what the row
+	// decided: the row's Winner names that team by the name it was recorded
+	// under (the row's, or the match's), and the mark is placed by comparing
+	// the two. A side given another team leaves the Winner as it was, the
+	// decision of the team that left. It is worked out before the row's own
+	// name is compared with the new one, because a row can already read the new
+	// name while its Winner still reads the old (a writer that restated the
+	// rename on the row alone).
+	w := bm.SubResults[row].Winner
+	carry := !another && w != "" && w != name && (w == old || w == matchOld)
+	if old == name && !carry {
+		return
+	}
+	subs := slices.Clone(bm.SubResults)
+	*field(&subs[row]) = name
+	if carry {
+		subs[row].Winner = name
+	}
+	bm.SubResults = subs
+}
+
+// feedsSide is the side of the next match (and of the 3rd-place match, for a
+// semifinal loser) that the match at index mIdx of its round feeds: the
+// round's even matches feed side A, the odd ones side B.
+func feedsSide(mIdx int) domain.MatchSide {
+	if mIdx%2 == 0 {
+		return domain.MatchSideA
+	}
+	return domain.MatchSideB
+}
diff --git a/internal/engine/bracket_seat_audit.go b/internal/engine/bracket_seat_audit.go
new file mode 100644
index 000000000..299dcc93f
--- /dev/null
+++ b/internal/engine/bracket_seat_audit.go
@@ -0,0 +1,165 @@
+package engine
+
+import (
+	"slices"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+// The history is the record of a re-seat; the log line seatBracketSide prints is
+// only its trace.
+//
+// A write that gives a knockout side another team takes the representative the
+// old team's member held on that side with it (seatBracketSide, the one clearer).
+// A downstream match the same write REOPENS names the group on its reopen line
+// (ReopenedMatch.RepPicksCleared, restoreForceReopened). Every other match a
+// bracket door re-seats -- the scheduled or requeued next round, the bronze, a
+// round further on that a retraction unwinds into, a slot a requalification
+// repaint paints -- changed outside any score write of its own, so it records
+// its own line too (recordDirectHistory: "every direct writer appends its own,
+// INSIDE the transaction that makes its write"), or a pick would vanish with
+// nothing in the match's history to say when or why.
+//
+// The mechanism needs no change to the re-seating functions and so covers every
+// route to a re-seat, the byes a winner passes through included: a door takes
+// ONE snapshot of the bracket's picks before it mutates the bracket
+// (repPickSnapshot) and diffs it afterwards (repPickClears) while it still holds
+// the bracket. That diff is the only account of what a door took from a pick: a
+// reopen captures none of its own. markRepPicksCleared copies it onto the reopen
+// line of each match the same write reopened (ReopenedMatch.RepPicksCleared), and
+// recordRepPickClears records the rest beside the place that already records the
+// reopen lines, in the same transaction. Only clears are diffed: nothing a door
+// does inside its bracket callback sets a pick, and one a writer sets is that
+// write's own change, which the merge's history line names. A pick replaced by
+// another is not a clear.
+
+// clearedPick is one side's representative pick that a door's mutation took
+// out, with the stamp seatBracketSide gave the group when it did.
+type clearedPick struct {
+	Group string
+	Stamp int64
+}
+
+// repPickClear is the picks one match lost to a door's mutation.
+type repPickClear struct {
+	MatchID string
+	Cleared []clearedPick
+}
+
+// repPickSnapshot records, for every round match and the 3rd-place match, the
+// representatives it holds on side A and side B, leaving out a match that holds
+// none. own is the match the door itself writes: its pick groups are that
+// write's to name (the merge's per-group line), never a re-seat's, so it is left
+// out of the snapshot and so can never appear in the diff. "" for a door that
+// writes no bracket match of its own.
+func repPickSnapshot(b *state.Bracket, own string) map[string][2]string {
+	out := map[string][2]string{}
+	if b == nil {
+		return out
+	}
+	note := func(m *state.BracketMatch) {
+		if m.ID == own {
+			return
+		}
+		if a, c := m.RepPicks(); a != "" || c != "" {
+			out[m.ID] = [2]string{a, c}
+		}
+	}
+	for ri := range b.Rounds {
+		for mi := range b.Rounds[ri] {
+			note(&b.Rounds[ri][mi])
+		}
+	}
+	if b.ThirdPlaceMatch != nil {
+		note(b.ThirdPlaceMatch)
+	}
+	return out
+}
+
+// repPickClears lists, in bracket order, the picks of before that the bracket no
+// longer holds: a side whose pick was non-empty and is now empty or has no
+// bout row left to carry one. The stamp of each is read from the bracket now, so
+// the recorder needs no second read. A nil before (a door that records nothing,
+// e.g. the K3 rollback replaying a prior) yields nothing.
+func repPickClears(before map[string][2]string, b *state.Bracket) []repPickClear {
+	if len(before) == 0 || b == nil {
+		return nil
+	}
+	var out []repPickClear
+	diff := func(m *state.BracketMatch) {
+		was, ok := before[m.ID]
+		if !ok {
+			return
+		}
+		a, c := m.RepPicks()
+		now := [2]string{a, c}
+		lost := repPickClear{MatchID: m.ID}
+		for i, side := range [...]domain.MatchSide{domain.MatchSideA, domain.MatchSideB} {
+			if was[i] != "" && now[i] == "" {
+				g := state.RepPickGroup(side)
+				lost.Cleared = append(lost.Cleared, clearedPick{Group: g, Stamp: m.GroupStamp(g)})
+			}
+		}
+		if len(lost.Cleared) > 0 {
+			out = append(out, lost)
+		}
+	}
+	for ri := range b.Rounds {
+		for mi := range b.Rounds[ri] {
+			diff(&b.Rounds[ri][mi])
+		}
+	}
+	if b.ThirdPlaceMatch != nil {
+		diff(b.ThirdPlaceMatch)
+	}
+	return out
+}
+
+// markRepPicksCleared records, on every reopened match the diff names, the pick
+// group of each side whose representative the door's re-seats took
+// (ReopenedMatch.RepPicksCleared, side A before side B, as repPickClears lists
+// them). A door calls it once, right after taking clears, so its reopened
+// matches and its reseat lines are both judged from the one snapshot; a match
+// the diff does not name keeps a nil list. recordRepPickClears then leaves out
+// the groups a reopen line names.
+func markRepPicksCleared(reopened []ReopenedMatch, clears []repPickClear) {
+	for i := range reopened {
+		for _, c := range clears {
+			if c.MatchID != reopened[i].ID {
+				continue
+			}
+			for _, p := range c.Cleared {
+				reopened[i].RepPicksCleared = append(reopened[i].RepPicksCleared, p.Group)
+			}
+		}
+	}
+}
+
+// recordRepPickClears appends, for each match in clears, one history line with
+// door doorReseat naming the pick groups that went (state.RepPickGroup), applied,
+// stamped with the group's stamp after the mutation (the later of the two when a
+// match lost both). A group a reopen line in reopened already names is skipped:
+// that line is its record, and a second would claim the change twice. It is
+// called with the SAME handle the bracket write used, beside restoreForceReopened,
+// so the lines land with the write or not at all.
+func (e *Engine) recordRepPickClears(h state.StoreTx, compID string, clears []repPickClear, reopened []ReopenedMatch) {
+	for _, c := range clears {
+		var groups []string
+		var stamp int64
+		for _, p := range c.Cleared {
+			named := slices.ContainsFunc(reopened, func(r ReopenedMatch) bool {
+				return r.ID == c.MatchID && slices.Contains(r.RepPicksCleared, p.Group)
+			})
+			if named {
+				continue
+			}
+			groups = append(groups, p.Group)
+			stamp = max(stamp, p.Stamp)
+		}
+		if len(groups) == 0 {
+			continue
+		}
+		e.recordDirectHistory(h, compID, c.MatchID, doorReseat, stamp, groups...)
+	}
+}
diff --git a/internal/engine/bracket_seat_audit_test.go b/internal/engine/bracket_seat_audit_test.go
new file mode 100644
index 000000000..5a112a9a8
--- /dev/null
+++ b/internal/engine/bracket_seat_audit_test.go
@@ -0,0 +1,501 @@
+package engine
+
+// A bracket door that gives a knockout side another team takes the
+// representative pick the old team's member held on it (seatBracketSide). A
+// downstream match the write REOPENS names the pick on its reopen line; every
+// other match the write re-seats -- scheduled or requeued, the bronze, a round
+// further on that a retraction unwinds into, a slot a requalification repaint
+// paints -- used to get a log line and nothing in its history. These tests pin
+// that each such match gets exactly one `reseat` line naming the group, from
+// each door, and that a reopened match keeps ONLY its reopen line.
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	auHawk   = "Hawk"
+	auHawkID = "44444444-4444-4444-8444-444444444444"
+)
+
+// auLines is the whole history of one match.
+func auLines(t *testing.T, store *state.Store, compID, matchID string) []state.MatchHistoryEntry {
+	t.Helper()
+	entries, err := store.LoadMatchHistory(compID, matchID)
+	require.NoError(t, err)
+	return entries
+}
+
+// auDoor is the entries of lines written through door.
+func auDoor(lines []state.MatchHistoryEntry, door string) []state.MatchHistoryEntry {
+	var out []state.MatchHistoryEntry
+	for _, l := range lines {
+		if l.Door == door {
+			out = append(out, l)
+		}
+	}
+	return out
+}
+
+// auRow is a representative bout row naming both teams and a pick for each.
+func auRow(nameA, nameB, pickA, pickB string) []state.SubMatchResult {
+	return []state.SubMatchResult{{
+		Position: state.DaihyosenSubPosition, SideA: nameA, SideB: nameB,
+		SideAMemberID: pickA, SideBMemberID: pickB,
+		Decision: string(domain.DecisionDaihyosen),
+	}}
+}
+
+// auStamped dates a match's picks mmT1 and the match itself mmT2, as rpSetup
+// does, so a pick a re-seat takes is dated after the stamp it held.
+func auStamped(m state.BracketMatch) state.BracketMatch {
+	m.ModifiedAt = mmT2
+	m.GroupStamps = map[string]int64{
+		state.GroupRepPickA:                         mmT1,
+		state.GroupRepPickB:                         mmT1,
+		state.BoutGroup(state.DaihyosenSubPosition): mmT1,
+		state.GroupPoints:                           mmT2,
+	}
+	return m
+}
+
+func auSaveFourTeams(t *testing.T, store *state.Store, compID string) {
+	t.Helper()
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Name: compID, Kind: "team", TeamSize: 3, Status: state.CompStatusKnockout,
+	}))
+	require.NoError(t, store.SaveParticipants(compID, []domain.Player{
+		{ID: wrTeamAID, Name: wrTeamA, Dojo: "DojoR"},
+		{ID: wrTeamBID, Name: wrTeamB, Dojo: "DojoT"},
+		{ID: wrTeamCID, Name: wrTeamC, Dojo: "DojoK"},
+		{ID: auHawkID, Name: auHawk, Dojo: "DojoH"},
+	}))
+}
+
+// auSemifinals stores a four-team knockout with a 3rd-place match: Ryu beat
+// Tora (m-r1-0) and Kuma beat Hawk (m-r1-1), so Ryu v Kuma is the final and
+// Tora v Hawk the bronze match. Both hold a representative bout with a pick on
+// each side.
+func auSemifinals(t *testing.T) (*Engine, *state.Store, string) {
+	t.Helper()
+	eng, store, _ := setupTestEngine(t)
+	const compID = "au-bronze"
+	auSaveFourTeams(t, store, compID)
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{
+		Rounds: [][]state.BracketMatch{
+			{
+				{ID: "m-r1-0", MatchNumber: 1, SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+					Status: state.MatchStatusCompleted, Winner: wrTeamA, WinnerID: wrTeamAID,
+					SubResults: []state.SubMatchResult{wrBout1("M")}},
+				{ID: "m-r1-1", MatchNumber: 2, SideA: wrTeamC, SideAID: wrTeamCID, SideB: auHawk, SideBID: auHawkID,
+					Status: state.MatchStatusCompleted, Winner: wrTeamC, WinnerID: wrTeamCID},
+			},
+			{auStamped(state.BracketMatch{ID: "m-final", MatchNumber: 4,
+				SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamC, SideBID: wrTeamCID,
+				Status: state.MatchStatusScheduled, SubResults: auRow(wrTeamA, wrTeamC, "pick-ryu", "pick-kuma")})},
+		},
+		ThirdPlaceMatch: func() *state.BracketMatch {
+			m := auStamped(state.BracketMatch{ID: "m-bronze", MatchNumber: 3,
+				SideA: wrTeamB, SideAID: wrTeamBID, SideB: auHawk, SideBID: auHawkID,
+				Status: state.MatchStatusScheduled, SubResults: auRow(wrTeamB, auHawk, "pick-tora", "pick-hawk")})
+			return &m
+		}(),
+	}))
+	return eng, store, compID
+}
+
+// A scheduled downstream match a correction re-seats gets one `reseat` line
+// naming the side's group, dated with the stamp the re-seat gave it.
+func TestReseatAudit_ScheduledDownstreamGetsAReseatLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	require.Empty(t, auLines(t, store, compID, rpNextID), "no history before the write")
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB), ForceOptions{})
+		return err
+	}))
+
+	next := rpNext(t, store, compID)
+	a, _ := next.RepPicks()
+	require.Empty(t, a, "the pick went with the team")
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1, "exactly one line on the re-seated match")
+	assert.Equal(t, doorReseat, lines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed, "side A only: side B was not re-seated")
+	assert.Equal(t, state.HistoryOutcomeApplied, lines[0].Outcomes[state.GroupRepPickA])
+	assert.Equal(t, next.GroupStamp(state.GroupRepPickA), lines[0].Stamp, "dated with the stamp the re-seat gave the group")
+	assert.Empty(t, lines[0].Held, "nothing was held")
+	assert.Empty(t, lines[0].Reason)
+}
+
+// A played downstream match the same write reopens keeps its reopen line as the
+// record of the pick, and gets no second line.
+func TestReseatAudit_PlayedDownstreamHasOnlyItsReopenLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, true)
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB), ForceOptions{Force: true})
+		return err
+	}))
+
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1, "the reopen line, and nothing else")
+	assert.Equal(t, doorDownstreamReopen, lines[0].Door)
+	assert.Contains(t, lines[0].Changed, state.GroupRepPickA, "the reopen line names the pick that went")
+	assert.Empty(t, auDoor(lines, doorReseat))
+}
+
+// The 3rd-place match is re-seated by the same write as the final: each gets
+// its own line, for the side the semifinal feeds.
+func TestReseatAudit_TheBronzeAndTheFinalEachGetALine(t *testing.T) {
+	eng, store, compID := auSemifinals(t)
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB), ForceOptions{})
+		return err
+	}))
+
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	for _, id := range []string{"m-final", "m-bronze"} {
+		m := b.MatchByID(id)
+		require.NotNil(t, m, id)
+		a, c := m.RepPicks()
+		assert.Empty(t, a, "%s: side A was given another team", id)
+		assert.NotEmpty(t, c, "%s: side B was not", id)
+
+		lines := auLines(t, store, compID, id)
+		require.Len(t, lines, 1, "%s: one line", id)
+		assert.Equal(t, doorReseat, lines[0].Door, id)
+		assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed, id)
+		assert.Equal(t, m.GroupStamp(state.GroupRepPickA), lines[0].Stamp, id)
+	}
+	assert.Empty(t, auLines(t, store, compID, "m-r1-1"), "the other semifinal was not written")
+}
+
+// A round further on that the retraction of a reopened match unwinds into is
+// re-seated without being reopened: it gets a `reseat` line while the match
+// reopened beside it keeps only its reopen line.
+func TestReseatAudit_AMatchUnwoundBeyondTheReopenedOneGetsALine(t *testing.T) {
+	eng, store, _ := setupTestEngine(t)
+	const compID = "au-chain"
+	auSaveFourTeams(t, store, compID)
+	played := auStamped(state.BracketMatch{ID: "m-r2-0", MatchNumber: 3,
+		SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamC, SideBID: wrTeamCID,
+		Status: state.MatchStatusCompleted, Winner: wrTeamA, WinnerID: wrTeamAID,
+		SubResults: auRow(wrTeamA, wrTeamC, "pick-ryu", "pick-kuma")})
+	final := auStamped(state.BracketMatch{ID: "m-r3-0", MatchNumber: 4,
+		SideA: wrTeamA, SideAID: wrTeamAID, SideB: auHawk, SideBID: auHawkID,
+		Status: state.MatchStatusScheduled, SubResults: auRow(wrTeamA, auHawk, "pick-ryu-final", "pick-hawk")})
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{Rounds: [][]state.BracketMatch{
+		{
+			{ID: "m-r1-0", MatchNumber: 1, SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+				Status: state.MatchStatusCompleted, Winner: wrTeamA, WinnerID: wrTeamAID,
+				SubResults: []state.SubMatchResult{wrBout1("M")}},
+			{ID: "m-r1-1", MatchNumber: 2, SideA: wrTeamC, SideAID: wrTeamCID,
+				Status: state.MatchStatusCompleted, Winner: wrTeamC, WinnerID: wrTeamCID},
+		},
+		{played},
+		{final},
+	}}))
+
+	var reopened []ReopenedMatch
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamB),
+			ForceOptions{Force: true, Reopened: &reopened})
+		return err
+	}))
+	require.Equal(t, []string{"m-r2-0"}, reopenedIDs(reopened), "only the played match is reopened")
+
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	a, c := b.MatchByID("m-r3-0").RepPicks()
+	require.Empty(t, a, "the slot went back to a placeholder, and the pick with it")
+	require.Equal(t, "pick-hawk", c)
+
+	finalLines := auLines(t, store, compID, "m-r3-0")
+	require.Len(t, finalLines, 1)
+	assert.Equal(t, doorReseat, finalLines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, finalLines[0].Changed)
+
+	playedLines := auLines(t, store, compID, "m-r2-0")
+	require.Len(t, playedLines, 1, "the reopened match keeps its reopen line alone")
+	assert.Equal(t, doorDownstreamReopen, playedLines[0].Door)
+	assert.Contains(t, playedLines[0].Changed, state.GroupRepPickA)
+}
+
+func TestReseatAudit_OverrideDoorRecordsTheLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+
+	applied, err := eng.OverrideBracketWinner(compID, "m-r1-0", wrTeamB, 0)
+	require.NoError(t, err)
+	require.True(t, applied)
+
+	next := rpNext(t, store, compID)
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1)
+	assert.Equal(t, doorReseat, lines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed)
+	assert.Equal(t, next.GroupStamp(state.GroupRepPickA), lines[0].Stamp)
+}
+
+// The decision door reaches the bracket through the same primitive as a score,
+// so a withdrawal that turns the winner re-seats the next round the same way.
+func TestReseatAudit_DecisionDoorRecordsTheLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+
+	_, _, err := eng.RecordDecision(compID, "m-r1-0", "kiken-voluntary", "aka", "illness", nil)
+	require.NoError(t, err)
+
+	next := rpNext(t, store, compID)
+	require.Equal(t, wrTeamB, next.SideA, "Tora advanced in place of the team that withdrew")
+	a, _ := next.RepPicks()
+	require.Empty(t, a)
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1)
+	assert.Equal(t, doorReseat, lines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed)
+}
+
+// An engi pair never holds a representative bout, so the picks here are built by
+// hand: the door's wiring is what is pinned, the same as the others'.
+func TestReseatAudit_EngiDoorRecordsTheLine(t *testing.T) {
+	eng, store, _ := setupTestEngine(t)
+	const compID = "au-engi"
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Name: "Engi Knockout", Kind: "individual",
+		Format: state.CompFormatKnockout, PoolSize: 3, PoolWinners: 2,
+		Courts: []string{"A"}, StartTime: "09:00", Status: "setup", Engi: true,
+	}))
+	saveTestParticipants(t, store, compID, []string{"Alice", "Bob", "Charlie", "Dave"})
+	require.NoError(t, eng.StartCompetition(compID))
+
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	last := len(b.Rounds) - 1
+	sf0, sf1, finalID := b.Rounds[last-1][0].ID, b.Rounds[last-1][1].ID, b.Rounds[last][0].ID
+	_, err = eng.recordEngiMatchResult(store, compID, sf0, 3, 2, "")
+	require.NoError(t, err)
+	_, err = eng.recordEngiMatchResult(store, compID, sf1, 3, 2, "")
+	require.NoError(t, err)
+
+	b, err = store.LoadBracket(compID)
+	require.NoError(t, err)
+	final := &b.Rounds[last][0]
+	final.SubResults = auRow(final.SideA, final.SideB, "pick-a", "pick-b")
+	require.NoError(t, store.SaveBracket(compID, b))
+	require.Empty(t, auLines(t, store, compID, finalID))
+
+	_, err = eng.recordEngiMatchResult(store, compID, sf0, 2, 3, "correction")
+	require.NoError(t, err)
+
+	got, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	a, c := got.Rounds[last][0].RepPicks()
+	require.Empty(t, a, "the final's side A was given the other pair")
+	require.Equal(t, "pick-b", c)
+	lines := auLines(t, store, compID, finalID)
+	require.Len(t, lines, 1)
+	assert.Equal(t, doorReseat, lines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed)
+}
+
+// A reopen retracts the winner it had advanced: the slot goes back to a
+// placeholder, which is a re-seat too.
+func TestReseatAudit_ReopenDoorRecordsTheLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	first := b.MatchByID("m-r1-0")
+	first.Decision, first.DecisionBy = string(domain.DecisionKikenVoluntary), "B"
+	require.NoError(t, store.SaveBracket(compID, b))
+
+	_, err = eng.ReopenMatch(compID, "m-r1-0", "wrong waza")
+	require.NoError(t, err)
+
+	next := rpNext(t, store, compID)
+	a, _ := next.RepPicks()
+	require.Empty(t, a)
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1)
+	assert.Equal(t, doorReseat, lines[0].Door)
+	assert.Equal(t, []string{state.GroupRepPickA}, lines[0].Changed)
+	assert.Equal(t, next.GroupStamp(state.GroupRepPickA), lines[0].Stamp)
+}
+
+// A pool correction that moves a qualifier repaints the knockout slots it
+// filled; a repainted match nobody has played gets a `reseat` line.
+func TestReseatAudit_RequalificationRepaintRecordsTheLine(t *testing.T) {
+	f := newRQFixture(t, "au-rq", 2, [][]string{{"A1", "A2"}, {"B1", "B2"}})
+	f.scorePool("Pool A-0", "A1")
+	f.scorePool("Pool B-0", "B1")
+	f.resolve()
+	first, firstSide := f.slot("Pool A-1st")
+	second, secondSide := f.slot("Pool A-2nd")
+	require.NotEqual(t, first.ID, second.ID, "the two Pool A places sit in different matches")
+
+	group := func(side string) string {
+		if side == "A" {
+			return state.GroupRepPickA
+		}
+		return state.GroupRepPickB
+	}
+	b := f.bracket()
+	for _, p := range []struct{ id, side, pick string }{
+		{first.ID, firstSide, "pick-a1"},
+		{second.ID, secondSide, "pick-a2"},
+	} {
+		row := state.SubMatchResult{Position: state.DaihyosenSubPosition}
+		if p.side == "A" {
+			row.SideAMemberID = p.pick
+		} else {
+			row.SideBMemberID = p.pick
+		}
+		findBracketMatchInBracket(b, p.id).SubResults = []state.SubMatchResult{row}
+	}
+	require.NoError(t, f.store.SaveBracket(f.compID, b))
+
+	// A2 now wins the pool: nothing is played in the knockout, so no
+	// confirmation is asked and both places are repainted.
+	require.NoError(t, f.write("Pool A-0", f.poolResult("Pool A-0", "A2")))
+
+	after := f.bracket()
+	for _, p := range []struct{ id, side string }{{first.ID, firstSide}, {second.ID, secondSide}} {
+		m := findBracketMatchInBracket(after, p.id)
+		a, c := m.RepPicks()
+		assert.Empty(t, a+c, "%s: the repaint took the pick of the team that left the slot", p.id)
+		lines := auLines(t, f.store, f.compID, p.id)
+		reseats := auDoor(lines, doorReseat)
+		require.Len(t, reseats, 1, "%s: one reseat line", p.id)
+		assert.Equal(t, []string{group(p.side)}, reseats[0].Changed, p.id)
+		assert.Equal(t, m.GroupStamp(group(p.side)), reseats[0].Stamp, p.id)
+	}
+}
+
+// A correction that stores the winner already recorded re-seats nothing.
+func TestReseatAudit_SameWinnerLeavesNoLine(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, err := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", rpCorrect(wrTeamA), ForceOptions{})
+		return err
+	}))
+
+	assert.Empty(t, auLines(t, store, compID, rpNextID), "nothing was re-seated, so nothing is recorded")
+}
+
+// The K3 rollback replays the prior result through the same bracket callback
+// under matchWriteRestore. That re-seats the next round's side again, but a
+// restore is not a door: it records no line.
+func TestReseatAudit_ARestoreIsNotADoor(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	b, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	// The stored state a rejected write left: Tora advanced and holds a pick.
+	prior := bracketMatchAsResult(b.MatchByID("m-r1-0"))
+	first := b.MatchByID("m-r1-0")
+	first.Winner, first.WinnerID = wrTeamB, wrTeamBID
+	next := b.MatchByID(rpNextID)
+	next.SideA, next.SideAID = wrTeamB, wrTeamBID
+	next.SubResults[0].SideA, next.SubResults[0].SideAMemberID = wrTeamB, "pick-tora"
+	require.NoError(t, store.SaveBracket(compID, b))
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		eng.rollbackMatchResultTx(tx, compID, "m-r1-0", prior)
+		return nil
+	}))
+
+	got := rpNext(t, store, compID)
+	assert.Equal(t, wrTeamA, got.SideA, "the restore put the prior winner back")
+	a, _ := got.RepPicks()
+	assert.Empty(t, a, "and the pick of the team that left went with the re-seat")
+	assert.Empty(t, auLines(t, store, compID, rpNextID), "but a restore is not a door and records no line")
+}
+
+// The recorder skips the groups a reopen line already names and only those: a
+// reopened match whose reopen line does not name a group that went still gets
+// the reseat line for it.
+func TestReseatAudit_RecorderSkipsOnlyWhatAReopenLineNames(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	clears := []repPickClear{{MatchID: rpNextID, Cleared: []clearedPick{
+		{Group: state.GroupRepPickA, Stamp: 5},
+		{Group: state.GroupRepPickB, Stamp: 9},
+	}}}
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		eng.recordRepPickClears(tx, compID, clears, []ReopenedMatch{{ID: rpNextID, RepPicksCleared: []string{state.GroupRepPickA}}})
+		return nil
+	}))
+	lines := auLines(t, store, compID, rpNextID)
+	require.Len(t, lines, 1)
+	assert.Equal(t, []string{state.GroupRepPickB}, lines[0].Changed, "side A is the reopen line's, side B is not")
+	assert.Equal(t, int64(9), lines[0].Stamp, "dated with the group the line names")
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		eng.recordRepPickClears(tx, compID, clears, []ReopenedMatch{{ID: rpNextID, RepPicksCleared: []string{state.GroupRepPickA, state.GroupRepPickB}}})
+		return nil
+	}))
+	assert.Len(t, auLines(t, store, compID, rpNextID), 1, "every group named by the reopen line: no further line")
+
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		eng.recordRepPickClears(tx, compID, clears, []ReopenedMatch{{ID: "another-match", RepPicksCleared: []string{state.GroupRepPickA, state.GroupRepPickB}}})
+		return nil
+	}))
+	both := auLines(t, store, compID, rpNextID)
+	require.Len(t, both, 2, "a reopen line on another match names nothing here")
+	assert.ElementsMatch(t, []string{state.GroupRepPickA, state.GroupRepPickB}, both[1].Changed)
+	assert.Equal(t, int64(9), both[1].Stamp, "a match that lost both is dated with the later of the two")
+}
+
+// The snapshot leaves out the match the door itself writes and any match with
+// no pick, and the diff lists only a pick that is gone.
+func TestReseatAudit_SnapshotAndDiff(t *testing.T) {
+	picked := func(id, a, c string) state.BracketMatch {
+		return state.BracketMatch{ID: id, SubResults: auRow("A", "B", a, c)}
+	}
+	build := func() *state.Bracket {
+		return &state.Bracket{
+			Rounds: [][]state.BracketMatch{
+				{picked("own", "own-a", "own-b"), picked("one", "p1", "p2")},
+				{picked("two", "p3", ""), {ID: "bare"}},
+			},
+			ThirdPlaceMatch: func() *state.BracketMatch { m := picked("bronze", "", "p4"); return &m }(),
+		}
+	}
+	b := build()
+	snap := repPickSnapshot(b, "own")
+	assert.Equal(t, map[string][2]string{
+		"one": {"p1", "p2"}, "two": {"p3", ""}, "bronze": {"", "p4"},
+	}, snap, "the written match and a match with no pick are not in it")
+	assert.Contains(t, repPickSnapshot(b, ""), "own")
+	assert.Empty(t, repPickSnapshot(nil, ""))
+
+	assert.Empty(t, repPickClears(snap, b), "nothing changed")
+	assert.Empty(t, repPickClears(nil, b), "no snapshot, no diff")
+
+	b.Rounds[0][1].SetRepPick(domain.MatchSideB, "")
+	b.Rounds[1][0].SubResults = nil // the whole row went
+	b.ThirdPlaceMatch.SetRepPick(domain.MatchSideB, "p9")
+	b.Rounds[0][0].SetRepPick(domain.MatchSideA, "")
+	got := repPickClears(snap, b)
+	require.Len(t, got, 2, "a pick replaced by another is not a clear; the written match is not diffed")
+	assert.Equal(t, "one", got[0].MatchID)
+	assert.Equal(t, []string{state.GroupRepPickB}, groupsOf(got[0]))
+	assert.Equal(t, "two", got[1].MatchID)
+	assert.Equal(t, []string{state.GroupRepPickA}, groupsOf(got[1]))
+}
+
+func groupsOf(c repPickClear) []string {
+	var out []string
+	for _, p := range c.Cleared {
+		out = append(out, p.Group)
+	}
+	slices.Sort(out)
+	return out
+}
diff --git a/internal/engine/bracket_seat_test.go b/internal/engine/bracket_seat_test.go
new file mode 100644
index 000000000..035733bbc
--- /dev/null
+++ b/internal/engine/bracket_seat_test.go
@@ -0,0 +1,751 @@
+package engine
+
+// seatBracketSide's contract, and every writer that routes through it:
+// propagateBracketWinner (next match and 3rd-place match), clearPropagatedSlots
+// (reached by a reopen) and resolveSlots' qualifier paint (reached by a pool
+// requalification). The doors that carry a score correction or an override are
+// in bracket_reseat_rep_picks_test.go.
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// seatFixture is a match whose rep bout holds a pick on each side, dated 400,
+// while the match itself was last written at 500.
+func seatFixture() *state.BracketMatch {
+	return &state.BracketMatch{
+		ID:    "m",
+		SideA: "Ryu", SideAID: "a", SideB: "Kuma", SideBID: "c",
+		ModifiedAt: 500,
+		GroupStamps: map[string]int64{
+			state.GroupRepPickA:                         400,
+			state.GroupRepPickB:                         400,
+			state.BoutGroup(state.DaihyosenSubPosition): 400,
+			state.GroupPoints:                           500,
+		},
+		SubResults: []state.SubMatchResult{{
+			Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "Kuma",
+			SideAMemberID: "pa", SideBMemberID: "pc",
+			Winner: "Ryu", WinnerMemberID: "pa",
+		}},
+	}
+}
+
+func TestSeatBracketSide(t *testing.T) {
+	t.Run("the same team under another name keeps the pick and every stamp", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Ryu II", "a")
+		assert.Equal(t, "Ryu II", bm.SideA)
+		assert.Equal(t, "a", bm.SideAID)
+		a, c := bm.RepPicks()
+		assert.Equal(t, "pa", a)
+		assert.Equal(t, "pc", c)
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.BoutGroup(state.DaihyosenSubPosition)), "a name write dates nothing")
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+		assert.Equal(t, "Ryu II", bm.SubResults[0].SideA, "the row follows the rename")
+		assert.Equal(t, "Kuma", bm.SubResults[0].SideB, "the other side's name is not touched")
+		assert.Equal(t, "pa", bm.SubResults[0].WinnerMemberID, "a rename keeps the pick and the id that rides on it")
+	})
+
+	t.Run("another team on side A clears that pick only, and the winner id that rode on it", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "b")
+		assert.Equal(t, "Tora", bm.SideA)
+		assert.Equal(t, "b", bm.SideAID)
+		assert.Equal(t, "Tora", bm.SubResults[0].SideA, "the row names the team now seated")
+		assert.Equal(t, "Kuma", bm.SubResults[0].SideB, "the other side's name is not touched")
+		a, c := bm.RepPicks()
+		assert.Empty(t, a)
+		assert.Equal(t, "pc", c, "the other side was not re-seated")
+		assert.Empty(t, bm.SubResults[0].WinnerMemberID, "the winner id is derived from the picks that stand")
+		stamp := bm.GroupStamp(state.GroupRepPickA)
+		assert.Greater(t, stamp, int64(400))
+		assert.GreaterOrEqual(t, stamp, int64(500))
+		assert.Equal(t, stamp, bm.ModifiedAt, "ModifiedAt is the newest group stamp")
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB), "the other side's pick keeps its date")
+		assert.Equal(t, int64(400), bm.GroupStamp(state.BoutGroup(state.DaihyosenSubPosition)), "the bout row is not what changed")
+	})
+
+	t.Run("another team on side B clears that pick only", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideB, "Tora", "b")
+		assert.Equal(t, "Tora", bm.SubResults[0].SideB, "the row names the team now seated")
+		assert.Equal(t, "Ryu", bm.SubResults[0].SideA, "the other side's name is not touched")
+		a, c := bm.RepPicks()
+		assert.Equal(t, "pa", a)
+		assert.Empty(t, c)
+		assert.Equal(t, "pa", bm.SubResults[0].WinnerMemberID, "the winner's pick stands")
+		assert.Greater(t, bm.GroupStamp(state.GroupRepPickB), int64(400))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA), "the other side's pick keeps its date")
+	})
+
+	t.Run("a slot going back to a placeholder clears the pick", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Winner of r1-m0", "")
+		assert.Equal(t, "Winner of r1-m0", bm.SideA)
+		assert.Empty(t, bm.SideAID)
+		assert.Equal(t, "Winner of r1-m0", bm.SubResults[0].SideA, "the row names whatever the match does, a placeholder included")
+		a, _ := bm.RepPicks()
+		assert.Empty(t, a)
+	})
+
+	t.Run("a slot cleared to nothing empties the row's name too, and clears the pick", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideB, "", "")
+		assert.Empty(t, bm.SideB)
+		assert.Empty(t, bm.SideBID)
+		assert.Empty(t, bm.SubResults[0].SideB, "one rule, no special case for the empty string")
+		_, c := bm.RepPicks()
+		assert.Empty(t, c)
+		assert.Equal(t, "Ryu", bm.SubResults[0].SideA)
+	})
+
+	t.Run("the cleared pick is dated above a stamp ahead of the server clock", func(t *testing.T) {
+		bm := seatFixture()
+		ahead := serverNowMs() + 3_600_000
+		bm.GroupStamps[state.GroupRepPickA] = ahead
+		bm.ModifiedAt = ahead
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "b")
+		assert.Equal(t, ahead+1, bm.GroupStamp(state.GroupRepPickA))
+	})
+
+	t.Run("a placeholder resolved to a team has no pick to lose and changes nothing else", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SideA, bm.SideAID = "Winner of r1-m0", ""
+		bm.SubResults[0].SideAMemberID, bm.SubResults[0].WinnerMemberID = "", ""
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "a")
+		assert.Equal(t, "Ryu", bm.SideA)
+		assert.Equal(t, "a", bm.SideAID)
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB))
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("a side with no pick leaves the other side's pick and every stamp", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SubResults[0].SideAMemberID = ""
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "b")
+		_, c := bm.RepPicks()
+		assert.Equal(t, "pc", c)
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB))
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("a match with no rep bout row gains no stamp", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SubResults = nil
+		bm.GroupStamps = nil
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "b")
+		assert.Equal(t, "b", bm.SideAID)
+		assert.Nil(t, bm.GroupStamps)
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("the row another copy of the match shares is not written through", func(t *testing.T) {
+		bm := seatFixture()
+		shared := bm.SubResults
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "b")
+		assert.Equal(t, "pa", shared[0].SideAMemberID)
+		assert.Equal(t, "pa", shared[0].WinnerMemberID)
+		assert.Equal(t, "Ryu", shared[0].SideA, "nor is the name the re-seat writes")
+	})
+
+	t.Run("the row another copy of the match shares is not written through by a rename either", func(t *testing.T) {
+		bm := seatFixture()
+		shared := bm.SubResults
+		seatBracketSide(bm, domain.MatchSideA, "Ryu II", "a")
+		assert.Equal(t, "Ryu", shared[0].SideA)
+		assert.Equal(t, "Ryu II", bm.SubResults[0].SideA)
+	})
+
+	t.Run("a name that already matches the row leaves the row's list alone", func(t *testing.T) {
+		bm := seatFixture()
+		before := &bm.SubResults[0]
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "a")
+		assert.Same(t, before, &bm.SubResults[0], "no copy when there is nothing to write")
+	})
+
+	// "Given another team" is judged by id when both sides have one, by name
+	// otherwise (the client's rule in admin_scoring_team.jsx: another team only
+	// when BOTH the side's lookup key and the resolved team changed). The cases
+	// below are legacy, id-less data; the id comparison alone got both wrong.
+	t.Run("an id-less side re-seated under another name is another team: the pick goes", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SideAID = ""
+		seatBracketSide(bm, domain.MatchSideA, "Tora", "")
+		assert.Equal(t, "Tora", bm.SideA)
+		assert.Empty(t, bm.SideAID)
+		assert.Equal(t, "Tora", bm.SubResults[0].SideA)
+		a, c := bm.RepPicks()
+		assert.Empty(t, a, "the team changed although neither side has an id")
+		assert.Equal(t, "pc", c)
+		assert.Greater(t, bm.GroupStamp(state.GroupRepPickA), int64(400))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB))
+	})
+
+	t.Run("an id-less side re-seated under the same name keeps the pick and every stamp", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SideAID = ""
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "")
+		a, _ := bm.RepPicks()
+		assert.Equal(t, "pa", a)
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("a writer that does not know the id, naming the same team, neither clears the pick nor blanks the id", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "")
+		assert.Equal(t, "Ryu", bm.SideA)
+		assert.Equal(t, "a", bm.SideAID, "a resolved id is never thrown away for a writer that did not know it")
+		a, _ := bm.RepPicks()
+		assert.Equal(t, "pa", a)
+		assert.Equal(t, "pa", bm.SubResults[0].WinnerMemberID)
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickB))
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("a side that carried only its team's name gaining the team's id is not another team", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SideAID = ""
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "a")
+		assert.Equal(t, "a", bm.SideAID, "the id is written")
+		a, _ := bm.RepPicks()
+		assert.Equal(t, "pa", a, "the pick stays")
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("an id-less placeholder resolved to a team is another team, with nothing to clear", func(t *testing.T) {
+		bm := seatFixture()
+		bm.SideA, bm.SideAID = "Winner of r1-m2", ""
+		bm.SubResults[0].SideA = "Winner of r1-m2"
+		bm.SubResults[0].SideAMemberID, bm.SubResults[0].WinnerMemberID = "", ""
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "a")
+		assert.Equal(t, "Ryu", bm.SideA)
+		assert.Equal(t, "a", bm.SideAID)
+		assert.Equal(t, "Ryu", bm.SubResults[0].SideA, "the row follows the match from the placeholder to the team")
+		assert.Equal(t, int64(400), bm.GroupStamp(state.GroupRepPickA), "no pick, so nothing is dated")
+		assert.Equal(t, int64(500), bm.ModifiedAt)
+	})
+
+	t.Run("two different ids are another team whatever the names say", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Ryu", "b")
+		assert.Equal(t, "b", bm.SideAID)
+		a, _ := bm.RepPicks()
+		assert.Empty(t, a)
+	})
+
+	t.Run("a stored id and an empty one under another name is another team: the id goes with the pick", func(t *testing.T) {
+		bm := seatFixture()
+		seatBracketSide(bm, domain.MatchSideA, "Winner of r1-m2", "")
+		assert.Empty(t, bm.SideAID)
+		a, _ := bm.RepPicks()
+		assert.Empty(t, a)
+	})
+}
+
+// A semifinal re-scored: the final's and the 3rd-place match's sides both get
+// another team, and each loses the pick it held for the team that left it.
+func TestPropagateBracketWinner_ReseatsTheNextAndTheBronzeSidesAndTheirPicks(t *testing.T) {
+	eng, _, _ := setupTestEngine(t)
+	row := func(nameA, nameB, a, b string) []state.SubMatchResult {
+		return []state.SubMatchResult{{
+			Position: state.DaihyosenSubPosition, SideA: nameA, SideB: nameB,
+			SideAMemberID: a, SideBMemberID: b,
+		}}
+	}
+	bracket := &state.Bracket{
+		Rounds: [][]state.BracketMatch{
+			{
+				{ID: "sf0", SideA: "Ryu", SideAID: "a", SideB: "Tora", SideBID: "b",
+					Status: state.MatchStatusCompleted, Winner: "Ryu", WinnerID: "a"},
+				{ID: "sf1", SideA: "Kuma", SideAID: "c", SideB: "Hawk", SideBID: "d",
+					Status: state.MatchStatusCompleted, Winner: "Kuma", WinnerID: "c"},
+			},
+			{
+				{ID: "final", SideA: "Tora", SideAID: "b", SideB: "Kuma", SideBID: "c",
+					Status: state.MatchStatusScheduled, SubResults: row("Tora", "Kuma", "pb", "pk")},
+			},
+		},
+		ThirdPlaceMatch: &state.BracketMatch{
+			ID: "bronze", SideA: "Ryu", SideAID: "a", SideB: "Hawk", SideBID: "d",
+			Status: state.MatchStatusScheduled, SubResults: row("Ryu", "Hawk", "pa", "ph"),
+		},
+	}
+
+	eng.propagateBracketWinner(bracket, 0, 0)
+
+	final := bracket.Rounds[1][0]
+	assert.Equal(t, "Ryu", final.SideA)
+	fa, fb := final.RepPicks()
+	assert.Empty(t, fa, "Tora left the final's side A")
+	assert.Equal(t, "pk", fb, "Kuma did not")
+	assert.Equal(t, final.SideA, final.SubResults[0].SideA, "the final's row names the team now seated")
+	assert.Equal(t, final.SideB, final.SubResults[0].SideB, "and the side that was not re-seated")
+	bronze := bracket.ThirdPlaceMatch
+	assert.Equal(t, "Tora", bronze.SideA)
+	ba, bb := bronze.RepPicks()
+	assert.Empty(t, ba, "Ryu left the bronze match's side A")
+	assert.Equal(t, "ph", bb, "Hawk did not")
+	assert.Equal(t, bronze.SideA, bronze.SubResults[0].SideA, "the bronze match's row names the team now seated")
+	assert.Equal(t, bronze.SideB, bronze.SubResults[0].SideB)
+}
+
+// A reopen retracts the winner it had sent on: the slot goes back to its
+// "Winner of" placeholder, and the pick the advanced team's member held goes
+// with it.
+func TestReopenMatch_RetractionTakesThePickOfTheClearedSlot(t *testing.T) {
+	// A reopen is for a match a withdrawal decided: Tora withdrew from m-r1-0.
+	withdrawn := func(t *testing.T, store *state.Store, compID string) {
+		t.Helper()
+		b, err := store.LoadBracket(compID)
+		require.NoError(t, err)
+		first := b.MatchByID("m-r1-0")
+		first.Decision, first.DecisionBy = string(domain.DecisionKikenVoluntary), "B"
+		require.NoError(t, store.SaveBracket(compID, b))
+	}
+	t.Run("a match nobody has played", func(t *testing.T) {
+		eng, store, compID := rpSetup(t, false)
+		withdrawn(t, store, compID)
+		prior := rpNext(t, store, compID)
+
+		_, err := eng.ReopenMatch(compID, "m-r1-0", "wrong waza")
+		require.NoError(t, err)
+
+		next := rpNext(t, store, compID)
+		assert.Empty(t, next.SideAID, "the slot is a placeholder again")
+		assert.NotEqual(t, wrTeamA, next.SideA)
+		require.GreaterOrEqual(t, state.DaihyosenSubIndex(next.SubResults), 0)
+		assert.Equal(t, next.SideA, next.SubResults[state.DaihyosenSubIndex(next.SubResults)].SideA, "the row names the placeholder the slot went back to")
+		a, c := next.RepPicks()
+		assert.Empty(t, a)
+		assert.Equal(t, rpPickC, c)
+		assert.Greater(t, next.GroupStamp(state.GroupRepPickA), mmT1)
+		assert.GreaterOrEqual(t, next.GroupStamp(state.GroupRepPickA), prior.ModifiedAt)
+		assert.Equal(t, mmT1, next.GroupStamp(state.GroupRepPickB), "side B's pick keeps its date")
+	})
+
+	t.Run("a match already played and reopened with it", func(t *testing.T) {
+		eng, store, compID := rpSetup(t, true)
+		withdrawn(t, store, compID)
+		var reopened []ReopenedMatch
+		_, err := eng.ReopenMatch(compID, "m-r1-0", "wrong waza", ForceOptions{Force: true, Reopened: &reopened})
+		require.NoError(t, err)
+		require.Equal(t, []string{rpNextID}, reopenedIDs(reopened))
+		assert.Equal(t, []string{state.GroupRepPickA}, reopened[0].RepPicksCleared, "judged after the retraction, which comes after the reopen")
+
+		a, c := func() (string, string) { n := rpNext(t, store, compID); return n.RepPicks() }()
+		assert.Empty(t, a)
+		assert.Equal(t, rpPickC, c)
+		entries, err := store.LoadMatchHistory(compID, rpNextID)
+		require.NoError(t, err)
+		var named, namedB bool
+		for _, e := range entries {
+			if e.Door == doorDownstreamReopen && slices.Contains(e.Changed, state.GroupRepPickA) {
+				named = true
+			}
+			if e.Door == doorDownstreamReopen && slices.Contains(e.Changed, state.GroupRepPickB) {
+				namedB = true
+			}
+		}
+		assert.True(t, named, "the reopen line names the cleared side's pick group")
+		assert.False(t, namedB, "and not the side that kept its pick")
+	})
+}
+
+// The qualifier paint gives a match's side another team: its pick goes. A
+// match that is running, or has its own result, is not repainted at all, so
+// its picks stay (the side is not changed).
+func TestResolveSlots_PaintedSideLosesItsPickAndALockedMatchKeepsIt(t *testing.T) {
+	build := func(status state.MatchStatus) *state.Bracket {
+		return &state.Bracket{Rounds: [][]state.BracketMatch{{{
+			ID: "m", PlaceholderA: "Pool A-1st", PlaceholderB: "Pool B-1st",
+			SideA: "Ryu", SideAID: "a", SideB: "Tora", SideBID: "b",
+			Status: status, ModifiedAt: 500,
+			GroupStamps: map[string]int64{state.GroupRepPickA: 400, state.GroupRepPickB: 400, state.BoutGroup(state.DaihyosenSubPosition): 400},
+			SubResults: []state.SubMatchResult{{
+				Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "Tora",
+				SideAMemberID: "pa", SideBMemberID: "pb",
+			}},
+		}}}}
+	}
+	resolver := map[string]resolvedFinisher{
+		"Pool A-1st": {Name: "Kuma", ID: "c"}, // Pool A's winner changed
+		"Pool B-1st": {Name: "Tora", ID: "b"}, // Pool B's did not
+	}
+
+	t.Run("scheduled", func(t *testing.T) {
+		eng, _, _ := setupTestEngine(t)
+		bracket := build(state.MatchStatusScheduled)
+		eng.resolveSlots(bracket, resolver)
+		m := bracket.Rounds[0][0]
+		assert.Equal(t, "Kuma", m.SideA)
+		assert.Equal(t, "c", m.SideAID)
+		a, b := m.RepPicks()
+		assert.Empty(t, a, "side A was given another team")
+		assert.Equal(t, "pb", b, "side B was not")
+		assert.Equal(t, "Kuma", m.SubResults[0].SideA, "the row names the competitor painted over the placeholder")
+		assert.Equal(t, "Tora", m.SubResults[0].SideB)
+		assert.Greater(t, m.GroupStamp(state.GroupRepPickA), int64(400))
+		assert.Equal(t, int64(400), m.GroupStamp(state.GroupRepPickB), "side B's pick keeps its date")
+	})
+
+	t.Run("running", func(t *testing.T) {
+		eng, _, _ := setupTestEngine(t)
+		bracket := build(state.MatchStatusRunning)
+		eng.resolveSlots(bracket, resolver)
+		m := bracket.Rounds[0][0]
+		assert.Equal(t, "Ryu", m.SideA, "a running match keeps its competitor")
+		assert.Equal(t, "Ryu", m.SubResults[0].SideA, "and its row keeps the name")
+		a, b := m.RepPicks()
+		assert.Equal(t, "pa", a)
+		assert.Equal(t, "pb", b)
+		assert.Equal(t, int64(400), m.GroupStamp(state.GroupRepPickA))
+		assert.Equal(t, int64(400), m.GroupStamp(state.GroupRepPickB))
+	})
+}
+
+// A team renamed while the competition is draw-ready: the add of a
+// representative bout commits the running match in its own transaction and
+// starts the competition after it, and a failed start is only logged, so a
+// draw-ready competition can hold a representative bout. The hantei mark is
+// placed on the winner's side by comparing the winner to that row's names, so
+// the row's names and its Winner follow the rename (the row carries no pick
+// and no winner member id here: either would credit the side by id and make
+// the assertion green without the rename).
+func TestReplaceParticipantInDraw_ARenamedTeamKeepsTheRepresentativeRowInStep(t *testing.T) {
+	const compID = "rename-rep-row"
+	// The representative bout was decided for side B, the team renamed.
+	build := func(sideBID string) *state.Bracket {
+		return &state.Bracket{Rounds: [][]state.BracketMatch{{{
+			ID:    "m1",
+			SideA: "Ryu", SideAID: "id-a", SideB: "Tora", SideBID: sideBID,
+			Status: state.MatchStatusRunning, ModifiedAt: 500,
+			SubResults: []state.SubMatchResult{{
+				Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "Tora",
+				IpponsA: []string{}, IpponsB: []string{domain.HanteiMark},
+				Winner: "Tora", Decision: "daihyosen",
+			}},
+		}}}}
+	}
+	for _, tc := range []struct {
+		name    string
+		sideBID string // "" is a legacy side no id was ever stamped on
+		pid     string
+	}{
+		{name: "a side carrying the team's id", sideBID: "id-b", pid: "id-b"},
+		{name: "a legacy side with no id", sideBID: "", pid: "id-elsewhere"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			eng, store, _ := setupTestEngine(t)
+			require.NoError(t, store.SaveCompetition(&state.Competition{
+				ID: compID, Name: "Rename", Kind: "team", TeamSize: 3, TeamMatchType: state.TeamMatchTypeFixed,
+				Format: state.CompFormatKnockout, Courts: []string{"A"}, StartTime: "09:00",
+				Status: state.CompStatusDrawReady,
+			}))
+			require.NoError(t, store.SaveBracket(compID, build(tc.sideBID)))
+
+			_, err := eng.ReplaceParticipantInDraw(compID, tc.pid, "Tora", "Dojo", "", "Lion", "Dojo", "")
+			require.NoError(t, err)
+
+			bracket, err := store.LoadBracket(compID)
+			require.NoError(t, err)
+			m := bracket.Rounds[0][0]
+			require.Equal(t, "Lion", m.SideB, "the match side is renamed")
+			row := m.SubResults[state.DaihyosenSubIndex(m.SubResults)]
+			assert.Equal(t, "Lion", row.SideB, "the representative row follows the match's name")
+			assert.Equal(t, "Lion", row.Winner, "and so does its winner, which the mark is placed by")
+			assert.Equal(t, "Ryu", row.SideA, "side A is untouched")
+			assert.Equal(t, domain.MatchSideB, state.SubBoutWinnerSide(row, m.SideA, m.SideB), "side B is still credited")
+		})
+	}
+}
+
+// A rename never clears a representative pick: the side keeps its team. Pass 2
+// of the rename (a side with no id) writes the name directly and must not read
+// "Tora" -> "Lion" as another team, which seatBracketSide would for an id-less
+// side.
+func TestReplaceParticipantInDraw_ARenamedIdlessSideKeepsItsPick(t *testing.T) {
+	eng, store, _ := setupTestEngine(t)
+	const compID = "rename-keeps-pick"
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Name: "Rename", Kind: "team", TeamSize: 3, TeamMatchType: state.TeamMatchTypeFixed,
+		Format: state.CompFormatKnockout, Courts: []string{"A"}, StartTime: "09:00",
+		Status: state.CompStatusDrawReady,
+	}))
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{Rounds: [][]state.BracketMatch{{{
+		ID:    "m1",
+		SideA: "Ryu", SideAID: "id-a", SideB: "Tora",
+		Status: state.MatchStatusRunning, ModifiedAt: 500,
+		GroupStamps: map[string]int64{state.GroupRepPickB: 400},
+		SubResults: []state.SubMatchResult{{
+			Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "Tora", SideBMemberID: "pb",
+		}},
+	}}}}))
+
+	_, err := eng.ReplaceParticipantInDraw(compID, "id-elsewhere", "Tora", "Dojo", "", "Lion", "Dojo", "")
+	require.NoError(t, err)
+
+	bracket, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	m := bracket.Rounds[0][0]
+	_, pickB := m.RepPicks()
+	assert.Equal(t, "pb", pickB, "the renamed side keeps its pick")
+	assert.Equal(t, "Lion", m.SubResults[0].SideB)
+	assert.Equal(t, int64(400), m.GroupStamp(state.GroupRepPickB), "and its date")
+}
+
+// Pass 2 of ReplaceParticipantInDraw renames an id-less side directly and hands
+// the representative row the match's old name (the one it matched on), so a row
+// that names no one still carries the winner recorded under that name.
+func TestReplaceParticipantInDraw_AnIdlessRenameCarriesTheWinnerOfARowThatNamesNoOne(t *testing.T) {
+	eng, store, _ := setupTestEngine(t)
+	const compID = "rename-carries-winner"
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Name: "Rename", Kind: "team", TeamSize: 3, TeamMatchType: state.TeamMatchTypeFixed,
+		Format: state.CompFormatKnockout, Courts: []string{"A"}, StartTime: "09:00",
+		Status: state.CompStatusDrawReady,
+	}))
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{Rounds: [][]state.BracketMatch{{{
+		ID:    "m1",
+		SideA: "Ryu", SideAID: "id-a", SideB: "Tora",
+		Status: state.MatchStatusRunning, ModifiedAt: 500,
+		SubResults: []state.SubMatchResult{{
+			Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "",
+			IpponsB: []string{domain.HanteiMark}, Winner: "Tora", Decision: "daihyosen",
+		}},
+	}}}}))
+
+	_, err := eng.ReplaceParticipantInDraw(compID, "id-elsewhere", "Tora", "Dojo", "", "Lion", "Dojo", "")
+	require.NoError(t, err)
+
+	bracket, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	m := bracket.Rounds[0][0]
+	assert.Equal(t, "Lion", m.SideB)
+	assert.Equal(t, "Lion", m.SubResults[0].SideB)
+	assert.Equal(t, "Lion", m.SubResults[0].Winner, "the winner follows the match's old name")
+	assert.Equal(t, domain.MatchSideB, state.SubBoutWinnerSide(m.SubResults[0], m.SideA, m.SideB))
+}
+
+// The same id under a new name is the same team: the representative row's
+// winner follows the row's name, or the mark would be placed on nobody. A side
+// given another team leaves the winner alone (the row keeps what was decided).
+func TestSeatBracketSide_ARenameCarriesTheRowsWinnerAndAnotherTeamDoesNot(t *testing.T) {
+	build := func() *state.BracketMatch {
+		return &state.BracketMatch{
+			ID:    "m",
+			SideA: "Ryu", SideAID: "a", SideB: "Tora", SideBID: "b",
+			SubResults: []state.SubMatchResult{{
+				Position: state.DaihyosenSubPosition, SideA: "Ryu", SideB: "Tora",
+				IpponsB: []string{domain.HanteiMark}, Winner: "Tora", Decision: "daihyosen",
+			}},
+		}
+	}
+
+	t.Run("the same id under a new name", func(t *testing.T) {
+		bm := build()
+		seatBracketSide(bm, domain.MatchSideB, "Lion", "b")
+		assert.Equal(t, "Lion", bm.SubResults[0].SideB)
+		assert.Equal(t, "Lion", bm.SubResults[0].Winner, "the winner follows the name it was recorded under")
+		assert.Equal(t, domain.MatchSideB, state.SubBoutWinnerSide(bm.SubResults[0], bm.SideA, bm.SideB))
+	})
+	t.Run("the other side's rename leaves a winner who is not it", func(t *testing.T) {
+		bm := build()
+		seatBracketSide(bm, domain.MatchSideA, "Dragon", "a")
+		assert.Equal(t, "Dragon", bm.SubResults[0].SideA)
+		assert.Equal(t, "Tora", bm.SubResults[0].Winner)
+	})
+	t.Run("another team", func(t *testing.T) {
+		bm := build()
+		seatBracketSide(bm, domain.MatchSideB, "Kuma", "c")
+		assert.Equal(t, "Kuma", bm.SubResults[0].SideB)
+		assert.Equal(t, "Tora", bm.SubResults[0].Winner, "a decision made for the team that left is left as it was")
+	})
+
+	// A row's side name can be blank or stale: AddDaihyosen stamps the names and
+	// adoptCurrentSideName only rewrites a row carrying the OLD name, never
+	// fills a blank, while the merge lands a payload row's names as sent, so a
+	// writer that does not restate them (rows written before the names rule,
+	// hand-edited data) leaves them blank. The Winner names the team by the
+	// match's name, so the rename carries it from there too.
+	t.Run("a row that names no one carries the winner the match's old name recorded", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideB = ""
+		seatBracketSide(bm, domain.MatchSideB, "Lion", "b")
+		assert.Equal(t, "Lion", bm.SubResults[0].SideB)
+		assert.Equal(t, "Lion", bm.SubResults[0].Winner, "the winner follows the match's old name")
+		assert.Equal(t, domain.MatchSideB, state.SubBoutWinnerSide(bm.SubResults[0], bm.SideA, bm.SideB))
+	})
+	t.Run("a row that names a stale team carries the winner the match's old name recorded", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideB = "Tigre"
+		seatBracketSide(bm, domain.MatchSideB, "Lion", "b")
+		assert.Equal(t, "Lion", bm.SubResults[0].SideB)
+		assert.Equal(t, "Lion", bm.SubResults[0].Winner)
+	})
+	// The carry is not skipped for a row that already reads the new name: a writer
+	// that restated the rename on the row (the merge lands a payload row's names as
+	// sent) can leave the Winner on the match's old name.
+	t.Run("a row that already reads the new name carries the winner the match's old name recorded", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideB = "Lion"
+		seatBracketSide(bm, domain.MatchSideB, "Lion", "b")
+		assert.Equal(t, "Lion", bm.SubResults[0].SideB)
+		assert.Equal(t, "Lion", bm.SubResults[0].Winner, "the winner follows the match's old name")
+		assert.Equal(t, domain.MatchSideB, state.SubBoutWinnerSide(bm.SubResults[0], bm.SideA, bm.SideB))
+	})
+	// PIN, green by design: a row that already reads the new name and whose Winner
+	// already follows it has nothing to carry, so it is not copied (the list a
+	// row's other holders share is replaced only when a row changes).
+	t.Run("a row that already reads the new name and winner is untouched and not copied", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideB, bm.SubResults[0].Winner = "Lion", "Lion"
+		before := &bm.SubResults[0]
+		seatBracketSide(bm, domain.MatchSideB, "Lion", "b")
+		assert.Same(t, before, &bm.SubResults[0], "the list is the one it was")
+		assert.Equal(t, "Lion", bm.SubResults[0].Winner)
+	})
+	// PIN, green by design: the match's old name carries the Winner only for a
+	// side that keeps its team, as the row's own old name does.
+	t.Run("a row that names no one, given another team, leaves the winner", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideB = ""
+		seatBracketSide(bm, domain.MatchSideB, "Kuma", "c")
+		assert.Equal(t, "Kuma", bm.SubResults[0].SideB)
+		assert.Equal(t, "Tora", bm.SubResults[0].Winner, "a decision made for the team that left is left as it was")
+	})
+	// PIN, green by design: the other side's rename must not take a winner that
+	// names this side, even through the match's old name.
+	t.Run("a row that names no one, the other side renamed, leaves a winner who is not it", func(t *testing.T) {
+		bm := build()
+		bm.SubResults[0].SideA = ""
+		seatBracketSide(bm, domain.MatchSideA, "Dragon", "a")
+		assert.Equal(t, "Dragon", bm.SubResults[0].SideA)
+		assert.Equal(t, "Tora", bm.SubResults[0].Winner)
+	})
+}
+
+// A pool requalification that reopens a played knockout match and repaints its
+// slot with another competitor: the reopen line names the picks group.
+func TestRequalify_ForcedReopenTakesThePickAndItsLineNamesIt(t *testing.T) {
+	f := newRQFixture(t, "rq-picks", 2, [][]string{{"A1", "A2"}, {"B1", "B2"}})
+	f.scorePool("Pool A-0", "A1")
+	f.scorePool("Pool B-0", "B1")
+	f.resolve()
+	m1, s1 := f.slot("Pool A-1st")
+	require.NoError(t, f.scoreKO(m1.ID, "A1"))
+
+	// The played match's rep bout holds a pick for Pool A's winner.
+	b := f.bracket()
+	played := findBracketMatchInBracket(b, m1.ID)
+	pick := state.SubMatchResult{Position: state.DaihyosenSubPosition}
+	if s1 == "A" {
+		pick.SideAMemberID = "pick-a1"
+	} else {
+		pick.SideBMemberID = "pick-a1"
+	}
+	played.SubResults = []state.SubMatchResult{pick}
+	require.NoError(t, f.store.SaveBracket(f.compID, b))
+
+	var reopened []ReopenedMatch
+	require.NoError(t, f.write("Pool A-0", f.poolResult("Pool A-0", "A2"), ForceOptions{Force: true, Reopened: &reopened}))
+	require.Len(t, reopened, 1)
+	assert.Equal(t, m1.ID, reopened[0].ID)
+	// The pick sat on the side Pool A's winner holds.
+	pickGroup, keptGroup := state.GroupRepPickB, state.GroupRepPickA
+	if s1 == "A" {
+		pickGroup, keptGroup = state.GroupRepPickA, state.GroupRepPickB
+	}
+	assert.Equal(t, []string{pickGroup}, reopened[0].RepPicksCleared)
+
+	got := findBracketMatchInBracket(f.bracket(), m1.ID)
+	name, _ := sideOf(*got, s1)
+	assert.Equal(t, "A2", name)
+	a, c := got.RepPicks()
+	assert.Empty(t, a)
+	assert.Empty(t, c)
+
+	entries, err := f.store.LoadMatchHistory(f.compID, m1.ID)
+	require.NoError(t, err)
+	var named, namedKept bool
+	for _, e := range entries {
+		if e.Door == doorDownstreamReopen && slices.Contains(e.Changed, pickGroup) {
+			named = true
+		}
+		if e.Door == doorDownstreamReopen && slices.Contains(e.Changed, keptGroup) {
+			namedKept = true
+		}
+	}
+	assert.True(t, named, "the reopen line names the cleared side's pick group")
+	assert.False(t, namedKept, "and not the side that held no pick")
+}
+
+// DELETE .../overrides removes a pool's hand-set order without asking the
+// planner (it only writes overrides.json), so the knockout still seats the
+// order that was removed until the next auto-complete repaints it through
+// ResolveQualifiedPools, which no confirmation or reopen answers for. A match
+// sent back to the queue keeps its representative bout's picks and is not
+// locked, so the repaint can take a pick from it; it records the re-seat in the
+// match's history like every other door that does (bracket_seat_audit.go).
+func TestResolveQualifiedPools_ARepaintTheOverridesRemovalLeftRecordsTheReseat(t *testing.T) {
+	f := newRQFixture(t, "rq-overrides-removed", 1, [][]string{{"A1", "A2"}, {"B1", "B2"}})
+	f.scorePool("Pool A-0", "A1")
+	f.scorePool("Pool B-0", "B1")
+	f.resolve()
+	// Pool A's order is set by hand: the planner seats A2.
+	_, err := f.eng.OverridePoolRanks(f.compID, "Pool A", []RankOverride{{PlayerID: rqID("A2"), Rank: 1}}, ForceOptions{})
+	require.NoError(t, err)
+	m, side := f.slot("Pool A-1st")
+	name, _ := sideOf(m, side)
+	require.Equal(t, "A2", name, "the hand-set order is seated")
+
+	// The match was sent back to the queue holding A2's representative pick.
+	b := f.bracket()
+	queued := findBracketMatchInBracket(b, m.ID)
+	require.Equal(t, state.MatchStatusScheduled, queued.Status)
+	pick := state.SubMatchResult{Position: state.DaihyosenSubPosition}
+	pickGroup := state.GroupRepPickB
+	if side == "A" {
+		pick.SideAMemberID, pickGroup = "pick-a2", state.GroupRepPickA
+	} else {
+		pick.SideBMemberID = "pick-a2"
+	}
+	queued.SubResults = []state.SubMatchResult{pick}
+	require.NoError(t, f.store.SaveBracket(f.compID, b))
+
+	changed, err := f.store.ResetOverridesChanged(f.compID)
+	require.NoError(t, err)
+	require.True(t, changed)
+	_, err = f.eng.MaybeAutoCompletePools(f.compID)
+	require.NoError(t, err)
+
+	got := findBracketMatchInBracket(f.bracket(), m.ID)
+	name, _ = sideOf(*got, side)
+	require.Equal(t, "A1", name, "the natural order is seated again")
+	a, c := got.RepPicks()
+	assert.Empty(t, a)
+	assert.Empty(t, c)
+
+	entries, err := f.store.LoadMatchHistory(f.compID, m.ID)
+	require.NoError(t, err)
+	var recorded bool
+	for _, e := range entries {
+		if e.Door == doorReseat && slices.Contains(e.Changed, pickGroup) {
+			recorded = true
+		}
+	}
+	assert.True(t, recorded, "the re-seat that took the pick is in the match's history, not only in a log line")
+}
diff --git a/internal/engine/daihyosen.go b/internal/engine/daihyosen.go
index 2b88c2017..1e74bd58b 100644
--- a/internal/engine/daihyosen.go
+++ b/internal/engine/daihyosen.go
@@ -379,9 +379,12 @@ func ComputeTeamSummary(subResults []state.SubMatchResult, sideAName, sideBName
 //
 // The returned SubMatchResult has Position = -1 (a sentinel for "this
 // is a daihyosen bout, not a numbered roster position") and
-// Decision = "daihyosen". The handler appends this to the match's
-// SubResults; the operator subsequently records the rep players +
-// ippon via the score modal.
+// Decision = "daihyosen", and its SideA/SideB are nameA/nameB, the
+// match's own team names (the caller passes match.SideA/match.SideB;
+// TeamSummary carries no name). The row is never nameless, not even
+// between the add and the first score write. The handler appends this
+// to the match's SubResults; the operator subsequently records the rep
+// players + ippon via the score modal.
 //
 // CHK026: when a team has exactly 1 eligible competitor, that
 // competitor MUST be the rep, the operator selects them in the score
@@ -391,7 +394,7 @@ func ComputeTeamSummary(subResults []state.SubMatchResult, sideAName, sideBName
 //
 // FR-046, CHK026, T139.
 func (e *Engine) AddDaihyosen(
-	compID, matchID string,
+	compID, matchID, nameA, nameB string,
 	sideA, sideB TeamSummary,
 	isPool bool,
 	sideAEligible, sideBEligible int,
@@ -407,6 +410,13 @@ func (e *Engine) AddDaihyosen(
 	}
 	return &state.SubMatchResult{
 		Position: -1, // sentinel: daihyosen, not a numbered roster bout
+		// The row names the match's two teams from the moment it exists: the
+		// hantei mark is placed on the winner's side by comparing the winner
+		// against THIS row's sideA/sideB, so a nameless row is one nothing can
+		// attribute. seatBracketSide keeps them equal to the match's from
+		// then on.
+		SideA:    nameA,
+		SideB:    nameB,
 		Decision: string(domain.DecisionDaihyosen),
 	}, nil
 }
diff --git a/internal/engine/daihyosen_test.go b/internal/engine/daihyosen_test.go
index 21f2f1da7..c886a4c1e 100644
--- a/internal/engine/daihyosen_test.go
+++ b/internal/engine/daihyosen_test.go
@@ -91,7 +91,7 @@ func TestDaihyosenAddableOnlyWhenTied(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			sub, err := eng.AddDaihyosen(compID, matchID, tc.sideA, tc.sideB, tc.isPool, tc.sideAEligible, tc.sideBEligible)
+			sub, err := eng.AddDaihyosen(compID, matchID, "Alpha", "Bravo", tc.sideA, tc.sideB, tc.isPool, tc.sideAEligible, tc.sideBEligible)
 			if tc.wantErr != nil {
 				require.Error(t, err)
 				assert.Truef(t, errors.Is(err, tc.wantErr), "want errors.Is == %v, got %v", tc.wantErr, err)
@@ -103,6 +103,8 @@ func TestDaihyosenAddableOnlyWhenTied(t *testing.T) {
 			if tc.wantSub {
 				assert.Equal(t, -1, sub.Position, "daihyosen sentinel position must be -1")
 				assert.Equal(t, string(domain.DecisionDaihyosen), sub.Decision)
+				assert.Equal(t, "Alpha", sub.SideA, "the row names the match's side A from the moment it exists")
+				assert.Equal(t, "Bravo", sub.SideB, "the row names the match's side B from the moment it exists")
 			}
 		})
 	}
diff --git a/internal/engine/engi.go b/internal/engine/engi.go
index b9e000269..d2f21fb8f 100644
--- a/internal/engine/engi.go
+++ b/internal/engine/engi.go
@@ -252,6 +252,9 @@ func (e *Engine) recordEngiMatch(
 	fo := firstForceOptions(opts)
 	force := fo.Force
 	var reopened []ReopenedMatch
+	// The picks the propagation takes from matches it re-seats without
+	// reopening, for their own history lines (bracket_seat_audit.go).
+	var clears []repPickClear
 	if !engiValidTotal(flagsA, flagsB) {
 		return nil, validationErrorf(
 			"engi: flag total %d+%d=%d is invalid; total must be odd and in {1,3,5} (3- or 5-referee panel, no draw possible)",
@@ -319,12 +322,15 @@ func (e *Engine) recordEngiMatch(
 					return err
 				}
 				priorWinner, priorWinnerID := propagatedWinnerOf(b, rIdx, mIdx, bm)
+				before := repPickSnapshot(b, matchID)
 				result = applyEngiToBracketMatch(bm, flagsA, flagsB, winnerSide, correctionReason)
 				stampEngiChanges(bm, stamp, groupStamps)
 				e.propagateBracketWinner(b, rIdx, mIdx)
 				if force && winnerActuallyChanged(priorWinner, priorWinnerID, bm) {
 					reopened = forceReopenDownstreamChain(b, rIdx, mIdx, bm.ID)
 				}
+				clears = repPickClears(before, b)
+				markRepPicksCleared(reopened, clears)
 				return nil
 			}
 		}
@@ -348,6 +354,7 @@ func (e *Engine) recordEngiMatch(
 		e.recordDirectHistory(h, compID, matchID, doorEngi, stamp, engiChangedGroups...)
 	}
 	e.restoreForceReopened(h, compID, reopened)
+	e.recordRepPickClears(h, compID, clears, reopened)
 	if fo.Reopened != nil {
 		*fo.Reopened = append(*fo.Reopened, reopened...)
 	}
diff --git a/internal/engine/export.go b/internal/engine/export.go
index 1f55448e7..7985e02ed 100644
--- a/internal/engine/export.go
+++ b/internal/engine/export.go
@@ -127,8 +127,17 @@ func (e *Engine) ExportCompetitionXlsx(id string) ([]byte, error) {
 		return nil, err
 	}
 
+	// Representative Bouts sheet's bouts. Opt-in the same way: only a
+	// fixed-order team competition whose draw holds a representative bout has
+	// any.
+	representativeBouts, err := e.collectRepresentativeBouts(id, comp)
+	if err != nil {
+		return nil, err
+	}
+
 	// The shared sheet pipeline (mp-yuy8): Data, Pool Draw, Pool Matches,
-	// knockout, Tree cleanup, Names to Print, Kachinuki Detail -- identical
+	// knockout, Tree cleanup, Names to Print, Kachinuki Detail, Representative
+	// Bouts -- identical
 	// steps and order to internal/export.BuildResultsWorkbook.
 	// RenderCompetitionWorkbook derives namesToPrintPlayers via
 	// KnockoutNamesToPrint (numbering.go, bc-pnum A8: a
@@ -137,7 +146,7 @@ func (e *Engine) ExportCompetitionXlsx(id string) ([]byte, error) {
 	// no-ops) -- internal/export.BuildResultsWorkbook resolves through the
 	// SAME derivation, so the two exports of one competition agree on
 	// whether that sheet exists at all.
-	_, namesToPrintPlayers, err := e.RenderCompetitionWorkbook(f, comp, pools, bracket, courts, courtOfPool, draw, kachinukiMatches)
+	_, namesToPrintPlayers, err := e.RenderCompetitionWorkbook(f, comp, pools, bracket, courts, courtOfPool, draw, kachinukiMatches, representativeBouts)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/engine/k3_refused_before_reseat_test.go b/internal/engine/k3_refused_before_reseat_test.go
new file mode 100644
index 000000000..d890f9d9e
--- /dev/null
+++ b/internal/engine/k3_refused_before_reseat_test.go
@@ -0,0 +1,94 @@
+package engine
+
+// K3 refuses a withdrawal whose loser ANOTHER match already made ineligible,
+// and a refusal must leave the bracket exactly as it found it. The pre-write
+// half (refuseConcurrentWithdrawal) used to resolve the loser from a probe copy
+// of the payload whose side NAMES were still empty, so a `/score`-shaped
+// withdrawal that names a winner but no sides, no winnerSide and no winnerId
+// resolved no loser there: the write went on, propagateBracketWinner re-seated
+// the next round's side (its representative pick cleared, its stamp moved), and
+// only THEN did the post-write check raise AlreadyIneligibleError, whose
+// rollback restores the written match row alone. The probe now takes the stored
+// pairing's names, so the loser resolves before anything is written.
+
+import (
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// k3Bracket stores rpSetup's team knockout with Ryu (who advanced into m-r2-0
+// side A, holding a representative pick) already barred by "other-match".
+func k3Bracket(t *testing.T) (*Engine, *state.Store, string) {
+	t.Helper()
+	eng, store, compID := rpSetup(t, false)
+	require.NoError(t, store.SetCompetitorStatus(compID, domain.CompetitorStatus{
+		PlayerID: wrTeamAID, Eligible: false, Reason: "kiken", MatchID: "other-match",
+	}))
+	return eng, store, compID
+}
+
+// k3Payload is the hand-built withdrawal: Ryu withdraws (kiken), so the winner
+// is Tora. It carries a winner NAME and nothing that names a side.
+func k3Payload() *state.MatchResult {
+	return &state.MatchResult{
+		Status:           state.MatchStatusCompleted,
+		Decision:         string(domain.DecisionKikenVoluntary),
+		Winner:           wrTeamB,
+		CorrectionReason: "Wrong side withdrew",
+	}
+}
+
+func TestK3_ARefusedWithdrawalNeverReseatsTheNextRound(t *testing.T) {
+	eng, store, compID := k3Bracket(t)
+	priorNext := rpNext(t, store, compID)
+	priorBracket, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	priorFirst := *priorBracket.MatchByID("m-r1-0")
+
+	err = inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, werr := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", k3Payload(), ForceOptions{})
+		return werr
+	})
+	var already *AlreadyIneligibleError
+	require.ErrorAs(t, err, &already, "the withdrawal is refused")
+	assert.Equal(t, wrTeamAID, already.PlayerID)
+	assert.Equal(t, "other-match", already.MatchID)
+
+	next := rpNext(t, store, compID)
+	assert.Equal(t, wrTeamA, next.SideA, "the refusal left the next round's side A where it was")
+	assert.Equal(t, wrTeamAID, next.SideAID)
+	a, c := next.RepPicks()
+	assert.Equal(t, rpPickA, a, "and the representative pick on it")
+	assert.Equal(t, rpPickC, c)
+	assert.Equal(t, mmT1, next.GroupStamp(state.GroupRepPickA), "dated as it was, not moved by a re-seat that was then refused")
+	assert.Equal(t, priorNext.ModifiedAt, next.ModifiedAt, "the next match was not written at all")
+
+	after, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	first := after.MatchByID("m-r1-0")
+	assert.Equal(t, priorFirst.Winner, first.Winner, "the refused match keeps its recorded winner")
+	assert.Equal(t, priorFirst.Status, first.Status)
+	assert.Equal(t, priorFirst.Decision, first.Decision)
+
+	for _, id := range []string{rpNextID, "m-r1-0"} {
+		entries, herr := store.LoadMatchHistory(compID, id)
+		require.NoError(t, herr)
+		assert.Empty(t, entries, "a refused write leaves no history line on %s, a re-seat's included", id)
+	}
+}
+
+// The same payload with the loser NOT barred is an ordinary correction: the
+// probe's names must not turn every withdrawal into a refusal.
+func TestK3_AWithdrawalNobodyBarredStillLands(t *testing.T) {
+	eng, store, compID := rpSetup(t, false)
+	require.NoError(t, inTx(t, store, compID, func(tx state.StoreTx) error {
+		_, werr := eng.RecordMatchResultWithIneligibilityTx(tx, compID, "m-r1-0", k3Payload(), ForceOptions{})
+		return werr
+	}))
+	next := rpNext(t, store, compID)
+	assert.Equal(t, wrTeamB, next.SideA, "Tora advanced in Ryu's place")
+}
diff --git a/internal/engine/kachinuki.go b/internal/engine/kachinuki.go
index be6ae6989..d5654ec02 100644
--- a/internal/engine/kachinuki.go
+++ b/internal/engine/kachinuki.go
@@ -1146,14 +1146,25 @@ func (e *Engine) reopenUnderCourtLock(compID string, comp *state.Competition, ma
 			// documented check-before-mutate contract (a no-op here), unwinds
 			// the byes and does the retraction.
 			var reopenedDownstream []ReopenedMatch
+			// The picks the retraction takes from the matches it re-seats
+			// without reopening, for their own history lines
+			// (bracket_seat_audit.go); the target is this door's own write.
+			var clears []repPickClear
 			if !h.Bronze {
+				before := repPickSnapshot(h.BracketRoot, matchID)
 				if fo.Force {
+					// No propagation precedes this reopen: the retraction
+					// below is what re-seats the slot, so the picks the
+					// reopened match held are judged after it, against the
+					// snapshot above.
 					reopenedDownstream = forceReopenDownstreamChain(h.BracketRoot, h.RIdx, h.MIdx, matchID)
 				}
 				if derr := retractPropagatedWinner(h.BracketRoot, h.RIdx, h.MIdx); derr != nil {
 					opErr = derr
 					return nil
 				}
+				clears = repPickClears(before, h.BracketRoot)
+				markRepPicksCleared(reopenedDownstream, clears)
 			}
 			prior := h.Bracket.Decision
 			reopenBracketMatchKeepingTheFight(h.Bracket, reason, targetStatus)
@@ -1162,6 +1173,7 @@ func (e *Engine) reopenUnderCourtLock(compID string, comp *state.Competition, ma
 			}
 			e.recordDirectHistory(tx, compID, matchID, doorReopen, h.Bracket.GroupStamp(state.GroupResult), reopenedBracketGroups...)
 			e.restoreForceReopened(tx, compID, reopenedDownstream)
+			e.recordRepPickClears(tx, compID, clears, reopenedDownstream)
 			if fo.Reopened != nil {
 				*fo.Reopened = reopenedDownstream
 			}
@@ -1974,7 +1986,7 @@ type bracketPos struct{ R, M int }
 // unresolveBye can take it back exactly.
 func resolvedByByeFrom(bm *state.BracketMatch, feedM int) bool {
 	fed, other := bm.SideB, bm.SideA
-	if feedM%2 == 0 {
+	if feedsSide(feedM) == domain.MatchSideA {
 		fed, other = bm.SideA, bm.SideB
 	}
 	return bm.Status == state.MatchStatusCompleted &&
@@ -2209,14 +2221,10 @@ func clearPropagatedSlots(bracket *state.Bracket, rIdx, mIdx int, bronze, next *
 		// alongside the name (bc-brid): propagateBracketWinner set both
 		// together, so undoing it must clear both together too, or the
 		// bronze slot would keep a stale id pointing at a name it no longer
-		// carries.
-		if mIdx%2 == 0 {
-			bronze.SideA = ""
-			bronze.SideAID = ""
-		} else {
-			bronze.SideB = ""
-			bronze.SideBID = ""
-		}
+		// carries. Through seatBracketSide, which also takes away the
+		// representative a team match's rep bout held for the team that left
+		// the slot.
+		seatBracketSide(bronze, feedsSide(mIdx), "", "")
 	}
 	if next != nil {
 		// winnerOfPlaceholder (bracket.go) is the ONE producer this now shares
@@ -2225,14 +2233,9 @@ func clearPropagatedSlots(bracket *state.Bracket, rIdx, mIdx int, bronze, next *
 		placeholder := winnerOfPlaceholder(len(bracket.Rounds)-rIdx, mIdx)
 		// Same id-follows-name rule as the bronze clear above: a "Winner of
 		// ..." placeholder is not a resolved competitor, so its slot must
-		// carry no id (bc-brid).
-		if mIdx%2 == 0 {
-			next.SideA = placeholder
-			next.SideAID = ""
-		} else {
-			next.SideB = placeholder
-			next.SideBID = ""
-		}
+		// carry no id (bc-brid), and no pick: seatBracketSide clears the
+		// representative the team that left the slot held.
+		seatBracketSide(next, feedsSide(mIdx), placeholder, "")
 	}
 }
 
diff --git a/internal/engine/kachinuki_export.go b/internal/engine/kachinuki_export.go
index d52b45c82..41f11302a 100644
--- a/internal/engine/kachinuki_export.go
+++ b/internal/engine/kachinuki_export.go
@@ -51,26 +51,16 @@ func (e *Engine) collectKachinukiMatches(compID string, comp *state.Competition)
 		return nil, nil
 	}
 
-	poolMatches, err := e.store.LoadPoolMatches(compID)
-	if err != nil {
-		return nil, err
-	}
-	pools, err := e.store.LoadPools(compID)
+	draw, err := e.loadDetailDraw("engine.collectKachinukiMatches", compID)
 	if err != nil {
 		return nil, err
 	}
-	// A bracket that cannot be read leaves the pool sections alone.
-	bracket, err := e.store.LoadBracket(compID)
-	if err != nil {
-		log.Printf("engine.collectKachinukiMatches compId=%s: bracket.json load error: %v; the export lists the pool sections only", compID, err)
-		bracket = nil
-	}
 
 	// Each match's section reads its fighters' positions from the lineup in
 	// force for its teams at that match, over the draw loaded above. The
 	// lineups are read once per export; they may be missing entirely, in which
 	// case positions render as empty strings.
-	rule := e.lineupRuleOrNone("engine.collectKachinukiMatches", compID, comp.IsKnockoutEnabled(), poolMatches, bracket)
+	rule := e.lineupRuleOrNone("engine.collectKachinukiMatches", compID, comp.IsKnockoutEnabled(), draw.poolMatches, draw.bracket)
 
 	// Squad member labels (bc-pnum: "make a team member's label available
 	// to the public surfaces" -- the printed record is one of the
@@ -81,40 +71,86 @@ func (e *Engine) collectKachinukiMatches(compID string, comp *state.Competition)
 	teamNumbers := e.buildKachinukiTeamNumbers(compID, comp)
 	squads := e.buildKachinukiSquads(compID)
 
-	var out []helper.KachinukiMatchDetail
-	// section builds a match's section; one not yet decided and with no bout
-	// recorded gets the empty rows for hand entry.
-	section := func(m *state.MatchResult, label string) helper.KachinukiMatchDetail {
+	// A match not yet decided and with no bout recorded gets the empty rows
+	// for hand entry.
+	return draw.sections(comp, func(m *state.MatchResult, label string) (helper.KachinukiMatchDetail, bool) {
 		detail := buildKachinukiDetail(m, label, rule.positionsForMatch(m), teamNumbers, squads)
 		if len(detail.Bouts) == 0 && m.Status != state.MatchStatusCompleted {
 			detail.BlankBoutRows = comp.TeamBoutRows()
 		}
-		return detail
+		return detail, true
+	}), nil
+}
+
+// detailDraw is a competition's draw as the bout-detail sheets read it. The
+// Kachinuki Detail and Representative Bouts sheets list their sections from
+// the one walk of it (sections), so they cannot order a draw differently.
+type detailDraw struct {
+	pools       []helper.Pool
+	poolMatches []state.MatchResult
+	bracket     *state.Bracket // nil when bracket.json could not be read
+}
+
+// detailSection builds the section of one match titled label, or reports that
+// the match has none.
+type detailSection func(m *state.MatchResult, label string) (helper.KachinukiMatchDetail, bool)
+
+// loadDetailDraw reads the pools, pool matches and bracket of compID. A
+// bracket that cannot be read leaves the pool sections alone; caller names the
+// export in that log line.
+func (e *Engine) loadDetailDraw(caller, compID string) (detailDraw, error) {
+	poolMatches, err := e.store.LoadPoolMatches(compID)
+	if err != nil {
+		return detailDraw{}, err
+	}
+	pools, err := e.store.LoadPools(compID)
+	if err != nil {
+		return detailDraw{}, err
+	}
+	bracket, err := e.store.LoadBracket(compID)
+	if err != nil {
+		log.Printf("%s compId=%s: bracket.json load error: %v; the export lists the pool sections only", caller, compID, err)
+		bracket = nil
+	}
+	return detailDraw{pools: pools, poolMatches: poolMatches, bracket: bracket}, nil
+}
+
+// sections lists the draw's matches that section gives a section for, in the
+// order every bout-detail sheet prints them: pool matches in the Pool Matches
+// grid's order, then bracket matches by match number (the order the
+// Elimination Matches sheet prints them, not storage order), then the
+// 3rd-place match.
+func (d detailDraw) sections(comp *state.Competition, section detailSection) []helper.KachinukiMatchDetail {
+	var out []helper.KachinukiMatchDetail
+	add := func(m *state.MatchResult, label string) {
+		if detail, ok := section(m, label); ok {
+			out = append(out, detail)
+		}
 	}
 
 	// Pool matches first, numbered as the Pool Matches grid lists them
 	// (helper.EachPoolMatch, shared with the blank template). A row the grid
 	// has no block for (a tie-break or daihyosen) has a section only once it
 	// has bouts, titled by its operator label rather than a draw number.
-	ordinals := AttachPoolMatches(pools, poolMatches)
-	byID := make(map[string]*state.MatchResult, len(poolMatches))
-	for i := range poolMatches {
-		byID[poolMatches[i].ID] = &poolMatches[i]
+	ordinals := AttachPoolMatches(d.pools, d.poolMatches)
+	byID := make(map[string]*state.MatchResult, len(d.poolMatches))
+	for i := range d.poolMatches {
+		byID[d.poolMatches[i].ID] = &d.poolMatches[i]
 	}
-	listed := make(map[string]bool, len(poolMatches))
-	helper.EachPoolMatch(pools, func(label string, pool helper.Pool, i int) {
+	listed := make(map[string]bool, len(d.poolMatches))
+	helper.EachPoolMatch(d.pools, func(label string, pool helper.Pool, i int) {
 		id := fmt.Sprintf("%s-%d", pool.PoolName, ordinals[pool.PoolName][i])
 		if m := byID[id]; m != nil {
 			listed[id] = true
-			out = append(out, section(m, label))
+			add(m, label)
 		}
 	})
-	for i := range poolMatches {
-		m := &poolMatches[i]
+	for i := range d.poolMatches {
+		m := &d.poolMatches[i]
 		if listed[m.ID] || len(m.SubResults) == 0 {
 			continue
 		}
-		out = append(out, section(m, OperatorMatchLabel(comp, nil, m.ID)))
+		add(m, OperatorMatchLabel(comp, nil, m.ID))
 	}
 
 	// Bracket matches in match-number order, the order the Elimination Matches
@@ -124,14 +160,14 @@ func (e *Engine) collectKachinukiMatches(compID string, comp *state.Competition)
 	// (state.Bracket.NumberMatches). A bye, hidden with one side empty, has no
 	// section. Each is titled and its sides named as the sheet prints them, so
 	// a side reading "M 3" leads to the section titled with match 3.
-	if bracket != nil {
-		printed := PrintedBracket(bracket)
+	if d.bracket != nil {
+		printed := PrintedBracket(d.bracket)
 		type stored struct {
 			bm            state.BracketMatch
 			fallbackTitle string // for a bracket stored before match numbers
 		}
 		var matches []stored
-		for rIdx, round := range bracket.Rounds {
+		for rIdx, round := range d.bracket.Rounds {
 			for mIdx, bm := range round {
 				if len(bm.SubResults) == 0 && (bm.Hidden || bm.SideA == "" || bm.SideB == "") {
 					continue
@@ -141,25 +177,28 @@ func (e *Engine) collectKachinukiMatches(compID string, comp *state.Competition)
 		}
 		// Stable, so matches without a number come first, in storage order.
 		slices.SortStableFunc(matches, func(a, b stored) int { return cmp.Compare(a.bm.MatchNumber, b.bm.MatchNumber) })
-		bracketSection := func(bm state.BracketMatch, fallbackTitle string) helper.KachinukiMatchDetail {
+		bracketSection := func(bm state.BracketMatch, fallbackTitle string) {
 			p := printed[bm.ID]
 			title := p.Title
 			if title == "" {
 				title = fallbackTitle
 			}
-			detail := section(bracketMatchToTeamResult(bm), title)
+			detail, ok := section(bracketMatchToTeamResult(bm), title)
+			if !ok {
+				return
+			}
 			detail.SideATeam, detail.SideBTeam = p.SideA, p.SideB
-			return detail
+			out = append(out, detail)
 		}
 		for _, m := range matches {
-			out = append(out, bracketSection(m.bm, m.fallbackTitle))
+			bracketSection(m.bm, m.fallbackTitle)
 		}
-		if bm := bracket.ThirdPlaceMatch; bm != nil {
-			out = append(out, bracketSection(*bm, helper.ThirdPlaceLabel))
+		if bm := d.bracket.ThirdPlaceMatch; bm != nil {
+			bracketSection(*bm, helper.ThirdPlaceLabel)
 		}
 	}
 
-	return out, nil
+	return out
 }
 
 // buildKachinukiTeamNumbers resolves every team-shaped participant's
@@ -281,6 +320,21 @@ func resolveKachinukiDisplayName(squads map[string][]domain.TeamMember, teamID,
 	return storedName
 }
 
+// boutFigures is what a bout's row prints beside its fighters, in side order:
+// each side's score string and result mark, and the one closed-set middle
+// mark. Every bout-detail sheet reads them here, attributed, marked and
+// maru-filled by the same domain owners as the main sheets' bout rows
+// (export's writeTeamSubMatchScores), so a bout reads the same on all of them;
+// IpponsScore drops placeholder dots and the Ht mark from a recorded score.
+func boutFigures(m *state.MatchResult, sub state.SubMatchResult) (scoreA, scoreB, markA, markB, middle string) {
+	att := domain.SubBoutAttributionForTeamRow(sub.Attribution(), m.SideA, m.SideB)
+	markA, markB = domain.SideMarksAB(sub.Decision, sub.HanteiDecided(), att)
+	scoreA, scoreB = domain.DefaultWinMaruAB(
+		domain.IpponsScore(sub.IpponsA), domain.IpponsScore(sub.IpponsB),
+		sub.Decision, sub.Encho.On(), att)
+	return scoreA, scoreB, markA, markB, domain.MiddleMark(sub.Decision, sub.Encho.On())
+}
+
 // buildKachinukiDetail converts a single state.MatchResult into the
 // helper-layer detail struct. positions is the match's own position lookup
 // (lineupRule.positionsForMatch).
@@ -290,15 +344,7 @@ func buildKachinukiDetail(m *state.MatchResult, label string, positions map[stri
 	}
 	bouts := make([]helper.KachinukiBout, 0, len(m.SubResults))
 	for _, sub := range m.SubResults {
-		// Attributed, marked and maru-filled by the same domain owners as the
-		// main sheets' bout rows (export's writeTeamSubMatchScores), so a bout
-		// reads the same on both; IpponsScore drops placeholder dots and the
-		// Ht mark from a recorded score.
-		att := domain.SubBoutAttributionForTeamRow(sub.Attribution(), m.SideA, m.SideB)
-		markA, markB := domain.SideMarksAB(sub.Decision, sub.HanteiDecided(), att)
-		scoreA, scoreB := domain.DefaultWinMaruAB(
-			domain.IpponsScore(sub.IpponsA), domain.IpponsScore(sub.IpponsB),
-			sub.Decision, sub.Encho.On(), att)
+		scoreA, scoreB, markA, markB, middle := boutFigures(m, sub)
 		bouts = append(bouts, helper.KachinukiBout{
 			Position:   sub.Position,
 			SideAName:  resolveKachinukiDisplayName(squads, m.SideAID, sub.SideAMemberID, sub.SideA),
@@ -309,7 +355,7 @@ func buildKachinukiDetail(m *state.MatchResult, label string, positions map[stri
 			SideBLabel: resolveKachinukiMemberLabel(teamNumbers, squads, m.SideBID, sub.SideBMemberID),
 			SideBPos:   resolvePos(m.SideB, sub.SideBMemberID, sub.SideB),
 			ScoreB:     scoreB,
-			Middle:     domain.MiddleMark(sub.Decision, sub.Encho.On()),
+			Middle:     middle,
 			MarkA:      markA,
 			MarkB:      markB,
 		})
diff --git a/internal/engine/kachinuki_test.go b/internal/engine/kachinuki_test.go
index 21a0b1f74..79cbb2bb6 100644
--- a/internal/engine/kachinuki_test.go
+++ b/internal/engine/kachinuki_test.go
@@ -2176,7 +2176,7 @@ func TestReopenKachinukiMatch_ReopenPending(t *testing.T) {
 // reopened without a reason carries ReopenPending, and sending it back to the
 // queue must CLEAR that audit debt. If it didn't, the requeued (now scheduled,
 // empty) match would still owe a correctionReason for a result that no longer
-// exists, and applyCorrectionReasonUnderTx would reject its next honest
+// exists, and the handler's applyCorrectionReason would reject its next honest
 // finalization demanding one. reopenBracketMatch's doc names this mirror
 // obligation on RevertMatchToQueue; the two homes carry the flag separately.
 func TestRevertMatchToQueue_ClearsReopenPending(t *testing.T) {
@@ -2223,7 +2223,7 @@ func TestRevertMatchToQueue_ClearsReopenPending(t *testing.T) {
 
 // TestOverrideBracketWinner_ClearsReopenPending pins the related half of R1:
 // override-winner is a second finalization path that bypasses
-// applyCorrectionReasonUnderTx, so a reopened bracket match closed out via an
+// applyCorrectionReason, so a reopened bracket match closed out via an
 // override must also discharge ReopenPending, or the flag lingers indefinitely.
 func TestOverrideBracketWinner_ClearsReopenPending(t *testing.T) {
 	compID := "override-pending"
diff --git a/internal/engine/knockout.go b/internal/engine/knockout.go
index ff9143991..0e2c818f4 100644
--- a/internal/engine/knockout.go
+++ b/internal/engine/knockout.go
@@ -7,6 +7,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
 	"github.com/gitrgoliveira/bracket-creator/internal/helper"
 	"github.com/gitrgoliveira/bracket-creator/internal/state"
 )
@@ -228,6 +229,28 @@ func qualifierLabelPool(label string) string {
 	return label
 }
 
+// slotFields returns the name and id fields of the bracket slot that side
+// names: side A's pair, side B's pair, or the Winner pair for
+// domain.MatchSideNone. paint compares, logs and writes through it, so a slot's
+// fields cannot disagree with its side. It only names the fields. A side write
+// still goes through seatBracketSide, which also takes away the representative
+// the leaving team held; the Winner is not a side, so it is written directly and
+// never through seatBracketSide. Any other side value is a BUG: it logs, and it
+// hands back scratch fields, so nothing on the match is compared or written.
+func slotFields(m *state.BracketMatch, side domain.MatchSide) (name, id *string) {
+	switch side {
+	case domain.MatchSideA:
+		return &m.SideA, &m.SideAID
+	case domain.MatchSideB:
+		return &m.SideB, &m.SideBID
+	case domain.MatchSideNone:
+		return &m.Winner, &m.WinnerID
+	}
+	log.Printf("engine: BUG: bracket match %s: slotFields called with side %q; nothing is compared or written", m.ID, side)
+	var scratchName, scratchID string
+	return &scratchName, &scratchID
+}
+
 // resolveSlots writes resolver's finishers into every bracket slot whose
 // draw-time label (PlaceholderA/B/Winner) is a resolver key, then completes and
 // propagates any bye that leaves. It does no I/O, so it serves both the
@@ -304,9 +327,28 @@ func (e *Engine) resolveSlots(bracket *state.Bracket, resolver map[string]resolv
 		// re-run is a no-op, and so a bracket resolved once BEFORE bc-brid
 		// (name only, id still "") gets its id backfilled the next time its
 		// pool's placeholder is looked at.
-		paint := func(label string, name, id *string) {
+		//
+		// paint writes the slot labelled label, which takes the competitor of side
+		// (domain.MatchSideA or B) or the Winner (domain.MatchSideNone). Its fields
+		// come from slotFields, so the compare, the log line and the write name the
+		// same ones. A side is written through seatBracketSide, which takes away the
+		// representative the team that leaves the slot held; the Winner is not a side
+		// and is written directly.
+		paint := func(label string, side domain.MatchSide) {
+			name, id := slotFields(m, side)
 			rf, ok := resolver[label]
-			if !ok || (*name == rf.Name && *id == rf.ID) {
+			if !ok {
+				return
+			}
+			// A slot whose resolver entry has no id (a standings player of
+			// legacy data) keeps the id it holds, as seatBracketSide keeps it
+			// for an incoming "" and the Winner (a bye passes its competitor
+			// through with the id the side holds) must: it is already seated,
+			// and repainting it would count a change on every pool write that
+			// never converges, and wipe the Winner's id each time. Only that
+			// direction: a slot with no id against an entry that has one is
+			// still painted, which is the id backfill above.
+			if *name == rf.Name && (*id == rf.ID || rf.ID == "") {
 				return
 			}
 			if frozen[qualifierLabelPool(label)] != "" {
@@ -316,13 +358,17 @@ func (e *Engine) resolveSlots(bracket *state.Bracket, resolver map[string]resolv
 				log.Printf("engine: bracket match %s (%s) keeps %q in its %s slot: it is running or has its own result, so the new occupant %q is not written over it", m.ID, m.Status, *name, label, rf.Name)
 				return
 			}
-			*name, *id = rf.Name, rf.ID
+			if side == domain.MatchSideNone {
+				*name, *id = rf.Name, rf.ID
+			} else {
+				seatBracketSide(m, side, rf.Name, rf.ID)
+			}
 			n++
 		}
-		paint(m.PlaceholderA, &m.SideA, &m.SideAID)
-		paint(m.PlaceholderB, &m.SideB, &m.SideBID)
+		paint(m.PlaceholderA, domain.MatchSideA)
+		paint(m.PlaceholderB, domain.MatchSideB)
 		// Winner-only changes count too, so a bye-propagated Winner fix is persisted.
-		paint(m.PlaceholderWinner, &m.Winner, &m.WinnerID)
+		paint(m.PlaceholderWinner, domain.MatchSideNone)
 	}
 	for ri := range bracket.Rounds {
 		for mi := range bracket.Rounds[ri] {
@@ -461,7 +507,13 @@ func (e *Engine) ResolveQualifiedPools(compID string) (int, bool, error) {
 	resolvedNow := 0
 	allResolved := false
 	backfilled := false
-	uerr := e.store.UpdateBracket(compID, func(bracket *state.Bracket) error {
+	// The picks the repaint takes from a re-seated match, for its history lines
+	// (bracket_seat_audit.go). This resolver repaints a slot whose pool moved
+	// outside the requalification planner (DELETE .../overrides writes the
+	// overrides alone), so it owns the record of what its re-seat took, written
+	// in the transaction that writes the bracket.
+	var clears []repPickClear
+	mutate := func(bracket *state.Bracket) error {
 		if bracket == nil || len(bracket.Rounds) == 0 {
 			return errMatchNotFound // nothing to resolve; signal no-save
 		}
@@ -486,7 +538,11 @@ func (e *Engine) ResolveQualifiedPools(compID string) (int, bool, error) {
 			// pools-times-winners layout this backfill reconstructs.
 			backfilled = backfillDrawPlaceholdersV1(bracket, poolNames, poolWinners)
 		}
+		before := repPickSnapshot(bracket, "")
 		n := e.resolveSlots(bracket, resolver)
+		// The repaint may have given a side another team and taken its pick
+		// with it. No reopen names it here: a locked match is never repainted.
+		clears = repPickClears(before, bracket)
 
 		allResolved = !bracketHasPoolPlaceholders(bracket)
 		if n == 0 && !backfilled {
@@ -500,6 +556,13 @@ func (e *Engine) ResolveQualifiedPools(compID string) (int, bool, error) {
 			bracket.Preview = false
 		}
 		return nil
+	}
+	uerr := e.store.WithTransaction(compID, func(tx state.StoreTx) error {
+		if err := tx.UpdateBracket(compID, mutate); err != nil {
+			return err
+		}
+		e.recordRepPickClears(tx, compID, clears, nil)
+		return nil
 	})
 	if uerr != nil && !errors.Is(uerr, errMatchNotFound) {
 		return 0, false, uerr
diff --git a/internal/engine/knockout_test.go b/internal/engine/knockout_test.go
index 8df9bf664..a28145d05 100644
--- a/internal/engine/knockout_test.go
+++ b/internal/engine/knockout_test.go
@@ -838,3 +838,133 @@ func TestResolveQualifiedPools_FivePoolsTwoWinners_ByePools(t *testing.T) {
 		assert.Empty(t, m.Winner, "empty slot %d has no winner to record", idx)
 	}
 }
+
+// TestResolveSlots_PaintsTheSideItNames pins that resolveSlots paints each slot
+// into the fields its side names and no others: side A's placeholder lands on
+// SideA/SideAID, side B's on SideB/SideBID, and the winner paint on
+// Winner/WinnerID. It returns how many sides it changed, so a slot already
+// holding its resolved occupant must not be repainted (and must not count).
+func TestResolveSlots_PaintsTheSideItNames(t *testing.T) {
+	eng, _, _ := setupTestEngine(t)
+	resolver := map[string]resolvedFinisher{
+		"Pool A-1st": {Name: "Alice", ID: "id-a"},
+		"Pool B-1st": {Name: "Bob", ID: "id-b"},
+		"Pool C-1st": {Name: "Carol", ID: "id-c"},
+	}
+	tests := []struct {
+		name        string
+		sideA       string
+		sideAID     string
+		sideB       string
+		sideBID     string
+		wantPainted int
+	}{
+		{name: "empty slots take their own occupants", wantPainted: 3},
+		{name: "side A already holding its occupant is not repainted", sideA: "Alice", sideAID: "id-a", wantPainted: 2},
+		{name: "side B already holding its occupant is not repainted", sideB: "Bob", sideBID: "id-b", wantPainted: 2},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			b := &state.Bracket{Rounds: [][]state.BracketMatch{{{
+				ID:                "m1",
+				Status:            state.MatchStatusScheduled,
+				PlaceholderA:      "Pool A-1st",
+				PlaceholderB:      "Pool B-1st",
+				PlaceholderWinner: "Pool C-1st",
+				SideA:             tc.sideA,
+				SideAID:           tc.sideAID,
+				SideB:             tc.sideB,
+				SideBID:           tc.sideBID,
+			}}}}
+			got := eng.resolveSlots(b, resolver)
+			m := b.Rounds[0][0]
+			assert.Equal(t, tc.wantPainted, got, "sides changed")
+			assert.Equal(t, "Alice", m.SideA)
+			assert.Equal(t, "id-a", m.SideAID)
+			assert.Equal(t, "Bob", m.SideB)
+			assert.Equal(t, "id-b", m.SideBID)
+			assert.Equal(t, "Carol", m.Winner)
+			assert.Equal(t, "id-c", m.WinnerID)
+		})
+	}
+}
+
+// A resolver entry with no id (a standings player of legacy data) names a side
+// whose id seatBracketSide keeps (an incoming "" beside the same name is a writer
+// that did not know the id). Such a side is already seated, so it is not counted
+// and not repainted on every pool write; a slot with no id against an entry that
+// has one is still painted, which is the id backfill.
+func TestResolveSlots_ASideTheResolverKnowsByNameOnlyIsSeated(t *testing.T) {
+	tests := []struct {
+		name        string
+		slotID      string
+		resolverID  string
+		wantPainted int
+		wantID      string
+	}{
+		{name: "a stored id against a resolver with none converges", slotID: "id-a", resolverID: "", wantPainted: 0, wantID: "id-a"},
+		{name: "no stored id against a resolver with one is the id backfill", slotID: "", resolverID: "id-a", wantPainted: 1, wantID: "id-a"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			eng, _, _ := setupTestEngine(t)
+			b := &state.Bracket{Rounds: [][]state.BracketMatch{{{
+				ID:           "m1",
+				Status:       state.MatchStatusScheduled,
+				PlaceholderA: "Pool A-1st",
+				PlaceholderB: "Pool B-1st",
+				SideA:        "Alice",
+				SideAID:      tc.slotID,
+				SideB:        "Bob",
+				SideBID:      "id-b",
+			}}}}
+			resolver := map[string]resolvedFinisher{
+				"Pool A-1st": {Name: "Alice", ID: tc.resolverID},
+				"Pool B-1st": {Name: "Bob", ID: "id-b"},
+			}
+			got := eng.resolveSlots(b, resolver)
+			assert.Equal(t, tc.wantPainted, got, "sides changed")
+			assert.Equal(t, "Alice", b.Rounds[0][0].SideA)
+			assert.Equal(t, tc.wantID, b.Rounds[0][0].SideAID)
+		})
+	}
+}
+
+// The Winner converges the same way a side does. A bye passes its competitor
+// through as the match's Winner with the id the side holds, and a resolver entry
+// with no id must not repaint it: the repaint wiped WinnerID, the legacy upgrade
+// restored it on the next start, and the next pool write wiped it again. A
+// Winner with no id against an entry that has one is still written, which is
+// the id backfill.
+func TestResolveSlots_TheWinnerTheResolverKnowsByNameOnlyIsSeated(t *testing.T) {
+	tests := []struct {
+		name        string
+		winnerID    string
+		resolverID  string
+		wantPainted int
+		wantID      string
+	}{
+		{name: "a stored id against a resolver with none converges", winnerID: "id-a", resolverID: "", wantPainted: 0, wantID: "id-a"},
+		{name: "no stored id against a resolver with one is the id backfill", winnerID: "", resolverID: "id-a", wantPainted: 1, wantID: "id-a"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			eng, _, _ := setupTestEngine(t)
+			b := &state.Bracket{Rounds: [][]state.BracketMatch{{{
+				ID:                "m1",
+				Status:            state.MatchStatusCompleted,
+				PlaceholderA:      "Pool A-1st",
+				PlaceholderWinner: "Pool A-1st",
+				SideA:             "Alice",
+				SideAID:           "id-a",
+				Winner:            "Alice",
+				WinnerID:          tc.winnerID,
+			}}}}
+			resolver := map[string]resolvedFinisher{"Pool A-1st": {Name: "Alice", ID: tc.resolverID}}
+			got := eng.resolveSlots(b, resolver)
+			assert.Equal(t, tc.wantPainted, got, "slots changed")
+			assert.Equal(t, "Alice", b.Rounds[0][0].Winner)
+			assert.Equal(t, tc.wantID, b.Rounds[0][0].WinnerID)
+		})
+	}
+}
diff --git a/internal/engine/landed_member_ids_pin_test.go b/internal/engine/landed_member_ids_pin_test.go
new file mode 100644
index 000000000..f2abd86e4
--- /dev/null
+++ b/internal/engine/landed_member_ids_pin_test.go
@@ -0,0 +1,355 @@
+package engine
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+// The self-run member judge (mobileapp.landedMembersRefusal) is only asked
+// about a write whose payload INTRODUCES a member id (introducesJudgedMember),
+// and that gate is equivalent to judging every write only while the ENGINE never
+// lands a member id the judge would refuse that the payload did not introduce.
+// This is a PIN, green by design: it holds the invariant from this side, so a
+// change inside the write that fills ids from somewhere new fails here rather
+// than silently slipping past a gate that does not look.
+//
+// The id fillers it exercises inside the write are preserveKachinukiMemberIDs
+// (the stored row's id at the same position and name), ResolveMemberWinnerID /
+// ReconcileWinnerMemberID (the winner's id, derived from the row's own landed
+// side ids, which the judge accepts) and the merge's copies of the groups a
+// write does not apply, state.CopyGroup and SetRepPick (the stored row's ids
+// and picks). The load repair (state.resolveSubMemberIDs) runs once per
+// competition per process, before the write under test, on rows that already
+// carry their ids, and fills only a row's own team's members.
+//
+// What the fixture is built to reach:
+//   - Both teams' starting lineups and team members are saved. The store mints
+//     the members' ids, so no row carries one: an id taken from a lineup or from
+//     the members by anything inside the write would be a FOREIGN id (neither
+//     the payload's nor the stored match's), which the invariant refuses.
+//     MaybeAdvanceKachinuki is NOT called: its lineup ids are added after the
+//     transaction, in the handler, and this pins what the write itself lands.
+//   - The match is stored at mmT0 and every write but one is stamped, so the
+//     merge orders it. The "older" cases send a write stamped between mmT0 and
+//     the stamp of the group it rewrites, with another group applying, so that
+//     group is HELD and copied back from the stored match; each case states
+//     which groups it expects held, and the match's history is asked.
+//   - Kachinuki runs on a league (the pool branch) and on a knockout (the
+//     bracket branch). The representative bout runs on the knockout only, the
+//     one place production writes it (AddDaihyosen refuses a pool match).
+//   - Nothing here sends startOnly, so keepQueuedScore (a start) is not pinned.
+//
+// The invariant, per landed row and judged field (either side's member id, and
+// the winner's): the id is empty, or the payload's row at that position carried
+// it, or the stored row at that position held it, or (the winner only) it is one
+// of the landed row's own side ids.
+
+// assertNoIntroducedMemberID fails for any landed member id at a judged field
+// that neither the payload nor the stored match supplied.
+func assertNoIntroducedMemberID(t *testing.T, stored, payload, landed []state.SubMatchResult) {
+	t.Helper()
+	supplied := func(got string, field func(state.SubMatchResult) string, row state.SubMatchResult) bool {
+		return got == "" ||
+			got == field(state.SubResultAt(payload, row.Position)) ||
+			got == field(state.SubResultAt(stored, row.Position))
+	}
+	sideA := func(r state.SubMatchResult) string { return r.SideAMemberID }
+	sideB := func(r state.SubMatchResult) string { return r.SideBMemberID }
+	winner := func(r state.SubMatchResult) string { return r.WinnerMemberID }
+	for _, row := range landed {
+		assert.True(t, supplied(row.SideAMemberID, sideA, row),
+			"position %d: side A member id %q was supplied by neither the payload nor the stored row", row.Position, row.SideAMemberID)
+		assert.True(t, supplied(row.SideBMemberID, sideB, row),
+			"position %d: side B member id %q was supplied by neither the payload nor the stored row", row.Position, row.SideBMemberID)
+		ownFighter := row.WinnerMemberID == row.SideAMemberID || row.WinnerMemberID == row.SideBMemberID
+		assert.True(t, supplied(row.WinnerMemberID, winner, row) || ownFighter,
+			"position %d: winner member id %q was supplied by neither the payload, the stored row, nor the row's own landed fighters", row.Position, row.WinnerMemberID)
+	}
+}
+
+// pinBetween is a stamp after the match was stored (mmT0) and before the stamps
+// the seeding writes give the groups they change (mmT1): a write made then is
+// older than those groups and newer than every other.
+const pinBetween = mmT0 + 30_000
+
+// pinIDs are the member ids a landed row must hold: its two fighters', and the
+// winner's.
+type pinIDs struct{ a, b, winner string }
+
+// pinWriteSpec is one stamped score write: when it was made, the groups it names
+// (nil: every group its rows carry, as an older client sends it), and its rows.
+type pinWriteSpec struct {
+	at      int64
+	changed []string
+	rows    []state.SubMatchResult
+}
+
+// pinPeople are the people each team is given, in lineup order. The store mints
+// their member ids, which no row of the fixtures carries.
+var pinPeople = []struct {
+	teamID string
+	names  []string
+}{
+	{wrTeamAID, []string{"Sato", "Ota", "Hara"}},
+	{wrTeamBID, []string{"Tanaka", "Ito", "Mori"}},
+}
+
+// pinHome seeds a team match of the given type, running since mmT0 and holding
+// the stored rows, on the pool branch (a league) or the bracket branch (a
+// knockout), with both teams' starting lineups and team members saved.
+func pinHome(t *testing.T, knockout bool, matchType state.TeamMatchType, stored []state.SubMatchResult) mmHome {
+	t.Helper()
+	eng, store, dir := setupTestEngine(t)
+	h := mmHome{eng: eng, store: store, dir: dir}
+	team := func(c *state.Competition) { c.Kind, c.TeamSize, c.TeamMatchType = "team", 3, matchType }
+	if knockout {
+		h.compID, h.matchID = "pin-ko", "m-r1-0"
+		c := &state.Competition{ID: h.compID, Name: "pin", Status: state.CompStatusKnockout}
+		team(c)
+		require.NoError(t, store.SaveCompetition(c))
+	} else {
+		h.compID, h.matchID = "pin-pool", "Pool A-0"
+		createTestCompetition(t, store, h.compID, "league", 3, func(c *state.Competition) { team(c); c.Status = state.CompStatusPools })
+	}
+	wrSaveTeams(t, store, h.compID)
+	for _, p := range pinPeople {
+		lineup := domain.TeamLineup{
+			TeamID: p.teamID, Round: 0,
+			Positions: map[domain.Position]string{}, MemberIDs: map[domain.Position]string{},
+		}
+		for i, name := range p.names {
+			member, err := store.AddTeamMember(h.compID, p.teamID, name)
+			require.NoError(t, err)
+			pos := domain.PositionNumbered(i + 1)
+			lineup.Positions[pos], lineup.MemberIDs[pos] = name, member.ID
+		}
+		require.NoError(t, store.SetTeamLineup(h.compID, lineup, 3))
+	}
+	if knockout {
+		require.NoError(t, store.SaveBracket(h.compID, &state.Bracket{Rounds: [][]state.BracketMatch{{{
+			ID: h.matchID, SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+			Status: state.MatchStatusRunning, ModifiedAt: mmT0, MatchNumber: 1,
+			SubResults: state.CloneSubResults(stored),
+		}}}}))
+		return h
+	}
+	require.NoError(t, store.SavePoolMatches(h.compID, []state.MatchResult{{
+		ID: h.matchID, SideA: wrTeamA, SideAID: wrTeamAID, SideB: wrTeamB, SideBID: wrTeamBID,
+		Status: state.MatchStatusRunning, ModifiedAt: mmT0, SubResults: state.CloneSubResults(stored),
+	}}))
+	return h
+}
+
+// pinWrite is the running score write a board makes. The write reshapes the rows
+// it is handed in place, so it is given a copy: the spec keeps what was sent.
+func pinWrite(h mmHome, s pinWriteSpec) *state.MatchResult {
+	w := mmRunning(h, s.at, s.changed...)
+	w.SubResults = state.CloneSubResults(s.rows)
+	return w
+}
+
+// pinHeld lists, sorted, the groups the last write in the match's history was
+// held on.
+func pinHeld(t *testing.T, entries []state.MatchHistoryEntry) []string {
+	t.Helper()
+	require.NotEmpty(t, entries)
+	var held []string
+	for group, outcome := range entries[len(entries)-1].Outcomes {
+		if outcome == state.HistoryOutcomeHeld {
+			held = append(held, group)
+		}
+	}
+	slices.Sort(held)
+	return held
+}
+
+func TestEngineLandsNoMemberIDThePayloadDidNotIntroduce(t *testing.T) {
+	// Sato (team Ryu) fought Tanaka and won; Sato now faces Ito.
+	kachinukiRows := func() []state.SubMatchResult {
+		return []state.SubMatchResult{
+			{Position: 1, SideA: "Sato", SideAMemberID: "k-sato", SideB: "Tanaka", SideBMemberID: "o-tanaka",
+				IpponsA: []string{"M"}, Winner: "Sato", WinnerMemberID: "k-sato", Decision: "fought"},
+			{Position: 2, SideA: "Sato", SideAMemberID: "k-sato", SideB: "Ito", SideBMemberID: "o-ito"},
+		}
+	}
+	// ito has Ito win bout 2 against Sato.
+	ito := func(rows []state.SubMatchResult) []state.SubMatchResult {
+		rows[1].IpponsB = []string{"K"}
+		rows[1].Winner, rows[1].WinnerMemberID, rows[1].Decision = "Ito", "o-ito", "fought"
+		return rows
+	}
+	// satoTwice gives Sato a second point in bout 1.
+	satoTwice := func(rows []state.SubMatchResult) []state.SubMatchResult {
+		rows[0].IpponsA = []string{"M", "K"}
+		return rows
+	}
+	fixedRows := func() []state.SubMatchResult {
+		return []state.SubMatchResult{
+			{Position: 1, SideA: "Sato", SideAMemberID: "k1", SideB: "Tanaka", SideBMemberID: "o1",
+				IpponsA: []string{"M"}, Winner: "Sato", WinnerMemberID: "k1", Decision: "fought"},
+		}
+	}
+	// repBout is the representative-bout row, with the picks and the point the
+	// board knows of (none: ""). A point is Ryu's, so Ryu is its winner.
+	repBout := func(sideAID, sideBID, winnerID string, point bool) state.SubMatchResult {
+		if !point {
+			return repRow(sideAID, sideBID, nil, nil)
+		}
+		row := repRow(sideAID, sideBID, []string{"M"}, nil)
+		row.Winner, row.WinnerMemberID = wrTeamA, winnerID
+		return row
+	}
+	// stripIDs is a write that names its fighters and sends no member id.
+	stripIDs := func(rows []state.SubMatchResult) []state.SubMatchResult {
+		out := make([]state.SubMatchResult, len(rows))
+		for i, r := range rows {
+			r.SideAMemberID, r.SideBMemberID, r.WinnerMemberID = "", "", ""
+			out[i] = r
+		}
+		return out
+	}
+	// repPicks is the write that seeds both representatives' picks at mmT1 (each
+	// side's pick is its own group), beside the stored numbered bout.
+	repPicks := pinWriteSpec{
+		at:      mmT1,
+		changed: []string{repBoutGroup, repPickAName, repPickBName},
+		rows:    append(fixedRows(), repBout("k-rep", "o-rep", "", false)),
+	}
+
+	tests := []struct {
+		name      string
+		matchType state.TeamMatchType
+		// bracketOnly keeps a case off the pool branch: the representative bout
+		// is a knockout shape.
+		bracketOnly bool
+		stored      []state.SubMatchResult
+		// setup are the writes made before the one under test.
+		setup []pinWriteSpec
+		write pinWriteSpec
+		// held are the groups the write under test must be held on, per the
+		// match's history: without them the held-group copies the "older"
+		// cases are built for would not be known to have run.
+		held []string
+		// inherited are the ids the landed rows must hold, by position, so the
+		// pin is not vacuously true of a write that dropped every id: the
+		// carry-over mechanisms it guards are really exercised.
+		inherited map[int]pinIDs
+	}{
+		{
+			name:      "kachinuki: a write echoing the stored member ids",
+			matchType: state.TeamMatchTypeKachinuki,
+			stored:    kachinukiRows(),
+			write:     pinWriteSpec{at: mmT1, changed: []string{"bout:2"}, rows: ito(kachinukiRows())},
+			inherited: map[int]pinIDs{1: {"k-sato", "o-tanaka", "k-sato"}, 2: {"k-sato", "o-ito", "o-ito"}},
+		},
+		{
+			name:      "kachinuki: a write whose rows carry names and no member ids, over a position the stored match lacks",
+			matchType: state.TeamMatchTypeKachinuki,
+			stored:    kachinukiRows(),
+			write: pinWriteSpec{at: mmT1, rows: append(stripIDs(ito(kachinukiRows())),
+				state.SubMatchResult{Position: 3, SideA: "Ota", SideB: "Ito"})},
+			inherited: map[int]pinIDs{1: {"k-sato", "o-tanaka", "k-sato"}, 2: {"k-sato", "o-ito", "o-ito"}, 3: {}},
+		},
+		{
+			name:      "kachinuki: the same write from a client that stamps nothing",
+			matchType: state.TeamMatchTypeKachinuki,
+			stored:    kachinukiRows(),
+			write: pinWriteSpec{rows: append(stripIDs(ito(kachinukiRows())),
+				state.SubMatchResult{Position: 3, SideA: "Ota", SideB: "Ito"})},
+			inherited: map[int]pinIDs{1: {"k-sato", "o-tanaka", "k-sato"}, 2: {"k-sato", "o-ito", "o-ito"}, 3: {}},
+		},
+		{
+			name:      "kachinuki: a write older than bout 1's last change, whose rows carry no member ids",
+			matchType: state.TeamMatchTypeKachinuki,
+			stored:    kachinukiRows(),
+			setup:     []pinWriteSpec{{at: mmT1, changed: []string{"bout:1"}, rows: satoTwice(kachinukiRows())}},
+			write:     pinWriteSpec{at: pinBetween, rows: stripIDs(ito(kachinukiRows()))},
+			held:      []string{"bout:1"},
+			inherited: map[int]pinIDs{1: {"k-sato", "o-tanaka", "k-sato"}, 2: {"k-sato", "o-ito", "o-ito"}},
+		},
+		{
+			name:        "fixed order with a representative bout: a write echoing the stored member ids",
+			matchType:   state.TeamMatchTypeFixed,
+			bracketOnly: true,
+			stored:      fixedRows(),
+			setup:       []pinWriteSpec{repPicks},
+			write: pinWriteSpec{at: mmT2,
+				rows: append(satoTwice(fixedRows()), repBout("k-rep", "o-rep", "k-rep", true))},
+			inherited: map[int]pinIDs{1: {"k1", "o1", "k1"}, state.DaihyosenSubPosition: {"k-rep", "o-rep", "k-rep"}},
+		},
+		{
+			name:        "fixed order with a representative bout: a point on it from a board that holds no picks",
+			matchType:   state.TeamMatchTypeFixed,
+			bracketOnly: true,
+			stored:      fixedRows(),
+			setup:       []pinWriteSpec{repPicks},
+			write: pinWriteSpec{at: mmT2, changed: []string{repBoutGroup},
+				rows: append(stripIDs(fixedRows()), repBout("", "", "", true))},
+			inherited: map[int]pinIDs{1: {"k1", "o1", "k1"}, state.DaihyosenSubPosition: {"k-rep", "o-rep", "k-rep"}},
+		},
+		{
+			name:        "fixed order with a representative bout: a write older than the picks, whose representative row carries none",
+			matchType:   state.TeamMatchTypeFixed,
+			bracketOnly: true,
+			stored:      fixedRows(),
+			setup:       []pinWriteSpec{repPicks},
+			write: pinWriteSpec{at: pinBetween,
+				rows: append(satoTwice(fixedRows()), repBout("", "", "", true))},
+			held:      []string{repBoutGroup, repPickAName, repPickBName},
+			inherited: map[int]pinIDs{1: {"k1", "o1", "k1"}, state.DaihyosenSubPosition: {"k-rep", "o-rep", ""}},
+		},
+		{
+			name:        "fixed order with a representative bout: a write from a sheet that does not list the row",
+			matchType:   state.TeamMatchTypeFixed,
+			bracketOnly: true,
+			stored:      fixedRows(),
+			setup:       []pinWriteSpec{repPicks},
+			write:       pinWriteSpec{at: mmT2, changed: []string{"bout:1"}, rows: satoTwice(fixedRows())},
+			inherited:   map[int]pinIDs{1: {"k1", "o1", "k1"}, state.DaihyosenSubPosition: {"k-rep", "o-rep", ""}},
+		},
+	}
+	branches := []struct {
+		name     string
+		knockout bool
+	}{{"pool", false}, {"knockout", true}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for _, b := range branches {
+				if tt.bracketOnly && !b.knockout {
+					continue
+				}
+				t.Run(b.name, func(t *testing.T) {
+					h := pinHome(t, b.knockout, tt.matchType, tt.stored)
+					for _, s := range tt.setup {
+						require.NoError(t, h.write(pinWrite(h, s)))
+					}
+					// The match as it stands before the write under test: after the
+					// setup writes it is no longer what the fixture stored.
+					before := h.load(t)
+					require.NotEmpty(t, before.SubResults)
+
+					require.NoError(t, h.write(pinWrite(h, tt.write)),
+						"the write applies in part: a write held whole answers superseded")
+
+					landed := h.load(t)
+					require.NotEmpty(t, landed.SubResults)
+					assertNoIntroducedMemberID(t, before.SubResults, tt.write.rows, landed.SubResults)
+					assert.ElementsMatch(t, tt.held, pinHeld(t, h.history(t)),
+						"the groups the merge held, per the match's history")
+
+					for position, want := range tt.inherited {
+						row := state.SubResultAt(landed.SubResults, position)
+						assert.Equal(t, want, pinIDs{row.SideAMemberID, row.SideBMemberID, row.WinnerMemberID},
+							"position %d: the ids the write was meant to carry over are still there", position)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/engine/match_history.go b/internal/engine/match_history.go
index a7ae6a9d9..67051c2eb 100644
--- a/internal/engine/match_history.go
+++ b/internal/engine/match_history.go
@@ -33,6 +33,13 @@ const (
 	doorKachinukiAdvance = "kachinuki-advance"
 	doorKachinukiRemove  = "kachinuki-remove-bout"
 	doorDownstreamReopen = "downstream-reopen"
+	// doorReseat names the line a match gets when a bracket door gave one of
+	// its sides another team and so took that side's representative pick
+	// (bracket_seat_audit.go). A downstream match the same write reopens
+	// names the pick on its doorDownstreamReopen line instead. The SPA words
+	// it in DOOR_WORDS: "Side given another team by a correction to an
+	// earlier match".
+	doorReseat = "reseat"
 )
 
 // clientDoors are the doors whose writer may legitimately state no groups:
@@ -200,6 +207,9 @@ func noteServerBoutChanges(result *state.MatchResult, before, stored []state.Sub
 			result.Changed = append(result.Changed, g)
 		}
 	}
+	// No clause for the representatives' pick groups: nothing the server does
+	// between the writer's rows and this call changes a pick (a kachinuki merge
+	// and the match-level padding keep the representative row as sent).
 }
 
 // serverNowMs is the stamp a direct writer gives the groups it changes: the
diff --git a/internal/engine/match_merge.go b/internal/engine/match_merge.go
index 4b1588f0d..48b9dcf35 100644
--- a/internal/engine/match_merge.go
+++ b/internal/engine/match_merge.go
@@ -125,6 +125,13 @@ func defaultChangedGroups(stored, incoming *state.MatchResult, nilSubsClear bool
 	for _, p := range positions {
 		out = append(out, state.BoutGroup(p))
 	}
+	// The representatives sit on the representative bout's row: a write that
+	// says nothing about that row says nothing about either side's pick.
+	if !slices.Contains(out, state.BoutGroup(state.DaihyosenSubPosition)) {
+		out = slices.DeleteFunc(out, func(g string) bool {
+			return g == state.GroupRepPickA || g == state.GroupRepPickB
+		})
+	}
 	return out
 }
 
@@ -299,6 +306,13 @@ func mergeMatchWrite(stored, incoming *state.MatchResult, policy matchWritePolic
 	if holdReason == "" && finishAtomic {
 		holdReason = HoldReasonFinishAtomic
 	}
+	// What the write said about the representatives, before the loop below
+	// copies stored rows over its own.
+	payloadPickA, payloadPickB := incoming.RepPicks()
+	// A write that names the representative bout and carries no row removes
+	// it: the daihyosen DELETE, or a stale whole-match write that omits it.
+	removalWrite := inChanged[state.BoutGroup(state.DaihyosenSubPosition)] &&
+		state.DaihyosenSubIndex(incoming.SubResults) < 0 && state.DaihyosenSubIndex(stored.SubResults) >= 0
 	rep := &state.MergeReport{Stamp: stamp, Changed: changed, HoldReason: holdReason}
 	storedStamps := state.MaterializedGroupStamps(stored.GroupStamps, stored.ModifiedAt, state.SubPositions(stored.SubResults))
 	stamps := state.CloneGroupStamps(storedStamps)
@@ -438,6 +452,12 @@ func mergeMatchWrite(stored, incoming *state.MatchResult, policy matchWritePolic
 		}
 	}
 
+	// The representatives sit on the representative bout's row, so what
+	// became of the row is judged once every hold above has had its say.
+	if mh.settleOrphanPicks(payloadPickA, payloadPickB, removalWrite, stamp) {
+		recomputeModifiedAt = true
+	}
+
 	for _, g := range rep.Applied {
 		if !state.GroupDiffers(stored, incoming, g) {
 			rep.Unchanged = append(rep.Unchanged, g)
@@ -476,6 +496,13 @@ func mergeMatchWrite(stored, incoming *state.MatchResult, policy matchWritePolic
 	if slices.Contains(rep.Unchanged, state.GroupResult) {
 		rep.ResultChanged = false
 	}
+	// The winner's member id is the bout's, the representatives their own
+	// change: after both are settled, the id is derived again from the winner's
+	// name and the stored picks, so it is exactly the winning side's pick (or
+	// empty), whatever id the write carried.
+	if i := state.DaihyosenSubIndex(incoming.SubResults); i >= 0 {
+		incoming.SubResults[i].ReconcileWinnerMemberID()
+	}
 	if len(stamps) == 0 {
 		stamps = nil
 	}
@@ -679,11 +706,7 @@ func (h *mergeHold) holdGroups(reason string, groups ...string) bool {
 		}
 		reportHeld(h.rep, g, h.stored, h.incoming, h.rawValues[g])
 		state.CopyGroup(h.incoming, h.stored, g)
-		if s, ok := h.storedStamps[g]; ok {
-			h.stamps[g] = s
-		} else {
-			delete(h.stamps, g)
-		}
+		h.restoreStamp(g)
 	}
 	if !heldSomething {
 		return false
@@ -738,6 +761,102 @@ func (h *mergeHold) holdDefaultWinScoring(decision string) {
 	h.rep.StandingDecision = decision
 }
 
+// restoreStamp puts group's stamp back to the one the stored match had, or
+// takes it out again when the stored match never stamped it.
+func (h *mergeHold) restoreStamp(group string) {
+	if s, ok := h.storedStamps[group]; ok {
+		h.stamps[group] = s
+	} else {
+		delete(h.stamps, group)
+	}
+}
+
+// settleOrphanPicks is the representatives' rule, asked ONCE after every hold
+// has had its say (a hold can take the representative bout's row out of the
+// write, or put the stored one back): a pick lives on that row, so what became
+// of the row decides what became of each side's pick. payloadA and payloadB are
+// the ids the write carried, captured before the merge copied stored rows over
+// its own, and removalWrite says it named the bout and carried no row.
+//
+//   - The row is gone and the write introduced a pick for a side (a row its
+//     stamp could not bring back, or one a hold took out of the write: R4, a
+//     decision that stands): the pick is held with its id, never applied onto
+//     nothing, and the side keeps the stamp it had.
+//   - The write removed the row and applied, and a pick stamped AFTER the
+//     removal is stored (J): in stamp order the removal came first and the pick
+//     landed on no bout, which is what the line above does when they arrive
+//     that way round. The stored pick is moved to the history under its own
+//     stamp with its id (a DisplacedChange, HoldReasonRepBoutRemoved), and the
+//     side is dated by the removal, the last thing that happened to the row, so
+//     both orders end in one state. It returns true then: the match no longer
+//     holds the newer stamp.
+//   - The write removed the row and a hold kept it (a point made after the
+//     removal is stored): a removal is one action, so its picks stay with the
+//     row that stays, held with the bout instead of clearing a pick the row
+//     still carries.
+func (h *mergeHold) settleOrphanPicks(payloadA, payloadB string, removalWrite bool, stamp int64) bool {
+	hasRow := state.DaihyosenSubIndex(h.incoming.SubResults) >= 0
+	storedRow := state.DaihyosenSubIndex(h.stored.SubResults) >= 0
+	storedA, storedB := h.stored.RepPicks()
+	displaced := map[int64]map[string]json.RawMessage{}
+	for _, side := range []struct {
+		side            domain.MatchSide
+		payload, stored string
+	}{{domain.MatchSideA, payloadA, storedA}, {domain.MatchSideB, payloadB, storedB}} {
+		g := state.RepPickGroup(side.side)
+		applied := slices.Index(h.rep.Applied, g)
+		switch {
+		case hasRow:
+			if !removalWrite || applied < 0 {
+				continue
+			}
+			h.rep.Applied = slices.Delete(h.rep.Applied, applied, applied+1)
+			// What the write said was an empty pick: held if the row still
+			// carries one, an echo if it does not.
+			reportHeld(h.rep, g, h.stored, &state.MatchResult{}, nil)
+			state.CopyGroup(h.incoming, h.stored, g)
+			h.restoreStamp(g)
+		case side.payload != "" && applied >= 0:
+			h.rep.Applied = slices.Delete(h.rep.Applied, applied, applied+1)
+			ghost := &state.MatchResult{SubResults: []state.SubMatchResult{{Position: state.DaihyosenSubPosition}}}
+			ghost.SetRepPick(side.side, side.payload)
+			reportHeld(h.rep, g, h.stored, ghost, nil)
+			h.restoreStamp(g)
+		case storedRow && side.stored != "" && slices.Contains(h.rep.Held, g):
+			at := h.stored.GroupStamp(g)
+			if displaced[at] == nil {
+				displaced[at] = map[string]json.RawMessage{}
+			}
+			displaced[at][g] = state.GroupValue(h.stored, g)
+			// The removal's own (empty) pick now applies, as it does when it
+			// arrives first, and the newer one is the history's.
+			i := slices.Index(h.rep.Held, g)
+			h.rep.Held = slices.Delete(h.rep.Held, i, i+1)
+			delete(h.rep.HeldValues, g)
+			if len(h.rep.HeldValues) == 0 {
+				h.rep.HeldValues = nil
+			}
+			if applied < 0 {
+				h.rep.Applied = append(h.rep.Applied, g)
+			}
+			if stamp > 0 {
+				h.stamps[g] = stamp
+			}
+		}
+	}
+	stamps := make([]int64, 0, len(displaced))
+	for at := range displaced {
+		stamps = append(stamps, at)
+	}
+	slices.Sort(stamps)
+	for _, at := range stamps {
+		h.rep.Displaced = append(h.rep.Displaced, state.DisplacedChange{
+			Stamp: at, Values: displaced[at], Reason: HoldReasonRepBoutRemoved,
+		})
+	}
+	return len(stamps) > 0
+}
+
 // needsWinnerReason is the history reason of a change held because the
 // match would be left with no winner it must have.
 func needsWinnerReason(mc mergeCtx) string {
@@ -782,6 +901,13 @@ func defaultWinStandsReason(decision string) string {
 // rule (R2's withdrawalOutranked) and never reaches this one.
 const HoldReasonFinishAtomic = "a finish and the scoreline it stood on are kept together"
 
+// HoldReasonRepBoutRemoved is the history reason of a representative picked
+// after the representative bout was removed (stamp order: the removal first,
+// the pick onto a bout that no longer existed), which a removal arriving
+// second moves out of the match. It is no needs_winner reason: the answer
+// carries displacedGroups for it and no heldReason.
+const HoldReasonRepBoutRemoved = "the representative bout was removed"
+
 // completesMatch reports whether the merged write leaves the match finished
 // (an empty status completes a bracket match, effectiveBracketWriteStatus).
 func completesMatch(m *state.MatchResult, mc mergeCtx) bool {
diff --git a/internal/engine/match_merge_rep_picks_test.go b/internal/engine/match_merge_rep_picks_test.go
new file mode 100644
index 000000000..6b42f4daa
--- /dev/null
+++ b/internal/engine/match_merge_rep_picks_test.go
@@ -0,0 +1,629 @@
+package engine
+
+// bc-mrgc, operator ruling: "every change is dated and ordered; a change must
+// only ever apply what it changed." The two representatives a team match's
+// representative bout is fought by (SideAMemberID/SideBMemberID on the row at
+// position -1) are each their own dated change, state.GroupRepPickA and
+// state.GroupRepPickB, ordered apart from each other and from the bout's score
+// and result: a point never alters a pick, a pick never alters the point or the
+// other side's pick, and an older change of any is kept in the match's history.
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+const (
+	repBoutGroup = "bout:-1"
+	// Each side's pick is its own group (side A is Aka, side B is Shiro).
+	repPickAName = "repPickA"
+	repPickBName = "repPickB"
+)
+
+// repRow is a representative-bout row as a board sends it: the TEAM names
+// (placeHt needs them), the sub-decision, and whatever ids / marks the board
+// knows about.
+func repRow(sideAID, sideBID string, ipponsA, ipponsB []string) state.SubMatchResult {
+	return state.SubMatchResult{
+		Position: state.DaihyosenSubPosition, SideA: wrTeamA, SideB: wrTeamB,
+		SideAMemberID: sideAID, SideBMemberID: sideBID,
+		IpponsA: ipponsA, IpponsB: ipponsB,
+		Decision: string(domain.DecisionDaihyosen),
+	}
+}
+
+// repWrite is a running write from a board that changed the named groups and
+// carries one representative row.
+func repWrite(h mmHome, at int64, row state.SubMatchResult, changed ...string) *state.MatchResult {
+	w := mmRunning(h, at, changed...)
+	w.SubResults = []state.SubMatchResult{row}
+	return w
+}
+
+// seedPick records Carol as the Ryu representative at mmT1 (the row is added
+// with its pick, as the picker does on a bout that already exists).
+func seedPick(t *testing.T, h mmHome) {
+	t.Helper()
+	require.NoError(t, h.write(repWrite(h, mmT1, repRow("carol", "", nil, nil), repBoutGroup, repPickAName)))
+	got := h.load(t)
+	require.Len(t, got.SubResults, 1)
+	require.Equal(t, "carol", got.SubResults[0].SideAMemberID, "setup: the pick is stored")
+}
+
+// repStamp is the stored stamp of group on the match under test, read through
+// GroupStamp (never the map keys: a side with no key reads the bout row's date).
+func repStamp(t *testing.T, h mmHome, group string) int64 {
+	t.Helper()
+	m := h.load(t)
+	return m.GroupStamp(group)
+}
+
+// Device 1 picks Carol; device 2, whose push has not arrived, taps a point on
+// the representative bout a moment later. Its write is newer and carries its
+// whole row view, which has no ids: the point applies and the pick stays.
+func TestMerge_RepPoint_KeepsAnotherDevicesPick(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		seedPick(t, h)
+
+		require.NoError(t, h.write(repWrite(h, mmT1+400, repRow("", "", []string{"M"}, nil), repBoutGroup)))
+
+		row := h.load(t).SubResults[0]
+		assert.Equal(t, []string{"M"}, row.IpponsA, "the point applies")
+		assert.Equal(t, "carol", row.SideAMemberID, "the pick is not the point's to erase")
+	})
+}
+
+// The reverse: a pick made after a point, on a board that never saw the point.
+func TestMerge_RepPick_KeepsAnotherDevicesPoint(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		require.NoError(t, h.write(repWrite(h, mmT1, repRow("", "", []string{"M"}, nil), repBoutGroup)))
+
+		require.NoError(t, h.write(repWrite(h, mmT2, repRow("carol", "", nil, nil), repPickAName)))
+
+		row := h.load(t).SubResults[0]
+		assert.Equal(t, "carol", row.SideAMemberID, "the pick applies")
+		assert.Equal(t, []string{"M"}, row.IpponsA, "the point is not the pick's to erase")
+	})
+}
+
+// A stale pick is held and kept in the history; a newer clear clears.
+func TestMerge_RepPick_StaleIsHeldAndANewerClearClears(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		require.NoError(t, h.write(repWrite(h, mmT2, repRow("carol", "", nil, nil), repBoutGroup, repPickAName)))
+
+		err := h.write(repWrite(h, mmT1, repRow("dana", "", nil, nil), repPickAName))
+		require.ErrorIs(t, err, ErrMatchSuperseded, "its one change is outranked")
+		assert.Equal(t, []string{repPickAName}, HeldGroupsOf(err))
+		assert.Equal(t, "carol", h.load(t).SubResults[0].SideAMemberID, "the newer pick stands")
+		entries := h.history(t)
+		held := entries[len(entries)-1]
+		assert.Equal(t, state.HistoryOutcomeHeld, held.Outcomes[repPickAName])
+		assert.JSONEq(t, `{"sideAMemberId":"dana"}`, string(held.Held[repPickAName]),
+			"the older pick is kept, never discarded")
+
+		// A deliberate clear is a change to the pick: the row is sent without
+		// the id and the change is named.
+		require.NoError(t, h.write(repWrite(h, mmT3, repRow("", "", nil, nil), repPickAName)))
+		assert.Empty(t, h.load(t).SubResults[0].SideAMemberID, "a newer clear clears")
+	})
+}
+
+// A write that carries no bout list and names nothing (an older client) says
+// nothing about the picks.
+func TestMerge_RepPicks_SurviveAWriteThatNamesNothingAndSendsNoBouts(t *testing.T) {
+	h := mmTeam(t, true)
+	seedPick(t, h)
+
+	w := mmRunning(h, mmT2) // Changed nil, SubResults nil
+	w.IpponsA = []string{"K"}
+	require.NoError(t, h.write(w))
+
+	m := h.load(t)
+	require.Len(t, m.SubResults, 1)
+	assert.Equal(t, "carol", m.SubResults[0].SideAMemberID)
+	assert.Equal(t, []string{"K"}, m.IpponsA)
+}
+
+// A write that names nothing but carries the row (bulk-score, an older
+// client) is ordered like the others: picks it has no newer opinion on stay.
+func TestMerge_RepPicks_NamelessWriteIsOrderedByStamp(t *testing.T) {
+	h := mmTeam(t, true)
+	require.NoError(t, h.write(repWrite(h, mmT3, repRow("carol", "", nil, nil), repBoutGroup, repPickAName)))
+
+	stale := repWrite(h, mmT2, repRow("dana", "", []string{"M"}, nil))
+	stale.Changed = nil
+	stale.WriteDoor = DoorBulkScore
+	_ = h.write(stale)
+
+	assert.Equal(t, "carol", h.load(t).SubResults[0].SideAMemberID, "the older pick does not replace the newer one")
+}
+
+// The winner's member id belongs to the bout's result, but a stored one must
+// name one of the stored picks (or be empty): a pick that changes under it
+// re-derives it from the winning side.
+func TestMerge_RepPick_ReDerivesTheWinnerMemberID(t *testing.T) {
+	h := mmTeam(t, true)
+	won := repRow("carol", "", []string{"M"}, nil)
+	won.Winner, won.WinnerMemberID = wrTeamA, "carol"
+	require.NoError(t, h.write(repWrite(h, mmT1, won, repBoutGroup, repPickAName)))
+
+	require.NoError(t, h.write(repWrite(h, mmT2, repRow("dana", "", nil, nil), repPickAName)))
+
+	row := h.load(t).SubResults[0]
+	assert.Equal(t, "dana", row.SideAMemberID)
+	assert.Equal(t, wrTeamA, row.Winner, "the bout's result is the point's, untouched")
+	assert.Equal(t, "dana", row.WinnerMemberID, "re-derived from the winning side and the stored pick")
+
+	// The pick cleared under a recorded winner id leaves no dangling id.
+	require.NoError(t, h.write(repWrite(h, mmT3, repRow("", "", nil, nil), repPickAName)))
+	row = h.load(t).SubResults[0]
+	assert.Empty(t, row.SideAMemberID)
+	assert.Empty(t, row.WinnerMemberID, "a winner id naming no stored pick is empty")
+}
+
+// A winner id that names the LOSING side's pick is as wrong as one naming nobody:
+// the merge derives it from the winner's NAME and the stored picks alone, never
+// through the id it is checking (id-first attribution would credit the side the
+// id names). The real board stamps the winner and its id together, so a
+// disagreeing pair is a crafted or confused write.
+func TestMerge_RepBout_WinnerMemberIDFollowsTheWinnersName(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		t.Run("an id naming the other side's pick is replaced by the winning side's", func(t *testing.T) {
+			h := mmTeam(t, knockout)
+			won := repRow("x", "y", []string{"M"}, nil)
+			won.Winner, won.WinnerMemberID = wrTeamB, "y"
+			require.NoError(t, h.write(repWrite(h, mmT1, won, repBoutGroup, repPickAName, repPickBName)))
+			require.Equal(t, "y", h.load(t).SubResults[0].WinnerMemberID, "setup: team B won, its pick y is the winner id")
+
+			crafted := repRow("x", "y", []string{"M"}, nil)
+			crafted.Winner, crafted.WinnerMemberID = wrTeamB, "x"
+			require.NoError(t, h.write(repWrite(h, mmT2, crafted, repBoutGroup)))
+
+			row := h.load(t).SubResults[0]
+			assert.Equal(t, wrTeamB, row.Winner)
+			assert.Equal(t, "y", row.WinnerMemberID, "x is team A's pick: the winner id is the winning side's, y")
+		})
+
+		t.Run("an id naming a pick of the side that has none is cleared", func(t *testing.T) {
+			h := mmTeam(t, knockout)
+			won := repRow("", "y", []string{"M"}, nil)
+			won.Winner, won.WinnerMemberID = wrTeamA, "y"
+			require.NoError(t, h.write(repWrite(h, mmT1, won, repBoutGroup, repPickBName)))
+
+			row := h.load(t).SubResults[0]
+			assert.Equal(t, wrTeamA, row.Winner)
+			assert.Equal(t, "y", row.SideBMemberID, "setup: only team B has a pick")
+			assert.Empty(t, row.WinnerMemberID, "team A won and has no pick: y is the loser's, so there is no winner id")
+		})
+	})
+}
+
+// The winner's member id is derived state: the merge works it out again from
+// the winner's name and the stored picks after every write, and the client's
+// bout:-1 comparison leaves it out. So a write that names nothing (bulk-score,
+// an older client) and echoes the representative row with the same score but
+// a different or absent winner id has changed nothing: it must not date the
+// bout (which would fence out an older real change) or count as scoring.
+func TestMerge_RepBout_WinnerMemberIDAloneIsAnEcho(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		for _, tc := range []struct{ name, id string }{
+			{"absent", ""},
+			{"the other side's pick", "dana"},
+			{"an id nobody holds", "zzz"},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				h := mmTeam(t, knockout)
+				won := repRow("carol", "dana", []string{"M"}, nil)
+				won.Winner = wrTeamA
+				require.NoError(t, h.write(repWrite(h, mmT1, won, repBoutGroup, repPickAName, repPickBName)))
+				seeded := h.load(t)
+				require.Len(t, seeded.SubResults, 1)
+				require.Equal(t, "carol", seeded.SubResults[0].WinnerMemberID, "setup: derived from the winner and the picks")
+				require.Equal(t, mmT1, seeded.GroupStamp(repBoutGroup), "setup: the bout is dated")
+				require.Equal(t, mmT1, seeded.ModifiedAt, "setup: the match is dated")
+
+				// The match-level winner id was backfilled after the seeding
+				// merge, so the echo carries it too: only the bout's winner
+				// member id differs from what is stored.
+				echo := repRow("carol", "dana", []string{"M"}, nil)
+				echo.Winner, echo.WinnerMemberID = wrTeamA, tc.id
+				w := repWrite(h, mmT2, echo)
+				w.Changed = nil
+				w.WriteDoor = DoorBulkScore
+				w.WinnerID = seeded.WinnerID
+				require.NoError(t, h.write(w))
+
+				got := h.load(t)
+				require.Len(t, got.SubResults, 1)
+				assert.Equal(t, mmT1, got.GroupStamp(repBoutGroup), "an id-only difference is an echo: the bout keeps its date")
+				assert.Equal(t, mmT1, got.ModifiedAt, "and so does the match")
+				assert.Equal(t, "carol", got.SubResults[0].WinnerMemberID, "re-derived from the winner and the picks")
+			})
+		}
+	})
+}
+
+// A pick has no bout to land on once the representative bout is removed: it
+// is held, in the history, not applied onto nothing.
+func TestMerge_RepPick_OnARemovedBoutIsHeld(t *testing.T) {
+	h := mmTeam(t, true)
+	seedPick(t, h)
+	remove := mmRunning(h, mmT2, repBoutGroup, repPickAName, repPickBName)
+	remove.WriteDoor = DoorDaihyosenDel
+	remove.SubResults = []state.SubMatchResult{}
+	require.NoError(t, h.write(remove))
+	require.Empty(t, h.load(t).SubResults)
+	removed := h.load(t)
+	assert.Equal(t, mmT2, removed.GroupStamp(repPickAName), "the removal dates side A's pick too")
+	assert.Equal(t, mmT2, removed.GroupStamp(repPickBName), "and side B's")
+
+	late := repWrite(h, mmT3, repRow("dana", "", nil, nil), repPickAName)
+	err := h.write(late)
+	require.ErrorIs(t, err, ErrMatchSuperseded)
+	assert.Equal(t, []string{repPickAName}, HeldGroupsOf(err))
+	assert.Empty(t, h.load(t).SubResults, "nothing is resurrected")
+
+	// Each side is held on its own, with only its own id kept in the history.
+	both := repWrite(h, mmT3+1, repRow("eve", "fay", nil, nil), repPickAName, repPickBName)
+	err = h.write(both)
+	require.ErrorIs(t, err, ErrMatchSuperseded)
+	assert.Equal(t, []string{repPickAName, repPickBName}, HeldGroupsOf(err))
+	entries := h.history(t)
+	held := entries[len(entries)-1]
+	assert.JSONEq(t, `{"sideAMemberId":"eve"}`, string(held.Held[repPickAName]))
+	assert.JSONEq(t, `{"sideBMemberId":"fay"}`, string(held.Held[repPickBName]))
+	still := h.load(t)
+	assert.Empty(t, still.SubResults, "still nothing is resurrected")
+	assert.Equal(t, mmT2, still.GroupStamp(repPickAName), "a held pick leaves the tombstone's date")
+	assert.Equal(t, mmT2, still.GroupStamp(repPickBName))
+}
+
+// A match written before the picks had a stamp of their own is ordered by the
+// stamp of its representative bout, as it always was.
+func TestMerge_RepPicks_LegacyStampFallsBackToTheBout(t *testing.T) {
+	h := mmTeam(t, true)
+	bracket, err := h.store.LoadBracket(h.compID)
+	require.NoError(t, err)
+	bm := &bracket.Rounds[0][0]
+	bm.SubResults = []state.SubMatchResult{repRow("carol", "gus", nil, nil)}
+	bm.ModifiedAt = mmT2
+	bm.GroupStamps = map[string]int64{repBoutGroup: mmT2} // a map written before the picks had an entry
+	require.NoError(t, h.store.SaveBracket(h.compID, bracket))
+
+	// Both sides read the row's date, until each is stamped itself.
+	require.Equal(t, mmT2, repStamp(t, h, repPickAName))
+	require.Equal(t, mmT2, repStamp(t, h, repPickBName))
+
+	err = h.write(repWrite(h, mmT1, repRow("dana", "gus", nil, nil), repPickAName))
+	require.ErrorIs(t, err, ErrMatchSuperseded, "older than the row it sits on")
+	assert.Equal(t, "carol", h.load(t).SubResults[0].SideAMemberID)
+	err = h.write(repWrite(h, mmT1, repRow("carol", "hal", nil, nil), repPickBName))
+	require.ErrorIs(t, err, ErrMatchSuperseded, "side B reads the row's date too")
+	assert.Equal(t, "gus", h.load(t).SubResults[0].SideBMemberID)
+
+	require.NoError(t, h.write(repWrite(h, mmT3, repRow("dana", "gus", nil, nil), repPickAName)))
+	got := h.load(t)
+	assert.Equal(t, "dana", got.SubResults[0].SideAMemberID)
+	assert.Equal(t, "gus", got.SubResults[0].SideBMemberID, "a pick the write did not name stays")
+	assert.Equal(t, mmT2, got.GroupStamp(repPickBName), "and keeps its date")
+}
+
+// A legacy match (no stamp map) that holds no representative bout row is not
+// given a pick stamp by an ordinary write: the materialization that runs before
+// the first group is stamped adds the keys only for a match that has the row to
+// date. Individual matches never have one.
+func TestMerge_LegacyMatchWithoutARepBoutGainsNoRepPicksStamp(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmIndividual(t, knockout)
+		require.Nil(t, h.load(t).GroupStamps, "precondition: a legacy match")
+		w := mmRunning(h, mmT1, state.GroupPoints)
+		w.IpponsA = []string{"M"}
+		require.NoError(t, h.write(w))
+		got := h.load(t)
+		assert.Equal(t, mmT1, got.GroupStamp(state.GroupPoints), "the group the write changed is stamped")
+		require.NotNil(t, got.GroupStamps)
+		assert.NotContains(t, got.GroupStamps, repPickAName)
+		assert.NotContains(t, got.GroupStamps, repPickBName)
+	})
+}
+
+// Two captains pick their representatives at about the same moment, each on
+// their own phone: device 1 picks Shiro's (side B), device 2, whose screen never
+// showed that pick, picks Aka's (side A) a moment later, carrying a row with no
+// side-B id. Each side's pick is its own dated change, so device 2's write
+// applies side A and leaves device 1's side B alone: both picks stand, each
+// dated by its own write. Both sides are asserted after every write.
+func TestMerge_RepPicks_TwoCaptainsBothLand(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+
+		// Device 1, at T1: the pick creates the row.
+		require.NoError(t, h.write(repWrite(h, mmT1, repRow("", "x", nil, nil), repBoutGroup, repPickBName)))
+		got := h.load(t)
+		require.Len(t, got.SubResults, 1)
+		require.Equal(t, "x", got.SubResults[0].SideBMemberID, "setup: device 1's pick is stored")
+		require.Empty(t, got.SubResults[0].SideAMemberID)
+
+		// Device 2, at T2 > T1: its row carries side A only.
+		err := h.write(repWrite(h, mmT2, repRow("y", "", nil, nil), repPickAName))
+
+		got = h.load(t)
+		require.Len(t, got.SubResults, 1)
+		assert.Equal(t, "y", got.SubResults[0].SideAMemberID, "device 2's pick applies")
+		assert.Equal(t, "x", got.SubResults[0].SideBMemberID, "and device 1's pick is not its to erase")
+		assert.NoError(t, err)
+		assert.Equal(t, mmT1, got.GroupStamp(repPickBName), "side B is still dated by device 1's write")
+		assert.Equal(t, mmT2, got.GroupStamp(repPickAName), "side A is dated by device 2's write")
+	})
+}
+
+// A stale pick on one side is held and kept in the history while a newer pick on
+// the other side, in the same write, applies. The seed order is deliberate: a
+// fresh match has no representative row, and the write that creates it dates
+// every side it does not name through the bout:-1 fallback, so side A is made
+// newer (T3) by its own write before the write under test (T2) arrives.
+func TestMerge_RepPicks_StaleSideHeldWhileTheOtherSideApplies(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		require.NoError(t, h.write(repWrite(h, mmT1, repRow("", "b1", nil, nil), repBoutGroup, repPickBName)))
+		require.NoError(t, h.write(repWrite(h, mmT3, repRow("a1", "", nil, nil), repPickAName)))
+		seeded := h.load(t)
+		require.Equal(t, "a1", seeded.SubResults[0].SideAMemberID, "setup: side A picked at T3")
+		require.Equal(t, "b1", seeded.SubResults[0].SideBMemberID, "setup: side B picked at T1")
+
+		err := h.write(repWrite(h, mmT2, repRow("a2", "b2", nil, nil), repPickAName, repPickBName))
+
+		got := h.load(t)
+		require.Len(t, got.SubResults, 1)
+		assert.Equal(t, "a1", got.SubResults[0].SideAMemberID, "the newer side-A pick stands")
+		assert.Equal(t, "b2", got.SubResults[0].SideBMemberID, "the side-B pick, newer than what it replaces, applies")
+		assert.NoError(t, err, "applied in part: not superseded")
+		entries := h.history(t)
+		last := entries[len(entries)-1]
+		assert.Equal(t, state.HistoryOutcomeHeld, last.Outcomes[repPickAName])
+		assert.Equal(t, state.HistoryOutcomeApplied, last.Outcomes[repPickBName])
+		assert.JSONEq(t, `{"sideAMemberId":"a2"}`, string(last.Held[repPickAName]), "the stale pick is kept, never discarded")
+		assert.NotContains(t, last.Held, repPickBName)
+		assert.Equal(t, mmT3, got.GroupStamp(repPickAName))
+		assert.Equal(t, mmT2, got.GroupStamp(repPickBName))
+	})
+}
+
+// repRemoval is the representative bout's removal as the daihyosen DELETE
+// door builds it: the bout, the verdict it carried, overtime and both
+// representatives, and no row.
+func repRemoval(h mmHome, at int64) *state.MatchResult {
+	remove := mmRunning(h, at, repBoutGroup, state.GroupResult, state.GroupEncho, repPickAName, repPickBName)
+	remove.WriteDoor = DoorDaihyosenDel
+	remove.SubResults = []state.SubMatchResult{}
+	return remove
+}
+
+// historyOf is the entries of one door, in the order they were written.
+func historyOf(entries []state.MatchHistoryEntry, door string) []state.MatchHistoryEntry {
+	var out []state.MatchHistoryEntry
+	for _, e := range entries {
+		if e.Door == door {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+// J. A removal that is OLDER than a representative picked after it: in stamp
+// order the bout was removed first and the pick came after, onto a bout that
+// no longer existed. Arriving second, the pick is held (the no-row hold, see
+// TestMerge_RepPick_OnARemovedBoutIsHeld). Arriving first, it must end in the
+// same place: no row, the pick kept in the history under its own stamp with its
+// id, and the pick dated by the removal, which is the last thing that happened
+// to the row. Before this the removal held the pick with ITS empty value, the
+// row went with the removal, and the newer pick was recorded nowhere.
+func TestMerge_RepBoutRemove_OlderThanAStoredPick_MovesThePickToTheHistory(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		seedPick(t, h)
+		require.NoError(t, h.write(repWrite(h, mmT3, repRow("dana", "", nil, nil), repPickAName)))
+		require.Equal(t, "dana", h.load(t).SubResults[0].SideAMemberID, "setup: the newer pick is stored")
+
+		remove := repRemoval(h, mmT2)
+		require.NoError(t, h.write(remove), "the removal applies: it is newer than the bout")
+
+		got := h.load(t)
+		assert.Empty(t, got.SubResults, "the row is gone")
+		assert.Equal(t, mmT2, got.GroupStamp(repPickAName), "the removal dates the picks, as it does when it comes first")
+		assert.Equal(t, mmT2, got.GroupStamp(repPickBName))
+		assert.Equal(t, mmT2, got.ModifiedAt, "the newest stamp the match still holds")
+
+		rep := remove.Merge
+		require.NotNil(t, rep)
+		assert.Equal(t, []string{repPickAName}, rep.DisplacedGroups(), "the answer names the pick moved to the history")
+		assert.Empty(t, rep.HeldGroups(), "nothing of the removal was held")
+		assert.Empty(t, rep.HeldReason(), "no needs_winner: the pick lost its bout, not its winner")
+		assert.False(t, rep.NeedsWinner)
+
+		entries := h.history(t)
+		own := historyOf(entries, DoorDaihyosenDel)
+		require.Len(t, own, 1)
+		assert.Equal(t, state.HistoryOutcomeApplied, own[0].Outcomes[repPickAName], "the removal's own entry applies the pick's clear")
+		assert.NotContains(t, own[0].Held, repPickAName, "and holds no empty value in its name")
+
+		moved := historyOf(entries, DoorDisplaced)
+		require.Len(t, moved, 1)
+		assert.Equal(t, mmT3, moved[0].Stamp, "at the pick's own stamp")
+		assert.Equal(t, state.HistoryOutcomeHeld, moved[0].Outcomes[repPickAName])
+		assert.JSONEq(t, `{"sideAMemberId":"dana"}`, string(moved[0].Held[repPickAName]), "with its id")
+		assert.Equal(t, HoldReasonRepBoutRemoved, moved[0].Reason)
+	})
+}
+
+// J, both arrival orders: (remove at T2, pick at T3) ends in one stored state
+// and one history content however they arrive.
+func TestMerge_RepBoutRemove_BothArrivalOrdersConverge(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		type outcome struct {
+			Rows      []state.SubMatchResult
+			StampA    int64
+			StampB    int64
+			Modified  int64
+			HeldPicks []string
+		}
+		run := func(removeFirst bool) outcome {
+			h := mmTeam(t, knockout)
+			seedPick(t, h)
+			pick := repWrite(h, mmT3, repRow("dana", "", nil, nil), repPickAName)
+			remove := repRemoval(h, mmT2)
+			if removeFirst {
+				require.NoError(t, h.write(remove))
+				require.ErrorIs(t, h.write(pick), ErrMatchSuperseded, "the pick lands on no bout")
+			} else {
+				require.NoError(t, h.write(pick))
+				require.NoError(t, h.write(remove))
+			}
+			got := h.load(t)
+			out := outcome{
+				Rows: got.SubResults, StampA: got.GroupStamp(repPickAName), StampB: got.GroupStamp(repPickBName),
+				Modified: got.ModifiedAt,
+			}
+			for _, e := range h.history(t) {
+				if v, ok := e.Held[repPickAName]; ok {
+					out.HeldPicks = append(out.HeldPicks, string(v))
+				}
+			}
+			return out
+		}
+		inOrder, reversed := run(true), run(false)
+		assert.Empty(t, inOrder.Rows)
+		assert.Equal(t, []string{`{"sideAMemberId":"dana"}`}, inOrder.HeldPicks, "the pick is in the history")
+		assert.Equal(t, inOrder, reversed, "rows, stamps and the picks kept in the history match")
+	})
+}
+
+// J with both sides: picks stamped alike share one history entry, each at its
+// own stamp otherwise, oldest first; each side is dated by the removal.
+func TestMerge_RepBoutRemove_OlderThanBothPicks_OneEntryPerStamp(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		seedPick(t, h)
+		require.NoError(t, h.write(repWrite(h, mmT3, repRow("dana", "gus", nil, nil), repPickAName, repPickBName)))
+		require.NoError(t, h.write(repWrite(h, mmT4, repRow("dana", "hal", nil, nil), repPickBName)))
+
+		remove := repRemoval(h, mmT2)
+		require.NoError(t, h.write(remove))
+
+		assert.Equal(t, []string{repPickAName, repPickBName}, remove.Merge.DisplacedGroups())
+		moved := historyOf(h.history(t), DoorDisplaced)
+		require.Len(t, moved, 2, "side A is the pick at T3, side B the one at T4")
+		assert.Equal(t, mmT3, moved[0].Stamp)
+		assert.JSONEq(t, `{"sideAMemberId":"dana"}`, string(moved[0].Held[repPickAName]))
+		assert.NotContains(t, moved[0].Held, repPickBName, "side B's pick was replaced at T4")
+		assert.Equal(t, mmT4, moved[1].Stamp)
+		assert.JSONEq(t, `{"sideBMemberId":"hal"}`, string(moved[1].Held[repPickBName]))
+		got := h.load(t)
+		assert.Empty(t, got.SubResults)
+		assert.Equal(t, mmT2, got.GroupStamp(repPickAName))
+		assert.Equal(t, mmT2, got.GroupStamp(repPickBName))
+		assert.Equal(t, mmT2, got.ModifiedAt)
+
+		// Both picks made in one write share its stamp: one entry.
+		h2 := mmTeam(t, knockout)
+		seedPick(t, h2)
+		require.NoError(t, h2.write(repWrite(h2, mmT3, repRow("dana", "gus", nil, nil), repPickAName, repPickBName)))
+		require.NoError(t, h2.write(repRemoval(h2, mmT2)))
+		one := historyOf(h2.history(t), DoorDisplaced)
+		require.Len(t, one, 1)
+		assert.Equal(t, mmT3, one[0].Stamp)
+		assert.Equal(t, []string{repPickAName, repPickBName}, one[0].Changed)
+	})
+}
+
+// A removal refused for the BOUT (a point on it, made after the removal, is
+// stored) is refused whole for the representatives: a pick stays on the row that
+// stays. Before this the pick's older stamp let the removal's empty pick apply, so
+// its history entry called the pick cleared and its stamp moved, while the row
+// kept the pick.
+func TestMerge_RepBoutRemove_RefusedForTheBout_HoldsItsPicksWithIt(t *testing.T) {
+	bothBranches(t, func(t *testing.T, knockout bool) {
+		h := mmTeam(t, knockout)
+		seedPick(t, h) // carol at T1
+		require.NoError(t, h.write(repWrite(h, mmT3, repRow("", "", []string{"M"}, nil), repBoutGroup)))
+
+		remove := repRemoval(h, mmT2)
+		err := h.write(remove)
+		require.ErrorIs(t, err, ErrMatchSuperseded, "nothing of the removal applies")
+		assert.Contains(t, HeldGroupsOf(err), repBoutGroup)
+		assert.Contains(t, HeldGroupsOf(err), repPickAName, "the pick is held with the bout")
+
+		got := h.load(t)
+		require.Len(t, got.SubResults, 1, "the row stays")
+		assert.Equal(t, "carol", got.SubResults[0].SideAMemberID, "with its pick")
+		assert.Equal(t, []string{"M"}, got.SubResults[0].IpponsA, "and its point")
+		assert.Equal(t, mmT1, remove.GroupStamps[repPickAName], "the pick keeps its date: the removal did not touch it")
+
+		entries := h.history(t)
+		last := entries[len(entries)-1]
+		assert.Equal(t, state.HistoryOutcomeHeld, last.Outcomes[repPickAName])
+		assert.JSONEq(t, `{"sideAMemberId":""}`, string(last.Held[repPickAName]), "the clear that was not applied")
+		assert.Equal(t, state.HistoryOutcomeHeld, last.Outcomes[repBoutGroup])
+	})
+}
+
+// K. A pick whose bout a LATER hold took out of the write has no bout to land
+// on either. A running write made after a knockout's finish names the bout and a
+// pick and ties the scoreline: R4 holds the bout (the stored match has no
+// representative row to put it on), and the pick the row carried must go with
+// it, held with its id, not left "applied" onto nothing with its stamp moved.
+func TestMerge_RepPick_OnARowAHoldTookOut_IsHeldWithItsValue(t *testing.T) {
+	finished := func(t *testing.T) mmHome {
+		h := mmTeam(t, true)
+		done := mmRunning(h, mmT1)
+		done.Changed = nil
+		done.Status = state.MatchStatusCompleted
+		done.IpponsA, done.IpponsB = []string{"M"}, []string{}
+		done.Winner = wrTeamA
+		require.NoError(t, h.write(done))
+		return h
+	}
+	tying := func(h mmHome, changed ...string) *state.MatchResult {
+		w := repWrite(h, mmT2, repRow("eve", "", nil, nil), append([]string{repBoutGroup, repPickAName, state.GroupPoints}, changed...)...)
+		w.IpponsA, w.IpponsB = []string{"M"}, []string{"K"}
+		return w
+	}
+
+	t.Run("the whole write is held", func(t *testing.T) {
+		h := finished(t)
+		late := tying(h)
+		err := h.write(late)
+		require.ErrorIs(t, err, ErrMatchSuperseded)
+		assert.ElementsMatch(t, []string{state.GroupPoints, repBoutGroup, repPickAName}, HeldGroupsOf(err))
+		assert.NotContains(t, late.Merge.Applied, repPickAName, "never applied onto nothing")
+		assert.Equal(t, HoldReasonKnockoutNeedsWinner, late.Merge.HoldReason)
+
+		last := h.history(t)
+		last0 := last[len(last)-1]
+		assert.Equal(t, state.HistoryOutcomeHeld, last0.Outcomes[repPickAName])
+		assert.JSONEq(t, `{"sideAMemberId":"eve"}`, string(last0.Held[repPickAName]), "the pick's id is kept")
+		got := h.load(t)
+		assert.Empty(t, got.SubResults)
+		assert.Zero(t, got.GroupStamps[repPickAName], "and its stamp is the stored one")
+	})
+	t.Run("a write applied in part moves no stamp of the pick", func(t *testing.T) {
+		h := finished(t)
+		late := tying(h, state.GroupEncho)
+		late.Encho = &state.EnchoMetadata{PeriodCount: 1}
+		require.NoError(t, h.write(late), "the overtime applies")
+		assert.NotContains(t, late.Merge.Applied, repPickAName)
+		assert.Contains(t, late.Merge.Held, repPickAName)
+		assert.JSONEq(t, `{"sideAMemberId":"eve"}`, string(late.Merge.HeldValues[repPickAName]))
+		got := h.load(t)
+		assert.Empty(t, got.SubResults)
+		assert.NotContains(t, got.GroupStamps, repPickAName, "the stored match never stamped the pick")
+	})
+}
diff --git a/internal/engine/match_merge_test.go b/internal/engine/match_merge_test.go
index 2a188e561..d530b6520 100644
--- a/internal/engine/match_merge_test.go
+++ b/internal/engine/match_merge_test.go
@@ -910,7 +910,7 @@ func TestMerge_FinishIsAtomicWithTheScorelineItStoodOn(t *testing.T) {
 
 		// A verdict-only correction (an operator's hantei call): Tora
 		// actually won. Needs no CorrectionReason here -- that gate is the
-		// handler's (applyCorrectionReasonUnderTx), not the engine's.
+		// handler's (applyCorrectionReason), not the engine's.
 		correction := mmRunning(h, mmT3, state.GroupResult)
 		correction.Status = state.MatchStatusCompleted
 		correction.Winner, correction.WinnerID = wrTeamB, wrTeamBID
diff --git a/internal/engine/pool_requalify.go b/internal/engine/pool_requalify.go
index bf35754d0..2e720117a 100644
--- a/internal/engine/pool_requalify.go
+++ b/internal/engine/pool_requalify.go
@@ -291,11 +291,16 @@ func (e *Engine) tiedQualifyingLabels(tx state.StoreTx, compID string, comp *sta
 // the bare store's per-competition lock is already held.
 func (e *Engine) applyRequalification(tx state.StoreTx, compID, reason string, plan *requalifyPlan) ([]ReopenedMatch, error) {
 	var reopened []ReopenedMatch
+	// The picks the repaint takes from the knockout matches it re-seats
+	// without reopening, for their own history lines (bracket_seat_audit.go).
+	// The write itself is a pool match, so no bracket match is excluded.
+	var clears []repPickClear
 	err := tx.UpdateBracket(compID, func(b *state.Bracket) error {
 		if b == nil {
 			return errMatchNotFound
 		}
-		reopened = nil
+		reopened, clears = nil, nil
+		before := repPickSnapshot(b, "")
 		for _, id := range plan.affected {
 			for ri := range b.Rounds {
 				for mi := range b.Rounds[ri] {
@@ -311,12 +316,17 @@ func (e *Engine) applyRequalification(tx state.StoreTx, compID, reason string, p
 			}
 		}
 		e.resolveSlots(b, plan.resolver)
+		// The repaint may have given a side another team and taken its pick
+		// with it; a reopened match names the group on its own line.
+		clears = repPickClears(before, b)
+		markRepPicksCleared(reopened, clears)
 		return nil
 	})
 	if err != nil {
 		return nil, fmt.Errorf("requalification: update bracket for %s: %w", compID, err)
 	}
 	e.restoreForceReopened(tx, compID, reopened)
+	e.recordRepPickClears(tx, compID, clears, reopened)
 	return reopened, nil
 }
 
diff --git a/internal/engine/replace_participant.go b/internal/engine/replace_participant.go
index ad86aaa60..04c80f50a 100644
--- a/internal/engine/replace_participant.go
+++ b/internal/engine/replace_participant.go
@@ -3,6 +3,7 @@ package engine
 import (
 	"fmt"
 
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
 	"github.com/gitrgoliveira/bracket-creator/internal/helper"
 
 	"github.com/gitrgoliveira/bracket-creator/internal/state"
@@ -164,13 +165,20 @@ func (e *Engine) ReplaceParticipantInDraw(
 		// apply (matchesParticipant), now extended to bracket.json now that
 		// it carries ids too.
 		bracketChanged := false
-		forEachBracketSideWithID(bracket, func(name, id *string) {
+		forEachBracketSlot(bracket, func(m *state.BracketMatch, slot domain.MatchSide, name, id *string) {
 			if !matchesParticipant(*id, pid) {
 				return
 			}
 			bracketFound = true
-			if *name != newName {
-				*name = newName
+			if slot == domain.MatchSideNone {
+				// The Winner is not a side: written directly.
+				if *name != newName {
+					*name = newName
+					bracketChanged = true
+				}
+				return
+			}
+			if renameBracketSide(m, slot, newName, *id) {
 				bracketChanged = true
 			}
 		})
@@ -207,7 +215,7 @@ func (e *Engine) ReplaceParticipantInDraw(
 		// manual check, while the silent-corruption direction costs someone
 		// else's match history.
 		bracketNames := make(map[string]bool)
-		forEachBracketSideWithID(bracket, func(name, id *string) {
+		forEachBracketSlot(bracket, func(_ *state.BracketMatch, _ domain.MatchSide, name, id *string) {
 			if *id == "" && *name != "" {
 				bracketNames[*name] = true
 			}
@@ -220,7 +228,7 @@ func (e *Engine) ReplaceParticipantInDraw(
 			}
 			bracketNameAmbiguous = amb
 		}
-		forEachBracketSideWithID(bracket, func(name, id *string) {
+		forEachBracketSlot(bracket, func(m *state.BracketMatch, slot domain.MatchSide, name, id *string) {
 			if *id != "" {
 				// Carries an id that is NOT pid's (pass 1 already renamed
 				// every pid match): a different competitor, full stop --
@@ -235,6 +243,13 @@ func (e *Engine) ReplaceParticipantInDraw(
 			if !bracketNameAmbiguous {
 				*name = newName
 				bracketChanged = true
+				// The side keeps its team and only has a new name, so the
+				// representative bout row's name follows it and no pick goes
+				// (seatBracketSide would read an id-less old name to a new
+				// one as another team).
+				if row := state.DaihyosenSubIndex(m.SubResults); row >= 0 && slot != domain.MatchSideNone {
+					nameRepBoutRow(m, row, slot, newName, oldName, false)
+				}
 			}
 		})
 		if bracketNameAmbiguous && bracketFound {
@@ -317,28 +332,55 @@ func matchesParticipant(rowID, pid string) bool {
 	return rowID != "" && pid != "" && rowID == pid
 }
 
-// forEachBracketSideWithID calls fn once for each of a bracket's three
-// (name, id) side pairs -- SideA/SideAID, SideB/SideBID, Winner/WinnerID --
-// across every round, plus the ThirdPlaceMatch sibling's when present. Both
-// pointers ALIAS the stored match (indexed slice access, never a
-// range-copy), so a caller mutating through them edits the bracket in
-// place. Shared by ReplaceParticipantInDraw's id-based rename pass, its
-// id-less name-collection pass, and its name-based fallback rename pass,
-// which would otherwise hand-copy the same enumeration three times
-// (bc-brid; this replaced the pre-bc-brid, name-only forEachBracketSide,
-// whose two callers both needed the id half once bracket.json grew one).
-func forEachBracketSideWithID(b *state.Bracket, fn func(name, id *string)) {
+// renameBracketSide gives side of m, which carries the renamed participant's
+// id, the participant's new name. It goes through seatBracketSide, so the
+// representative bout row's name (and its Winner, when the row or the match named
+// the side by the old name) follows the match's: the same id is the same team, so no pick
+// is cleared. It reports whether anything was out of step, the match's name or
+// the row's, so a bracket already in step is not saved again.
+func renameBracketSide(m *state.BracketMatch, side domain.MatchSide, newName, id string) bool {
+	name, _ := slotFields(m, side)
+	inStep := *name == newName
+	if row := state.DaihyosenSubIndex(m.SubResults); row >= 0 {
+		rowName := m.SubResults[row].SideA
+		if side == domain.MatchSideB {
+			rowName = m.SubResults[row].SideB
+		}
+		inStep = inStep && rowName == newName
+	}
+	if inStep {
+		return false
+	}
+	seatBracketSide(m, side, newName, id)
+	return true
+}
+
+// forEachBracketSlot calls fn once for each of a bracket's three (name, id)
+// slots -- SideA/SideAID, SideB/SideBID, Winner/WinnerID -- across every round,
+// plus the ThirdPlaceMatch sibling's when present, with the slot's match and
+// which of its slots it is: domain.MatchSideA, domain.MatchSideB, or
+// domain.MatchSideNone for the Winner (not a side). Both pointers ALIAS the
+// stored match (indexed slice access, never a range-copy), so a caller mutating
+// through them edits the bracket in place. Shared by ReplaceParticipantInDraw's
+// id-based rename pass, its id-less name-collection pass, and its name-based
+// fallback rename pass, which would otherwise hand-copy the same enumeration
+// three times (bc-brid; this replaced the pre-bc-brid, name-only
+// forEachBracketSide, whose two callers both needed the id half once
+// bracket.json grew one). The passes that write a side through seatBracketSide,
+// or keep the representative bout row in step with one, need the match and the
+// slot; the collection pass ignores both.
+func forEachBracketSlot(b *state.Bracket, fn func(m *state.BracketMatch, slot domain.MatchSide, name, id *string)) {
+	visit := func(m *state.BracketMatch) {
+		fn(m, domain.MatchSideA, &m.SideA, &m.SideAID)
+		fn(m, domain.MatchSideB, &m.SideB, &m.SideBID)
+		fn(m, domain.MatchSideNone, &m.Winner, &m.WinnerID)
+	}
 	for i := range b.Rounds {
 		for j := range b.Rounds[i] {
-			m := &b.Rounds[i][j]
-			fn(&m.SideA, &m.SideAID)
-			fn(&m.SideB, &m.SideBID)
-			fn(&m.Winner, &m.WinnerID)
+			visit(&b.Rounds[i][j])
 		}
 	}
 	if bm := b.ThirdPlaceMatch; bm != nil {
-		fn(&bm.SideA, &bm.SideAID)
-		fn(&bm.SideB, &bm.SideBID)
-		fn(&bm.Winner, &bm.WinnerID)
+		visit(bm)
 	}
 }
diff --git a/internal/engine/representative_export.go b/internal/engine/representative_export.go
new file mode 100644
index 000000000..8bb3820f0
--- /dev/null
+++ b/internal/engine/representative_export.go
@@ -0,0 +1,110 @@
+package engine
+
+// representative_export.go converts a fixed-order team competition's
+// representative bouts into the helper-layer KachinukiMatchDetail shape the
+// "Representative Bouts" sheet is drawn from. The sheet exists because the
+// main sheets' team block lists the numbered bouts only (it skips position -1,
+// so its height, page breaks and IV/PW ranges stay TeamBoutRows' alone), which
+// left a representative bout, and the representatives, out of every
+// workbook. The renderer is the Kachinuki Detail sheet's
+// (internal/helper/excel_kachinuki.go), and the matches are walked by the same
+// detailDraw.sections, so the two sheets order a draw alike.
+
+import (
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/helper"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+// RepresentativeBoutMatches returns one section per match of a fixed-order
+// team competition that holds a representative bout, or an empty slice for
+// any other competition. Exported, like KachinukiDetailMatches, so the
+// "Download results" path (internal/export.BuildResultsWorkbook) emits the
+// sheet without duplicating the collection logic ExportCompetitionXlsx uses.
+func (e *Engine) RepresentativeBoutMatches(id string) ([]helper.KachinukiMatchDetail, error) {
+	comp, err := e.store.LoadCompetition(id)
+	if err != nil {
+		return nil, err
+	}
+	return e.collectRepresentativeBouts(id, comp)
+}
+
+// collectRepresentativeBouts returns the Representative Bouts sections of a
+// fixed-order team competition's draw, nil for any other competition (a
+// kachinuki one has no representative bout: AddDaihyosen refuses it), in the
+// order the Kachinuki Detail sheet lists a draw. A match without the bout has
+// no section. It is read-only and, like the Kachinuki Detail read, tolerant of
+// a missing or unreadable team-members.yaml, roster or bracket.json: the
+// representatives then print as the bout label alone.
+func (e *Engine) collectRepresentativeBouts(compID string, comp *state.Competition) ([]helper.KachinukiMatchDetail, error) {
+	if !comp.IsTeam() || comp.IsKachinuki() {
+		return nil, nil
+	}
+	draw, err := e.loadDetailDraw("engine.collectRepresentativeBouts", compID)
+	if err != nil {
+		return nil, err
+	}
+	teamNumbers := e.buildKachinukiTeamNumbers(compID, comp)
+	squads := e.buildKachinukiSquads(compID)
+	return draw.sections(comp, func(m *state.MatchResult, label string) (helper.KachinukiMatchDetail, bool) {
+		return buildRepresentativeBoutDetail(m, label, teamNumbers, squads)
+	}), nil
+}
+
+// buildRepresentativeBoutDetail converts m's representative bout (the row at
+// state.DaihyosenSubPosition) into a one-bout section titled label, or reports
+// false when m holds none. The bout's score, result marks and centre come from
+// boutFigures, the Kachinuki Detail sheet's own, so the two sheets cannot
+// disagree on a bout; the centre reads (DH) through domain.MiddleMark.
+//
+// The row keeps the TEAM names in SideA/SideB by rule (the result mark is
+// placed on the winner's side by comparing against them), so its fighters come
+// from the member ids alone, via representativeOf. A representative has no
+// lineup position, so none is printed.
+func buildRepresentativeBoutDetail(m *state.MatchResult, label string, teamNumbers map[string]string, squads map[string][]domain.TeamMember) (helper.KachinukiMatchDetail, bool) {
+	i := state.DaihyosenSubIndex(m.SubResults)
+	if i < 0 {
+		return helper.KachinukiMatchDetail{}, false
+	}
+	sub := m.SubResults[i]
+	scoreA, scoreB, markA, markB, middle := boutFigures(m, sub)
+	nameA, labelA := representativeOf(teamNumbers, squads, m.SideAID, sub.SideAMemberID)
+	nameB, labelB := representativeOf(teamNumbers, squads, m.SideBID, sub.SideBMemberID)
+	return helper.KachinukiMatchDetail{
+		Label:     label,
+		SideATeam: m.SideA,
+		SideBTeam: m.SideB,
+		Bouts: []helper.KachinukiBout{{
+			Position:   sub.Position,
+			SideAName:  nameA,
+			SideALabel: labelA,
+			ScoreA:     scoreA,
+			SideBName:  nameB,
+			SideBLabel: labelB,
+			ScoreB:     scoreB,
+			Middle:     middle,
+			MarkA:      markA,
+			MarkB:      markB,
+		}},
+	}, true
+}
+
+// representativeOf names the representative a side picked: the current name
+// and "T1.3"-style label of the member memberID in teamID's team members.
+// Both are empty for a side that picked nobody (no member id) or whose pick
+// does not resolve to a member of that team (a member since removed, a team
+// without an id, no team-members file): unlike a numbered bout's row, the
+// representative's row stores the team's name where a fighter's would be, so
+// the stored name is never a fallback here, and the bout prints its label
+// alone, as the viewer shows "-".
+func representativeOf(teamNumbers map[string]string, squads map[string][]domain.TeamMember, teamID, memberID string) (name, label string) {
+	if teamID == "" || memberID == "" {
+		return "", ""
+	}
+	for _, member := range squads[teamID] {
+		if member.ID == memberID {
+			return member.Name, resolveKachinukiMemberLabel(teamNumbers, squads, teamID, memberID)
+		}
+	}
+	return "", ""
+}
diff --git a/internal/engine/representative_export_test.go b/internal/engine/representative_export_test.go
new file mode 100644
index 000000000..4f796107c
--- /dev/null
+++ b/internal/engine/representative_export_test.go
@@ -0,0 +1,356 @@
+package engine
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/helper"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+)
+
+// representativeTeams is a fixed-order team knockout's two teams with three
+// named members each; the draw puts Red first, so its members are T1.1-T1.3
+// and White's T2.1-T2.3.
+type representativeTeams struct {
+	redID, whiteID string
+	red, white     []domain.TeamMember
+}
+
+// setupRepresentativeComp saves a fixed-order team knockout with two teams and
+// their members, and returns the engine over it. Deliberately NOT
+// setupKachinukiComp: this fixture's point is the non-kachinuki team type.
+func setupRepresentativeComp(t *testing.T, compID string) (*Engine, *state.Store, representativeTeams) {
+	t.Helper()
+	eng, store, _ := setupTestEngine(t)
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID:            compID,
+		Format:        state.CompFormatKnockout,
+		Status:        state.CompStatusKnockout,
+		Kind:          "team",
+		TeamSize:      3,
+		TeamMatchType: state.TeamMatchTypeFixed,
+		NumberPrefix:  "T",
+	}))
+
+	teams := representativeTeams{redID: helper.NewUUID4(), whiteID: helper.NewUUID4()}
+	require.NoError(t, store.SaveParticipants(compID, []domain.Player{
+		{ID: teams.redID, Name: "RedTeam", Dojo: "DojoR"},
+		{ID: teams.whiteID, Name: "WhiteTeam", Dojo: "DojoW"},
+	}))
+	add := func(teamID string, names ...string) []domain.TeamMember {
+		out := make([]domain.TeamMember, 0, len(names))
+		for _, n := range names {
+			m, err := store.AddTeamMember(compID, teamID, n)
+			require.NoError(t, err)
+			out = append(out, m)
+		}
+		return out
+	}
+	teams.red = add(teams.redID, "Alice", "Aiko", "Akira")
+	teams.white = add(teams.whiteID, "Bob", "Bea", "Ben")
+	require.Equal(t, 3, teams.red[2].Index, "Akira is Red's third member")
+	require.Equal(t, 2, teams.white[1].Index, "Bea is White's second member")
+	return eng, store, teams
+}
+
+// representativeRow is the representative bout a hantei decided for Red: the
+// row names the TEAMS (by rule), the picked members ride in the member ids.
+func representativeRow(teams representativeTeams) state.SubMatchResult {
+	return state.SubMatchResult{
+		Position:      state.DaihyosenSubPosition,
+		SideA:         "RedTeam",
+		SideB:         "WhiteTeam",
+		SideAMemberID: teams.red[2].ID,
+		SideBMemberID: teams.white[1].ID,
+		Winner:        "RedTeam",
+		Decision:      string(domain.DecisionDaihyosen),
+		IpponsA:       []string{domain.HanteiMark},
+	}
+}
+
+// bracketMatchWith is one completed knockout semi-final between Red and White
+// holding subs.
+func bracketMatchWith(teams representativeTeams, subs ...state.SubMatchResult) state.BracketMatch {
+	return state.BracketMatch{
+		ID:           "SF1",
+		MatchNumber:  1,
+		DisplayRound: 1,
+		SideA:        "RedTeam",
+		SideAID:      teams.redID,
+		SideB:        "WhiteTeam",
+		SideBID:      teams.whiteID,
+		Winner:       "RedTeam",
+		Status:       state.MatchStatusCompleted,
+		SubResults:   subs,
+	}
+}
+
+func saveBracketOf(t *testing.T, store *state.Store, compID string, teams representativeTeams, matches ...state.BracketMatch) {
+	t.Helper()
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{
+		DrawOrder: []string{teams.redID, teams.whiteID},
+		Rounds:    [][]state.BracketMatch{matches},
+	}))
+}
+
+// numberedBout is a tied numbered bout, which the sheet must not list.
+func numberedBout(teams representativeTeams) state.SubMatchResult {
+	return state.SubMatchResult{
+		Position: 1, SideA: "Alice", SideAMemberID: teams.red[0].ID,
+		SideB: "Bob", SideBMemberID: teams.white[0].ID, Decision: "hikiwake",
+	}
+}
+
+func TestRepresentativeBoutMatches_ListsTheRepresentativeBout(t *testing.T) {
+	compID := "representative-lists-the-bout"
+	eng, store, teams := setupRepresentativeComp(t, compID)
+	saveBracketOf(t, store, compID, teams, bracketMatchWith(teams, numberedBout(teams), representativeRow(teams)))
+
+	out, err := eng.RepresentativeBoutMatches(compID)
+	require.NoError(t, err)
+	require.Len(t, out, 1, "one section for the one match holding a representative bout")
+
+	section := out[0]
+	assert.Equal(t, helper.EliminationMatchTitle(1, 1), section.Label, "titled as the Elimination Matches sheet prints the match")
+	assert.Equal(t, "RedTeam", section.SideATeam)
+	assert.Equal(t, "WhiteTeam", section.SideBTeam)
+	require.Len(t, section.Bouts, 1, "the representative bout alone: the numbered bouts are on the main sheets")
+
+	bout := section.Bouts[0]
+	assert.Equal(t, state.DaihyosenSubPosition, bout.Position)
+	assert.Equal(t, "Akira", bout.SideAName, "Red's representative, not the team")
+	assert.Equal(t, "T1.3", bout.SideALabel)
+	assert.Equal(t, "Bea", bout.SideBName)
+	assert.Equal(t, "T2.2", bout.SideBLabel)
+	assert.Empty(t, bout.SideAPos, "a representative holds no lineup position")
+	assert.Empty(t, bout.SideBPos)
+	assert.Equal(t, "(DH)", bout.Middle, "the centre is the closed-set daihyosen mark, domain.MiddleMark's")
+	assert.Equal(t, "Ht", bout.MarkA, "the hantei mark rides beside the winner's side")
+	assert.Empty(t, bout.MarkB)
+	assert.Empty(t, bout.ScoreA, "the hantei mark is not a point")
+	assert.Empty(t, bout.ScoreB)
+	assert.Zero(t, section.BlankBoutRows)
+}
+
+// A side whose representative was not picked prints no fighter: the row stores
+// the TEAM's name where a fighter's would be, and the viewer shows "-" there,
+// so the export must not print the team as a person.
+func TestRepresentativeBoutMatches_UnpickedSidePrintsNoName(t *testing.T) {
+	cases := []struct {
+		name  string
+		sideB func(teams representativeTeams) string
+	}{
+		{"no pick", func(representativeTeams) string { return "" }},
+		{"an id that resolves to no member", func(representativeTeams) string { return "a-removed-member" }},
+		{"a member of the other team", func(teams representativeTeams) string { return teams.red[0].ID }},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			compID := "representative-unpicked-" + strings.ReplaceAll(tc.name, " ", "-")
+			eng, store, teams := setupRepresentativeComp(t, compID)
+			row := representativeRow(teams)
+			row.SideBMemberID = tc.sideB(teams)
+			saveBracketOf(t, store, compID, teams, bracketMatchWith(teams, row))
+
+			out, err := eng.RepresentativeBoutMatches(compID)
+			require.NoError(t, err)
+			require.Len(t, out, 1)
+			bout := out[0].Bouts[0]
+			assert.Empty(t, bout.SideBName, "White's side picked nobody that resolves")
+			assert.Empty(t, bout.SideBLabel)
+			assert.Equal(t, "Akira", bout.SideAName, "the other side's pick is unaffected")
+			assert.Equal(t, "T1.3", bout.SideALabel)
+		})
+	}
+}
+
+// With no team-members file at all every pick is unresolvable.
+func TestRepresentativeBoutMatches_NoMembersFilePrintsTheBoutLabelAlone(t *testing.T) {
+	compID := "representative-no-members"
+	eng, store, _ := setupTestEngine(t)
+	require.NoError(t, store.SaveCompetition(&state.Competition{
+		ID: compID, Format: state.CompFormatKnockout, Status: state.CompStatusKnockout,
+		Kind: "team", TeamSize: 3, TeamMatchType: state.TeamMatchTypeFixed, NumberPrefix: "T",
+	}))
+	teams := representativeTeams{redID: helper.NewUUID4(), whiteID: helper.NewUUID4()}
+	teams.red = []domain.TeamMember{{ID: "m-red"}, {ID: "m-red-2"}, {ID: "m-red-3"}}
+	teams.white = []domain.TeamMember{{ID: "m-white"}, {ID: "m-white-2"}}
+	saveBracketOf(t, store, compID, teams, bracketMatchWith(teams, representativeRow(teams)))
+
+	out, err := eng.RepresentativeBoutMatches(compID)
+	require.NoError(t, err)
+	require.Len(t, out, 1)
+	bout := out[0].Bouts[0]
+	assert.Empty(t, bout.SideAName)
+	assert.Empty(t, bout.SideALabel)
+	assert.Empty(t, bout.SideBName)
+	assert.Empty(t, bout.SideBLabel)
+	assert.Equal(t, "(DH)", bout.Middle, "the bout is still listed, with its centre")
+}
+
+func TestRepresentativeBoutMatches_NoneWithoutARepresentativeBout(t *testing.T) {
+	t.Run("a match with numbered bouts only", func(t *testing.T) {
+		compID := "representative-none-numbered"
+		eng, store, teams := setupRepresentativeComp(t, compID)
+		saveBracketOf(t, store, compID, teams, bracketMatchWith(teams, numberedBout(teams)))
+
+		out, err := eng.RepresentativeBoutMatches(compID)
+		require.NoError(t, err)
+		assert.Empty(t, out)
+	})
+	t.Run("a draw with no matches fought", func(t *testing.T) {
+		compID := "representative-none-undrawn"
+		eng, _, _ := setupRepresentativeComp(t, compID)
+
+		out, err := eng.RepresentativeBoutMatches(compID)
+		require.NoError(t, err)
+		assert.Empty(t, out)
+	})
+	t.Run("an individual competition", func(t *testing.T) {
+		eng, store, _ := setupTestEngine(t)
+		compID := "representative-none-individual"
+		createTestCompetition(t, store, compID, "mixed", 3)
+		saveTestParticipants(t, store, compID, []string{"Alice", "Bob", "Charlie"})
+
+		out, err := eng.RepresentativeBoutMatches(compID)
+		require.NoError(t, err)
+		assert.Empty(t, out)
+	})
+}
+
+// A kachinuki encounter has no representative bout (AddDaihyosen refuses it),
+// so a stray position -1 row there is not listed; the Kachinuki Detail sheet
+// owns that competition's bouts.
+func TestRepresentativeBoutMatches_NoneForKachinuki(t *testing.T) {
+	compID := "representative-none-kachinuki"
+	eng, store, _ := setupKachinukiComp(t, compID, 3, func(c *state.Competition) {
+		c.Format = state.CompFormatKnockout
+		c.Status = state.CompStatusKnockout
+		c.NumberPrefix = "T"
+	})
+	teams := representativeTeams{redID: helper.NewUUID4(), whiteID: helper.NewUUID4()}
+	teams.red = []domain.TeamMember{{ID: "m1"}, {ID: "m2"}, {ID: "m3"}}
+	teams.white = []domain.TeamMember{{ID: "w1"}, {ID: "w2"}}
+	saveBracketOf(t, store, compID, teams, bracketMatchWith(teams, representativeRow(teams)))
+
+	out, err := eng.RepresentativeBoutMatches(compID)
+	require.NoError(t, err)
+	assert.Empty(t, out)
+}
+
+func TestRepresentativeBoutMatches_UnknownOrInvalidCompetition(t *testing.T) {
+	eng, _, _ := setupTestEngine(t)
+
+	out, err := eng.RepresentativeBoutMatches("does-not-exist")
+	assert.NoError(t, err, "an unknown competition lists nothing, as the Kachinuki Detail read does")
+	assert.Nil(t, out)
+
+	out, err = eng.RepresentativeBoutMatches("../evil")
+	require.Error(t, err)
+	assert.Nil(t, out)
+	assert.Contains(t, err.Error(), "invalid competition ID")
+}
+
+// Pool rows come first (a row the Pool Matches grid has no block for is titled
+// by its operator label), then the bracket in match-number order, not storage
+// order, then the 3rd-place match: the Kachinuki Detail sheet's own order.
+func TestRepresentativeBoutMatches_ListedInTheKachinukiDetailOrder(t *testing.T) {
+	compID := "representative-order"
+	eng, store, teams := setupRepresentativeComp(t, compID)
+	comp, err := store.LoadCompetition(compID)
+	require.NoError(t, err)
+
+	poolRow := state.MatchResult{
+		ID: "Pool A-0", SideA: "RedTeam", SideAID: teams.redID, SideB: "WhiteTeam", SideBID: teams.whiteID,
+		Status: state.MatchStatusCompleted, SubResults: []state.SubMatchResult{representativeRow(teams)},
+	}
+	require.NoError(t, store.SavePoolMatches(compID, []state.MatchResult{poolRow}))
+
+	second := bracketMatchWith(teams, representativeRow(teams))
+	second.ID, second.MatchNumber = "SF2", 2
+	first := bracketMatchWith(teams, representativeRow(teams))
+	third := bracketMatchWith(teams, representativeRow(teams))
+	third.ID = "BR"
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{
+		DrawOrder:       []string{teams.redID, teams.whiteID},
+		Rounds:          [][]state.BracketMatch{{second, first}},
+		ThirdPlaceMatch: &third,
+	}))
+
+	out, err := eng.RepresentativeBoutMatches(compID)
+	require.NoError(t, err)
+	labels := make([]string, len(out))
+	for i, s := range out {
+		labels[i] = s.Label
+	}
+	assert.Equal(t, []string{
+		OperatorMatchLabel(comp, nil, "Pool A-0"),
+		helper.EliminationMatchTitle(1, 1),
+		helper.EliminationMatchTitle(1, 2),
+		helper.ThirdPlaceLabel,
+	}, labels)
+}
+
+// The stored-draw export carries the sheet too (the results workbook's twin is
+// in internal/export): a real drawn team knockout, one semi-final decided by a
+// representative bout.
+func TestExportCompetitionXlsx_RepresentativeBoutsSheet(t *testing.T) {
+	eng, store, _ := setupTestEngine(t)
+	compID := "export-representative-bouts"
+	createTestCompetition(t, store, compID, state.CompFormatKnockout, 0, func(c *state.Competition) {
+		c.Kind = "team"
+		c.TeamSize = 3
+		c.TeamMatchType = state.TeamMatchTypeFixed
+		c.NumberPrefix = "T"
+	})
+	saveTestParticipants(t, store, compID, []string{"Ryu", "Tora", "Kame", "Taka"})
+	require.NoError(t, eng.StartCompetition(compID))
+
+	t.Run("none before a representative bout exists", func(t *testing.T) {
+		f := openExportedWorkbook(t, eng, compID)
+		assert.NotContains(t, f.GetSheetList(), helper.SheetRepresentativeBouts)
+	})
+
+	bracket, err := store.LoadBracket(compID)
+	require.NoError(t, err)
+	semi := bracket.Rounds[0][0]
+	require.NotEmpty(t, semi.SideAID)
+	require.NotEmpty(t, semi.SideBID)
+	a, err := store.AddTeamMember(compID, semi.SideAID, "Hiro")
+	require.NoError(t, err)
+	b, err := store.AddTeamMember(compID, semi.SideBID, "Sayaka")
+	require.NoError(t, err)
+	found, err := store.UpdateBracketMatchByID(compID, semi.ID, func(bm *state.BracketMatch) {
+		bm.Status = state.MatchStatusCompleted
+		bm.Winner = bm.SideA
+		bm.SubResults = []state.SubMatchResult{{
+			Position: state.DaihyosenSubPosition, SideA: bm.SideA, SideB: bm.SideB,
+			SideAMemberID: a.ID, SideBMemberID: b.ID, Winner: bm.SideA,
+			Decision: string(domain.DecisionDaihyosen), IpponsA: []string{domain.HanteiMark},
+		}}
+	})
+	require.NoError(t, err)
+	require.True(t, found)
+
+	f := openExportedWorkbook(t, eng, compID)
+	require.Contains(t, f.GetSheetList(), helper.SheetRepresentativeBouts)
+	assert.NotContains(t, f.GetSheetList(), helper.SheetKachinukiDetail, "a fixed-order competition has no Kachinuki Detail sheet")
+
+	rows, err := f.GetRows(helper.SheetRepresentativeBouts)
+	require.NoError(t, err)
+	var flat []string
+	for _, row := range rows {
+		flat = append(flat, strings.Join(row, "|"))
+	}
+	text := strings.Join(flat, "\n")
+	assert.Contains(t, text, "(Representative bout)")
+	assert.Contains(t, text, "DH ", "the bout's number cell reads DH")
+	assert.Contains(t, text, "Hiro")
+	assert.Contains(t, text, "Sayaka")
+	assert.Contains(t, text, "(DH)")
+	assert.Contains(t, text, "Ht")
+}
diff --git a/internal/engine/scoring.go b/internal/engine/scoring.go
index a28186367..bda032785 100644
--- a/internal/engine/scoring.go
+++ b/internal/engine/scoring.go
@@ -541,6 +541,12 @@ func preserveSubHantei(stored, incoming []state.SubMatchResult) {
 	// guards it): the mark and the winner it names move as one atomic
 	// unit, never separately.
 	in.Winner = prior.Winner
+	// Neither id is trusted, the stored one included: the representatives are
+	// their own change, so even the stored id may disagree with the picks this
+	// row now holds. The reconcile derives the id again from the winner's NAME
+	// and those picks, so it is exactly the winning side's pick or empty
+	// (SubMatchResult.ReconcileWinnerMemberID).
+	in.ReconcileWinnerMemberID()
 }
 
 // preserveDaihyosenOutcome is the call every forward SubResults replacement
@@ -636,6 +642,13 @@ type ReopenedMatch struct {
 	// Court is the shiaijo the match is on ("" when it has none), so a
 	// refusal can tell the operator where the match is being fought.
 	Court string
+	// RepPicksCleared lists the pick groups (state.RepPickGroup) of the sides
+	// the same write that reopened the match gave another team, which took
+	// that side's representative with it (seatBracketSide); nil when none
+	// went. Its reopen history line then names those groups beside the
+	// verdict's, and only those. markRepPicksCleared fills it from the diff the
+	// door takes (repPickClears), so no second copy of the picks rides here.
+	RepPicksCleared []string
 }
 
 // bracketMatchRef is the ONE way a bracket match becomes a ReopenedMatch, so
@@ -2387,18 +2400,24 @@ func markTiedStandingsLeague(comp *state.Competition, sorted []state.PlayerStand
 // step amplified the risk because it mutates ADJACENT bracket cells
 // (the next-round match), so a concurrent save with a stale view
 // could clobber another operator's propagation too.
+//
+// The matches the write re-seats without reopening get their own history line
+// beside the reopen lines (recordRepPickClears), in the same transaction; a
+// restore (matchWriteRestore) is not a door and records none.
 func (e *Engine) recordBracketMatchResult(h state.StoreTx, compId string, matchId string, result *state.MatchResult, policy matchWritePolicy, force bool, comp *state.Competition) ([]ReopenedMatch, bool, error) {
 	var (
 		reopened  []ReopenedMatch
 		inherited bool
+		clears    []repPickClear
 	)
 	err := h.UpdateBracket(compId, func(bracket *state.Bracket) error {
 		var ierr error
-		reopened, inherited, ierr = e.applyBracketResultIn(bracket, compId, matchId, result, policy, force, comp)
+		reopened, inherited, clears, ierr = e.applyBracketResultIn(bracket, compId, matchId, result, policy, force, comp)
 		return ierr
 	})
 	if err == nil {
 		e.restoreForceReopened(h, compId, reopened)
+		e.recordRepPickClears(h, compId, clears, reopened)
 	}
 	return reopened, inherited && err == nil, err
 }
@@ -2640,9 +2659,9 @@ func applyBracketMatchResult(bm *state.BracketMatch, result *state.MatchResult,
 // correction and its propagation have landed, requeues the ONE downstream
 // match the correction would otherwise have silently repainted; its id is
 // returned so the caller can broadcast match_updated for it.
-func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID string, result *state.MatchResult, policy matchWritePolicy, force bool, comp *state.Competition) ([]ReopenedMatch, bool, error) {
+func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID string, result *state.MatchResult, policy matchWritePolicy, force bool, comp *state.Competition) ([]ReopenedMatch, bool, []repPickClear, error) {
 	if bracket == nil {
-		return nil, false, notFoundErrorf("bracket not found for competition %s", compID)
+		return nil, false, nil, notFoundErrorf("bracket not found for competition %s", compID)
 	}
 	mc := mergeCtx{comp: comp, knockout: true}
 	for rIdx := range bracket.Rounds {
@@ -2656,7 +2675,7 @@ func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID st
 			// and a payload that omits its sides would otherwise read as one
 			// with no sides at all (bc-mrgc review S6).
 			if sidesBeforeMerge(bm, result, policy) {
-				return nil, false, ErrMatchSideMismatch
+				return nil, false, nil, ErrMatchSideMismatch
 			}
 			// The merge (bc-mrgc), the SAME owner the pool branch calls, and
 			// FIRST: everything below judges the merged match. A write whose
@@ -2666,7 +2685,7 @@ func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID st
 			// against a result it is not changing (bc-cse finding 2).
 			// Returning an error makes UpdateBracket skip the save.
 			if mergeMatchWrite(bracketMatchAsResult(bm), result, policy, mc).Superseded() {
-				return nil, false, ErrMatchSuperseded
+				return nil, false, nil, ErrMatchSuperseded
 			}
 			// A bout-row correction over a recorded withdrawal keeps the
 			// ruling (bc-tmfn). It must run BEFORE the downstream guard below,
@@ -2678,7 +2697,7 @@ func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID st
 			// The guard runs forced too: force gets past a played later
 			// match, never a running one (bc-rfsw).
 			if err := guardDownstreamKnockoutCorrection(bracket, rIdx, mIdx, bm, result, policy, force); err != nil {
-				return nil, false, err
+				return nil, false, nil, err
 			}
 			// Captured BEFORE the write, so the force branch below can tell a
 			// correction that actually changes the winner from one that does
@@ -2686,8 +2705,19 @@ func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID st
 			// cleared the next round for a write that stored the same winner --
 			// including one confirmed for an unrelated reason.
 			priorWinner, priorWinnerID := propagatedWinnerOf(bracket, rIdx, mIdx, bm)
+			// The representatives every other match holds before the
+			// propagation below can re-seat a side and take one away
+			// (bracket_seat_audit.go): a played downstream match the write
+			// reopens names its lost pick on its own reopen line, one it
+			// leaves alone but re-seats has the door record a reseat line. A
+			// restore (the K3 rollback replaying a prior) is not a door and
+			// records nothing, so it takes no snapshot.
+			var before map[string][2]string
+			if policy == matchWriteForward {
+				before = repPickSnapshot(bracket, matchID)
+			}
 			if _, err := applyBracketMatchResult(bm, result, policy); err != nil {
-				return nil, false, err
+				return nil, false, nil, err
 			}
 			// Propagate only a genuinely completed result. A "running" update is
 			// for live-status display, so the next round's SideA/SideB must stay
@@ -2704,27 +2734,30 @@ func (e *Engine) applyBracketResultIn(bracket *state.Bracket, compID, matchID st
 					reopened = forceReopenDownstreamChain(bracket, rIdx, mIdx, bm.ID)
 				}
 			}
-			return reopened, inherited, nil
+			clears := repPickClears(before, bracket)
+			markRepPicksCleared(reopened, clears)
+			return reopened, inherited, clears, nil
 		}
 	}
 	// The bronze (3rd-place) knockout lives in Bracket.ThirdPlaceMatch, NOT in
 	// Rounds, so the scan above never finds it. There is no propagation out of
 	// bronze: it has no downstream match, so the downstream-correction guard
-	// does not apply here either.
+	// does not apply here either, and no other match can lose a pick to this
+	// write (so, unlike the round branch, no snapshot of the picks is taken).
 	if bracket.ThirdPlaceMatch != nil && bracket.ThirdPlaceMatch.ID == matchID {
 		if sidesBeforeMerge(bracket.ThirdPlaceMatch, result, policy) {
-			return nil, false, ErrMatchSideMismatch
+			return nil, false, nil, ErrMatchSideMismatch
 		}
 		if mergeMatchWrite(bracketMatchAsResult(bracket.ThirdPlaceMatch), result, policy, mc).Superseded() {
-			return nil, false, ErrMatchSuperseded
+			return nil, false, nil, ErrMatchSuperseded
 		}
 		inherited := preserveWithdrawalRuling(rulingOfBracketMatch(bracket.ThirdPlaceMatch), result, policy)
 		if _, err := applyBracketMatchResult(bracket.ThirdPlaceMatch, result, policy); err != nil {
-			return nil, false, err
+			return nil, false, nil, err
 		}
-		return nil, inherited, nil
+		return nil, inherited, nil, nil
 	}
-	return nil, false, notFoundErrorf("bracket match %s not found", matchID)
+	return nil, false, nil, notFoundErrorf("bracket match %s not found", matchID)
 }
 
 // bracketMatchCarriesOwnResult reports whether bm holds a result someone
@@ -2838,11 +2871,17 @@ func winnerActuallyChanged(priorWinner, priorWinnerID string, bm *state.BracketM
 // (operator ruling 2026-09-19: "no changes in the queue necessary if the
 // matches were already played"). It carries its own audit note rather than
 // owing one -- see downstreamReopenReason.
+//
+// It leaves the representatives alone and names none as cleared: the caller,
+// which holds the door's snapshot (repPickSnapshot), marks the reopened
+// matches from the diff once every re-seat of the write is done
+// (markRepPicksCleared).
 func forceReopenDownstreamChain(bracket *state.Bracket, rIdx, mIdx int, correctedID string) []ReopenedMatch {
 	d := propagatedDownstreamOf(bracket, rIdx, mIdx)
 	var reopened []ReopenedMatch
 	for _, m := range d.played() {
-		reopened = append(reopened, reopenDisplacedBracketMatch(m, downstreamReopenReason(correctedID)))
+		ref := reopenDisplacedBracketMatch(m, downstreamReopenReason(correctedID))
+		reopened = append(reopened, ref)
 		// The reopened next-round match no longer has a winner, so what it
 		// had propagated comes back out of a round nobody has touched, the
 		// same retraction a pool correction's reopen applies
@@ -2902,6 +2941,9 @@ func reopenDisplacedBracketMatch(m *state.BracketMatch, reason string) ReopenedM
 	}
 	ref := bracketMatchRef(m)
 	ref.PriorDecision = priorDecision
+	// The reopen leaves the picks as they were; what the re-seat of a side
+	// does to them is judged by the door's repPickClears diff, which
+	// markRepPicksCleared copies onto the reopen line.
 	return ref
 }
 
@@ -2909,9 +2951,10 @@ func reopenDisplacedBracketMatch(m *state.BracketMatch, reason string) ReopenedM
 // winner and a hantei mark, and keeps the points struck in it. The row
 // settles the encounter on its own: the next write copies its winner to the
 // match (deriveDaihyosenWinner), matching it through the row's own side
-// names. After a correction those still name the competitor the correction
-// took out, so the one put in their place would inherit a win they never
-// fought. Only the verdict goes, exactly as at match level.
+// names. The row's names follow the match's (seatBracketSide), but the winner
+// it records was fought by the OLD pairing, so the one put in their place would
+// inherit a win they never fought. Only the verdict goes, exactly as at match
+// level.
 func clearDaihyosenVerdict(subs []state.SubMatchResult) {
 	for i := range subs {
 		if subs[i].Position != state.DaihyosenSubPosition {
@@ -2938,7 +2981,12 @@ func (e *Engine) restoreForceReopened(h state.StoreTx, compID string, reopened [
 		reopened[i].Restored = e.restoreIfWithdrawalRemoved(h, compID, reopened[i].ID, reopened[i].PriorDecision, "", nil)
 		// The reopen changed the match outside the merge, so it records its
 		// own history entry (bc-mrgc).
-		e.recordDirectHistory(h, compID, reopened[i].ID, doorDownstreamReopen, serverNowMs(), reopenedBracketGroups...)
+		groups := reopenedBracketGroups
+		if len(reopened[i].RepPicksCleared) > 0 {
+			// A copy: reopenedBracketGroups is shared.
+			groups = append(append([]string(nil), groups...), reopened[i].RepPicksCleared...)
+		}
+		e.recordDirectHistory(h, compID, reopened[i].ID, doorDownstreamReopen, serverNowMs(), groups...)
 	}
 }
 
@@ -2979,8 +3027,8 @@ func requeueBracketMatch(m *state.BracketMatch, stamp int64) {
 	m.CorrectionReason = ""
 	// Mirror of the pool branch (mp-gmcg review): clear the reopen-pending
 	// audit debt so a reopened-then-requeued bracket match can be replayed
-	// and finalized without applyCorrectionReasonUnderTx demanding a reason
-	// for a result the requeue already discarded.
+	// and finalized without the handler's applyCorrectionReason demanding a
+	// reason for a result the requeue already discarded.
 	m.ReopenPending = false
 	// Revert fence (mp-y3nk): stamp now() so any pre-revert offline write
 	// (T_stale < T_revert) cannot put the verdict back on replay. Using 0
@@ -3081,7 +3129,7 @@ func propagatedWinnerOf(bracket *state.Bracket, rIdx, mIdx int, bm *state.Bracke
 		return "", ""
 	}
 	slot, slotID := next.SideB, next.SideBID
-	if mIdx%2 == 0 {
+	if feedsSide(mIdx) == domain.MatchSideA {
 		slot, slotID = next.SideA, next.SideAID
 	}
 	if isUnresolvedBracketSide(slot) {
@@ -3136,7 +3184,7 @@ func newDownstreamKnockoutPlayedError(bm *state.BracketMatch, blocking []*state.
 // placeholder rather than a competitor.
 func displacedCompetitor(bm, blocking *state.BracketMatch, mIdx int) string {
 	slot := blocking.SideB
-	if mIdx%2 == 0 {
+	if feedsSide(mIdx) == domain.MatchSideA {
 		slot = blocking.SideA
 	}
 	if slot != "" && !helper.IsWinnerOfPlaceholder(slot) {
@@ -3222,13 +3270,10 @@ func (e *Engine) propagateBracketWinner(bracket *state.Bracket, rIdx, mIdx int)
 	nextMatchIdx := mIdx / 2
 	nextM := &bracket.Rounds[rIdx+1][nextMatchIdx]
 
-	if mIdx%2 == 0 {
-		nextM.SideA = m.Winner
-		nextM.SideAID = m.WinnerID
-	} else {
-		nextM.SideB = m.Winner
-		nextM.SideBID = m.WinnerID
-	}
+	// seatBracketSide, not a bare assignment: a side given another team takes
+	// its representative-bout pick away with it.
+	side := feedsSide(mIdx)
+	seatBracketSide(nextM, side, m.Winner, m.WinnerID)
 
 	// Feed the loser of a SEMIFINAL into the bronze (3rd-place) knockout match.
 	// The semifinal round index is len(Rounds)-2 (the round that feeds the
@@ -3259,13 +3304,7 @@ func (e *Engine) propagateBracketWinner(bracket *state.Bracket, rIdx, mIdx int)
 			// semifinal overwrites the correct bronze slot in place. A
 			// fill-first-empty scheme would leave a stale loser pinned once
 			// both slots are populated and a semifinal is later re-scored.
-			if mIdx%2 == 0 {
-				bronze.SideA = loser
-				bronze.SideAID = loserID
-			} else {
-				bronze.SideB = loser
-				bronze.SideBID = loserID
-			}
+			seatBracketSide(bronze, side, loser, loserID)
 		}
 	}
 
@@ -3276,8 +3315,7 @@ func (e *Engine) propagateBracketWinner(bracket *state.Bracket, rIdx, mIdx int)
 		if r >= 0 && r < len(bracket.Rounds) && m >= 0 && m < len(bracket.Rounds[r]) {
 			srcM := bracket.Rounds[r][m]
 			if srcM.Status == state.MatchStatusCompleted {
-				nextM.SideA = srcM.Winner
-				nextM.SideAID = srcM.WinnerID
+				seatBracketSide(nextM, domain.MatchSideA, srcM.Winner, srcM.WinnerID)
 			}
 		}
 	}
@@ -3286,8 +3324,7 @@ func (e *Engine) propagateBracketWinner(bracket *state.Bracket, rIdx, mIdx int)
 		if r >= 0 && r < len(bracket.Rounds) && m >= 0 && m < len(bracket.Rounds[r]) {
 			srcM := bracket.Rounds[r][m]
 			if srcM.Status == state.MatchStatusCompleted {
-				nextM.SideB = srcM.Winner
-				nextM.SideBID = srcM.WinnerID
+				seatBracketSide(nextM, domain.MatchSideB, srcM.Winner, srcM.WinnerID)
 			}
 		}
 	}
@@ -3421,6 +3458,9 @@ func guardOverrideDownstreamKnockoutCorrection(bracket *state.Bracket, rIdx, mId
 func (e *Engine) OverrideBracketWinner(compId string, matchId string, winnerName string, modifiedAt int64, opts ...ForceOptions) (bool, error) {
 	fo := firstForceOptions(opts)
 	var reopened []ReopenedMatch
+	// The picks the override's propagation takes from matches it re-seats
+	// without reopening, for their own history lines (bracket_seat_audit.go).
+	var clears []repPickClear
 	// The write and its history entry are one transaction (bc-mrgc): a held
 	// (errLWWDropped) assertion makes no write at all, so it is recorded
 	// outside the transaction below, but an APPLIED override must not land
@@ -3457,12 +3497,13 @@ func (e *Engine) OverrideBracketWinner(compId string, matchId string, winnerName
 						// that names the winner already recorded must not requeue
 						// the next round.
 						priorWinner, priorWinnerID := propagatedWinnerOf(bracket, rIdx, mIdx, m)
+						before := repPickSnapshot(bracket, matchId)
 						setBracketOverrideWinner(m, winnerName)
 						m.IsOverridden = true
 						m.Status = state.MatchStatusCompleted
 						// An override ends the match, so a reopened match closed out
 						// this way must not keep ReopenPending set: it bypasses
-						// applyCorrectionReasonUnderTx/dischargeReopenPendingUnderTx,
+						// applyCorrectionReason/dischargeReopenPendingUnderTx,
 						// which clear it on every other way of ending a match.
 						m.ReopenPending = false
 						m.StampGroups(modifiedAt, state.GroupResult)
@@ -3474,12 +3515,15 @@ func (e *Engine) OverrideBracketWinner(compId string, matchId string, winnerName
 						if fo.Force && winnerActuallyChanged(priorWinner, priorWinnerID, m) {
 							reopened = forceReopenDownstreamChain(bracket, rIdx, mIdx, m.ID)
 						}
+						clears = repPickClears(before, bracket)
+						markRepPicksCleared(reopened, clears)
 						return nil
 					}
 				}
 			}
 			// The bronze (3rd-place) knockout lives outside Rounds; handle it
-			// here. Bronze has no downstream match, so no propagation is needed.
+			// here. Bronze has no downstream match, so no propagation is needed
+			// and no other match can lose a pick to this write: no snapshot.
 			if bracket.ThirdPlaceMatch != nil && bracket.ThirdPlaceMatch.ID == matchId {
 				bm := bracket.ThirdPlaceMatch
 				if !bracketMatchPlayable(bm) {
@@ -3517,6 +3561,10 @@ func (e *Engine) OverrideBracketWinner(compId string, matchId string, winnerName
 		// would see a reopened match with no history line, or a bar the
 		// restore had not yet lifted/could wrongly lift).
 		e.restoreForceReopened(tx, compId, reopened)
+		// And a line for each downstream match the propagation re-seated
+		// without reopening, in the same transaction and beside the reopen
+		// lines (a reopened match's own line names its pick instead).
+		e.recordRepPickClears(tx, compId, clears, reopened)
 		return nil
 	})
 	if held {
diff --git a/internal/engine/scoring_test.go b/internal/engine/scoring_test.go
index 9fea23350..0842abdc1 100644
--- a/internal/engine/scoring_test.go
+++ b/internal/engine/scoring_test.go
@@ -1678,6 +1678,80 @@ func TestRecordBracketMatchResult_DaihyosenWinnerDerived(t *testing.T) {
 	assert.Equal(t, "TeamB", saved.Rounds[1][0].SideA, "TeamB must propagate to next round")
 }
 
+// bc-dhrp: the representative bout names each side's member (the picker's pick)
+// beside the TEAM names it keeps. The member ids change nothing about the
+// encounter: the team that wins the bout still advances, and a hantei mark
+// on the winner's side is kept in the row as recorded.
+func TestRecordBracketMatchResult_DaihyosenWithRepresentativeIDs(t *testing.T) {
+	twoRounds := func() *state.Bracket {
+		return &state.Bracket{
+			Rounds: [][]state.BracketMatch{
+				{{ID: "r0m0", SideA: "TeamA", SideB: "TeamB", Status: state.MatchStatusScheduled}},
+				{{ID: "r1m0", SideA: "", SideB: "TeamC", Status: state.MatchStatusScheduled}},
+			},
+		}
+	}
+	repRow := func(ipponsA, ipponsB []string) state.SubMatchResult {
+		return state.SubMatchResult{
+			Position: -1, SideA: "TeamA", SideB: "TeamB",
+			IpponsA: ipponsA, IpponsB: ipponsB,
+			SideAMemberID: "rep-a", SideBMemberID: "rep-b", WinnerMemberID: "rep-b",
+			Decision: "daihyosen",
+		}
+	}
+
+	t.Run("a point decides the team the representative won for", func(t *testing.T) {
+		eng, store, _ := setupTestEngine(t)
+		compID := "dh-rep-ids-point"
+		require.NoError(t, store.SaveCompetition(&state.Competition{
+			ID: compID, Name: "DH Rep IDs", Format: state.CompFormatKnockout,
+			Status: state.CompStatusKnockout, TeamSize: 3,
+		}))
+		require.NoError(t, store.SaveBracket(compID, twoRounds()))
+
+		row := repRow(nil, []string{"M"})
+		row.Winner = "TeamB"
+		_, err := eng.RecordMatchResultWithIneligibility(compID, "r0m0", &state.MatchResult{
+			ID: "r0m0", SideA: "TeamA", SideB: "TeamB", Status: state.MatchStatusCompleted,
+			SubResults: []state.SubMatchResult{row},
+		})
+		require.NoError(t, err)
+
+		saved, err := store.LoadBracket(compID)
+		require.NoError(t, err)
+		assert.Equal(t, "TeamB", saved.Rounds[0][0].Winner)
+		assert.Equal(t, "TeamB", saved.Rounds[1][0].SideA, "the winning team advances")
+		assert.Equal(t, "rep-b", saved.Rounds[0][0].SubResults[0].SideBMemberID, "the pick is kept on the row")
+	})
+
+	t.Run("a hantei mark on the winner's side is kept in the row", func(t *testing.T) {
+		eng, store, _ := setupTestEngine(t)
+		compID := "dh-rep-ids-hantei"
+		require.NoError(t, store.SaveCompetition(&state.Competition{
+			ID: compID, Name: "DH Rep IDs", Format: state.CompFormatKnockout,
+			Status: state.CompStatusKnockout, TeamSize: 3,
+		}))
+		require.NoError(t, store.SaveBracket(compID, twoRounds()))
+
+		// A tied scoreline (1-1) decided by the judges' mark on side B.
+		row := repRow([]string{"M"}, []string{"K", "Ht"})
+		row.Winner = "TeamB"
+		_, err := eng.RecordMatchResultWithIneligibility(compID, "r0m0", &state.MatchResult{
+			ID: "r0m0", SideA: "TeamA", SideB: "TeamB", Status: state.MatchStatusCompleted,
+			SubResults: []state.SubMatchResult{row},
+		})
+		require.NoError(t, err)
+
+		saved, err := store.LoadBracket(compID)
+		require.NoError(t, err)
+		assert.Equal(t, "TeamB", saved.Rounds[0][0].Winner)
+		assert.Equal(t, "TeamB", saved.Rounds[1][0].SideA)
+		got := saved.Rounds[0][0].SubResults[0]
+		assert.Equal(t, []string{"K", "Ht"}, got.IpponsB, "the mark stays where the judges put it")
+		assert.True(t, got.HanteiDecided())
+	})
+}
+
 // TestPreviewBracket_RejectsAllMutations verifies that all bracket mutation
 // paths (scoring, override, court/time reassignment) return an error when
 // bracket.Preview is true (mp-9dz). The UI disables scoring for preview
diff --git a/internal/engine/scoring_tx.go b/internal/engine/scoring_tx.go
index d29ddc1f8..9695a7828 100644
--- a/internal/engine/scoring_tx.go
+++ b/internal/engine/scoring_tx.go
@@ -72,17 +72,24 @@ import (
 // T156.
 //
 // opts (bc-kcdg) is variadic ForceOptions purely to keep every pre-existing
-// call site source-compatible; see ForceOptions' doc comment. Known gap: a
-// forced write that force-reopens downstream matches and is THEN rolled back
-// by the K3 AlreadyIneligibleError path below only restores the corrected
-// match itself (rollbackMatchResultTx replays `prior` through this same
-// match id) -- the downstream matches forceReopenDownstreamChain reopened
-// stay reopened. The same holds for the knockout matches a forced POOL
-// correction reopens (requalifyAfterPoolWrite): the rollback restores the
-// pool match, not the bracket. Reaching either requires force=true on a
-// decision write whose loser turns out to already be ineligible from a
-// different match, a narrow intersection not covered by this bead's test
-// list; recorded here rather than silently left undiscoverable.
+// call site source-compatible; see ForceOptions' doc comment.
+//
+// K3 runs in two halves. The pre-write half (refuseConcurrentWithdrawal)
+// resolves the loser from the stored pairing exactly as the post-write half
+// (recordIneligibilityFromDecision) does, so a withdrawal the post-write check
+// would refuse is refused BEFORE anything is written: no downstream match is
+// reopened or re-seated and no history line is recorded. The post-write arm and
+// its rollback stay as a backstop, reached only if the two halves ever
+// disagree (a merge that works the winner out again differently from the
+// payload). That rollback (rollbackMatchResultTx replays `prior` through this
+// same match id) restores the corrected match ONLY: the downstream matches
+// forceReopenDownstreamChain reopened or propagateBracketWinner re-seated stay
+// as written, and so do the knockout matches a forced POOL correction reopens
+// (requalifyAfterPoolWrite; the rollback restores the pool match, not the
+// bracket). A whole-bracket restore is deliberately not attempted: the
+// eligibility restores those reopens made (restoreForceReopened) are
+// competitor-status writes made before K3, and a bracket-only restore would put
+// a downstream match back to a verdict whose competitor stays restored.
 func (e *Engine) RecordMatchResultWithIneligibilityTx(tx state.StoreTx, compID, matchID string, result *state.MatchResult, opts ...ForceOptions) (*domain.CompetitorStatus, error) {
 	fo := firstForceOptions(opts)
 	result.ID = matchID
@@ -430,16 +437,32 @@ func keepQueuedScore(prior, result *state.MatchResult) {
 // AlreadyIneligibleError when a different match has already made them
 // ineligible and the decision is a kiken (checkConcurrentIneligibility, the
 // check recordDecisionTx makes before its own write; a fusenpai there chains
-// onto the existing bar instead, alreadyBarredRefusal). The loser is read off a scratch copy with the stored
-// identity folded in by backfillMatchIdentity, the same fold the write
-// applies, so it is the loser the post-write check would name. A payload that
-// fold rejects, or whose losing side cannot be attributed, is left to the
-// write and the post-write check, which answer it as before.
+// onto the existing bar instead, alreadyBarredRefusal). The loser is read off a
+// scratch copy with the stored pairing folded in the way the write folds it, so
+// it is the loser the post-write check would name: the sides' NAMES first (what
+// reconcileSides gives an empty payload name inside the write), then the ids
+// (backfillMatchIdentity). Both matter. A hand-built /score or bulk payload
+// that names a winner but no sides, no winnerSide and no winnerId carries the
+// loser only as "the side the winner is not", which resolveWinnerIDFromSides can
+// read only against side names; a probe with the names still empty found no
+// loser here, so the write went on, re-seated the next round's side (its
+// representative pick cleared, its stamp moved), and the post-write check then
+// refused it with a rollback that restores the written match row alone (the
+// SPA's /decision sets winnerSide and its /score sends the sides, so only a
+// payload built by hand reaches this). A payload that fold rejects, or whose
+// losing side cannot be attributed, is left to the write and the post-write
+// check, which answer it as before.
 func (e *Engine) refuseConcurrentWithdrawal(tx state.StoreTx, compID, matchID string, result, prior *state.MatchResult) error {
 	if prior == nil || !domain.IsWithdrawalDecisionStr(result.Decision) {
 		return nil
 	}
 	probe := *result
+	if probe.SideA == "" {
+		probe.SideA = prior.SideA
+	}
+	if probe.SideB == "" {
+		probe.SideB = prior.SideB
+	}
 	if err := backfillMatchIdentity(&probe, prior, matchWriteForward); err != nil {
 		return nil
 	}
diff --git a/internal/engine/sub_hantei_preserve_test.go b/internal/engine/sub_hantei_preserve_test.go
index 56d319413..31e691a63 100644
--- a/internal/engine/sub_hantei_preserve_test.go
+++ b/internal/engine/sub_hantei_preserve_test.go
@@ -951,3 +951,45 @@ func TestPreserveSubHantei_ZeroZeroWithdrawalIsNotSilence(t *testing.T) {
 		assert.Equal(t, []string{"K"}, incoming[0].IpponsB)
 	})
 }
+
+// The winner's member id is derived again from the restored winner. The
+// restored hantei winner is the stored one, so an incoming winner id must not
+// outlive it: an empty one would lose the id, and a stale one naming the
+// other side's pick would credit the wrong side, id-first, were it not derived
+// again from the winner's name by ReconcileWinnerMemberID.
+func TestPreserveSubHanteiRestoresTheWinnersMemberIDWithTheWinner(t *testing.T) {
+	dh := state.DaihyosenSubPosition
+	stored := func() []state.SubMatchResult {
+		return []state.SubMatchResult{{
+			Position: dh, SideA: "Kyoto", SideB: "Osaka",
+			SideAMemberID: "member-a", SideBMemberID: "member-b",
+			IpponsA: []string{domain.HanteiMark}, IpponsB: []string{},
+			Winner: "Kyoto", WinnerMemberID: "member-a", Decision: "daihyosen",
+		}}
+	}
+	for name, incomingWinnerID := range map[string]string{
+		"an empty incoming id restores the stored one":                          "",
+		"a stale id naming the other side's pick is replaced by the stored one": "member-b",
+	} {
+		t.Run(name, func(t *testing.T) {
+			incoming := []state.SubMatchResult{{
+				Position: dh, SideA: "Kyoto", SideB: "Osaka",
+				SideAMemberID: "member-a", SideBMemberID: "member-b",
+				WinnerMemberID: incomingWinnerID, Decision: "daihyosen",
+			}}
+			preserveSubHantei(stored(), incoming)
+			require.True(t, incoming[0].HanteiDecided())
+			assert.Equal(t, "Kyoto", incoming[0].Winner)
+			assert.Equal(t, "member-a", incoming[0].WinnerMemberID)
+		})
+	}
+
+	t.Run("a stored id naming a pick the merge replaced is derived again", func(t *testing.T) {
+		incoming := []state.SubMatchResult{{
+			Position: dh, SideA: "Kyoto", SideB: "Osaka",
+			SideAMemberID: "member-a2", SideBMemberID: "member-b", Decision: "daihyosen",
+		}}
+		preserveSubHantei(stored(), incoming)
+		assert.Equal(t, "member-a2", incoming[0].WinnerMemberID, "the winner id names a standing pick")
+	})
+}
diff --git a/internal/engine/workbook.go b/internal/engine/workbook.go
index f6765bb24..114563178 100644
--- a/internal/engine/workbook.go
+++ b/internal/engine/workbook.go
@@ -41,7 +41,8 @@ import (
 //  6. Names to Print sheet, one per shiaijo (helper.CreateNamesWithPoolToPrint,
 //     or helper.CreateNamesToPrint over namesToPrintPlayers -- same branch as
 //     step 1)
-//  7. Kachinuki Detail sheet (helper.WriteKachinukiDetailSheet)
+//  7. Kachinuki Detail sheet (helper.WriteKachinukiDetailSheet) and
+//     Representative Bouts sheet (helper.WriteRepresentativeBoutsSheet)
 //
 // Every caller-specific extra rides OUTSIDE this function, called by the
 // caller before or after: the stored-draw export's Tags sheet (needs the
@@ -51,8 +52,8 @@ import (
 // Elimination Matches sheets, and it is safe for them to run AFTER this
 // function returns rather than interleaved where they used to sit: nothing
 // this function does past PrintPoolMatches (step 3) and
-// PrintEliminationWithBronze (step 4) touches either sheet again. Steps 5-7 write to the Tree, Names to Print and
-// Kachinuki Detail sheets, none of which any overlay reads or writes.
+// PrintEliminationWithBronze (step 4) touches either sheet again. Steps 5-7 write to the Tree, Names to Print,
+// Kachinuki Detail and Representative Bouts sheets, none of which any overlay reads or writes.
 //
 // Parameters are explicit values, not a *state.Store: every strict/best-
 // effort load already happened in the caller (mp-yuy8 criterion 6) and must
@@ -73,6 +74,12 @@ import (
 //     prints a knockout-only competition's skeleton, there is no stored
 //     bracket for that read to list, and the sections come from the rounds
 //     step 4 printed instead (helper.BlankKachinukiSections).
+//   - representativeBouts is the caller's own read of the representative bouts
+//     (collectRepresentativeBouts; RepresentativeBoutMatches takes only the
+//     id), for the same reason: step 7 writes them, whichever way they were
+//     read. It is empty for every competition but a fixed-order team one whose
+//     matches hold such a bout, and the blank template /create draws has no
+//     stored match to hold one, so its sheets are unchanged.
 //
 // courts is the caller's own CompetitionCourts(comp, tourn) result rather
 // than a tournament parameter this function would resolve itself, because
@@ -92,8 +99,8 @@ import (
 // pools) -- bc-pnum A8's single guarded branch for a knockout-only
 // competition (never has a pools.csv, so nothing above would otherwise
 // populate the Data / Names-to-Print sheets at all): non-nil only for that
-// one shape, nil for every other competition. Unlike draw and
-// kachinukiMatches (see above), both callers derived this identically from
+// one shape, nil for every other competition. Unlike draw,
+// kachinukiMatches and representativeBouts (see above), both callers derived this identically from
 // arguments this function already takes (comp, pools), so there was nothing
 // caller-specific left to preserve by keeping it a parameter -- deriving it
 // here instead is what makes it impossible for the two callers' Data /
@@ -121,6 +128,7 @@ func (e *Engine) RenderCompetitionWorkbook(
 	courtOfPool map[string]string,
 	draw *helper.KnockoutDraw,
 	kachinukiMatches []helper.KachinukiMatchDetail,
+	representativeBouts []helper.KachinukiMatchDetail,
 ) ([][]int, []helper.Player, error) {
 	namesToPrintPlayers, err := e.KnockoutNamesToPrint(comp, pools, bracket)
 	if err != nil {
@@ -284,14 +292,19 @@ func (e *Engine) RenderCompetitionWorkbook(
 		helper.CreateNamesWithPoolToPrint(f, pools, comp.EffectiveWithZekkenName(), courts, courtOfPool, playerCoords, comp.EffectiveNumberPrefix())
 	}
 
-	// 7. Kachinuki Detail sheet (T195-T203, CHK037). Opt-in: only emitted
-	//    when the competition runs the kachinuki team-match format and its
-	//    draw has matches, or before the draw the skeleton step 4 printed.
-	//    The renderer is a no-op for empty input, so this is safe for every
-	//    other team format.
+	// 7. Kachinuki Detail sheet (T195-T203, CHK037) and Representative Bouts
+	//    sheet. Opt-in: the first is only emitted when the competition runs
+	//    the kachinuki team-match format and its draw has matches, or before
+	//    the draw the skeleton step 4 printed; the second only when a
+	//    fixed-order team competition's draw holds a representative bout.
+	//    Each renderer is a no-op for empty input, so this is safe for every
+	//    other competition.
 	if err := helper.WriteKachinukiDetailSheet(f, kachinukiMatches); err != nil {
 		return nil, nil, err
 	}
+	if err := helper.WriteRepresentativeBoutsSheet(f, representativeBouts); err != nil {
+		return nil, nil, err
+	}
 
 	// namesToPrintPlayers is returned as a second value so callers that also
 	// need it for their own extras (ExportCompetitionXlsx's Tags sheet)
diff --git a/internal/export/builder.go b/internal/export/builder.go
index 4b177ca2b..66f717ab8 100644
--- a/internal/export/builder.go
+++ b/internal/export/builder.go
@@ -135,6 +135,14 @@ func BuildResultsWorkbook(store *state.Store, eng *engine.Engine, compID string)
 		return nil, fmt.Errorf("export: collect kachinuki detail: %w", err)
 	}
 
+	// Representative Bouts sheet's bouts: the same opt-in as the stored-draw
+	// export's, a fixed-order team competition's representative bouts, which
+	// no other sheet of this workbook lists.
+	representativeBouts, err := eng.RepresentativeBoutMatches(compID)
+	if err != nil {
+		return nil, fmt.Errorf("export: collect representative bouts: %w", err)
+	}
+
 	f, err := excel.NewFileFromScratch()
 	if err != nil {
 		return nil, fmt.Errorf("export: create workbook: %w", err)
@@ -144,7 +152,8 @@ func BuildResultsWorkbook(store *state.Store, eng *engine.Engine, compID string)
 	}()
 
 	// The shared sheet pipeline (mp-yuy8): Data, Pool Draw, Pool Matches,
-	// knockout, Tree cleanup, Names to Print, Kachinuki Detail -- identical
+	// knockout, Tree cleanup, Names to Print, Kachinuki Detail, Representative
+	// Bouts -- identical
 	// steps and order to Engine.ExportCompetitionXlsx. poolsByCourt is the one
 	// artifact the overlays below need (PrintPoolMatches's pool-index grouping
 	// per shiaijo band); everything else PrintPoolMatches/AddPoolDataToSheet
@@ -161,7 +170,7 @@ func BuildResultsWorkbook(store *state.Store, eng *engine.Engine, compID string)
 	// The second return value (the knockout-only numbered roster) is the
 	// stored-draw export's own extra (its Tags sheet); this results
 	// export has no such extra and discards it.
-	poolsByCourt, _, err := eng.RenderCompetitionWorkbook(f, comp, pools, bracket, courts, courtOfPool, draw, kachinukiMatches)
+	poolsByCourt, _, err := eng.RenderCompetitionWorkbook(f, comp, pools, bracket, courts, courtOfPool, draw, kachinukiMatches, representativeBouts)
 	if err != nil {
 		return nil, fmt.Errorf("export: %w", err)
 	}
diff --git a/internal/export/builder_test.go b/internal/export/builder_test.go
index 89d52e2e7..cdd61e637 100644
--- a/internal/export/builder_test.go
+++ b/internal/export/builder_test.go
@@ -3969,6 +3969,119 @@ func TestBuildResultsWorkbook_FixedFormatNoKachinukiSheet(t *testing.T) {
 		"fixed-format comps must not emit a Kachinuki Detail sheet")
 }
 
+// saveFixedTeamBracket turns compID (as testSetup saved it) into a fixed-order
+// team knockout of two teams, Red and White, with one named member each, and
+// stores a completed bracket of their one match: a tied numbered bout, and,
+// when withRepresentativeBout, the representative bout (Red's Hiro against
+// White's Sayaka) that a hantei decided for Red. The competition's Status is
+// the knockout one because the competitor numbers (the "T1.1" labels) come
+// from the draw only once it is.
+func saveFixedTeamBracket(t *testing.T, store *state.Store, compID string, withRepresentativeBout bool) {
+	t.Helper()
+	comp, err := store.LoadCompetition(compID)
+	require.NoError(t, err)
+	comp.Format = state.CompFormatKnockout
+	comp.Status = state.CompStatusKnockout
+	comp.Kind = "team"
+	comp.TeamMatchType = state.TeamMatchTypeFixed
+	comp.TeamSize = 3
+	comp.NumberPrefix = "T"
+	require.NoError(t, store.SaveCompetition(comp))
+
+	redID, whiteID := helper.NewUUID4(), helper.NewUUID4()
+	require.NoError(t, store.SaveParticipants(compID, []domain.Player{
+		{ID: redID, Name: "RedTeam", Dojo: "DojoR"},
+		{ID: whiteID, Name: "WhiteTeam", Dojo: "DojoW"},
+	}))
+	hiro, err := store.AddTeamMember(compID, redID, "Hiro")
+	require.NoError(t, err)
+	sayaka, err := store.AddTeamMember(compID, whiteID, "Sayaka")
+	require.NoError(t, err)
+
+	subs := []state.SubMatchResult{
+		{Position: 1, SideA: "Hiro", SideAMemberID: hiro.ID, SideB: "Sayaka", SideBMemberID: sayaka.ID, Decision: "hikiwake"},
+	}
+	if withRepresentativeBout {
+		subs = append(subs, state.SubMatchResult{
+			Position: state.DaihyosenSubPosition, SideA: "RedTeam", SideB: "WhiteTeam",
+			SideAMemberID: hiro.ID, SideBMemberID: sayaka.ID, Winner: "RedTeam",
+			Decision: string(domain.DecisionDaihyosen), IpponsA: []string{domain.HanteiMark},
+		})
+	}
+	require.NoError(t, store.SavePools(compID, []helper.Pool{}))
+	require.NoError(t, store.SavePoolMatches(compID, nil))
+	require.NoError(t, store.SaveBracket(compID, &state.Bracket{
+		DrawOrder: []string{redID, whiteID},
+		Rounds: [][]state.BracketMatch{{{
+			ID: "R1M0", MatchNumber: 1, DisplayRound: 1,
+			SideA: "RedTeam", SideAID: redID, SideB: "WhiteTeam", SideBID: whiteID,
+			Winner: "RedTeam", Status: state.MatchStatusCompleted, SubResults: subs,
+		}}},
+	}))
+}
+
+// TestBuildResultsWorkbook_RepresentativeBoutsSheetIffARepresentativeBoutExists
+// pins the results workbook's Representative Bouts sheet (the main sheets'
+// team block lists numbered bouts only, so a representative bout and its
+// representatives reached no sheet): present, editable, naming both
+// representatives, DH as the bout number and (DH) in the centre, exactly when a
+// match of the fixed-order team competition holds a position -1 row, and never
+// beside a Kachinuki Detail sheet.
+func TestBuildResultsWorkbook_RepresentativeBoutsSheetIffARepresentativeBoutExists(t *testing.T) {
+	t.Parallel()
+
+	build := func(t *testing.T, withRepresentativeBout bool) *excelize.File {
+		t.Helper()
+		dir, store, eng, compID := testSetup(t)
+		t.Cleanup(func() { _ = os.RemoveAll(dir) })
+
+		saveFixedTeamBracket(t, store, compID, withRepresentativeBout)
+
+		data, err := BuildResultsWorkbook(store, eng, compID)
+		require.NoError(t, err)
+		f, err := excelize.OpenReader(bytes.NewReader(data))
+		require.NoError(t, err)
+		t.Cleanup(func() { _ = f.Close() })
+		return f
+	}
+
+	t.Run("with a representative bout", func(t *testing.T) {
+		t.Parallel()
+		f := build(t, true)
+
+		require.Contains(t, f.GetSheetList(), helper.SheetRepresentativeBouts)
+		assert.NotContains(t, f.GetSheetList(), helper.SheetKachinukiDetail,
+			"a fixed-order competition never gets a Kachinuki Detail sheet")
+		protection, err := f.GetSheetProtection(helper.SheetRepresentativeBouts)
+		require.NoError(t, err)
+		assert.Equal(t, excelize.SheetProtectionOptions{}, protection, "the sheet holds no formula to protect")
+
+		rows, err := f.GetRows(helper.SheetRepresentativeBouts)
+		require.NoError(t, err)
+		var cells []string
+		for _, row := range rows {
+			cells = append(cells, row...)
+		}
+		flat := strings.Join(cells, "|")
+		assert.Contains(t, flat, "(Representative bout)", "the section is titled")
+		assert.Contains(t, flat, "Hiro", "Aka's representative")
+		assert.Contains(t, flat, "Sayaka", "Shiro's representative")
+		assert.Contains(t, flat, helper.RepresentativeBoutRowLabel+" T1.1 Hiro", "DH is the bout's number, then the representative")
+		assert.Contains(t, cells, "(DH)", "the centre carries the representative-bout mark")
+		assert.Contains(t, cells, "Ht", "the hantei mark rides beside the winner")
+		assert.NotContains(t, flat, "-1", "the stored position is never printed")
+	})
+
+	t.Run("without one", func(t *testing.T) {
+		t.Parallel()
+		f := build(t, false)
+
+		assert.NotContains(t, f.GetSheetList(), helper.SheetRepresentativeBouts,
+			"no representative bout, no sheet: the main sheets' workbook is unchanged")
+		assert.NotContains(t, f.GetSheetList(), helper.SheetKachinukiDetail)
+	})
+}
+
 // readCourtBandLetters reads a court-banded sheet's shiaijo band headers back
 // out of the rendered workbook, in column order, and asserts each band sits on
 // the court grid and is non-empty. bctest.ReadCourtBands does the reading (the
diff --git a/internal/export/pipeline_parity_test.go b/internal/export/pipeline_parity_test.go
index c1e7f9cbb..f1874d458 100644
--- a/internal/export/pipeline_parity_test.go
+++ b/internal/export/pipeline_parity_test.go
@@ -33,7 +33,7 @@ var engineOnlySheets = []string{helper.SheetTags}
 
 // TestExportPipelineSheetParity guards the two workbook builders that both
 // walk the "data / Pool Draw / Pool Matches / Elimination Matches / Tree N /
-// Names to Print X / Kachinuki Detail / ..." sheet pipeline for one
+// Names to Print X / Kachinuki Detail / Representative Bouts / ..." sheet pipeline for one
 // competition: Engine.ExportCompetitionXlsx (internal/engine/export.go, the
 // stored-draw export) and BuildResultsWorkbook (internal/export/builder.go,
 // the results export). Before mp-yuy8 the two functions were hand-maintained
@@ -163,6 +163,22 @@ func TestExportPipelineSheetParity(t *testing.T) {
 			},
 			mustAppearInBoth: []string{helper.SheetKachinukiDetail},
 		},
+		{
+			// The Representative Bouts sheet's twin of the case above: a
+			// fixed-order team knockout whose match was settled by a
+			// representative bout. Engine.collectRepresentativeBouts (the
+			// stored-draw export) and Engine.RepresentativeBoutMatches (the
+			// results export) are two reads feeding one renderer, and a
+			// sheet one of them forgot is the R8 bug again. The fixture is
+			// builder_test.go's saveFixedTeamBracket, a hand-crafted bracket
+			// on the same Knockout-with-no-pools footing as the case above.
+			name: "fixed_team_bracket_representative_bout",
+			configure: func(t *testing.T, store *state.Store, eng *engine.Engine, compID string) {
+				t.Helper()
+				saveFixedTeamBracket(t, store, compID, true)
+			},
+			mustAppearInBoth: []string{helper.SheetRepresentativeBouts},
+		},
 		{
 			// A pure knockout competition (no pools) drives a different
 			// leaf-order path (isPureKnockout / knockoutLeaves /
diff --git a/internal/helper/constants.go b/internal/helper/constants.go
index 60312929f..2c14f9135 100644
--- a/internal/helper/constants.go
+++ b/internal/helper/constants.go
@@ -172,6 +172,10 @@ const EliminationMatchTitleFormat = "Round %d - Match %d"
 // SheetKachinukiDetail is opt-in: only emitted when a competition has
 // teamMatchType=kachinuki and a draw with matches in it. See
 // excel_kachinuki.go (T199–T203).
+//
+// SheetRepresentativeBouts is opt-in too: only emitted when a fixed-order team
+// competition's results hold at least one representative bout. It is drawn by
+// the same renderer as the Kachinuki Detail sheet.
 const (
 	SheetData               = "data"
 	SheetTimeEstimator      = "Time Estimator"
@@ -182,4 +186,12 @@ const (
 	SheetTags               = "Tags"
 	SheetTree               = "Tree"
 	SheetKachinukiDetail    = "Kachinuki Detail"
+
+	SheetRepresentativeBouts = "Representative Bouts"
 )
+
+// RepresentativeBoutRowLabel is what a representative bout's row prints where a
+// numbered bout prints its number: the bout is the extra one appended to a
+// tied knockout encounter (position -1), not one of the numbered bouts, so a
+// number would name a bout the team match does not have.
+const RepresentativeBoutRowLabel = "DH"
diff --git a/internal/helper/excel.go b/internal/helper/excel.go
index fd3700d6a..64717b99a 100644
--- a/internal/helper/excel.go
+++ b/internal/helper/excel.go
@@ -2176,9 +2176,10 @@ func ProtectSheets(f *excelize.File, sheetNames []string) {
 func ProtectAllSheets(f *excelize.File) {
 	for _, name := range f.GetSheetList() {
 		// Data, Time Estimator, and Pool Draw remain fully editable, and so
-		// does Kachinuki Detail: it holds no formula to protect, and its
-		// empty bout rows are there to be filled in.
-		if name == SheetData || name == SheetTimeEstimator || name == SheetPoolDraw || name == SheetKachinukiDetail {
+		// do Kachinuki Detail and Representative Bouts: they hold no formula
+		// to protect, and the empty bout rows of the first are there to be
+		// filled in.
+		if name == SheetData || name == SheetTimeEstimator || name == SheetPoolDraw || name == SheetKachinukiDetail || name == SheetRepresentativeBouts {
 			continue
 		}
 		ProtectSheets(f, []string{name})
diff --git a/internal/helper/excel_kachinuki.go b/internal/helper/excel_kachinuki.go
index 48f50af95..9a91fb94e 100644
--- a/internal/helper/excel_kachinuki.go
+++ b/internal/helper/excel_kachinuki.go
@@ -1,7 +1,13 @@
 package helper
 
 // excel_kachinuki.go renders the "Kachinuki Detail" sheet, one section per
-// kachinuki ("winner-stays-on") team match with full bout-by-bout detail.
+// kachinuki ("winner-stays-on") team match with full bout-by-bout detail, and,
+// with the same renderer, the "Representative Bouts" sheet of a fixed-order team
+// competition: one section per match that holds a representative bout, listing
+// that bout alone (its row prints RepresentativeBoutRowLabel where a numbered
+// bout prints its number, and its fighters are the representatives each team
+// picked). Everything below describes the Kachinuki Detail sheet; the other
+// differs only in its sheet name, its section suffix and that label.
 //
 // Each section is drawn like a team match block on the Elimination Matches
 // sheet (operator decision 2026-10-02): the same seven columns and widths, the
@@ -28,7 +34,8 @@ package helper
 // domain.SideMarksAB) go in the side's outer score cell, the cell the results
 // overlay fills on the match sheets, and the centre carries the bout's one
 // closed-set middle mark (domain.MiddleMark: X or (E); kachinuki has no
-// daihyosen, so (DH) never appears here) or stays empty, as there. The
+// daihyosen, so (DH) appears only on the Representative Bouts sheet) or stays
+// empty, as there. The
 // match's own Pool or Elimination Matches row carries the result, so a
 // section has no Winner or Decision column (operator decision 2026-09-27)
 // and no tally: it ends at its last bout row (operator decision 2026-10-02).
@@ -52,7 +59,9 @@ import (
 // WhiteLeft takes the pair in side order and places it in sheet columns, so
 // nothing upstream of the sheet writer needs to know about column layout.
 type KachinukiBout struct {
-	Position  int    // 1-based bout index within the team match
+	// Position is the 1-based bout index within the team match, or -1 for a
+	// representative bout, which prints RepresentativeBoutRowLabel instead.
+	Position  int
 	SideAName string // player name for Side A
 	// SideALabel is the squad member's "T10.1"-style label (bc-pnum: "make
 	// a team member's label available to the public surfaces"), composed
@@ -73,8 +82,9 @@ type KachinukiBout struct {
 	ScoreB     string
 	// Middle is the ONE mark the bout's centre cell may carry
 	// (domain.MiddleMark): "" (the cell stays empty), "X"
-	// (hikiwake), or "(E)" (overtime). Kachinuki has no daihyosen, so
-	// "(DH)" never appears here.
+	// (hikiwake), "(E)" (overtime) or, on a representative bout's row only,
+	// "(DH)". Kachinuki has no daihyosen, so "(DH)" never appears on the
+	// Kachinuki Detail sheet.
 	Middle string
 	// MarkA/MarkB are the per-side RESULT marks (domain.SideMarksAB) in
 	// SIDE order: Ht (hantei), Kiken (withdrawer) or Fus. (no-show / a
@@ -187,6 +197,22 @@ const kachinukiFighterColWidth = 38
 // created, the caller is responsible for checking the input length AND
 // the renderer guards against accidental emission of an empty sheet.
 func WriteKachinukiDetailSheet(f *excelize.File, matches []KachinukiMatchDetail) error {
+	return writeBoutDetailSheet(f, SheetKachinukiDetail, "Kachinuki", matches)
+}
+
+// WriteRepresentativeBoutsSheet creates the SheetRepresentativeBouts sheet and
+// writes one section per match, each listing that match's representative bout
+// (the extra bout that settles a tied knockout encounter of a fixed-order team
+// competition; the caller builds each section's Bouts from it alone). It is the
+// Kachinuki Detail sheet's renderer under another name and section suffix, so
+// the two read alike, and like it creates no sheet for empty input.
+func WriteRepresentativeBoutsSheet(f *excelize.File, matches []KachinukiMatchDetail) error {
+	return writeBoutDetailSheet(f, SheetRepresentativeBouts, "Representative bout", matches)
+}
+
+// writeBoutDetailSheet is the one renderer of a bout-detail sheet: sheet names
+// it and titleSuffix closes each section's title, "<label> (<titleSuffix>)".
+func writeBoutDetailSheet(f *excelize.File, sheet, titleSuffix string, matches []KachinukiMatchDetail) error {
 	// Skip when no match has a row to print (no bouts and no blank rows):
 	// the detail sheet is purely additive, never create an empty sheet
 	// (T201 acceptance).
@@ -201,7 +227,6 @@ func WriteKachinukiDetailSheet(f *excelize.File, matches []KachinukiMatchDetail)
 		return nil
 	}
 
-	sheet := SheetKachinukiDetail
 	// Create the sheet if it doesn't already exist. (Engine export creates
 	// the workbook via NewFileFromScratch which does NOT include the
 	// detail sheet, it's opt-in.)
@@ -236,7 +261,7 @@ func WriteKachinukiDetailSheet(f *excelize.File, matches []KachinukiMatchDetail)
 			handleExcelError("InsertPageBreak", f.InsertPageBreak(sheet, "A"+strconv.Itoa(row)))
 			rowsOnPage = 0
 		}
-		nextRow := writeKachinukiMatchSection(f, sheet, styles, match, row)
+		nextRow := writeKachinukiMatchSection(f, sheet, titleSuffix, styles, match, row)
 		// Separator blank row between sections (except after the last).
 		if i < len(matches)-1 {
 			nextRow++
@@ -257,14 +282,14 @@ func WriteKachinukiDetailSheet(f *excelize.File, matches []KachinukiMatchDetail)
 // writeKachinukiMatchSection writes a single match section starting at
 // `startRow`, in the first court's columns of a match block, and returns the
 // row index immediately after the section (the row a separator would occupy).
-func writeKachinukiMatchSection(f *excelize.File, sheet string, styles matchStyles, match KachinukiMatchDetail, startRow int) int {
+func writeKachinukiMatchSection(f *excelize.File, sheet, titleSuffix string, styles matchStyles, match KachinukiMatchDetail, startRow int) int {
 	cols := buildMatchColumnNames(1)
 	bouts := match.sectionBouts()
 	row := startRow
 
 	// --- A match block's heading (title, White | vs | Red), then each side's
 	// team under its colour ---
-	row = printMatchBlockHeading(f, sheet, cols, styles, row, fmt.Sprintf("%s (Kachinuki)", match.Label), false)
+	row = printMatchBlockHeading(f, sheet, cols, styles, row, fmt.Sprintf("%s (%s)", match.Label, titleSuffix), false)
 	leftTeam, rightTeam := WhiteLeft(match.SideATeam, match.SideBTeam)
 	handleExcelError("SetCellStyle", f.SetCellStyle(sheet, cols.startColName+strconv.Itoa(row), cols.endColName+strconv.Itoa(row), styles.text))
 	handleExcelError("SetCellValue", f.SetCellValue(sheet, cols.startColName+strconv.Itoa(row), leftTeam))
@@ -292,6 +317,9 @@ func writeKachinukiBoutRow(f *excelize.File, sheet string, cols matchColumnNames
 	// position when the bout names one, side order built first, then
 	// placed left/right.
 	number := strconv.Itoa(bout.Position)
+	if bout.Position < 0 {
+		number = RepresentativeBoutRowLabel
+	}
 	akaPlayer := domain.JoinNonEmpty(number, formatKachinukiPlayer(bout.SideALabel, bout.SideAName, bout.SideAPos))
 	shiroPlayer := domain.JoinNonEmpty(number, formatKachinukiPlayer(bout.SideBLabel, bout.SideBName, bout.SideBPos))
 	leftPlayer, rightPlayer := WhiteLeft(akaPlayer, shiroPlayer)
diff --git a/internal/helper/excel_kachinuki_test.go b/internal/helper/excel_kachinuki_test.go
index b32e7be97..55edfcaf0 100644
--- a/internal/helper/excel_kachinuki_test.go
+++ b/internal/helper/excel_kachinuki_test.go
@@ -687,3 +687,123 @@ func TestBlankKachinukiSections(t *testing.T) {
 		}, got)
 	})
 }
+
+// representativeTestMatch is one match's Representative Bouts section: Red
+// (SideA, Aka) won it through a representative bout, hantei, both
+// representatives picked.
+func representativeTestMatch() KachinukiMatchDetail {
+	return KachinukiMatchDetail{
+		Label:     "Round 1 - Match 2",
+		SideATeam: "Kodokan",
+		SideBTeam: "Mumeishi",
+		Bouts: []KachinukiBout{{
+			Position:  -1,
+			SideAName: "Akagi", SideALabel: "T1.3", MarkA: "Ht",
+			SideBName: "Shirai", SideBLabel: "T2.2",
+			Middle: "(DH)",
+		}},
+	}
+}
+
+// TestWriteRepresentativeBoutsSheet_TitleAndRowLabel pins the sheet's three
+// differences from the Kachinuki Detail sheet that draws it: its name, its
+// section title ("<label> (Representative bout)"), and the bout's number cell
+// reading DH where a numbered bout reads its number, never the stored -1. The
+// centre carries the closed-set (DH) mark, and the result mark rides beside the
+// side it names, Shiro left and Aka right as on every sheet.
+func TestWriteRepresentativeBoutsSheet_TitleAndRowLabel(t *testing.T) {
+	f := excelize.NewFile()
+	defer func() { _ = f.Close() }()
+
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, []KachinukiMatchDetail{representativeTestMatch()}))
+
+	cell := func(ref string) string {
+		t.Helper()
+		v, err := f.GetCellValue(SheetRepresentativeBouts, ref)
+		require.NoError(t, err)
+		return v
+	}
+	cols := buildMatchColumnNames(1)
+
+	assert.Equal(t, "Round 1 - Match 2 (Representative bout)", cell(cols.startColName+"1"), "the section is titled by its match")
+	assert.Equal(t, "Mumeishi", cell(cols.startColName+"3"), "Shiro's team on the left")
+	assert.Equal(t, "Kodokan", cell(cols.endColName+"3"), "Aka's team on the right")
+
+	const boutRow = "4"
+	assert.Equal(t, RepresentativeBoutRowLabel+" T2.2 Shirai", cell(cols.startColName+boutRow), "Shiro's representative after the DH label")
+	assert.Equal(t, RepresentativeBoutRowLabel+" T1.3 Akagi", cell(cols.endColName+boutRow), "Aka's representative after the DH label")
+	assert.Equal(t, "(DH)", cell(cols.middleColName+boutRow), "the centre is the representative-bout mark")
+	assert.Equal(t, "Ht", cell(cols.rightVictoriesColName+boutRow), "Aka's hantei mark beside Aka's score cell")
+	assert.Empty(t, cell(cols.leftVictoriesColName+boutRow), "Shiro's cell carries nothing")
+
+	rows, err := f.GetRows(SheetRepresentativeBouts)
+	require.NoError(t, err)
+	for r, row := range rows {
+		for c, v := range row {
+			assert.NotContainsf(t, v, "-1", "row %d col %d (%q) must not print the stored position", r+1, c+1, v)
+			assert.NotContainsf(t, v, "Kachinuki", "row %d col %d (%q): this is not the Kachinuki Detail sheet", r+1, c+1, v)
+		}
+	}
+
+	idx, err := f.GetSheetIndex(SheetKachinukiDetail)
+	require.NoError(t, err)
+	assert.Equal(t, -1, idx, "writing the Representative Bouts sheet creates no Kachinuki Detail sheet")
+}
+
+// A side that picked no representative prints the bout label alone, never a
+// name or a "-1".
+func TestWriteRepresentativeBoutsSheet_UnpickedSidePrintsTheLabelAlone(t *testing.T) {
+	f := excelize.NewFile()
+	defer func() { _ = f.Close() }()
+
+	match := representativeTestMatch()
+	match.Bouts[0].SideBName, match.Bouts[0].SideBLabel = "", ""
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, []KachinukiMatchDetail{match}))
+
+	cols := buildMatchColumnNames(1)
+	shiro, err := f.GetCellValue(SheetRepresentativeBouts, cols.startColName+"4")
+	require.NoError(t, err)
+	assert.Equal(t, RepresentativeBoutRowLabel, shiro)
+	aka, err := f.GetCellValue(SheetRepresentativeBouts, cols.endColName+"4")
+	require.NoError(t, err)
+	assert.Equal(t, RepresentativeBoutRowLabel+" T1.3 Akagi", aka)
+}
+
+// No section to list, no sheet; one section, a portrait page one wide, as the
+// Kachinuki Detail sheet it shares its renderer with.
+func TestWriteRepresentativeBoutsSheet_NoSheetForEmptyInputAndPageLayout(t *testing.T) {
+	f := excelize.NewFile()
+	defer func() { _ = f.Close() }()
+
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, nil))
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, []KachinukiMatchDetail{{Label: "Round 1 - Match 1", SideATeam: "A", SideBTeam: "B"}}))
+	idx, err := f.GetSheetIndex(SheetRepresentativeBouts)
+	require.NoError(t, err)
+	assert.Equal(t, -1, idx, "nothing to list creates no sheet")
+
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, []KachinukiMatchDetail{representativeTestMatch()}))
+	layout, err := f.GetPageLayout(SheetRepresentativeBouts)
+	require.NoError(t, err)
+	require.NotNil(t, layout.Orientation)
+	assert.Equal(t, "portrait", *layout.Orientation)
+	require.NotNil(t, layout.FitToWidth)
+	assert.Equal(t, 1, *layout.FitToWidth)
+}
+
+// Like Kachinuki Detail, the sheet holds no formula to protect.
+func TestProtectAllSheets_LeavesTheRepresentativeBoutsSheetEditable(t *testing.T) {
+	f := excelize.NewFile()
+	defer func() { _ = f.Close() }()
+
+	require.NoError(t, WriteRepresentativeBoutsSheet(f, []KachinukiMatchDetail{representativeTestMatch()}))
+	_, err := f.NewSheet(SheetPoolMatches)
+	require.NoError(t, err)
+	ProtectAllSheets(f)
+
+	bouts, err := f.GetSheetProtection(SheetRepresentativeBouts)
+	require.NoError(t, err)
+	assert.Equal(t, excelize.SheetProtectionOptions{}, bouts, "the Representative Bouts sheet is left editable")
+	pool, err := f.GetSheetProtection(SheetPoolMatches)
+	require.NoError(t, err)
+	assert.NotEqual(t, excelize.SheetProtectionOptions{}, pool, "the control: a score-entry sheet is protected")
+}
diff --git a/internal/mobileapp/daihyosen_row_names_test.go b/internal/mobileapp/daihyosen_row_names_test.go
new file mode 100644
index 000000000..8188826a1
--- /dev/null
+++ b/internal/mobileapp/daihyosen_row_names_test.go
@@ -0,0 +1,71 @@
+package mobileapp
+
+// The representative bout's row keeps the team names, and it keeps them from the
+// moment it exists. The hantei mark is placed on the winner's side by comparing
+// the winner against THAT row's sideA/sideB, so a row that names nobody between
+// the add and the first score write is a row nothing can attribute. The add
+// stores the match's own names (engine.AddDaihyosen); the first write restates
+// the same strings, so it lands as an echo, not as a side mismatch or a verdict
+// the organiser alone may touch.
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDaihyosenAdd_TheRowCarriesTheMatchsTeamNames(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		selfRun  bool
+		password string
+	}{
+		{"the organiser's add", false, "main-pw"},
+		{"a participant's add", true, ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			f := newRepBoutFixture(t, tc.selfRun)
+			w := f.send(http.MethodPost, repBoutMatchPath+"/daihyosen", tc.password, map[string]any{"modifiedAt": f.now})
+			require.Equal(t, http.StatusOK, w.Code, "adding the representative bout: %s", w.Body.String())
+
+			bm := storedB1(t, f.store, "c1")
+			row := f.storedRepBout(t)
+			assert.Equal(t, bm.SideA, row.SideA, "the stored row names the match's side A the moment it exists")
+			assert.Equal(t, bm.SideB, row.SideB, "the stored row names the match's side B the moment it exists")
+			assert.Equal(t, "TeamA", row.SideA)
+			assert.Equal(t, "TeamB", row.SideB)
+
+			var body struct {
+				SubResult state.SubMatchResult `json:"subResult"`
+			}
+			require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))
+			assert.Equal(t, "TeamA", body.SubResult.SideA, "the answer carries the same names")
+			assert.Equal(t, "TeamB", body.SubResult.SideB, "the answer carries the same names")
+		})
+	}
+}
+
+// The first write after the add restates the names the add stored. It lands
+// whole: no side_mismatch, no hantei_organiser_only, the scoreline is written
+// and the names stay what the match's are.
+func TestSelfRun_TheFirstWriteRestatingTheStoredNamesLands(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	stored := f.storedRepBout(t)
+	require.Equal(t, "TeamA", stored.SideA, "precondition: the add stored the names")
+
+	w := f.score("", state.MatchStatusRunning, "", f.now+100, repBoutRow([]string{"M"}, []string{}, "TeamA"))
+	require.Equal(t, http.StatusOK, w.Code, "scoring the row that restates the names: %s", w.Body.String())
+	assert.NotContains(t, w.Body.String(), `"applied":false`)
+	assert.NotContains(t, w.Body.String(), "side_mismatch")
+	assert.NotContains(t, w.Body.String(), "hantei_organiser_only")
+
+	row := f.storedRepBout(t)
+	assert.Equal(t, []string{"M"}, row.IpponsA, "the scoreline is written")
+	assert.Equal(t, "TeamA", row.SideA)
+	assert.Equal(t, "TeamB", row.SideB)
+}
diff --git a/internal/mobileapp/handlers_announcement_test.go b/internal/mobileapp/handlers_announcement_test.go
index a17ede1bd..f88d669c9 100644
--- a/internal/mobileapp/handlers_announcement_test.go
+++ b/internal/mobileapp/handlers_announcement_test.go
@@ -9,6 +9,7 @@ import (
 	"strings"
 	"testing"
 	"testing/fstest"
+	"time"
 
 	"github.com/gitrgoliveira/bracket-creator/internal/engine"
 	"github.com/gitrgoliveira/bracket-creator/internal/resources"
@@ -207,3 +208,120 @@ func TestAnnouncementHandlers(t *testing.T) {
 	router.ServeHTTP(w, req)
 	assert.Equal(t, http.StatusUnauthorized, w.Code)
 }
+
+// TestAnnouncementHandlers_IdenticalMessageReplaces pins bc-cdbl: posting the
+// text that is already showing replaces its banner rather than stacking a
+// second one, so a double tap on Call to court is one announcement from any
+// device.
+func TestAnnouncementHandlers_IdenticalMessageReplaces(t *testing.T) {
+	store, err := state.NewStore(t.TempDir())
+	require.NoError(t, err)
+	require.NoError(t, store.SaveTournament(&state.Tournament{Name: "Test Tournament", Password: "secret-password"}))
+
+	eng := engine.New(store)
+	res := resources.NewResources(nil, fstest.MapFS{
+		"web-mobile/index.html": {Data: []byte("<html><body>Mobile</body></html>")},
+	})
+	router, _, limiter := NewRouter(store, eng, res, NewFileVerifier(store))
+	t.Cleanup(limiter.Close)
+
+	post := func(msg string) state.Announcement {
+		t.Helper()
+		body, _ := json.Marshal(announcementRequest{Message: msg, DurationMinutes: 5})
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("POST", "/api/tournament/announce", bytes.NewReader(body))
+		req.Header.Set("X-Tournament-Password", "secret-password")
+		router.ServeHTTP(w, req)
+		require.Equal(t, http.StatusOK, w.Code)
+		var ann state.Announcement
+		require.NoError(t, json.Unmarshal(w.Body.Bytes(), &ann))
+		return ann
+	}
+
+	first := post("Now calling Yamada and Tanaka to Shiaijo A.")
+	second := post("Now calling Yamada and Tanaka to Shiaijo A.")
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/api/tournament/announcements", nil)
+	router.ServeHTTP(w, req)
+	var list []state.Announcement
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &list))
+	require.Len(t, list, 1)
+	assert.Equal(t, second.ID, list[0].ID)
+	assert.NotEqual(t, first.ID, list[0].ID)
+}
+
+// TestAnnouncementHandlers_DeleteThroughAReplacedID pins the follow-up to
+// bc-cdbl: a court console that holds the id of a call a later identical call
+// replaced (another device called the same match, or its own re-call's answer
+// was lost) still takes the call down. The DELETE answers 204 and broadcasts
+// the list without the announcement that replaced the id, instead of a 404 that
+// left the banner up until it expired. The server still tags no call with a
+// match: it only knows which id replaced which.
+func TestAnnouncementHandlers_DeleteThroughAReplacedID(t *testing.T) {
+	store, err := state.NewStore(t.TempDir())
+	require.NoError(t, err)
+	require.NoError(t, store.SaveTournament(&state.Tournament{Name: "Test Tournament", Password: "secret-password"}))
+
+	eng := engine.New(store)
+	res := resources.NewResources(nil, fstest.MapFS{
+		"web-mobile/index.html": {Data: []byte("<html><body>Mobile</body></html>")},
+	})
+	router, hub, limiter := NewRouter(store, eng, res, NewFileVerifier(store))
+	t.Cleanup(limiter.Close)
+
+	post := func(msg string) state.Announcement {
+		t.Helper()
+		body, _ := json.Marshal(announcementRequest{Message: msg, DurationMinutes: 5})
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("POST", "/api/tournament/announce", bytes.NewReader(body))
+		req.Header.Set("X-Tournament-Password", "secret-password")
+		router.ServeHTTP(w, req)
+		require.Equal(t, http.StatusOK, w.Code)
+		var ann state.Announcement
+		require.NoError(t, json.Unmarshal(w.Body.Bytes(), &ann))
+		return ann
+	}
+	del := func(id string) *httptest.ResponseRecorder {
+		t.Helper()
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("DELETE", "/api/announcements/"+id, nil)
+		req.Header.Set("X-Tournament-Password", "secret-password")
+		router.ServeHTTP(w, req)
+		return w
+	}
+
+	const call = "Now calling Yamada and Tanaka to Shiaijo A."
+	first := post(call)
+	second := post(call)
+	require.NotEqual(t, first.ID, second.ID)
+
+	// Subscribe after the POSTs, so the next event is the DELETE's broadcast.
+	ch := hub.Subscribe()
+	defer hub.Unsubscribe(ch)
+
+	w := del(first.ID)
+	assert.Equal(t, http.StatusNoContent, w.Code, "the replaced id must withdraw the announcement that replaced it")
+
+	select {
+	case msg := <-ch:
+		env := decodeHubEvent(t, msg)
+		assert.Equal(t, EventAnnouncement, env.Type)
+		list, ok := env.Data.([]any)
+		require.Truef(t, ok, "the broadcast carries the announcement list, got %T", env.Data)
+		assert.Empty(t, list, "the withdrawn call must leave the broadcast list")
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for the announcement broadcast after the withdrawal")
+	}
+
+	w = httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/api/tournament/announcements", nil)
+	router.ServeHTTP(w, req)
+	var list []state.Announcement
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &list))
+	assert.Empty(t, list)
+
+	// Both ids are spent: nothing is left to take down through either.
+	assert.Equal(t, http.StatusNotFound, del(first.ID).Code)
+	assert.Equal(t, http.StatusNotFound, del(second.ID).Code)
+}
diff --git a/internal/mobileapp/handlers_daihyosen.go b/internal/mobileapp/handlers_daihyosen.go
index fa7d79553..daf940831 100644
--- a/internal/mobileapp/handlers_daihyosen.go
+++ b/internal/mobileapp/handlers_daihyosen.go
@@ -123,7 +123,7 @@ func respondIfValidationError(c *gin.Context, err error) bool {
 // variant so the read-modify-write runs under the same per-comp lock the
 // read used (see RegisterDaihyosenHandlers).
 type DaihyosenEngine interface {
-	AddDaihyosen(compID, matchID string, sideA, sideB engine.TeamSummary, isPool bool, sideAEligible, sideBEligible int) (*state.SubMatchResult, error)
+	AddDaihyosen(compID, matchID, nameA, nameB string, sideA, sideB engine.TeamSummary, isPool bool, sideAEligible, sideBEligible int) (*state.SubMatchResult, error)
 	RecordMatchResultWithIneligibilityTx(tx state.StoreTx, compID, matchID string, result *state.MatchResult, opts ...engine.ForceOptions) (*domain.CompetitorStatus, error)
 	MaybeAutoCompletePoolsAfterWrite(compID string, written ...state.MatchResult) (engine.AutoCompleteOutcome, error)
 }
@@ -267,9 +267,12 @@ func RegisterDaihyosenHandlers(r *gin.RouterGroup, eng DaihyosenEngine, store Da
 			u.Encho = nil
 			// What the remove changes (bc-mrgc): the representative bout (its
 			// stamp stays as a tombstone, so an older write still carrying the
-			// row cannot bring it back), the verdict, the overtime, and the
-			// scoreline when clearing the verdict took a hantei mark out of it.
-			u.Changed = daihyosenChangedGroups(match, &u, state.GroupResult, state.GroupEncho)
+			// row cannot bring it back), its representatives (they go with the
+			// row, and each side's stamp dates the removal so a pick made before
+			// it is held, not applied onto nothing), the verdict, the overtime,
+			// and the scoreline when clearing the verdict took a hantei mark out
+			// of it.
+			u.Changed = daihyosenChangedGroups(match, &u, state.GroupResult, state.GroupEncho, state.GroupRepPickA, state.GroupRepPickB)
 			u.WriteDoor = engine.DoorDaihyosenDel
 			if _, err := eng.RecordMatchResultWithIneligibilityTx(stx, id, mid, &u); err != nil {
 				if errors.Is(err, engine.ErrMatchSuperseded) {
@@ -421,7 +424,10 @@ func RegisterDaihyosenHandlers(r *gin.RouterGroup, eng DaihyosenEngine, store Da
 				return err
 			}
 
-			sub, err := eng.AddDaihyosen(id, mid, sideASummary, sideBSummary, engine.IsPoolMatchID(mid), sideAEligible, sideBEligible)
+			// The row is stored with the match's own team names (nameA/nameB),
+			// for the organiser's add and the participant's alike, so it is
+			// never nameless between this add and the first score write.
+			sub, err := eng.AddDaihyosen(id, mid, match.SideA, match.SideB, sideASummary, sideBSummary, engine.IsPoolMatchID(mid), sideAEligible, sideBEligible)
 			if err != nil {
 				switch {
 				case errors.Is(err, engine.ErrNotTied):
@@ -471,8 +477,14 @@ func RegisterDaihyosenHandlers(r *gin.RouterGroup, eng DaihyosenEngine, store Da
 			u.Status = state.MatchStatusRunning // daihyosen bout in progress
 			// What the add changes (bc-mrgc): the new representative bout and
 			// the verdict, and the scoreline when clearing the verdict took a
-			// hantei mark out of it.
-			u.Changed = daihyosenChangedGroups(match, &u, state.GroupResult)
+			// hantei mark out of it. The new row is built with no
+			// representatives, and the add names both side groups
+			// (state.GroupRepPickA, state.GroupRepPickB) all the same, as the
+			// remove does: it dates the (empty) picks of THIS bout, so a pick
+			// made on the previous representative bout, stamped between the
+			// remove and the add, is older than the add and is held rather than
+			// landing on the new bout through the remove's tombstone stamp.
+			u.Changed = daihyosenChangedGroups(match, &u, state.GroupResult, state.GroupRepPickA, state.GroupRepPickB)
 			u.WriteDoor = engine.DoorDaihyosenAdd
 			if _, err := eng.RecordMatchResultWithIneligibilityTx(stx, id, mid, &u); err != nil {
 				if errors.Is(err, engine.ErrMatchSuperseded) {
diff --git a/internal/mobileapp/handlers_lineup.go b/internal/mobileapp/handlers_lineup.go
index 4f024fcd2..93d4064e3 100644
--- a/internal/mobileapp/handlers_lineup.go
+++ b/internal/mobileapp/handlers_lineup.go
@@ -460,32 +460,45 @@ var errTeamNotInMatch = &selfRunRefusal{
 // memberIDsOutsideTeam refuses a lineup that places a member id the team does
 // not hold (400 team_member_not_in_team): ids are bare UUIDs, so the team's own
 // squad is the only thing that says whose they are, and a lineup naming another
-// team's member would put that member on this team's score sheet.
+// team's member would put that member on this team's score sheet. A members
+// file that cannot be read refuses the save with errTeamMembersUnreadable (409),
+// not a 500 the offline queue retries forever; a save that names no member id
+// (a cleared position) never reads it.
 func memberIDsOutsideTeam(stx state.StoreTx, compID, teamID string, memberIDs map[domain.Position]string) *txResponse {
-	if len(memberIDs) == 0 {
-		return nil
-	}
-	squads, err := stx.LoadSquads(compID)
-	if err != nil {
-		log.Printf("mobileapp: lineup member check for %s: %v", compID, err)
-		return &txResponse{status: http.StatusInternalServerError, body: gin.H{"error": "internal error"}}
-	}
-	held := make(map[string]bool, len(squads[teamID]))
-	for _, m := range squads[teamID] {
-		held[m.ID] = true
-	}
+	judge := &memberJudge{stx: stx, compID: compID}
 	for pos, id := range memberIDs {
-		if id != "" && !held[id] {
+		if id == "" {
+			continue
+		}
+		held, err := judge.holds(teamID, id)
+		if err != nil {
+			return errTeamMembersUnreadable.response()
+		}
+		if !held {
 			return errLineupMemberNotInTeam(pos).response()
 		}
 	}
 	return nil
 }
 
+// teamMemberIDs is the set of member ids a team holds in squads: the one answer to
+// "is this member the team's" that every member check asks.
+func teamMemberIDs(squads map[string][]domain.TeamMember, teamID string) map[string]bool {
+	held := make(map[string]bool, len(squads[teamID]))
+	for _, m := range squads[teamID] {
+		held[m.ID] = true
+	}
+	return held
+}
+
+// codeTeamMemberNotInTeam is the refusal code for a member id the named team does
+// not hold. The lineup refusal and the representative pick's refusal both answer it.
+const codeTeamMemberNotInTeam = "team_member_not_in_team"
+
 func errLineupMemberNotInTeam(pos domain.Position) *selfRunRefusal {
 	return &selfRunRefusal{
 		status:  http.StatusBadRequest,
-		code:    "team_member_not_in_team",
+		code:    codeTeamMemberNotInTeam,
 		message: "The member chosen for " + string(pos) + " is not on this team. Pick again from the list.",
 	}
 }
diff --git a/internal/mobileapp/handlers_match.go b/internal/mobileapp/handlers_match.go
index fd9b412de..c3e093d2f 100644
--- a/internal/mobileapp/handlers_match.go
+++ b/internal/mobileapp/handlers_match.go
@@ -729,7 +729,12 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 			// "downstream_knockout_running" when that pool entry would move a
 			// qualifier out of a knockout match being fought now, or a knockout
 			// entry would change a side of one (terminal: finish or requeue
-			// that match, then retry).
+			// that match, then retry); and "team_member_not_in_team" when a
+			// representative pick the entry lands is not on its side's team
+			// (the entry stores nothing; /score answers it with a 400); and
+			// "team_members_unreadable" when the competition's team members
+			// cannot be read to judge such a pick (the entry stores nothing;
+			// /score answers it with a 409).
 			//
 			// It matters because the single-match endpoints answer those
 			// conditions with a distinct body ({"applied": false, "reason":
@@ -879,10 +884,11 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 				// completed -> completed overwrite, otherwise carry the STORED
 				// reason forward; ending a match reopened without a reason is
 				// never refused). The rule itself lives in
-				// applyCorrectionReasonUnderTx, shared with the single-score path
-				// so the two cannot drift; only the error SHAPE differs here
-				// (partial-success entries carry a plain message).
-				check, snapErr := applyCorrectionReasonUnderTx(stx, id, results[i].ID, &results[i].MatchResult)
+				// applyCorrectionReason, shared with the single-score path (which
+				// calls it over its own snapshot) so the two cannot drift; only
+				// the error SHAPE differs here (partial-success entries carry a
+				// plain message).
+				check, snap, snapErr := applyCorrectionReasonUnderTx(stx, id, results[i].ID, &results[i].MatchResult)
 				if snapErr != nil {
 					return snapErr
 				}
@@ -892,6 +898,11 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 				if refusal := teamFinishRefusalUnderTx(finishRefusal, check, &results[i].MatchResult); refusal != nil {
 					return errors.New(refusal.Error())
 				}
+				// The entry's representative picks are judged on what the write
+				// landed, as /score's are (landedMembersRefusal), decided here,
+				// before the engine rewrites the entry. Its numbered rows are
+				// not: this is the organiser's tooling.
+				judgePicks := introducesJudgedMember(results[i].SubResults, snap, false)
 				status, err := eng.RecordMatchResultWithIneligibilityTx(stx, id, results[i].ID, &results[i].MatchResult, engine.ForceOptions{
 					Force:    results[i].ForceDownstreamReopen,
 					Reopened: &reopenedThisItem,
@@ -905,6 +916,14 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 				if err != nil {
 					return err
 				}
+				if judgePicks {
+					// A refusal aborts this entry's transaction: it stores
+					// nothing, history line included, and the entries beside
+					// it are unaffected.
+					if err := landedMembersRefusal(stx, id, results[i].ID, snap, false); err != nil {
+						return err
+					}
+				}
 				capturedStatus = status
 				if check.ClearBracketReopenPending {
 					// ClearBracketReopenPending is snap.InBracket && snap.ReopenPending,
@@ -921,7 +940,14 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 				var downstreamPlayedErr *engine.DownstreamKnockoutPlayedError
 				var downstreamRunningErr *engine.DownstreamKnockoutRunningError
 				var alreadyIneligErr *engine.AlreadyIneligibleError
+				var landedRefusal *landedWriteRefusal
 				switch {
+				case errors.As(err, &landedRefusal):
+					// A pick the write landed that the side's team does not
+					// hold: the refusal's code rides in Reason and its
+					// sentence, the page's own, in Error.
+					bulkErr.Reason = landedRefusal.refusal.code
+					bulkErr.Error = landedRefusal.refusal.message
 				case errors.Is(err, engine.ErrMatchSuperseded):
 					bulkErr.Reason = "superseded"
 					bulkErr.Error = SupersededMessage
@@ -1386,7 +1412,7 @@ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store Competi
 	// no reason either (operator ruling 2026-09-25: a match can be reopened
 	// without any reason, and nothing is gated on that). A reason-less reopen
 	// sets state.MatchResult.ReopenPending, which only lets a reason sent with
-	// the next completion be kept (see applyCorrectionReasonUnderTx).
+	// the next completion be kept (see applyCorrectionReason).
 	//
 	// A completed match that is neither kachinuki nor decided by a withdrawal
 	// gets 400 (its sanctioned edit of a finished result remains the
@@ -1899,11 +1925,13 @@ func enforceSelfRunPolicy(c *gin.Context, tl TournamentLoader, verifier Password
 	return "self-reported", true
 }
 
-// selfRunRefusal is a refusal of an anonymous self-run write: the status of
-// the response, its code (the body's error) and the sentence the public page
-// shows as it is (the body's message). The sentence is written where the
-// refusal is decided, so the handler that sends it never works the case out
-// again.
+// selfRunRefusal is a refusal of a score write the handler judged under the
+// write's lock: an anonymous self-run write, or the organiser's representative
+// pick (landedMembersRefusal, which answers the same refusal as a
+// participant's). It carries the status of the response, its code (the body's
+// error) and the sentence the page shows as it is (the body's message). The
+// sentence is written where the refusal is decided, so the handler that sends
+// it never works the case out again.
 type selfRunRefusal struct {
 	status  int
 	code    string
@@ -1978,7 +2006,8 @@ var errRepBoutAdded = &selfRunRefusal{
 
 // holdSelfReportedWriteUnderTx is the one judge of an anonymous self-run score
 // write. It runs inside WithTransaction (under the per-comp lock), so the
-// stored match it reads, once, cannot change before the write lands. It
+// stored match it is handed (snap, found: read once for every guard of the
+// write by the caller) cannot change before the write lands. It
 // refuses the write or lets it through, and it can rewrite it on the way: a
 // representative bout the organiser decided is written back exactly as
 // stored. In order:
@@ -1999,6 +2028,12 @@ var errRepBoutAdded = &selfRunRefusal{
 //     unscored check): a write listing the bouts without the row the match
 //     has comes from a sheet a moment behind an add, so the stored row is
 //     kept, scored or not, and a finish is refused (errRepBoutAdded).
+//   - Who a write seats is not judged here. It is judged on what the write
+//     LANDS, after the engine has merged it and in the same transaction
+//     (landedMembersRefusal): the engine rewrites a write before its own merge
+//     (a kachinuki bout log is merged by position, member ids are filled in,
+//     the winner is worked out), so a reading of the payload can disagree with
+//     what is stored.
 //   - Once the organiser recorded a judges' decision on the representative
 //     bout, the write's row must send it back (sameHanteiVerdict) or leave the
 //     row's ippons out (engine.KeepsStoredDaihyosenVerdict), a write listing
@@ -2017,15 +2052,11 @@ var errRepBoutAdded = &selfRunRefusal{
 // so its sub-results are not judged, and the engine derives its winner from
 // the bouts it keeps.
 //
-// Fails closed: a load error rejects the request rather than allowing the write
-// (matchSnapshotOrErr). A match in neither store passes on purpose: the write
-// that follows under the same lock refuses it (errMatchNotFound), so nothing
-// can land on it.
-func holdSelfReportedWriteUnderTx(stx state.StoreTx, compID, matchID string, result *state.MatchResult, startOnly bool) error {
-	snap, found, err := matchSnapshotOrErr(stx, compID, matchID, "self-run")
-	if err != nil {
-		return err
-	}
+// Fails closed: the caller's read of the snapshot rejects the request on a load
+// error rather than allowing the write (matchSnapshotOrErr). A match in neither
+// store (found false) passes on purpose: the write that follows under the same
+// lock refuses it (errMatchNotFound), so nothing can land on it.
+func holdSelfReportedWriteUnderTx(compID, matchID string, snap matchSnapshot, found bool, result *state.MatchResult, startOnly bool) error {
 	if !found {
 		return nil
 	}
@@ -2096,6 +2127,334 @@ func holdSelfReportedWriteUnderTx(stx state.StoreTx, compID, matchID string, res
 	return nil
 }
 
+// errRepMemberNotInTeam refuses a representative pick, a participant's or the
+// organiser's (landedMembersRefusal), that names a member the side's team does
+// not hold (400 team_member_not_in_team). The lineup refusal
+// (errLineupMemberNotInTeam) says the same thing about a fielded position.
+var errRepMemberNotInTeam = &selfRunRefusal{
+	status:  http.StatusBadRequest,
+	code:    codeTeamMemberNotInTeam,
+	message: "The representative chosen is not on this team. Pick again from the list.",
+}
+
+// landedWriteRefusal carries the refusal of a write judged on what it LANDED
+// out of the write's transaction, as an error. Returning it is what aborts the
+// transaction: the engine's match write, its history line and its eligibility
+// record are all staged in that transaction, so a refusal stored into the
+// caller's engErr from inside it would commit them instead. The caller unwraps
+// it once WithTransaction has returned and answers it like any other refusal.
+type landedWriteRefusal struct{ refusal *selfRunRefusal }
+
+func (e *landedWriteRefusal) Error() string { return e.refusal.Error() }
+func (e *landedWriteRefusal) Unwrap() error { return e.refusal }
+
+// introducesJudgedMember is the gate in front of landedMembersRefusal: it says
+// whether a score write, as the judges before the engine leave it (subs),
+// introduces a member id on a row that judge looks at, against the match as it
+// stood before the write (before, the snapshot read at the top of it). Those
+// rows are judgedRows', the selection the judge (membersOutsideTeams) reads too:
+// the representative bout's, for anyone's write (either side's pick, against
+// before.RepBout, the row the judge compares it with), and with numbered a
+// participant's numbered rows (either fighter and the winner, against the stored
+// row at the same Position). A position the stored match lacks holds no id, so
+// every id its row carries is an introduction.
+//
+// The invariant that makes the gate equivalent to judging every write: the
+// engine never lands a member id the judge would refuse that the payload did
+// not introduce. It adds an id to a row only by copying the one the stored row
+// holds at that position (preserveKachinukiMemberIDs) or by deriving the
+// winner's from the row's own landed side ids (ResolveMemberWinnerID,
+// ReconcileWinnerMemberID), which the judge accepts. So a write that introduces
+// none leaves the staged match unread. The echo is the common case: the team
+// editor stamps member ids on every row that has a lineup, and a gate that
+// fired on any id would parse pool-matches.csv (and bracket.json for a knockout
+// match) again under the competition's write lock on nearly every autosave.
+//
+// Only the ids are compared, never a team id from before.Pairing: the judge
+// reads a side's team from the LANDED pairing, and on the pool branch a payload
+// side id over an id-less stored side lands (reconcileSides), so a gate keyed on
+// the stored team ids would skip exactly that write.
+func introducesJudgedMember(subs []state.SubMatchResult, before matchSnapshot, numbered bool) bool {
+	for _, j := range judgedRows(subs, before, numbered) {
+		if introducesFighter(j.row, j.stored) || (!j.rep && introducesWinnerMember(j.row, j.stored)) {
+			return true
+		}
+	}
+	return false
+}
+
+// judgedRow is a row the member judge looks at with the stored row it compares
+// the row with, and whether it is the representative bout's.
+type judgedRow struct {
+	row, stored state.SubMatchResult
+	rep         bool
+}
+
+// judgedRows is the ONE selection of what the member judge looks at, read by the
+// gate (introducesJudgedMember, on the payload's rows) and by the judge
+// (membersOutsideTeams, on the landed rows), so a row added to one is added to
+// the other. Per row, not per field: the winner check needs the row's two side
+// ids with the stored row's as its fallback. Every representative-bout row is
+// judged for anyone, against before.RepBout (the row the judge compares a pick
+// with, the empty row when the match has none); with numbered, a participant's
+// write, every other row too, against the stored row at its Position
+// (state.SubResultAt: a position the stored match lacks holds no id, so every id
+// its row carries is an introduction). Rows come in the order given.
+func judgedRows(subs []state.SubMatchResult, before matchSnapshot, numbered bool) []judgedRow {
+	var storedRows []state.SubMatchResult
+	if before.Stored != nil {
+		storedRows = before.Stored.SubResults
+	}
+	var out []judgedRow
+	for _, row := range subs {
+		switch {
+		case row.Position == state.DaihyosenSubPosition:
+			var stored state.SubMatchResult
+			if before.RepBout != nil {
+				stored = *before.RepBout
+			}
+			out = append(out, judgedRow{row: row, stored: stored, rep: true})
+		case numbered:
+			out = append(out, judgedRow{row: row, stored: state.SubResultAt(storedRows, row.Position)})
+		}
+	}
+	return out
+}
+
+// introducesFighter reports whether a row puts a member id on either side that
+// the stored row at the same position does not already hold.
+func introducesFighter(row, stored state.SubMatchResult) bool {
+	return introducesID(row.SideAMemberID, stored.SideAMemberID) ||
+		introducesID(row.SideBMemberID, stored.SideBMemberID)
+}
+
+// landedMembersRefusal judges who a score write SEATS by what it landed, read
+// back through stx after the engine wrote it (a StoreTx reads its own staged
+// bytes), against the match as it stood before (before, the snapshot read once
+// at the top of the write). Introduced means the stored row now holds an id it
+// did not hold before at that position: an id the row already had is its own,
+// whoever seated it, and a write answers for what it introduces, not for what it
+// inherited. In the match as it now stands:
+//
+//   - a representative bout's pick must be on its side's team
+//     (errRepMemberNotInTeam), for any caller, as the lineup's member check is
+//     (handlers_lineup.go: the pick names a SIDE, whose team a correction
+//     elsewhere can change under an open editor, and every surface resolves the
+//     bare id through the side's team);
+//   - with numbered, a participant's write: each numbered row's fighters must be
+//     on their side's team (errBoutFighterNotInTeam), and a winner member id the
+//     row now holds must be one of its two fighters (errWinnerMemberNotInBout).
+//     The organiser's numbered rows are not judged (the lineup's always-editable
+//     rule, mp-q722).
+//
+// It judges the landed match rather than the payload because the engine rewrites
+// a write before its own merge: a kachinuki bout log is merged by position,
+// member ids are filled in and the winner is worked out, and two merge rules
+// decide from that rewritten content (the newer scoring a finish displaces, a
+// finish held whole). A reading of the payload could skip a row the real write
+// landed. A group the merge does not land is the stored one in the landed
+// match, so it introduces nothing and is never judged: a stale change the write
+// NAMES is kept in the history and answered in heldGroups, never refused, and
+// one it does not name is copied from the stored match, neither written nor
+// reported. Only team membership is read, never the match's status, so the
+// organiser can pick again at once, on a finished match too.
+//
+// A refusal is returned as a *landedWriteRefusal and the caller returns it from
+// the transaction, which writes nothing. The caller runs this only for a write
+// the engine accepted (a superseded or rolled-back write must still commit its
+// history and its restore) and that introduces a judged member id
+// (introducesJudgedMember). A members file that cannot be read refuses a write
+// that needs it, terminally (errTeamMembersUnreadable): nothing is written,
+// which the offline queue reads as final.
+func landedMembersRefusal(stx state.StoreTx, compID, matchID string, before matchSnapshot, numbered bool) error {
+	after, found, err := matchSnapshotOrErr(stx, compID, matchID, "member")
+	if err != nil || !found {
+		return err
+	}
+	judge := &memberJudge{stx: stx, compID: compID}
+	err = membersOutsideTeams(judge, before, after, numbered)
+	var refusal *selfRunRefusal
+	if errors.As(err, &refusal) {
+		return &landedWriteRefusal{refusal}
+	}
+	return err
+}
+
+// membersOutsideTeams is landedMembersRefusal's judgement: it answers the first
+// refusal, an error of another kind being a read that failed. The rows it
+// judges are judgedRows' over the landed rows, the same selection the gate
+// (introducesJudgedMember) makes over the payload's.
+func membersOutsideTeams(judge *memberJudge, before, after matchSnapshot, numbered bool) error {
+	for _, j := range judgedRows(after.Stored.SubResults, before, numbered) {
+		refusal := errRepMemberNotInTeam
+		if !j.rep {
+			if err := winnerMemberOutsideBout(j.row, j.stored); err != nil {
+				return err
+			}
+			refusal = errBoutFighterNotInTeam
+		}
+		if err := rowMembersOutsideTeams(judge, after.Pairing, j.row, j.stored, refusal); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// errBoutFighterNotInTeam refuses a participant's numbered bout row that seats a
+// fighter the side's team does not hold (400 team_member_not_in_team, the code
+// the lineup and the representative pick answer too). A numbered row carries
+// its fighters' member ids from the editor (a kachinuki pairing's pick, the
+// fixed-order name box), and every surface reads them through the side's team.
+var errBoutFighterNotInTeam = &selfRunRefusal{
+	status:  http.StatusBadRequest,
+	code:    codeTeamMemberNotInTeam,
+	message: "The fighter chosen is not on this team. Pick again from the list.",
+}
+
+// errWinnerMemberNotInBout refuses a participant's numbered bout row whose
+// winner member is not one of the row's two fighters. The winner id is read
+// first by domain.AttributeWinnerSide, so an id that names no fighter of the
+// bout decides who won it, and who stayed on in a kachinuki encounter.
+var errWinnerMemberNotInBout = &selfRunRefusal{
+	status:  http.StatusBadRequest,
+	code:    "winner_member_not_in_bout",
+	message: "The winner recorded is not one of the two fighters in this bout.",
+}
+
+// errTeamMembersUnreadable refuses a write that needs the team members to judge
+// a choice when the competition's team-members.yaml cannot be read: 409, never
+// the 500 the offline queue retries forever, so the operator is told once and
+// retries after the file is repaired. The sentence is the page's own and says
+// what to check, since a participant cannot open the data folder; the read's
+// error is logged where it happens (memberJudge.holds).
+var errTeamMembersUnreadable = &selfRunRefusal{
+	status:  http.StatusConflict,
+	code:    "team_members_unreadable",
+	message: "The team members could not be read, so this choice cannot be checked. The organiser needs to check team-members.yaml in the tournament data.",
+}
+
+// memberJudge is what the member checks of ONE score write share: the
+// transaction they run in, and the competition's team members, each team's
+// member ids built at most once, and only when a row introduces a member id
+// to judge. A write that introduces none never reads the file, so a corrupt
+// team-members.yaml blocks no ordinary scoring; one that introduces several
+// reads it once.
+type memberJudge struct {
+	stx    state.StoreTx
+	compID string
+
+	read   bool
+	squads map[string][]domain.TeamMember
+	err    error
+
+	// ids is each team's member ids (teamMemberIDs), built on the first ask.
+	ids map[string]map[string]bool
+}
+
+// holds reports whether the team holds the member (teamMemberIDs, the one
+// answer to that question). A members file that cannot be read is
+// errTeamMembersUnreadable, logged with the file's name, for the rest of the
+// write.
+func (j *memberJudge) holds(teamID, memberID string) (bool, error) {
+	if !j.read {
+		j.read = true
+		if j.squads, j.err = j.stx.LoadSquads(j.compID); j.err != nil {
+			log.Printf("mobileapp: team-members.yaml for %s cannot be read: %v", j.compID, j.err)
+		}
+	}
+	if j.err != nil {
+		return false, errTeamMembersUnreadable
+	}
+	held, ok := j.ids[teamID]
+	if !ok {
+		if j.ids == nil {
+			j.ids = make(map[string]map[string]bool)
+		}
+		held = teamMemberIDs(j.squads, teamID)
+		j.ids[teamID] = held
+	}
+	return held[memberID], nil
+}
+
+// introducesMember reports whether a write puts a member id on a side that the
+// stored row does not already hold, on a side whose team is known. A write
+// answers for what it introduces, not for what it inherited (the write guard's
+// rule): the stored id is the row's own, whoever seated it (a correction since
+// seated another team), and a side with no team id has nothing to judge a
+// member against.
+func introducesMember(teamID, memberID, storedID string) bool {
+	return teamID != "" && introducesID(memberID, storedID)
+}
+
+// introducesID reports whether a write's member id is one the stored row at the
+// same position does not hold: the test every judge and the gate in front of
+// them (introducesJudgedMember) share.
+func introducesID(memberID, storedID string) bool {
+	return memberID != "" && memberID != storedID
+}
+
+// rowMembersOutsideTeams judges the member ids a landed bout row names against
+// the team that holds each side, for the representative bout and the numbered
+// rows alike (membersOutsideTeams). Ids are bare UUIDs, so the team's own
+// members are the only thing that says whose they are: a member of another
+// team, or an id no team holds, is refused (refusal) rather than kept. A side
+// is judged only for what the row introduces (introducesMember). stored is the
+// row at the same position before the write, an empty row when the match had
+// none.
+func rowMembersOutsideTeams(j *memberJudge, pairing domain.WinnerAttribution, row, stored state.SubMatchResult, refusal *selfRunRefusal) error {
+	for _, side := range []struct {
+		teamID, memberID, storedID string
+	}{
+		{pairing.SideAID, row.SideAMemberID, stored.SideAMemberID},
+		{pairing.SideBID, row.SideBMemberID, stored.SideBMemberID},
+	} {
+		if !introducesMember(side.teamID, side.memberID, side.storedID) {
+			continue
+		}
+		held, err := j.holds(side.teamID, side.memberID)
+		if err != nil {
+			return err
+		}
+		if !held {
+			return refusal
+		}
+	}
+	return nil
+}
+
+// winnerMemberOutsideBout judges the winner member a landed numbered row
+// INTRODUCES (it differs from the row's at the same position before the write):
+// it must be empty or one of the row's two fighters, a side the landed row
+// carries no id for counting as the fighter the row held there before. A winner id
+// the stored row already holds is never judged, whoever it names: a legacy row,
+// a correction that seated another team and a renamed member leave such ids
+// behind, and refusing them would refuse every later write of the match. Pure:
+// it reads no store.
+func winnerMemberOutsideBout(row, stored state.SubMatchResult) error {
+	if !introducesWinnerMember(row, stored) {
+		return nil
+	}
+	winner := row.WinnerMemberID
+	a, b := row.SideAMemberID, row.SideBMemberID
+	if a == "" {
+		a = stored.SideAMemberID
+	}
+	if b == "" {
+		b = stored.SideBMemberID
+	}
+	if winner == a || winner == b {
+		return nil
+	}
+	return errWinnerMemberNotInBout
+}
+
+// introducesWinnerMember reports whether a row's winner member id is one the
+// write changes against the stored row at the same position, as
+// introducesMember does for a side's fighter.
+func introducesWinnerMember(row, stored state.SubMatchResult) bool {
+	return introducesID(row.WinnerMemberID, stored.WinnerMemberID)
+}
+
 // isMatchFinalized reports whether the given stored status represents a
 // concluded match. Any completed match is finalized, anonymous callers must
 // not overwrite it regardless of whether a winner was explicitly recorded.
@@ -2116,15 +2475,18 @@ type matchStores interface {
 // matchSnapshot is the stored state of a match as this file's guards read
 // it: Status drives the correction / stale-write / finalized gates,
 // CorrectionReason carries the kachinuki reopen justification forward (see
-// applyCorrectionReasonUnderTx), and ReopenPending says a reason-less reopen
+// applyCorrectionReason), and ReopenPending says a reason-less reopen
 // has not been ended again.
 //
-// It carries only the fields the guards actually read: the post-advance
-// kachinuki bout log now rides back to the editor on MaybeAdvanceKachinuki's
-// postLog return (result.SubResults), not through this snapshot, so keeping a
-// SubResults field here would be a write-only value — and an expensive one, as
-// lookupMatchSnapshot deep-clones every sub-bout under the per-comp write lock
-// (mp-gmcg review).
+// It carries only the fields the guards actually read. The post-advance
+// kachinuki bout log rides back to the editor on MaybeAdvanceKachinuki's
+// postLog return (result.SubResults), not through this snapshot, and no field
+// here deep-clones the stored sub-bouts (mp-gmcg review: that was a write-only
+// value, and an expensive one, under the per-comp write lock). Stored is the
+// one reader of the stored match's rows, and it SHARES the loaded copy rather
+// than cloning it: the member judge (landedMembersRefusal) only reads it, as the
+// match stood before the write, and each load hands out a copy of its own, so
+// the engine's write never reaches it.
 //
 // InBracket is the match's HOME rather than its content: the pool write is a
 // whole-struct overwrite that carries ReopenPending itself, while the bracket
@@ -2145,8 +2507,10 @@ type matchSnapshot struct {
 	// RepBout is a copy of the stored representative-bout row (position -1),
 	// nil when the match has none: the self-run judge compares a
 	// participant's write against it, and writes back a deep copy of it once
-	// the organiser has decided it (holdSelfReportedWriteUnderTx). One row,
-	// not the bout log the note above keeps out.
+	// the organiser has decided it (holdSelfReportedWriteUnderTx); the picks the
+	// write lands are judged against it, for what they introduce
+	// (landedMembersRefusal). One row, which a writer deep-clones (Stored
+	// carries the whole bout log).
 	RepBout *state.SubMatchResult
 	// Pairing is the stored match's attribution (its sides, their ids and its
 	// winner), which the self-run judge reads a participant's winner against
@@ -2156,6 +2520,16 @@ type matchSnapshot struct {
 	// verdict was last changed), which the correction-reason check reads to
 	// tell a stale replay of a finish from a correction (bc-mrgc review).
 	ResultStamp int64
+	// Stored is the stored match itself, as the pool-shaped record the merge
+	// reads (a pool row as loaded; a bracket match through
+	// engine.BracketMatchAsResult). It is what the judges ask about, and it
+	// shares the loaded copy's rows, so a reader clones before it changes
+	// anything. Read before the write it is the baseline the member judge
+	// compares the landed match against, row by position; read again after the
+	// write (the same lookupMatchSnapshot, through the same transaction) it is
+	// what landed (landedMembersRefusal). nil only on a zero snapshot (no match
+	// found).
+	Stored *state.MatchResult
 }
 
 // repBoutOf returns a copy of the first representative-bout row in subs, nil
@@ -2208,6 +2582,7 @@ func lookupMatchSnapshot(s matchStores, compID, matchID string) (matchSnapshot,
 				RepBout:          repBoutOf(poolMatches[i].SubResults),
 				Pairing:          poolMatches[i].Attribution(),
 				ResultStamp:      poolMatches[i].GroupStamp(state.GroupResult),
+				Stored:           &poolMatches[i],
 			}, true, loadErr
 		}
 	}
@@ -2242,6 +2617,7 @@ func bracketMatchSnapshot(bm *state.BracketMatch) matchSnapshot {
 		RepBout:          repBoutOf(bm.SubResults),
 		Pairing:          bm.Attribution(),
 		ResultStamp:      bm.GroupStamp(state.GroupResult),
+		Stored:           engine.BracketMatchAsResult(bm),
 	}
 }
 
@@ -2489,7 +2865,7 @@ func matchStatusFromStore(store CompetitionStore, compID, matchID string) state.
 	return status
 }
 
-// correctionCheck is applyCorrectionReasonUnderTx's verdict.
+// correctionCheck is applyCorrectionReason's verdict.
 //
 //   - StoredStatus is the match's status as stored, returned so the caller's
 //     stale-after-complete guard doesn't have to look the match up again.
@@ -2509,10 +2885,10 @@ type correctionCheck struct {
 	ClearBracketReopenPending bool
 }
 
-// applyCorrectionReasonUnderTx applies the correction-reason audit policy to
-// r and returns the match's STORED status. Runs inside WithTransaction
-// (caller MUST hold the per-comp lock via the supplied StoreTx), so the
-// is-completed read is race-free against a concurrent score write.
+// applyCorrectionReason applies the correction-reason audit policy to r over
+// the match's STORED snapshot and returns the verdict with the stored status.
+// The snapshot is read inside WithTransaction (the per-comp lock is held), so
+// the is-completed read is race-free against a concurrent score write.
 //
 // The policy is shared by the single-score and bulk-score paths so the audit
 // rule cannot drift between them (same reason applyKachinukiMerge is shared
@@ -2550,20 +2926,15 @@ type correctionCheck struct {
 // what keeps the flag alive across a pool match's running writes, which would
 // otherwise blank it through the same whole-struct overwrite.
 //
-// Returning the stored status keeps this the transaction's ONLY match lookup:
+// Returning the stored status spares the caller a second match lookup:
 // StoreTx loads deliberately bypass the file cache (state.LoadPoolMatchesLocked
-// / loadBracketLocked), so a second walk is a real os.Open plus a full CSV
+// / loadBracketLocked), so a walk is a real os.Open plus a full CSV
 // parse (and, for a bracket match, an os.ReadFile plus a whole-bracket
-// json.Unmarshal) while the per-comp WRITE lock is held. The caller's
-// stale-after-complete guard reads the returned status instead.
-func applyCorrectionReasonUnderTx(stx state.StoreTx, compID, matchID string, r *state.MatchResult) (correctionCheck, error) {
-	// matchSnapshotOrErr fails CLOSED on a load error: the correction-reason
-	// gate below must not pass on an assumed-running status, silently
-	// overwriting a finalized result without the mandatory reason.
-	snap, _, err := matchSnapshotOrErr(stx, compID, matchID, "correction-reason")
-	if err != nil {
-		return correctionCheck{}, err
-	}
+// json.Unmarshal) while the per-comp WRITE lock is held. The score handler
+// reads the snapshot ONCE for every guard of the write (the self-run judge or
+// the pick judge, then this), and the start gate after it reads the returned
+// status instead.
+func applyCorrectionReason(snap matchSnapshot, r *state.MatchResult) correctionCheck {
 	r.ReopenPending = snap.ReopenPending
 	if r.Status == state.MatchStatusCompleted && snap.Status == state.MatchStatusCompleted {
 		// A finish made BEFORE the stored result (a queued Finish replayed
@@ -2576,12 +2947,12 @@ func applyCorrectionReasonUnderTx(stx state.StoreTx, compID, matchID string, r *
 		// exact replay, which applies, so it is still a correction to
 		// justify.
 		if r.ModifiedAt > 0 && r.ModifiedAt < snap.ResultStamp {
-			return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}, nil
+			return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}
 		}
 		if r.CorrectionReason == "" {
-			return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision, Reject: missingCorrectionReasonError()}, nil
+			return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision, Reject: missingCorrectionReasonError()}
 		}
-		return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}, nil
+		return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}
 	}
 	if r.Status == state.MatchStatusCompleted && snap.ReopenPending {
 		// Ended again after a reason-less reopen: never refused, the
@@ -2591,7 +2962,7 @@ func applyCorrectionReasonUnderTx(stx state.StoreTx, compID, matchID string, r *
 			StoredStatus:              snap.Status,
 			StoredDecision:            snap.Decision,
 			ClearBracketReopenPending: snap.InBracket,
-		}, nil
+		}
 	}
 	// Non-completing write: pin the reason to the STORED one. This is not just a
 	// carry-forward — it also refuses a client-supplied reason on a running
@@ -2605,7 +2976,23 @@ func applyCorrectionReasonUnderTx(stx state.StoreTx, compID, matchID string, r *
 	// without re-checking that a running write still cannot rewrite the note
 	// (mp-gmcg review F5).
 	r.CorrectionReason = snap.CorrectionReason
-	return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}, nil
+	return correctionCheck{StoredStatus: snap.Status, StoredDecision: snap.Decision}
+}
+
+// applyCorrectionReasonUnderTx reads the match's snapshot itself, applies
+// applyCorrectionReason to it and hands the snapshot back: the entry point of
+// bulk-score, one read per entry, whose later guard (the landed picks'
+// judge) compares the match against it. The score handler reads the snapshot
+// once for all its guards and asks applyCorrectionReason directly.
+func applyCorrectionReasonUnderTx(stx state.StoreTx, compID, matchID string, r *state.MatchResult) (correctionCheck, matchSnapshot, error) {
+	// matchSnapshotOrErr fails CLOSED on a load error: the correction-reason
+	// gate must not pass on an assumed-running status, silently overwriting a
+	// finalized result without the mandatory reason.
+	snap, _, err := matchSnapshotOrErr(stx, compID, matchID, "correction-reason")
+	if err != nil {
+		return correctionCheck{}, matchSnapshot{}, err
+	}
+	return applyCorrectionReason(snap, r), snap, nil
 }
 
 // missingCorrectionReasonError is the refusal for overwriting a completed
@@ -2851,7 +3238,10 @@ func scoreResponseWithReopened(result *state.MatchResult, reopened []engine.Reop
 // a newer change to each is stored (or, with heldReason "needs_winner",
 // because applying them would have left the match without the winner it
 // needs, R4); displacedGroups, stored newer scoring this write moved to the
-// history (S2 with R4); heldReason itself; and, when heldReason is
+// history (S2 with R4, answered with heldReason "needs_winner"), or a
+// representative pick stamped after the representative bout's removal that the
+// removal moved (answered with NO heldReason); heldReason itself; and, when
+// heldReason is
 // "default_win_stands", heldDecision naming the decision that closed the
 // match. The ONE owner of those four keys: the score answer, the
 // representative-bout add and remove (handlers_daihyosen.go) and each
@@ -3178,28 +3568,42 @@ func registerScoreHandler(r *gin.RouterGroup, eng ScoringEngine, store Competiti
 			// court, plus participant ineligibility. Withdrawal decisions bypass
 			// so operators can record kiken on matches with ineligible participants.
 			return tx.WithTransaction(id, func(stx state.StoreTx) error {
+				// The stored match is read ONCE, here, for every guard below:
+				// nothing writes it between them (the self-run judge rewrites
+				// result only), and each walk of it is a real file read while
+				// the per-comp write lock is held. Fails CLOSED on a load error
+				// (the correction-reason gate must not pass on an assumed status).
+				snap, found, snapErr := matchSnapshotOrErr(stx, id, mid, "score write")
+				if snapErr != nil {
+					return snapErr
+				}
 				// mp-ba3, bc-dhas: the self-run judge runs under the per-comp
 				// lock, so concurrent anonymous submissions cannot race it. It
 				// may rewrite result's representative bout before the write.
-				if resultSource == "self-reported" {
-					if err := holdSelfReportedWriteUnderTx(stx, id, mid, result, body.StartOnly); err != nil {
+				selfReported := resultSource == "self-reported"
+				if selfReported {
+					if err := holdSelfReportedWriteUnderTx(id, mid, snap, found, result, body.StartOnly); err != nil {
 						engErr = err
 						return nil
 					}
 				}
+				// Who the write seats is judged after the engine has written
+				// it, on what it landed (landedMembersRefusal), and decided
+				// here, before the engine rewrites result: a participant's
+				// numbered rows and the representative bout's picks, the
+				// organiser's picks alone. A start keeps the stored score
+				// whatever it sends, so the row it carries is no pick.
+				judgeLanded := found && !body.StartOnly && introducesJudgedMember(result.SubResults, snap, selfReported)
 				// Correction audit: a completed -> completed overwrite requires a
 				// non-empty CorrectionReason for traceability. Ending a match
 				// reopened without a reason is never refused (operator ruling
 				// 2026-09-25). A genuine first finalization needs no reason but
 				// must carry the STORED one forward. All of that rule lives in
-				// applyCorrectionReasonUnderTx, shared with the bulk-score path. It
+				// applyCorrectionReason, shared with the bulk-score path. It
 				// runs inside the tx so the is-completed read is race-free (same
-				// lock), and the status it returns is reused by the stale-write
-				// guard below rather than looked up a second time.
-				check, snapErr := applyCorrectionReasonUnderTx(stx, id, mid, result)
-				if snapErr != nil {
-					return snapErr
-				}
+				// lock), over the snapshot read above, and the status it returns
+				// is reused by the start gate below.
+				check := applyCorrectionReason(snap, result)
 				existingStatus := check.StoredStatus
 				if check.Reject != nil {
 					engErr = check.Reject
@@ -3250,6 +3654,18 @@ func registerScoreHandler(r *gin.RouterGroup, eng ScoringEngine, store Competiti
 				// includes the K3 rollback for the AlreadyIneligible path,
 				// returning nil here commits whatever final state the engine
 				// settled on.
+				//
+				// The one exception is a refusal of what the write landed:
+				// it is RETURNED, which aborts the transaction, so nothing of
+				// the write survives (no match write, no history line, no
+				// eligibility record). It is judged only for a write the
+				// engine accepted: a superseded or rolled-back one must still
+				// commit its history and its restore.
+				if engErr == nil && judgeLanded {
+					if err := landedMembersRefusal(stx, id, mid, snap, selfReported); err != nil {
+						return err
+					}
+				}
 				if engErr == nil && check.ClearBracketReopenPending {
 					// Only after the write actually landed: this branch commits
 					// even when engErr is set, so discharging any earlier would
@@ -3260,6 +3676,12 @@ func registerScoreHandler(r *gin.RouterGroup, eng ScoringEngine, store Competiti
 				return nil
 			})
 		})
+		// A refusal of what the write landed aborted the transaction
+		// (landedMembersRefusal) and is answered like any other refusal below.
+		var landed *landedWriteRefusal
+		if errors.As(txErr, &landed) {
+			engErr, txErr = landed.refusal, nil
+		}
 		if txErr != nil {
 			// txErr carries errors from CheckCrossCompCourtBusy (cross-comp
 			// court conflict or match-not-found) or from the WithTransaction
diff --git a/internal/mobileapp/handlers_match_kachinuki_test.go b/internal/mobileapp/handlers_match_kachinuki_test.go
index 1ed8204e4..501aa9086 100644
--- a/internal/mobileapp/handlers_match_kachinuki_test.go
+++ b/internal/mobileapp/handlers_match_kachinuki_test.go
@@ -1401,8 +1401,9 @@ func TestReopenHandler_ReEndKeepsAReasonSent(t *testing.T) {
 }
 
 // TestReopenHandler_BulkScoreEndsAReopenWithoutReason pins the same rule on the
-// bulk-score path, which shares applyCorrectionReasonUnderTx with the single
-// score path: a reopened match is ended there without a reason too.
+// bulk-score path, which shares applyCorrectionReason with the single score
+// path (through applyCorrectionReasonUnderTx): a reopened match is ended there
+// without a reason too.
 func TestReopenHandler_BulkScoreEndsAReopenWithoutReason(t *testing.T) {
 	compID := "kachinuki-reopen-bulk"
 	r, store := setupKachinukiScoreServer(t, compID)
diff --git a/internal/mobileapp/handlers_match_test.go b/internal/mobileapp/handlers_match_test.go
index 4999da7d9..51cff67d6 100644
--- a/internal/mobileapp/handlers_match_test.go
+++ b/internal/mobileapp/handlers_match_test.go
@@ -45,7 +45,7 @@ func TestApplyCorrectionReasonUnderTx_FailsClosedOnLoadError(t *testing.T) {
 	var gotErr error
 	txErr := store.WithTransaction("c1", func(stx state.StoreTx) error {
 		r := &state.MatchResult{ID: "m1", Status: state.MatchStatusCompleted}
-		_, gotErr = applyCorrectionReasonUnderTx(stx, "c1", "m1", r)
+		_, _, gotErr = applyCorrectionReasonUnderTx(stx, "c1", "m1", r)
 		return nil
 	})
 	require.NoError(t, txErr)
@@ -3774,7 +3774,7 @@ func seedKcdgBracket(t *testing.T, store *state.Store, compID string) {
 // against: {"error":"downstream_knockout_played","matchId":...,
 // "blockingMatchId":...,"displaced":...,"message":...}. A correctionReason is
 // required first (a completed->completed write is a correction, gated by
-// applyCorrectionReasonUnderTx) so the payload includes one throughout.
+// applyCorrectionReason) so the payload includes one throughout.
 func TestScoreHandler_DownstreamKnockoutPlayed_409Shape(t *testing.T) {
 	r, store, _, _, tempDir := setupTestRouter(t)
 	defer os.RemoveAll(tempDir)
diff --git a/internal/mobileapp/introduces_judged_member_test.go b/internal/mobileapp/introduces_judged_member_test.go
new file mode 100644
index 000000000..18b07c571
--- /dev/null
+++ b/internal/mobileapp/introduces_judged_member_test.go
@@ -0,0 +1,207 @@
+package mobileapp
+
+// introducesJudgedMember is the gate in front of the landed member judge
+// (landedMembersRefusal): the judge re-reads the staged match under the
+// competition's write lock, so it is asked only for a write that INTRODUCES a
+// member id on a judged row, against the match as it stood before the write.
+// A team editor stamps member ids on every row that has a lineup, so an echo
+// of the stored ids is the common case and must read nothing.
+
+import (
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIntroducesJudgedMember(t *testing.T) {
+	rep := func(a, b string) state.SubMatchResult {
+		return state.SubMatchResult{Position: state.DaihyosenSubPosition, SideAMemberID: a, SideBMemberID: b}
+	}
+	bout := func(position int, a, b, winner string) state.SubMatchResult {
+		return state.SubMatchResult{Position: position, SideAMemberID: a, SideBMemberID: b, WinnerMemberID: winner}
+	}
+	// stored builds the snapshot of a match as it stood before the write.
+	stored := func(pairing domain.WinnerAttribution, repBout *state.SubMatchResult, rows ...state.SubMatchResult) matchSnapshot {
+		return matchSnapshot{
+			Pairing: pairing,
+			RepBout: repBout,
+			Stored:  &state.MatchResult{SubResults: rows},
+		}
+	}
+	teams := domain.WinnerAttribution{SideAID: "team-a", SideBID: "team-b"}
+	repRow := rep("ma", "mb")
+
+	tests := []struct {
+		name     string
+		subs     []state.SubMatchResult
+		snap     matchSnapshot
+		numbered bool
+		want     bool
+	}{
+		{
+			name: "no rows",
+			snap: stored(teams, &repRow, repRow),
+			want: false,
+		},
+		{
+			name: "an echo of the stored representative pick",
+			subs: []state.SubMatchResult{rep("ma", "mb")},
+			snap: stored(teams, &repRow, repRow),
+			want: false,
+		},
+		{
+			name: "a representative row that names no member",
+			subs: []state.SubMatchResult{rep("", "")},
+			snap: stored(teams, &repRow, repRow),
+			want: false,
+		},
+		{
+			name: "a representative pick on side A that the stored row does not hold",
+			subs: []state.SubMatchResult{rep("other", "mb")},
+			snap: stored(teams, &repRow, repRow),
+			want: true,
+		},
+		{
+			name: "a representative pick on side B that the stored row does not hold",
+			subs: []state.SubMatchResult{rep("ma", "other")},
+			snap: stored(teams, &repRow, repRow),
+			want: true,
+		},
+		{
+			name: "a representative pick on a match that has no representative bout",
+			subs: []state.SubMatchResult{rep("ma", "")},
+			snap: stored(teams, nil),
+			want: true,
+		},
+		{
+			name: "a representative winner id alone is no pick",
+			subs: []state.SubMatchResult{{Position: state.DaihyosenSubPosition, WinnerMemberID: "ma"}},
+			snap: stored(teams, nil),
+			want: false,
+		},
+		{
+			name:     "an echo of a numbered row's fighters and winner, a participant's write",
+			subs:     []state.SubMatchResult{bout(1, "ma", "mb", "ma")},
+			snap:     stored(teams, nil, bout(1, "ma", "mb", "ma")),
+			numbered: true,
+			want:     false,
+		},
+		{
+			name:     "a numbered row's fighter the stored row does not hold, a participant's write",
+			subs:     []state.SubMatchResult{bout(1, "ma", "other", "")},
+			snap:     stored(teams, nil, bout(1, "ma", "mb", "")),
+			numbered: true,
+			want:     true,
+		},
+		{
+			name:     "a numbered row's winner the stored row does not hold, a participant's write",
+			subs:     []state.SubMatchResult{bout(1, "ma", "mb", "mb")},
+			snap:     stored(teams, nil, bout(1, "ma", "mb", "ma")),
+			numbered: true,
+			want:     true,
+		},
+		{
+			name:     "a numbered row at a position the stored match lacks, a participant's write",
+			subs:     []state.SubMatchResult{bout(3, "ma", "", "")},
+			snap:     stored(teams, nil, bout(1, "ma", "mb", "")),
+			numbered: true,
+			want:     true,
+		},
+		{
+			name:     "a numbered row at a position the stored match lacks that names no member",
+			subs:     []state.SubMatchResult{bout(3, "", "", "")},
+			snap:     stored(teams, nil, bout(1, "ma", "mb", "")),
+			numbered: true,
+			want:     false,
+		},
+		{
+			name:     "a numbered row's fighter over a stored side that holds none, on a match whose stored sides carry no team id",
+			subs:     []state.SubMatchResult{bout(1, "ma", "", "")},
+			snap:     stored(domain.WinnerAttribution{}, nil, bout(1, "", "", "")),
+			numbered: true,
+			want:     true,
+		},
+		{
+			name: "a representative pick over a stored side that holds none, on a match whose stored sides carry no team id",
+			subs: []state.SubMatchResult{rep("ma", "")},
+			snap: stored(domain.WinnerAttribution{}, &state.SubMatchResult{Position: state.DaihyosenSubPosition}, state.SubMatchResult{Position: state.DaihyosenSubPosition}),
+			want: true,
+		},
+		{
+			name: "the organiser's numbered rows are not judged",
+			subs: []state.SubMatchResult{bout(1, "other", "other", "other")},
+			snap: stored(teams, nil, bout(1, "ma", "mb", "ma")),
+			want: false,
+		},
+		{
+			name:     "a write on a snapshot that holds no stored match introduces every id it carries",
+			subs:     []state.SubMatchResult{bout(1, "ma", "", "")},
+			snap:     matchSnapshot{},
+			numbered: true,
+			want:     true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, introducesJudgedMember(tt.subs, tt.snap, tt.numbered))
+		})
+	}
+}
+
+// TestJudgedRows pins the ONE selection the gate (introducesJudgedMember, on the
+// payload's rows) and the judge (membersOutsideTeams, on the landed rows) both
+// read: which rows are judged, and against which stored row. Each used to walk
+// the rows and choose for itself, tied only by a comment, so a row or a field
+// added to one was silently missing from the other.
+func TestJudgedRows(t *testing.T) {
+	t.Parallel()
+
+	rep := func(a, b string) state.SubMatchResult {
+		return state.SubMatchResult{Position: state.DaihyosenSubPosition, SideAMemberID: a, SideBMemberID: b}
+	}
+	bout := func(position int, a, b string) state.SubMatchResult {
+		return state.SubMatchResult{Position: position, SideAMemberID: a, SideBMemberID: b}
+	}
+	storedRep := rep("sa", "sb")
+	before := matchSnapshot{
+		RepBout: &storedRep,
+		Stored: &state.MatchResult{SubResults: []state.SubMatchResult{
+			bout(1, "m1a", "m1b"), bout(2, "m2a", "m2b"), storedRep,
+		}},
+	}
+
+	t.Run("the representative bout is judged for anyone, against the stored representative row", func(t *testing.T) {
+		got := judgedRows([]state.SubMatchResult{bout(1, "x", "y"), rep("p", "q")}, before, false)
+		require.Len(t, got, 1, "a numbered row is left out unless numbered")
+		assert.True(t, got[0].rep)
+		assert.Equal(t, rep("p", "q"), got[0].row)
+		assert.Equal(t, storedRep, got[0].stored)
+	})
+
+	t.Run("a match with no stored representative row compares the pick with the empty row", func(t *testing.T) {
+		got := judgedRows([]state.SubMatchResult{rep("p", "")}, matchSnapshot{}, false)
+		require.Len(t, got, 1)
+		assert.True(t, got[0].rep)
+		assert.Equal(t, state.SubMatchResult{}, got[0].stored)
+	})
+
+	t.Run("numbered rows are judged for a participant, each against the stored row at its position", func(t *testing.T) {
+		got := judgedRows([]state.SubMatchResult{bout(2, "x", "y"), rep("p", "q"), bout(9, "z", "")}, before, true)
+		require.Len(t, got, 3, "rows come in the order they were given")
+		assert.False(t, got[0].rep)
+		assert.Equal(t, bout(2, "m2a", "m2b"), got[0].stored)
+		assert.True(t, got[1].rep)
+		assert.Equal(t, storedRep, got[1].stored)
+		assert.False(t, got[2].rep)
+		assert.Equal(t, state.SubMatchResult{}, got[2].stored, "a position the stored match lacks holds no id")
+	})
+
+	t.Run("a snapshot with no stored match judges every numbered row against the empty row", func(t *testing.T) {
+		got := judgedRows([]state.SubMatchResult{bout(1, "x", "")}, matchSnapshot{}, true)
+		require.Len(t, got, 1)
+		assert.Equal(t, state.SubMatchResult{}, got[0].stored)
+	})
+}
diff --git a/internal/mobileapp/organiser_rep_pick_judge_test.go b/internal/mobileapp/organiser_rep_pick_judge_test.go
new file mode 100644
index 000000000..b1fb94d93
--- /dev/null
+++ b/internal/mobileapp/organiser_rep_pick_judge_test.go
@@ -0,0 +1,475 @@
+package mobileapp
+
+// A representative pick is judged for every caller (PR #463, round 13, gap H).
+//
+// The pick is a bare member id on a side whose team a correction elsewhere can
+// change under an open editor (the re-seat), and every surface resolves it later
+// through the side's team, so an id that team does not hold shows as nobody.
+// The organiser's write is therefore judged exactly as a participant's is
+// (400 team_member_not_in_team), scoped the same way: only a side the merge will
+// apply, only an id the stored row does not already hold, only against a side
+// that carries a team id. The organiser's rights are untouched: they can pick
+// again at once, on a finished match too (only team membership is read).
+//
+// The fixture is repBoutFixture (self_run_daihyosen_test.go); every request here
+// carries the main password, in a self-run tournament and in an officiated one.
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// organiserPassword is the main password (handlers_lineup_changed_test.go).
+const (
+	// unheldMemberID is a well-formed id no team holds.
+	unheldMemberID = "99999999-9999-4999-8999-999999999999"
+	notOnTeamBody  = "The representative chosen is not on this team. Pick again from the list."
+)
+
+var organiserModes = []struct {
+	name    string
+	selfRun bool
+}{
+	{"self-run tournament, organiser password", true},
+	{"officiated tournament", false},
+}
+
+// organiserPickFixture is a repBoutFixture whose representative bout the
+// organiser added, with each team's members read once.
+type organiserPickFixture struct {
+	*repBoutFixture
+	membersA, membersB []string
+}
+
+func newOrganiserPickFixture(t *testing.T, selfRun bool) *organiserPickFixture {
+	t.Helper()
+	f := newRepBoutFixture(t, selfRun)
+	w := f.send(http.MethodPost, repBoutMatchPath+"/daihyosen", organiserPassword, map[string]any{"modifiedAt": f.now})
+	require.Equal(t, http.StatusOK, w.Code, "the organiser adds the representative bout: %s", w.Body.String())
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	ids := func(teamID string) []string {
+		var out []string
+		for _, m := range squads[teamID] {
+			out = append(out, m.ID)
+		}
+		return out
+	}
+	p := &organiserPickFixture{repBoutFixture: f, membersA: ids(repBoutTeamAID), membersB: ids(repBoutTeamBID)}
+	require.GreaterOrEqual(t, len(p.membersA), 2, "team A is seeded with members")
+	require.GreaterOrEqual(t, len(p.membersB), 2, "team B is seeded with members")
+	return p
+}
+
+// sheetWith is the team sheet with the representative row naming a on side A
+// and b on side B ("" names no one), stamped at, naming the groups in changed
+// (nil names none, as an older client sends it).
+func sheetWith(status state.MatchStatus, winner string, at int64, changed []string, row map[string]any, a, b string) map[string]any {
+	row["sideAMemberId"], row["sideBMemberId"] = a, b
+	sheet := scoreSheet(status, winner, at, row)
+	if changed != nil {
+		sheet["changed"] = changed
+	}
+	return sheet
+}
+
+// pick sends a running sheet from the organiser.
+func (p *organiserPickFixture) pick(at int64, changed []string, a, b string) *httptest.ResponseRecorder {
+	row := repBoutRow([]string{}, []string{}, "")
+	return p.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword,
+		sheetWith(state.MatchStatusRunning, "", at, changed, row, a, b))
+}
+
+func requireNotOnTeam(t *testing.T, w *httptest.ResponseRecorder) {
+	t.Helper()
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", notOnTeamBody)
+}
+
+// teamMembersUnreadableBody is the sentence the page shows, as it is, when the
+// members file cannot be read.
+const teamMembersUnreadableBody = "The team members could not be read, so this choice cannot be checked. The organiser needs to check team-members.yaml in the tournament data."
+
+func requireTeamMembersUnreadable(t *testing.T, w *httptest.ResponseRecorder) {
+	t.Helper()
+	requireRefusal(t, w, http.StatusConflict, "team_members_unreadable", teamMembersUnreadableBody)
+}
+
+// An organiser's pick of a member the side's team does not hold is refused like
+// a participant's, and nothing is written: not the id, not the pick's stamp.
+func TestOrganiser_RepresentativeMembersMustBeOnTheirTeam(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			cases := []struct {
+				name    string
+				changed []string
+				a, b    func(p *organiserPickFixture) string
+			}{
+				{"another team's member on side A", []string{state.GroupRepPickA},
+					func(p *organiserPickFixture) string { return p.membersB[0] }, nil},
+				{"a member no team holds on side A", []string{state.GroupRepPickA},
+					func(*organiserPickFixture) string { return unheldMemberID }, nil},
+				{"another team's member on side B", []string{state.GroupRepPickB}, nil,
+					func(p *organiserPickFixture) string { return p.membersA[0] }},
+				{"an older client that names no groups", nil,
+					func(p *organiserPickFixture) string { return p.membersB[0] }, nil},
+			}
+			for _, tc := range cases {
+				t.Run(tc.name, func(t *testing.T) {
+					p := newOrganiserPickFixture(t, mode.selfRun)
+					var a, b string
+					if tc.a != nil {
+						a = tc.a(p)
+					}
+					if tc.b != nil {
+						b = tc.b(p)
+					}
+					before := storedB1(t, p.store, "c1")
+
+					w := p.pick(p.now+100, tc.changed, a, b)
+					requireNotOnTeam(t, w)
+					after := storedB1(t, p.store, "c1")
+					assert.Equal(t, *p.storedRepBout(t), before.SubResults[state.DaihyosenSubIndex(before.SubResults)],
+						"a refused pick writes nothing")
+					assert.Equal(t, before.GroupStamp(state.GroupRepPickA), after.GroupStamp(state.GroupRepPickA))
+					assert.Equal(t, before.GroupStamp(state.GroupRepPickB), after.GroupStamp(state.GroupRepPickB))
+					assert.Empty(t, p.storedRepBout(t).SideAMemberID)
+					assert.Empty(t, p.storedRepBout(t).SideBMemberID)
+
+					// The organiser's rights are untouched: their own team's
+					// members are accepted at once.
+					w = p.pick(p.now+200, tc.changed, p.membersA[0], p.membersB[0])
+					require.Equal(t, http.StatusOK, w.Code, "each side's own member is accepted: %s", w.Body.String())
+					stored := p.storedRepBout(t)
+					if tc.changed == nil || tc.changed[0] == state.GroupRepPickA {
+						assert.Equal(t, p.membersA[0], stored.SideAMemberID)
+					}
+					if tc.changed == nil || tc.changed[0] == state.GroupRepPickB {
+						assert.Equal(t, p.membersB[0], stored.SideBMemberID)
+					}
+				})
+			}
+		})
+	}
+}
+
+// The merge holds a pick stamped before the stored pick's, and a write whose
+// every group is held is answered superseded: the judge must not refuse what the
+// merge was going to keep in the history anyway.
+func TestOrganiser_AStalePickTheMergeHoldsIsNotRefused(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			w := p.pick(p.now, nil, p.membersA[0], "")
+			require.Equal(t, http.StatusOK, w.Code, "a valid pick: %s", w.Body.String())
+			before := *p.storedRepBout(t)
+			require.Equal(t, p.membersA[0], before.SideAMemberID)
+
+			w = p.pick(p.now-100, nil, p.membersB[0], "")
+			require.Equal(t, http.StatusOK, w.Code, "a write stamped before the stored pick is held, not refused: %s", w.Body.String())
+			assert.Contains(t, w.Body.String(), `"superseded"`)
+			assert.Equal(t, before, *p.storedRepBout(t), "the held pick is not written")
+
+			requireNotOnTeam(t, p.pick(p.now, nil, p.membersB[0], ""))
+			requireNotOnTeam(t, p.pick(p.now+100, nil, p.membersB[0], ""))
+			assert.Equal(t, before, *p.storedRepBout(t), "a refused pick writes nothing")
+		})
+	}
+}
+
+// A finish stamped before the stored verdict that names another winner is held
+// WHOLE by the merge (HoldReasonFinishAtomic): its picks land nowhere, even when
+// their own stamps are newer than the stored picks'. The judge reads what the
+// write landed, and a held write lands nothing, so such a write is answered
+// superseded and kept in the history, never refused for a pick that was not
+// written.
+func TestOrganiser_AStaleFinishWithAForeignPickIsSupersededNotRefused(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			// The match finished on TeamA at p.now; its representative bout and
+			// the picks on it were dated before that.
+			p.setB1(t, func(bm *state.BracketMatch) {
+				bm.Status, bm.Winner, bm.WinnerID = state.MatchStatusCompleted, "TeamA", repBoutTeamAID
+				bm.ModifiedAt = p.now
+				row := &bm.SubResults[state.DaihyosenSubIndex(bm.SubResults)]
+				row.IpponsA, row.Winner = []string{"M"}, "TeamA"
+				bm.GroupStamps = map[string]int64{
+					state.GroupResult: p.now,
+					state.BoutGroup(state.DaihyosenSubPosition): p.now - 40_000,
+					state.GroupRepPickA:                         p.now - 50_000,
+					state.GroupRepPickB:                         p.now - 50_000,
+				}
+			})
+			before := storedB1(t, p.store, "c1")
+
+			// Another winner, stamped between the picks' stamps and the verdict's.
+			stale := sheetWith(state.MatchStatusCompleted, "TeamB", p.now-20_000, nil,
+				repBoutRow([]string{}, []string{"M"}, "TeamB"), unheldMemberID, "")
+			w := p.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword, stale)
+			require.Equal(t, http.StatusOK, w.Code, "held whole, not refused for its pick: %s", w.Body.String())
+			assert.Contains(t, w.Body.String(), `"superseded"`)
+			assert.Equal(t, before, storedB1(t, p.store, "c1"), "a held write changes nothing")
+			assert.Empty(t, p.storedRepBout(t).SideAMemberID)
+		})
+	}
+}
+
+// A write answers for what it introduces, not for what it inherited: a stored
+// id the side's team does not hold (a re-seat left it) is echoed back by an
+// editor that has not seen the re-seat, and that is not a pick.
+func TestOrganiser_AnInheritedPickIsNotJudged(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			p.setB1(t, func(bm *state.BracketMatch) {
+				bm.SubResults[state.DaihyosenSubIndex(bm.SubResults)].SideAMemberID = p.membersB[0]
+			})
+
+			w := p.pick(p.now+200, nil, p.membersB[0], "")
+			require.Equal(t, http.StatusOK, w.Code, "the echo of the stored pick is kept: %s", w.Body.String())
+			assert.Equal(t, p.membersB[0], p.storedRepBout(t).SideAMemberID)
+
+			w = p.pick(p.now+250, nil, p.membersB[0], p.membersB[1])
+			require.Equal(t, http.StatusOK, w.Code, "an echo beside a valid new pick: %s", w.Body.String())
+			assert.Equal(t, p.membersB[0], p.storedRepBout(t).SideAMemberID)
+			assert.Equal(t, p.membersB[1], p.storedRepBout(t).SideBMemberID)
+
+			requireNotOnTeam(t, p.pick(p.now+300, nil, p.membersB[1], p.membersB[1]))
+			assert.Equal(t, p.membersB[0], p.storedRepBout(t).SideAMemberID, "a refused pick writes nothing")
+		})
+	}
+}
+
+// Only a side the write names is judged, as for a participant: an echo of an id
+// the side's team no longer holds beside the named side is not refused.
+func TestOrganiser_ASideTheWriteDoesNotNameIsNotJudged(t *testing.T) {
+	p := newOrganiserPickFixture(t, true)
+	w := p.pick(p.now+300, []string{state.GroupRepPickA}, p.membersA[0], p.membersA[1])
+	require.Equal(t, http.StatusOK, w.Code, "side B is not named, so it is not judged: %s", w.Body.String())
+	assert.Equal(t, p.membersA[0], p.storedRepBout(t).SideAMemberID, "the named side applies")
+	assert.Empty(t, p.storedRepBout(t).SideBMemberID, "and the side it did not name is not written")
+
+	requireNotOnTeam(t, p.pick(p.now+400, []string{state.GroupRepPickA, state.GroupRepPickB}, p.membersA[0], p.membersA[1]))
+}
+
+// A pick on a side with no team id has nothing to be judged against.
+func TestOrganiser_APickOnAnIdlessSideIsNotJudged(t *testing.T) {
+	p := newOrganiserPickFixture(t, true)
+	p.setB1(t, func(bm *state.BracketMatch) { bm.SideAID = "" })
+
+	w := p.pick(p.now+200, nil, p.membersB[0], "")
+	require.Equal(t, http.StatusOK, w.Code, "the pick on an id-less side is accepted: %s", w.Body.String())
+	assert.Equal(t, p.membersB[0], p.storedRepBout(t).SideAMemberID)
+}
+
+// A pick on a finished match is judged like any other, and an invalid one is
+// refused for the pick, never for the finish (409 result_finalized is a
+// participant's refusal; the organiser corrects a finished match).
+func TestOrganiser_PickOnAFinishedMatchIsJudgedButNotRefusedForTheFinish(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			finish := sheetWith(state.MatchStatusCompleted, "TeamA", p.now+100, nil,
+				repBoutRow([]string{"M"}, []string{}, "TeamA"), "", "")
+			w := p.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword, finish)
+			require.Equal(t, http.StatusOK, w.Code, "the organiser finishes the match: %s", w.Body.String())
+			require.Equal(t, state.MatchStatusCompleted, storedB1(t, p.store, "c1").Status)
+
+			correct := func(at int64, a, b string) *httptest.ResponseRecorder {
+				sheet := sheetWith(state.MatchStatusCompleted, "TeamA", at, []string{state.GroupRepPickA, state.GroupRepPickB},
+					repBoutRow([]string{"M"}, []string{}, "TeamA"), a, b)
+				sheet["correctionReason"] = "the wrong fighter was picked"
+				return p.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword, sheet)
+			}
+
+			w = correct(p.now+200, p.membersB[0], "")
+			requireNotOnTeam(t, w)
+			assert.Empty(t, p.storedRepBout(t).SideAMemberID, "a refused pick writes nothing")
+
+			w = correct(p.now+300, p.membersA[0], p.membersB[0])
+			require.Equal(t, http.StatusOK, w.Code, "the organiser corrects a finished match: %s", w.Body.String())
+			assert.Equal(t, state.MatchStatusCompleted, storedB1(t, p.store, "c1").Status)
+			assert.Equal(t, p.membersA[0], p.storedRepBout(t).SideAMemberID)
+			assert.Equal(t, p.membersB[0], p.storedRepBout(t).SideBMemberID)
+		})
+	}
+}
+
+// A start keeps the stored score whatever it sends (startOnly), so the row it
+// carries is not a pick and is not judged.
+func TestOrganiser_StartOnlyIsNotJudged(t *testing.T) {
+	p := newOrganiserPickFixture(t, true)
+	sheet := sheetWith(state.MatchStatusRunning, "", p.now+100, nil,
+		repBoutRow([]string{}, []string{}, ""), p.membersB[0], "")
+	sheet["startOnly"] = true
+
+	w := p.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword, sheet)
+	require.Equal(t, http.StatusOK, w.Code, "a start is not judged on the row it carries: %s", w.Body.String())
+	assert.Empty(t, p.storedRepBout(t).SideAMemberID, "and the stored score is kept")
+}
+
+// A write whose representative row names no member reads no team members: with
+// the file unreadable it is still answered, while a pick fails closed.
+func TestOrganiser_AWriteThatPicksNobodyReadsNoTeamMembers(t *testing.T) {
+	p := newOrganiserPickFixture(t, true)
+	require.NoError(t, os.WriteFile(
+		filepath.Join(p.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+		[]byte("not: [valid yaml"), 0o600))
+
+	w := p.pick(p.now+100, nil, "", "")
+	require.Equal(t, http.StatusOK, w.Code, "no pick, nothing to judge: %s", w.Body.String())
+
+	w = p.pick(p.now+200, nil, p.membersA[0], "")
+	requireTeamMembersUnreadable(t, w)
+	assert.Empty(t, p.storedRepBout(t).SideAMemberID)
+}
+
+// A members file that cannot be read refuses a pick that needs it with a
+// refusal the queue does not retry (409, never the 500 it retries forever), for
+// the organiser as for a participant, and writes nothing.
+func TestOrganiser_UnreadableTeamMembersRefusesThePickTerminally(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			require.NoError(t, os.WriteFile(
+				filepath.Join(p.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+				[]byte("not: [valid yaml"), 0o600))
+			before := p.storedState(t)
+
+			requireTeamMembersUnreadable(t, p.pick(p.now+100, nil, p.membersA[0], ""))
+			assert.Equal(t, before, p.storedState(t), "a refused pick writes nothing, not even its history line")
+		})
+	}
+}
+
+// The organiser's write can create the representative row (a participant's
+// never does), and every pick on a row it creates is introduced: a member no
+// team holds is refused there too, and no row is created.
+func TestOrganiser_APickOnARowTheWriteCreatesIsJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	sheet := sheetWith(state.MatchStatusRunning, "", f.now+100, nil,
+		repBoutRow([]string{}, []string{}, ""), unheldMemberID, "")
+
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", organiserPassword, sheet)
+	requireNotOnTeam(t, w)
+	assert.False(t, carriesDaihyosenRow(storedB1(t, f.store, "c1").SubResults), "a refused write creates nothing")
+}
+
+// Bulk-score takes the client's subResults entry by entry, each written in its
+// own transaction, so a representative pick on an entry is judged like /score's
+// and a refused entry stores nothing, the history line included, while the
+// entries beside it are written.
+func TestOrganiser_BulkScoreJudgesTheRepresentativePicksPerEntry(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			before := p.storedState(t)
+
+			entry := func(a string) map[string]any {
+				sheet := sheetWith(state.MatchStatusRunning, "", p.now+100, nil, repBoutRow([]string{}, []string{}, ""), a, "")
+				sheet["id"] = "B1"
+				return sheet
+			}
+			bulk := func(entries ...map[string]any) (succeeded int, errs []map[string]any) {
+				w := p.send(http.MethodPost, "/api/competitions/c1/matches/bulk-score", organiserPassword, entries)
+				require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+				var body struct {
+					Succeeded int              `json:"succeeded"`
+					Errors    []map[string]any `json:"errors"`
+				}
+				require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))
+				return body.Succeeded, body.Errors
+			}
+
+			succeeded, errs := bulk(entry(p.membersB[0]))
+			assert.Zero(t, succeeded)
+			require.Len(t, errs, 1)
+			assert.Equal(t, "B1", errs[0]["matchId"])
+			assert.Equal(t, codeTeamMemberNotInTeam, errs[0]["reason"])
+			assert.Equal(t, notOnTeamBody, errs[0]["error"])
+			assert.Equal(t, before, p.storedState(t), "the refused entry stores nothing, not even its history line")
+
+			succeeded, errs = bulk(entry(p.membersA[0]))
+			assert.Equal(t, 1, succeeded, "the side's own member is accepted: %v", errs)
+			assert.Equal(t, p.membersA[0], p.storedRepBout(t).SideAMemberID)
+		})
+	}
+}
+
+// PIN, green by design (the loop already isolates entries: each runs in its own
+// WithTransaction and a refusal is recorded against that entry and moved past).
+// The test above sends one entry per request, which cannot show it: here the
+// FIRST entry of one request carries a foreign pick and the SECOND, for the same
+// match, a valid one. The first is refused and stores nothing, history line
+// included, and does not poison the second, which is written.
+func TestOrganiser_BulkScoreRefusesOneEntryAndWritesTheNextOnTheSameMatch(t *testing.T) {
+	for _, mode := range organiserModes {
+		t.Run(mode.name, func(t *testing.T) {
+			p := newOrganiserPickFixture(t, mode.selfRun)
+			before := p.storedState(t)
+
+			entry := func(at int64, a string) map[string]any {
+				sheet := sheetWith(state.MatchStatusRunning, "", at, nil, repBoutRow([]string{}, []string{}, ""), a, "")
+				sheet["id"] = "B1"
+				return sheet
+			}
+			w := p.send(http.MethodPost, "/api/competitions/c1/matches/bulk-score", organiserPassword, []map[string]any{
+				entry(p.now+100, p.membersB[0]), // a member of the other team
+				entry(p.now+200, p.membersA[0]), // the side's own member
+			})
+			require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+			var body struct {
+				Succeeded int              `json:"succeeded"`
+				Errors    []map[string]any `json:"errors"`
+			}
+			require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))
+
+			assert.Equal(t, 1, body.Succeeded, "the valid entry is written: %v", body.Errors)
+			require.Len(t, body.Errors, 1)
+			assert.Equal(t, "B1", body.Errors[0]["matchId"])
+			assert.Equal(t, codeTeamMemberNotInTeam, body.Errors[0]["reason"])
+			assert.Equal(t, notOnTeamBody, body.Errors[0]["error"])
+
+			assert.Equal(t, p.membersA[0], p.storedRepBout(t).SideAMemberID, "the second entry landed")
+			assert.Empty(t, p.storedRepBout(t).SideBMemberID)
+			after := p.storedState(t)
+			assert.Len(t, after.history, len(before.history)+1,
+				"one history line, the written entry's: the refused entry left none")
+		})
+	}
+}
+
+// A members file that cannot be read refuses a bulk entry that needs it, with
+// the reason a client can branch on, and the entry stores nothing.
+func TestOrganiser_BulkScoreRefusesAPickWhenTheTeamMembersCannotBeRead(t *testing.T) {
+	p := newOrganiserPickFixture(t, true)
+	require.NoError(t, os.WriteFile(
+		filepath.Join(p.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+		[]byte("not: [valid yaml"), 0o600))
+	before := p.storedState(t)
+
+	entry := sheetWith(state.MatchStatusRunning, "", p.now+100, nil, repBoutRow([]string{}, []string{}, ""), p.membersA[0], "")
+	entry["id"] = "B1"
+	w := p.send(http.MethodPost, "/api/competitions/c1/matches/bulk-score", organiserPassword, []any{entry})
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+
+	var body struct {
+		Succeeded int `json:"succeeded"`
+		Errors    []struct {
+			Reason string `json:"reason"`
+		} `json:"errors"`
+	}
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))
+	assert.Zero(t, body.Succeeded)
+	require.Len(t, body.Errors, 1)
+	assert.Equal(t, errTeamMembersUnreadable.code, body.Errors[0].Reason)
+	assert.Equal(t, before, p.storedState(t), "the refused entry stores nothing")
+}
diff --git a/internal/mobileapp/self_run_bout_members_test.go b/internal/mobileapp/self_run_bout_members_test.go
new file mode 100644
index 000000000..a7af86767
--- /dev/null
+++ b/internal/mobileapp/self_run_bout_members_test.go
@@ -0,0 +1,357 @@
+package mobileapp
+
+// A participant's fighters are their team's, and a bout's winner is one of its
+// two fighters. The member judge (landedMembersRefusal) refuses a score write
+// that LANDS, on a numbered bout row, a side member id the side's team does not
+// hold (400 team_member_not_in_team), or a winnerMemberId that is not one of the
+// row's two side ids (400 winner_member_not_in_bout), and the refused write
+// leaves the match and its history untouched. Landed means the stored row now
+// holds it and did not before, at the same position: an id the row already held
+// is never judged, so a row that a correction left with another team's fighter,
+// or a stale winner id, does not refuse every later write. The organiser is not
+// judged here (the lineup's always-editable rule), and a members file that
+// cannot be read refuses the write with a terminal 409 only when a row actually
+// needs it.
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
+	"github.com/gitrgoliveira/bracket-creator/internal/state"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	fighterNotOnTeamBody = "The fighter chosen is not on this team. Pick again from the list."
+	winnerNotInBoutBody  = "The winner recorded is not one of the two fighters in this bout."
+)
+
+// boutIDs are the member ids a numbered row carries; an empty one is left off
+// the row, as the editor leaves it off.
+type boutIDs struct{ a, b, winner string }
+
+// bouts sends the team sheet with the member ids it names on its numbered rows.
+func (f *repBoutFixture) bouts(password string, at int64, ids map[int]boutIDs) *httptest.ResponseRecorder {
+	sheet := scoreSheet(state.MatchStatusRunning, "", at, nil)
+	rows := sheet["subResults"].([]any)
+	for pos, id := range ids {
+		row := rows[pos-1].(map[string]any)
+		for key, v := range map[string]string{"sideAMemberId": id.a, "sideBMemberId": id.b, "winnerMemberId": id.winner} {
+			if v != "" {
+				row[key] = v
+			}
+		}
+	}
+	return f.send(http.MethodPut, repBoutMatchPath+"/score", password, sheet)
+}
+
+// teamMembers are the two teams' members, seeded.
+func (f *repBoutFixture) teamMembers(t *testing.T) (a, b []domain.TeamMember) {
+	t.Helper()
+	f.store.EnsureLegacyUpgraded("c1")
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	a, b = squads[repBoutTeamAID], squads[repBoutTeamBID]
+	require.GreaterOrEqual(t, len(a), 2, "team A is seeded with members")
+	require.GreaterOrEqual(t, len(b), 2, "team B is seeded with members")
+	return a, b
+}
+
+func (f *repBoutFixture) storedBout(t *testing.T, position int) state.SubMatchResult {
+	t.Helper()
+	for _, sub := range storedB1(t, f.store, "c1").SubResults {
+		if sub.Position == position {
+			return sub
+		}
+	}
+	t.Fatalf("B1 has no bout %d", position)
+	return state.SubMatchResult{}
+}
+
+func (f *repBoutFixture) corruptTeamMembers(t *testing.T) {
+	t.Helper()
+	require.NoError(t, os.WriteFile(
+		filepath.Join(f.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+		[]byte("not: [valid yaml"), 0o600))
+}
+
+func TestSelfRun_NumberedRowFighterMustBeOnTheirTeam(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+
+	for name, ids := range map[string]boutIDs{
+		"side A fielding the other team's member": {a: b[0].ID},
+		"side B fielding the other team's member": {b: a[0].ID},
+		"an id no team holds":                     {a: "00000000-0000-4000-8000-000000000000"},
+		"one good fighter and one foreign one":    {a: a[0].ID, b: a[1].ID},
+	} {
+		t.Run(name, func(t *testing.T) {
+			w := f.bouts("", f.now+100, map[int]boutIDs{1: ids})
+			requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", fighterNotOnTeamBody)
+			bout := f.storedBout(t, 1)
+			assert.Empty(t, bout.SideAMemberID, "a refused write writes nothing")
+			assert.Empty(t, bout.SideBMemberID)
+		})
+	}
+}
+
+func TestSelfRun_NumberedRowFighterOfOwnTeamPasses(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+
+	w := f.bouts("", f.now+100, map[int]boutIDs{1: {a: a[0].ID, b: b[0].ID, winner: a[0].ID}, 2: {a: a[1].ID, b: b[1].ID, winner: b[1].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "each side's own member, and a winner who is one of the two: %s", w.Body.String())
+	assert.Equal(t, a[0].ID, f.storedBout(t, 1).SideAMemberID)
+	assert.Equal(t, b[0].ID, f.storedBout(t, 1).SideBMemberID)
+	assert.Equal(t, b[1].ID, f.storedBout(t, 2).SideBMemberID)
+}
+
+// An id the stored row already holds is not what the write introduces, so it is
+// not judged, and the members file is not even read (it is corrupt here).
+func TestSelfRun_NumberedRowInheritedFighterIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	_, b := f.teamMembers(t)
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[0].SideAMemberID = b[0].ID // a correction seated another team on side A
+	})
+	f.corruptTeamMembers(t)
+
+	w := f.bouts("", f.now+100, map[int]boutIDs{1: {a: b[0].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "the echo of the stored id is kept: %s", w.Body.String())
+	assert.Equal(t, b[0].ID, f.storedBout(t, 1).SideAMemberID)
+}
+
+func TestSelfRun_WinnerMemberMustBeAFighterOfTheBout(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+
+	for name, ids := range map[string]boutIDs{
+		"a member who is not in the bout":          {a: a[0].ID, b: b[0].ID, winner: a[1].ID},
+		"an id no team holds":                      {a: a[0].ID, b: b[0].ID, winner: "00000000-0000-4000-8000-000000000000"},
+		"a winner on a row that names no fighters": {winner: a[0].ID},
+	} {
+		t.Run(name, func(t *testing.T) {
+			w := f.bouts("", f.now+100, map[int]boutIDs{1: ids})
+			requireRefusal(t, w, http.StatusBadRequest, "winner_member_not_in_bout", winnerNotInBoutBody)
+			assert.Empty(t, f.storedBout(t, 1).WinnerMemberID, "a refused write writes nothing")
+		})
+	}
+}
+
+// A winner id the stored row already holds is not judged, whoever it names: a
+// legacy row, a correction that seated another team and a renamed member leave
+// such ids behind, and refusing them would refuse every later write.
+func TestSelfRun_InheritedWinnerMemberIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, _ := f.teamMembers(t)
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[0].WinnerMemberID = a[1].ID // names neither of the row's (empty) sides
+	})
+	f.corruptTeamMembers(t)
+
+	w := f.bouts("", f.now+100, map[int]boutIDs{1: {winner: a[1].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "the stale winner id is echoed, not introduced: %s", w.Body.String())
+}
+
+// A row silent about a side keeps the stored row's id there (the kachinuki
+// merge's inherit), so a winner who is the stored fighter of that side is one
+// of the bout's two fighters and passes.
+func TestSelfRun_WinnerMemberMayBeTheStoredFighterOfASilentSide(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, _ := f.teamMembers(t)
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[0].SideAMemberID = a[0].ID
+	})
+
+	w := f.bouts("", f.now+100, map[int]boutIDs{1: {winner: a[0].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "the row names no side, the stored row's side A is the winner: %s", w.Body.String())
+}
+
+// The organiser's write is not judged on numbered rows (as the lineup PUT is
+// always editable for the organiser).
+func TestOrganiser_NumberedRowsAreNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+
+	w := f.bouts(organiserPassword, f.now+100, map[int]boutIDs{1: {a: b[0].ID, b: a[0].ID, winner: a[1].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "the organiser may seat any member: %s", w.Body.String())
+	assert.Equal(t, b[0].ID, f.storedBout(t, 1).SideAMemberID)
+}
+
+// A write whose ids all equal the stored row's reads no members at all.
+func TestSelfRun_AnEchoedIdReadsNoTeamMembers(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, _ := f.teamMembers(t)
+	w := f.bouts("", f.now+100, map[int]boutIDs{1: {a: a[0].ID}})
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+	f.corruptTeamMembers(t)
+
+	w = f.bouts("", f.now+200, map[int]boutIDs{1: {a: a[0].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "nothing is introduced, so nothing is read: %s", w.Body.String())
+}
+
+// A fighter that needs the members file while it cannot be read is refused
+// terminally, for a numbered row as for a representative pick.
+func TestSelfRun_UnreadableTeamMembersRefusesANumberedRowTerminally(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, _ := f.teamMembers(t)
+	f.corruptTeamMembers(t)
+	before := f.storedState(t)
+
+	requireTeamMembersUnreadable(t, f.bouts("", f.now+100, map[int]boutIDs{1: {a: a[0].ID}}))
+	assert.Equal(t, before, f.storedState(t), "a refused write writes nothing, not even its history line")
+}
+
+// The participant's lineup PUT is refused the same way when the members file
+// cannot be read (it was a 500 the offline queue retried forever).
+func TestSelfRun_UnreadableTeamMembersRefusesTheLineupTerminally(t *testing.T) {
+	f := newTeamWritesFixture(t, true)
+	require.NoError(t, os.WriteFile(
+		filepath.Join(f.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+		[]byte("not: [valid yaml"), 0o600))
+
+	w := f.send(http.MethodPut, f.lineupPath("PoolA-0"), "", senpo("Mei Ito", f.blankA))
+	requireTeamMembersUnreadable(t, w)
+	_, ok := f.savedLineup(t, "PoolA-0")
+	assert.False(t, ok, "a refused lineup writes nothing")
+}
+
+// A numbered row is judged on what LANDS, as a representative pick is
+// (landedMembersRefusal): a row whose stored counterpart is NEWER is held and
+// kept in the match's history, so the fighter it names is never written, and
+// refusing the write for it would refuse the whole write, terminally, for a
+// fighter that was not written, losing the groups of the write that apply. Here
+// the stored bout 1 names fighter Y, stamped T; the write names another team's
+// member on it under T-1, beside bouts 2 and 3 and the scoreline, which apply.
+func TestSelfRun_AHeldNumberedRowIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[0].SideAMemberID = a[0].ID
+		bm.ModifiedAt = f.now
+		bm.GroupStamps = map[string]int64{
+			state.BoutGroup(1):  f.now,
+			state.GroupPoints:   f.now - 10_000,
+			state.BoutGroup(2):  f.now - 10_000,
+			state.BoutGroup(3):  f.now - 10_000,
+			state.GroupResult:   f.now - 10_000,
+			state.GroupRepPickA: f.now - 10_000,
+		}
+	})
+
+	w := f.bouts("", f.now-1, map[int]boutIDs{1: {a: b[0].ID}})
+	require.Equal(t, http.StatusOK, w.Code, "the held row is kept in the history, not refused: %s", w.Body.String())
+	assert.Contains(t, w.Body.String(), `"heldGroups":["bout:1"]`)
+	assert.Equal(t, a[0].ID, f.storedBout(t, 1).SideAMemberID, "the newer stored fighter stands")
+}
+
+// The pin beside it: the same write stamped AFTER the stored row applies the row,
+// so its fighter is judged and refused.
+func TestSelfRun_ANewerNumberedRowIsStillJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	a, b := f.teamMembers(t)
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[0].SideAMemberID = a[0].ID
+		bm.ModifiedAt = f.now
+		bm.GroupStamps = map[string]int64{state.BoutGroup(1): f.now}
+	})
+
+	w := f.bouts("", f.now+1, map[int]boutIDs{1: {a: b[0].ID}})
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", fighterNotOnTeamBody)
+	assert.Equal(t, a[0].ID, f.storedBout(t, 1).SideAMemberID, "a refused write writes nothing")
+}
+
+// A row the write does not name in `changed` is not written either, so its
+// fighter is not judged.
+func TestSelfRun_ANumberedRowTheWriteDoesNotNameIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	_, b := f.teamMembers(t)
+
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+100, nil)
+	sheet["subResults"].([]any)[0].(map[string]any)["sideAMemberId"] = b[0].ID
+	sheet["changed"] = []string{state.GroupPoints}
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", "", sheet)
+	require.Equal(t, http.StatusOK, w.Code, "bout 1 is not among the groups the write changes: %s", w.Body.String())
+	assert.Empty(t, f.storedBout(t, 1).SideAMemberID, "and it is not written")
+}
+
+// A fighter is judged on what the write LANDS, not on what its payload says it
+// changes. A kachinuki write is rewritten by the engine before the merge (the
+// bout log is merged by position and the rows' member ids are filled in), so a
+// row the payload does not name can still land: here `changed` names the match's
+// points alone, and the engine writes bout 1 with the foreign fighter anyway.
+// The write is refused and leaves the match and its history untouched.
+func TestSelfRun_AKachinukiRowTheEngineRewritesIsJudgedOnWhatLands(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	require.NoError(t, f.store.SaveCompetition(&state.Competition{
+		ID: "c1", Name: "Teams", Kind: "team", Format: state.CompFormatKnockout,
+		TeamSize: 3, TeamMatchType: state.TeamMatchTypeKachinuki,
+	}))
+	_, b := f.teamMembers(t)
+	before := f.storedState(t)
+
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+100, nil)
+	row := sheet["subResults"].([]any)[0].(map[string]any)
+	row["sideA"], row["sideB"], row["winner"] = "Alice", "Bob", "Alice"
+	row["sideAMemberId"] = b[0].ID
+	sheet["changed"] = []string{state.GroupPoints}
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", "", sheet)
+
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", fighterNotOnTeamBody)
+	assert.Equal(t, before, f.storedState(t), "a refused write leaves the match and its history as they were")
+}
+
+// The pin beside it for the other home of a match: a pool match is read back
+// from the staged pool-matches.csv, not bracket.json, and is judged the same way.
+func TestSelfRun_AKachinukiPoolRowTheEngineRewritesIsJudgedOnWhatLands(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	require.NoError(t, f.store.SaveCompetition(&state.Competition{
+		ID: "c1", Name: "Teams", Kind: "team", Format: state.CompFormatLeague,
+		TeamSize: 3, TeamMatchType: state.TeamMatchTypeKachinuki,
+	}))
+	f.setB1(t, func(bm *state.BracketMatch) { bm.Status = state.MatchStatusScheduled }) // a team fights one match at a time
+	require.NoError(t, f.store.SavePoolMatches("c1", []state.MatchResult{{
+		ID: "Pool A-0", SideA: "TeamA", SideB: "TeamB", SideAID: repBoutTeamAID, SideBID: repBoutTeamBID,
+		Status: state.MatchStatusRunning, ModifiedAt: f.now - 60_000,
+		SubResults: []state.SubMatchResult{{Position: 1, IpponsA: []string{"M"}, Winner: "TeamA"}},
+	}}))
+	_, b := f.teamMembers(t)
+	path := "/api/competitions/c1/matches/Pool%20A-0/score"
+	poolRows := func() []state.SubMatchResult {
+		matches, err := f.store.LoadPoolMatches("c1")
+		require.NoError(t, err)
+		return matches[0].SubResults
+	}
+	before := poolRows()
+
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+100, nil)
+	row := sheet["subResults"].([]any)[0].(map[string]any)
+	row["sideA"], row["sideB"], row["winner"] = "Alice", "Bob", "Alice"
+	row["sideAMemberId"] = b[0].ID
+	sheet["changed"] = []string{state.GroupPoints}
+	w := f.send(http.MethodPut, path, "", sheet)
+
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", fighterNotOnTeamBody)
+	assert.Equal(t, before, poolRows(), "a refused write leaves the pool match as it was")
+}
+
+// matchState is what a refused write must leave as it was: the bracket file's
+// bytes and the match's history.
+type matchState struct {
+	bracket string
+	history []state.MatchHistoryEntry
+}
+
+func (f *repBoutFixture) storedState(t *testing.T) matchState {
+	t.Helper()
+	bracket, err := os.ReadFile(filepath.Join(f.store.GetFolder(), "competitions", "c1", "bracket.json")) // #nosec G304 -- a test fixture path
+	require.NoError(t, err)
+	history, err := f.store.LoadMatchHistory("c1", "B1")
+	require.NoError(t, err)
+	return matchState{bracket: string(bracket), history: history}
+}
diff --git a/internal/mobileapp/self_run_daihyosen_test.go b/internal/mobileapp/self_run_daihyosen_test.go
index fa7a50568..fa1790ea5 100644
--- a/internal/mobileapp/self_run_daihyosen_test.go
+++ b/internal/mobileapp/self_run_daihyosen_test.go
@@ -817,9 +817,9 @@ func TestHoldSelfReportedWriteUnderTx(t *testing.T) {
 			sent := state.CloneSubResults(tc.incoming)
 			result := &state.MatchResult{SubResults: tc.incoming, Winner: tc.winner, WinnerID: tc.winnerID, Status: tc.status}
 
-			err := store.WithTransaction("c1", func(stx state.StoreTx) error {
-				return holdSelfReportedWriteUnderTx(stx, "c1", "B1", result, tc.startOnly)
-			})
+			snap, found, err := matchSnapshotOrErr(store, "c1", "B1", "test")
+			require.NoError(t, err)
+			err = holdSelfReportedWriteUnderTx("c1", "B1", snap, found, result, tc.startOnly)
 			if tc.want != nil {
 				var refusal *selfRunRefusal
 				require.ErrorAs(t, err, &refusal)
@@ -957,6 +957,378 @@ func TestDaihyosenResponses_CarryNoAuditFields(t *testing.T) {
 	})
 }
 
+// bc-dhrp: a participant's pick of a side's representative names a member of
+// THAT side's team, the same rule a lineup places a member by (400
+// team_member_not_in_team). The organiser's pick is not judged here.
+func TestSelfRun_RepresentativeMembersMustBeOnTheirTeam(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA, membersB := squads[repBoutTeamAID], squads[repBoutTeamBID]
+	require.NotEmpty(t, membersA, "team A is seeded with members")
+	require.NotEmpty(t, membersB, "team B is seeded with members")
+
+	pick := func(sideAID, sideBID string) map[string]any {
+		row := repBoutRow([]string{}, []string{}, "")
+		row["sideAMemberId"] = sideAID
+		row["sideBMemberId"] = sideBID
+		return row
+	}
+
+	w := f.score("", state.MatchStatusRunning, "", f.now+100, pick(membersA[0].ID, membersA[0].ID))
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+	assert.Empty(t, f.storedRepBout(t).SideBMemberID, "a refused pick writes nothing")
+
+	w = f.score("", state.MatchStatusRunning, "", f.now+200, pick(membersA[0].ID, membersB[0].ID))
+	require.Equal(t, http.StatusOK, w.Code, "each side's own member is accepted: %s", w.Body.String())
+	stored := f.storedRepBout(t)
+	assert.Equal(t, membersA[0].ID, stored.SideAMemberID)
+	assert.Equal(t, membersB[0].ID, stored.SideBMemberID)
+
+	// The organiser's pick is judged the same way (organiser_rep_pick_judge_test.go):
+	// another team's member is refused, the side's own is accepted at once.
+	w = f.score("main-pw", state.MatchStatusRunning, "", f.now+300, pick(membersB[0].ID, membersB[0].ID))
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+	w = f.score("main-pw", state.MatchStatusRunning, "", f.now+400, pick(membersA[1].ID, membersB[1].ID))
+	assert.Equal(t, http.StatusOK, w.Code, "the organiser's own-team pick is accepted: %s", w.Body.String())
+}
+
+// The merge holds a pick whose stamp is strictly older than the stored stamp of
+// that side's pick (state.GroupRepPickA here, a change dated apart from the
+// other side's and from the bout row), so such a pick is never written. Judging it would refuse a stale
+// queued write for a pick the merge was going to hold anyway (and keep in the
+// history). An EQUAL stamp applies under the merge (domain.ApplyByTimestamp), so
+// an equal-stamped pick is still judged.
+func TestSelfRun_AStalePickTheMergeHoldsIsNotRefused(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA, membersB := squads[repBoutTeamAID], squads[repBoutTeamBID]
+	require.NotEmpty(t, membersA, "team A is seeded with members")
+	require.NotEmpty(t, membersB, "team B is seeded with members")
+
+	// Team A's own member is picked on side A at f.now: the picks' stamp.
+	valid := repBoutRow([]string{}, []string{}, "")
+	valid["sideAMemberId"] = membersA[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now, valid)
+	require.Equal(t, http.StatusOK, w.Code, "a valid pick: %s", w.Body.String())
+	before := *f.storedRepBout(t)
+	require.Equal(t, membersA[0].ID, before.SideAMemberID)
+
+	// Team B's member on side A: another team's, which the row would be refused for.
+	pick := repBoutRow([]string{}, []string{}, "")
+	pick["sideAMemberId"] = membersB[0].ID
+
+	w = f.score("", state.MatchStatusRunning, "", f.now-100, pick)
+	require.Equal(t, http.StatusOK, w.Code, "a write stamped before the stored pick is held, not refused: %s", w.Body.String())
+	assert.Contains(t, w.Body.String(), `"superseded"`, "the merge answers the held write as superseded")
+	assert.Equal(t, before, *f.storedRepBout(t), "the held pick is not written")
+
+	w = f.score("", state.MatchStatusRunning, "", f.now, pick)
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+
+	w = f.score("", state.MatchStatusRunning, "", f.now+100, pick)
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+	assert.Equal(t, before, *f.storedRepBout(t), "a refused pick writes nothing")
+}
+
+// A pick is judged against that side's OWN stamp, not the bout row's and not the
+// match's ModifiedAt (the newest stamp of any group). A point struck on the
+// representative bout moves the bout's stamp past the picks' while the picks
+// keep theirs, and a pick stamped between the two applies to the picks under the
+// merge, so it is judged. The write that struck the point names only the bout
+// and so is never judged for picks.
+func TestSelfRun_APickIsJudgedAgainstThePicksOwnStamp(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA, membersB := squads[repBoutTeamAID], squads[repBoutTeamBID]
+	require.NotEmpty(t, membersA, "team A is seeded with members")
+	require.NotEmpty(t, membersB, "team B is seeded with members")
+
+	valid := repBoutRow([]string{}, []string{}, "")
+	valid["sideAMemberId"] = membersA[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now, valid)
+	require.Equal(t, http.StatusOK, w.Code, "a valid pick: %s", w.Body.String())
+	pickedMatch := storedB1(t, f.store, "c1")
+	beforeB := pickedMatch.GroupStamp(state.GroupRepPickB)
+
+	// A point on the representative bout from a board that never saw the pick:
+	// it names the bout only, so its row (with no ids, and so no pick of its own)
+	// is not judged for picks, and it leaves the stored pick alone.
+	point := scoreSheet(state.MatchStatusRunning, "", f.now+100, repBoutRow([]string{"M"}, []string{}, ""))
+	point["changed"] = []string{state.BoutGroup(state.DaihyosenSubPosition)}
+	w = f.send(http.MethodPut, repBoutMatchPath+"/score", "", point)
+	require.Equal(t, http.StatusOK, w.Code, "the point: %s", w.Body.String())
+	stored := storedB1(t, f.store, "c1")
+	require.Equal(t, f.now+100, stored.GroupStamp(state.BoutGroup(state.DaihyosenSubPosition)), "the bout moved on")
+	require.Equal(t, f.now, stored.GroupStamp(state.GroupRepPickA), "the pick kept its stamp")
+	require.Equal(t, beforeB, stored.GroupStamp(state.GroupRepPickB), "and the point did not date the other side's either")
+	assert.Equal(t, membersA[0].ID, f.storedRepBout(t).SideAMemberID, "the point did not erase the pick")
+
+	bad := repBoutRow([]string{}, []string{}, "")
+	bad["sideAMemberId"] = membersB[0].ID
+	w = f.score("", state.MatchStatusRunning, "", f.now+50, bad)
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+}
+
+// Each side's pick is judged only when the write names that side's group (and
+// the merge will apply it). A write that names side A's pick while merely
+// echoing an id on side B the stored row does not hold (as a re-seat that has
+// cleared it would leave) is not refused for side B against the team it holds
+// now, and writes nothing for it; naming side B's pick as well judges it.
+func TestSelfRun_ASideTheWriteDoesNotNameIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.GreaterOrEqual(t, len(membersA), 2, "team A is seeded with members")
+
+	// Side A's own member; on side B, a member of team A (not team B's).
+	row := repBoutRow([]string{}, []string{}, "")
+	row["sideAMemberId"] = membersA[0].ID
+	row["sideBMemberId"] = membersA[1].ID
+
+	named := scoreSheet(state.MatchStatusRunning, "", f.now+300, row)
+	named["changed"] = []string{state.GroupRepPickA}
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", "", named)
+	require.Equal(t, http.StatusOK, w.Code, "side B is not named, so it is not judged: %s", w.Body.String())
+	stored := f.storedRepBout(t)
+	assert.Equal(t, membersA[0].ID, stored.SideAMemberID, "the named side applies")
+	assert.Empty(t, stored.SideBMemberID, "and the side it did not name is not written")
+
+	both := scoreSheet(state.MatchStatusRunning, "", f.now+400, row)
+	both["changed"] = []string{state.GroupRepPickA, state.GroupRepPickB}
+	w = f.send(http.MethodPut, repBoutMatchPath+"/score", "", both)
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+	assert.Empty(t, f.storedRepBout(t).SideBMemberID, "a refused pick writes nothing")
+}
+
+// A write that names the bout alone changes no pick, so a foreign id on its row
+// is neither judged nor written: the judge reads which picks the write landed.
+func TestSelfRun_AWriteNamingTheBoutAloneIsNotJudgedForThePick(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersB := squads[repBoutTeamBID]
+	require.NotEmpty(t, membersB, "team B is seeded with members")
+
+	row := repBoutRow([]string{"M"}, []string{}, "")
+	row["sideAMemberId"] = membersB[0].ID // side A is team A's
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+100, row)
+	sheet["changed"] = []string{state.BoutGroup(state.DaihyosenSubPosition)}
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", "", sheet)
+	require.Equal(t, http.StatusOK, w.Code, "the bout is not a pick: %s", w.Body.String())
+	stored := f.storedRepBout(t)
+	assert.Equal(t, []string{"M"}, stored.IpponsA, "the bout applies")
+	assert.Empty(t, stored.SideAMemberID, "and the id it carried is no pick")
+}
+
+// A members file that cannot be read refuses a pick that needs it with a
+// refusal the offline queue does not retry (409; a 500 is retried forever),
+// and writes nothing.
+func TestSelfRun_UnreadableTeamMembersRefusesThePickTerminally(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.NotEmpty(t, membersA, "team A is seeded with members")
+	require.NoError(t, os.WriteFile(
+		filepath.Join(f.store.GetFolder(), "competitions", "c1", "team-members.yaml"),
+		[]byte("not: [valid yaml"), 0o600))
+
+	before := f.storedState(t)
+
+	row := repBoutRow([]string{}, []string{}, "")
+	row["sideAMemberId"] = membersA[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now+100, row)
+	requireTeamMembersUnreadable(t, w)
+	assert.Equal(t, before, f.storedState(t), "a refused pick writes nothing, not even its history line")
+}
+
+// Removing the representative bout dates both sides' representatives with the
+// removal (it names state.GroupRepPickA and state.GroupRepPickB beside the
+// bout), so a pick a board made before it, on a sheet that still showed the row,
+// is held and kept in the history rather than applied onto nothing.
+func TestDaihyosenRemove_DatesTheRepresentativesToo(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.NotEmpty(t, membersA)
+
+	pick := repBoutRow([]string{}, []string{}, "")
+	pick["sideAMemberId"] = membersA[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now+10, pick)
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+
+	w = f.send(http.MethodDelete, repBoutMatchPath+"/daihyosen", "main-pw", map[string]any{"modifiedAt": f.now + 50})
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+	stored := storedB1(t, f.store, "c1")
+	require.False(t, carriesDaihyosenRow(stored.SubResults), "the bout is gone")
+	assert.Equal(t, f.now+50, stored.GroupStamp(state.GroupRepPickA), "the removal dates side A's representative")
+	assert.Equal(t, f.now+50, stored.GroupStamp(state.GroupRepPickB), "and side B's")
+
+	// A pick made after the removal on a sheet that still showed the row names
+	// the pick alone: it is newer, but the bout it sits on is gone.
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+60, pick)
+	sheet["changed"] = []string{state.GroupRepPickA}
+	late := f.send(http.MethodPut, repBoutMatchPath+"/score", "main-pw", sheet)
+	require.Equal(t, http.StatusOK, late.Code, late.Body.String())
+	assert.Contains(t, late.Body.String(), `"superseded"`, "a pick has no bout to land on: it is held")
+	assert.False(t, carriesDaihyosenRow(storedB1(t, f.store, "c1").SubResults), "nothing is resurrected")
+}
+
+// Adding the representative bout dates both sides' representatives with the add,
+// as the remove does. Without it the new row inherits the stamp of the earlier removal's
+// tombstone, and a pick made on the PREVIOUS representative bout, stamped between
+// the remove and the add, lands on the new bout.
+func TestDaihyosenAdd_DatesTheRepresentativesToo(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.NotEmpty(t, membersA)
+
+	w := f.send(http.MethodDelete, repBoutMatchPath+"/daihyosen", "main-pw", map[string]any{"modifiedAt": f.now + 100})
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+	w = f.send(http.MethodPost, repBoutMatchPath+"/daihyosen", "main-pw", map[string]any{"modifiedAt": f.now + 200})
+	require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+	added := storedB1(t, f.store, "c1")
+	require.Equal(t, f.now+200, added.GroupStamp(state.GroupRepPickA), "the add dates side A's representative")
+	require.Equal(t, f.now+200, added.GroupStamp(state.GroupRepPickB), "and side B's")
+
+	// A pick made on the previous bout, between the remove and the add, arrives late.
+	pick := repBoutRow([]string{}, []string{}, "")
+	pick["sideAMemberId"] = membersA[0].ID
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+150, pick)
+	sheet["changed"] = []string{state.GroupRepPickA}
+	late := f.send(http.MethodPut, repBoutMatchPath+"/score", "main-pw", sheet)
+	require.Equal(t, http.StatusOK, late.Code, late.Body.String())
+	assert.Contains(t, late.Body.String(), `"superseded"`, "a pick older than the add is held")
+	assert.Empty(t, f.storedRepBout(t).SideAMemberID, "the old bout's pick is not on the new bout")
+}
+
+// The winner id a participant's write carries is not judged: the merge keeps the
+// pair consistent itself (SubMatchResult.ReconcileWinnerMemberID). Another device
+// changed side A's pick; the participant's winning point (bout:-1, not the picks)
+// still carries the OLD pick's id. The point is the participant's and applies, and
+// the stored winner id ends up naming the stored pick of the winning side, rather
+// than the write being refused and the point lost.
+func TestSelfRun_AWinningPointCarryingAReplacedPicksIdIsAcceptedAndReconciled(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.GreaterOrEqual(t, len(membersA), 2, "team A is seeded with members")
+	oldPick, newPick := membersA[0].ID, membersA[1].ID
+
+	organiserPick := func(memberID string, at int64) {
+		t.Helper()
+		row := repBoutRow([]string{}, []string{}, "")
+		row["sideAMemberId"] = memberID
+		sheet := scoreSheet(state.MatchStatusRunning, "", at, row)
+		sheet["changed"] = []string{state.GroupRepPickA}
+		w := f.send(http.MethodPut, repBoutMatchPath+"/score", "main-pw", sheet)
+		require.Equal(t, http.StatusOK, w.Code, w.Body.String())
+	}
+	organiserPick(oldPick, f.now+10)
+	organiserPick(newPick, f.now+100) // the other device's change, T2
+
+	point := repBoutRow([]string{"M"}, []string{}, "TeamA")
+	point["sideAMemberId"] = oldPick
+	point["winnerMemberId"] = oldPick
+	sheet := scoreSheet(state.MatchStatusRunning, "", f.now+200, point)
+	sheet["changed"] = []string{state.BoutGroup(state.DaihyosenSubPosition)}
+	w := f.send(http.MethodPut, repBoutMatchPath+"/score", "", sheet)
+	require.Equal(t, http.StatusOK, w.Code, "the point is not refused for the id of the pick it replaced: %s", w.Body.String())
+
+	stored := f.storedRepBout(t)
+	assert.Equal(t, []string{"M"}, stored.IpponsA, "the winning point applied")
+	assert.Equal(t, newPick, stored.SideAMemberID, "the other device's pick stands")
+	assert.Equal(t, newPick, stored.WinnerMemberID, "the winner id names the stored pick of the winning side")
+}
+
+// A pick the stored row already holds is inherited, not introduced by the write:
+// a correction that seated another team leaves the old team's member on the row,
+// and the participant's echo of it is kept rather than refused against the team
+// now holding that side. A pick the write changes is still judged.
+func TestSelfRun_AStoredRepresentativeIdIsNotJudgedAgainstTheTeamNow(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersB := squads[repBoutTeamBID]
+	require.GreaterOrEqual(t, len(membersB), 2, "team B is seeded with members")
+	f.setB1(t, func(bm *state.BracketMatch) {
+		bm.SubResults[state.DaihyosenSubIndex(bm.SubResults)].SideAMemberID = membersB[0].ID
+	})
+
+	echo := repBoutRow([]string{}, []string{}, "")
+	echo["sideAMemberId"] = membersB[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now+200, echo)
+	require.Equal(t, http.StatusOK, w.Code, "the echo of the stored pick is kept: %s", w.Body.String())
+	assert.Equal(t, membersB[0].ID, f.storedRepBout(t).SideAMemberID)
+
+	changed := repBoutRow([]string{}, []string{}, "")
+	changed["sideAMemberId"] = membersB[1].ID
+	w = f.score("", state.MatchStatusRunning, "", f.now+300, changed)
+	requireRefusal(t, w, http.StatusBadRequest, "team_member_not_in_team", "The representative chosen is not on this team. Pick again from the list.")
+	assert.Equal(t, membersB[0].ID, f.storedRepBout(t).SideAMemberID, "a refused pick writes nothing")
+}
+
+// A side the stored match carries no participant id for has no team to judge a
+// pick against, so the pick is not refused as "not on this team". An empty team
+// id names no team, so every pick on such a side used to be refused.
+func TestSelfRun_ARepresentativePickOnAnIdlessSideIsNotJudged(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersA := squads[repBoutTeamAID]
+	require.NotEmpty(t, membersA, "team A is seeded with members")
+	f.setB1(t, func(bm *state.BracketMatch) { bm.SideAID = "" })
+
+	pick := repBoutRow([]string{}, []string{}, "")
+	pick["sideAMemberId"] = membersA[0].ID
+	w := f.score("", state.MatchStatusRunning, "", f.now+200, pick)
+	require.Equal(t, http.StatusOK, w.Code, "the pick on an id-less side is accepted: %s", w.Body.String())
+	assert.Equal(t, membersA[0].ID, f.storedRepBout(t).SideAMemberID)
+}
+
+// A participant's echo of the organiser's recorded verdict is replaced by the
+// stored row whatever picks it carries, so a foreign pick on it is not refused
+// (the picks are never written).
+func TestSelfRun_RepresentativeMembersAreNotJudgedOnADecidedVerdict(t *testing.T) {
+	f := newRepBoutFixture(t, true)
+	f.addRepBout(t)
+	f.recordHantei(t)
+	squads, err := f.store.LoadSquads("c1")
+	require.NoError(t, err)
+	membersB := squads[repBoutTeamBID]
+	require.NotEmpty(t, membersB, "team B is seeded with members")
+
+	echo := hanteiRow()
+	echo["sideAMemberId"] = membersB[0].ID // team B's member on team A's side
+
+	w := f.score("", state.MatchStatusRunning, "", f.now+200, echo)
+	require.Equal(t, http.StatusOK, w.Code, "the verdict's echo is kept whatever its picks: %s", w.Body.String())
+	assert.NotContains(t, w.Body.String(), "team_member_not_in_team")
+	row := f.storedRepBout(t)
+	assert.Equal(t, []string{domain.HanteiMark}, row.IpponsA, "the verdict stands")
+	assert.Equal(t, "TeamA", row.Winner)
+	assert.Empty(t, row.SideAMemberID, "the stored row keeps its own picks, not the echo's")
+}
+
 // A password sent but wrong is answered 401 before the body is read, so a
 // stale organiser is not told about their clock or their body instead.
 func TestDaihyosen_AWrongPasswordIsRefusedBeforeTheStamp(t *testing.T) {
diff --git a/internal/mobileapp/team_finish_gate.go b/internal/mobileapp/team_finish_gate.go
index c3b13742f..d770d2fbe 100644
--- a/internal/mobileapp/team_finish_gate.go
+++ b/internal/mobileapp/team_finish_gate.go
@@ -149,9 +149,10 @@ func refuseUnfinishedTeamFinishForComp(comp *state.Competition, matchID string,
 // correction to the bouts of a match a default-win ruling already ended, and
 // it keeps the ruling (operator ruling 2026-09-24: "Save correction should
 // just save what the operator enters"), so the bouts nobody fought after it
-// are not a finish it has to answer for. check is the snapshot
-// applyCorrectionReasonUnderTx read under the same lock the write holds, so
-// the stored decision this exemption reads is the one the engine will see.
+// are not a finish it has to answer for. check is the verdict
+// applyCorrectionReason drew from the snapshot read under the same lock the
+// write holds, so the stored decision this exemption reads is the one the
+// engine will see.
 func teamFinishRefusalUnderTx(refusal *ValidationError, check correctionCheck, req *state.MatchResult) *ValidationError {
 	if refusal == nil || engine.KeepsWithdrawalRuling(check.StoredStatus, check.StoredDecision, req) {
 		return nil
diff --git a/internal/state/announcement_store.go b/internal/state/announcement_store.go
index cb7eb6711..ef7f96951 100644
--- a/internal/state/announcement_store.go
+++ b/internal/state/announcement_store.go
@@ -1,6 +1,7 @@
 package state
 
 import (
+	"slices"
 	"sync"
 	"time"
 )
@@ -10,15 +11,23 @@ const maxActiveAnnouncements = 10
 type AnnouncementStore struct {
 	mu     sync.Mutex
 	active []Announcement
+	// replaced maps the id of an announcement that an identical Add replaced to
+	// the id of the announcement now standing in its place, always one hop. It
+	// lets a court console that still holds the older id take the call down
+	// (bc-cdbl). An alias never outlives its target: dropOrphanAliasesLocked
+	// sweeps it after every removal from active.
+	replaced map[string]string
 }
 
 func NewAnnouncementStore() *AnnouncementStore {
 	return &AnnouncementStore{}
 }
 
-// Add appends a new announcement. Returns the new item and the updated list
-// snapshot under the same lock, eliminating any race between mutation and
-// broadcast.
+// Add appends a new announcement. If an active announcement with the identical
+// message already exists, it is replaced (removed and re-added with a new ID and
+// fresh TTL); the replaced ID stays valid for Remove while the new item is
+// active. Returns the new item and the updated list snapshot under the same
+// lock, eliminating any race between mutation and broadcast.
 func (s *AnnouncementStore) Add(msg string, dur time.Duration) (Announcement, []Announcement) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -26,28 +35,46 @@ func (s *AnnouncementStore) Add(msg string, dur time.Duration) (Announcement, []
 	ann := makeAnnouncement(msg, dur)
 	s.pruneExpiredLocked(time.Now())
 
+	// Remove the active announcement with the identical message, if any: at
+	// most one exists, since every Add replaces it (bc-cdbl). Its id keeps
+	// resolving to the announcement that replaces it, so a court console that
+	// still holds the older id can take the call down.
+	if i := slices.IndexFunc(s.active, func(a Announcement) bool { return a.Message == msg }); i >= 0 {
+		s.recordReplacementLocked(s.active[i].ID, ann.ID)
+		s.active = slices.Delete(s.active, i, i+1)
+	}
+
 	if len(s.active) >= maxActiveAnnouncements {
 		s.active = s.active[1:]
 	}
 
 	s.active = append(s.active, ann)
+	s.dropOrphanAliasesLocked()
 	return ann, snapshotLocked(s.active)
 }
 
-// Remove dismisses the announcement with the given ID. Returns whether it was
-// found and the updated list snapshot under the same lock.
+// Remove dismisses the announcement with the given ID, or, for an ID an
+// identical Add replaced, the announcement that replaced it. Returns whether it
+// was found and the updated list snapshot under the same lock.
 func (s *AnnouncementStore) Remove(id string) (bool, []Announcement) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	s.pruneExpiredLocked(time.Now())
-	for i, a := range s.active {
-		if a.ID == id {
-			s.active = append(s.active[:i], s.active[i+1:]...)
-			return true, snapshotLocked(s.active)
+	i := s.indexOfIDLocked(id)
+	if i < 0 {
+		// An id that an identical Add replaced withdraws the announcement now
+		// standing in its place.
+		if target, ok := s.replaced[id]; ok {
+			i = s.indexOfIDLocked(target)
 		}
 	}
-	return false, snapshotLocked(s.active)
+	if i < 0 {
+		return false, snapshotLocked(s.active)
+	}
+	s.active = slices.Delete(s.active, i, i+1)
+	s.dropOrphanAliasesLocked()
+	return true, snapshotLocked(s.active)
 }
 
 // Clear removes all announcements and returns an empty snapshot.
@@ -55,6 +82,7 @@ func (s *AnnouncementStore) Clear() []Announcement {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.active = nil
+	s.dropOrphanAliasesLocked()
 	return []Announcement{}
 }
 
@@ -90,6 +118,7 @@ func (s *AnnouncementStore) Set(msg string, dur time.Duration) Announcement {
 
 	ann := makeAnnouncement(msg, dur)
 	s.active = []Announcement{ann}
+	s.dropOrphanAliasesLocked()
 	return ann
 }
 
@@ -102,6 +131,41 @@ func (s *AnnouncementStore) pruneExpiredLocked(now time.Time) {
 		}
 	}
 	s.active = kept
+	s.dropOrphanAliasesLocked()
+}
+
+// indexOfIDLocked returns the index of the active announcement with the given
+// id, or -1. Must be called with mu held.
+func (s *AnnouncementStore) indexOfIDLocked(id string) int {
+	return slices.IndexFunc(s.active, func(a Announcement) bool { return a.ID == id })
+}
+
+// recordReplacementLocked notes that the announcement newID replaced oldID, and
+// re-points every alias that targeted oldID at newID, so a run of identical
+// re-calls stays one hop from each older id to the latest. Must be called with
+// mu held.
+func (s *AnnouncementStore) recordReplacementLocked(oldID, newID string) {
+	if s.replaced == nil {
+		s.replaced = make(map[string]string)
+	}
+	for alias, target := range s.replaced {
+		if target == oldID {
+			s.replaced[alias] = newID
+		}
+	}
+	s.replaced[oldID] = newID
+}
+
+// dropOrphanAliasesLocked drops every alias whose target is no longer active,
+// so an alias never outlives the announcement it points at. Call it after ANY
+// removal from s.active (expiry, the cap's eviction, Remove, Clear, Set). Must
+// be called with mu held.
+func (s *AnnouncementStore) dropOrphanAliasesLocked() {
+	for alias, target := range s.replaced {
+		if s.indexOfIDLocked(target) < 0 {
+			delete(s.replaced, alias)
+		}
+	}
 }
 
 func makeAnnouncement(msg string, dur time.Duration) Announcement {
diff --git a/internal/state/announcement_store_test.go b/internal/state/announcement_store_test.go
index 9dcafb168..9fe4926d4 100644
--- a/internal/state/announcement_store_test.go
+++ b/internal/state/announcement_store_test.go
@@ -1,6 +1,7 @@
 package state
 
 import (
+	"fmt"
 	"sync"
 	"testing"
 	"time"
@@ -135,8 +136,10 @@ func TestAnnouncementStoreRemovePrunesExpired(t *testing.T) {
 func TestAnnouncementStoreCapEvictsOldest(t *testing.T) {
 	store := NewAnnouncementStore()
 
-	for range maxActiveAnnouncements {
-		_, _ = store.Add("msg", 30*time.Minute)
+	// Distinct messages: an identical one would replace its predecessor
+	// (bc-cdbl), and this test is about the cap, not about replacement.
+	for i := range maxActiveAnnouncements {
+		_, _ = store.Add(fmt.Sprintf("msg %d", i), 30*time.Minute)
 	}
 	newest, _ := store.Add("newest", 30*time.Minute)
 	list := store.List()
@@ -197,3 +200,278 @@ func TestAnnouncementStoreConcurrentAddList(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+func TestAnnouncementStore_AddReplacesIdenticalActive(t *testing.T) {
+	tests := []struct {
+		name     string
+		scenario func(t *testing.T, store *AnnouncementStore)
+	}{
+		{
+			name: "identical active announcement is replaced",
+			scenario: func(t *testing.T, store *AnnouncementStore) {
+				msg := "Call to court"
+				a1, _ := store.Add(msg, 5*time.Minute)
+				a2, list := store.Add(msg, 5*time.Minute)
+
+				// Only one announcement should exist
+				if len(list) != 1 {
+					t.Fatalf("expected 1 announcement, got %d", len(list))
+				}
+				// IDs should differ (a2 is the new one)
+				if a1.ID == a2.ID {
+					t.Error("new announcement should have a different ID")
+				}
+				// The stored announcement should be a2, not a1
+				if list[0].ID != a2.ID {
+					t.Errorf("expected newest announcement (ID %s), got ID %s", a2.ID, list[0].ID)
+				}
+				if list[0].Message != msg {
+					t.Errorf("expected message %q, got %q", msg, list[0].Message)
+				}
+			},
+		},
+		{
+			name: "different messages both stack",
+			scenario: func(t *testing.T, store *AnnouncementStore) {
+				a1, _ := store.Add("First call", 5*time.Minute)
+				a2, list := store.Add("Second call", 5*time.Minute)
+
+				if len(list) != 2 {
+					t.Fatalf("expected 2 announcements, got %d", len(list))
+				}
+				if list[0].ID != a1.ID {
+					t.Errorf("expected first announcement first")
+				}
+				if list[1].ID != a2.ID {
+					t.Errorf("expected second announcement second")
+				}
+			},
+		},
+		{
+			name: "identical message after expiry just adds",
+			scenario: func(t *testing.T, store *AnnouncementStore) {
+				msg := "Call to court"
+				a1, _ := store.Add(msg, 5*time.Millisecond)
+				time.Sleep(10 * time.Millisecond)
+				a2, list := store.Add(msg, 5*time.Minute)
+
+				// The expired copy is pruned, so the fresh one is the only entry
+				// and nothing is replaced: the identical message just adds.
+				if len(list) != 1 {
+					t.Fatalf("expected 1 announcement (expired first removed), got %d", len(list))
+				}
+				if list[0].ID != a2.ID {
+					t.Errorf("expected the fresh announcement, got %q", list[0].ID)
+				}
+				// a1 should be gone (expired)
+				if list[0].ID == a1.ID {
+					t.Error("expired announcement should be pruned")
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			store := NewAnnouncementStore()
+			tt.scenario(t, store)
+		})
+	}
+}
+
+// aliasCount reads the size of the replaced-id map under the store's lock.
+func aliasCount(s *AnnouncementStore) int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.replaced)
+}
+
+// TestAnnouncementStore_RemoveThroughAReplacedID pins the follow-up to bc-cdbl:
+// a court console holding the id of a call that a later identical call replaced
+// (a second device re-called the match, or its own re-call's answer was lost)
+// still takes the call down, because the id resolves to the announcement that
+// replaced it.
+func TestAnnouncementStore_RemoveThroughAReplacedID(t *testing.T) {
+	store := NewAnnouncementStore()
+	a1, _ := store.Add("x", 5*time.Minute)
+	a2, _ := store.Add("x", 5*time.Minute)
+	if a1.ID == a2.ID {
+		t.Fatal("the replacement must carry a new ID")
+	}
+
+	found, list := store.Remove(a1.ID)
+	if !found {
+		t.Fatal("expected Remove through the replaced ID to find the announcement that replaced it")
+	}
+	if len(list) != 0 {
+		t.Errorf("expected an empty list after the withdrawal, got %v", list)
+	}
+	if got := store.List(); len(got) != 0 {
+		t.Errorf("expected the store to be empty, got %v", got)
+	}
+}
+
+// TestAnnouncementStore_RemoveThroughAReplacedIDLeavesOthers: the withdrawal
+// takes down only the announcement that replaced the id, never a different one.
+func TestAnnouncementStore_RemoveThroughAReplacedIDLeavesOthers(t *testing.T) {
+	store := NewAnnouncementStore()
+	a1, _ := store.Add("x", 5*time.Minute)
+	y, _ := store.Add("y", 5*time.Minute)
+	a3, _ := store.Add("x", 5*time.Minute)
+
+	found, list := store.Remove(a1.ID)
+	if !found {
+		t.Fatal("expected Remove through the replaced ID to find a3")
+	}
+	if len(list) != 1 || list[0].ID != y.ID {
+		t.Fatalf("expected only the unrelated announcement to remain, got %v", list)
+	}
+	if found, _ := store.Remove(a3.ID); found {
+		t.Error("a3 was withdrawn through a1, so removing it again must not be found")
+	}
+}
+
+// TestAnnouncementStore_ReplacementChainResolvesToTheLatest: three identical
+// Adds leave one announcement, and every older id reaches it in one hop.
+func TestAnnouncementStore_ReplacementChainResolvesToTheLatest(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		idx  int
+	}{
+		{"oldest id", 0},
+		{"middle id", 1},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			store := NewAnnouncementStore()
+			a1, _ := store.Add("x", 5*time.Minute)
+			a2, _ := store.Add("x", 5*time.Minute)
+			a3, list := store.Add("x", 5*time.Minute)
+			if len(list) != 1 || list[0].ID != a3.ID {
+				t.Fatalf("expected only a3 to be active, got %v", list)
+			}
+
+			// One hop: re-pointed on the third Add, not a chain id1 -> id2 -> id3.
+			store.mu.Lock()
+			hop1, hop2 := store.replaced[a1.ID], store.replaced[a2.ID]
+			store.mu.Unlock()
+			if hop1 != a3.ID || hop2 != a3.ID {
+				t.Fatalf("expected both aliases to point at a3 (%s), got %q and %q", a3.ID, hop1, hop2)
+			}
+
+			found, after := store.Remove([]string{a1.ID, a2.ID}[tc.idx])
+			if !found {
+				t.Fatal("expected the older ID to withdraw the latest announcement")
+			}
+			if len(after) != 0 {
+				t.Errorf("expected an empty list, got %v", after)
+			}
+			if n := aliasCount(store); n != 0 {
+				t.Errorf("expected the aliases to go with their target, %d remain", n)
+			}
+		})
+	}
+}
+
+// TestAnnouncementStore_AliasGoesWithItsTarget: an alias is only an alternate
+// name for an active announcement, so once that announcement is gone, by any
+// route, the older id is not found and nothing is kept for it.
+func TestAnnouncementStore_AliasGoesWithItsTarget(t *testing.T) {
+	t.Run("removed through its own id", func(t *testing.T) {
+		store := NewAnnouncementStore()
+		a1, _ := store.Add("x", 5*time.Minute)
+		a2, _ := store.Add("x", 5*time.Minute)
+		if found, _ := store.Remove(a2.ID); !found {
+			t.Fatal("expected a2 to be found")
+		}
+		if found, _ := store.Remove(a1.ID); found {
+			t.Error("a1 resolved to a2, which is gone: it must not be found")
+		}
+		if n := aliasCount(store); n != 0 {
+			t.Errorf("expected no alias to remain, got %d", n)
+		}
+	})
+
+	t.Run("expired, swept by List", func(t *testing.T) {
+		store := NewAnnouncementStore()
+		a1, _ := store.Add("x", 5*time.Minute)
+		_, _ = store.Add("x", 10*time.Millisecond)
+		time.Sleep(20 * time.Millisecond)
+		if got := store.List(); len(got) != 0 {
+			t.Fatalf("expected the replacement to have expired, got %v", got)
+		}
+		if n := aliasCount(store); n != 0 {
+			t.Errorf("expected the alias to go with the expired target, got %d", n)
+		}
+		if found, _ := store.Remove(a1.ID); found {
+			t.Error("a1 resolved to an expired announcement: it must not be found")
+		}
+	})
+
+	t.Run("expired, found by Remove", func(t *testing.T) {
+		store := NewAnnouncementStore()
+		a1, _ := store.Add("x", 5*time.Minute)
+		_, _ = store.Add("x", 10*time.Millisecond)
+		time.Sleep(20 * time.Millisecond)
+		if found, list := store.Remove(a1.ID); found || len(list) != 0 {
+			t.Errorf("expected not found and an empty list, got %v %v", found, list)
+		}
+		if n := aliasCount(store); n != 0 {
+			t.Errorf("expected the alias to go with the expired target, got %d", n)
+		}
+	})
+
+	t.Run("cleared", func(t *testing.T) {
+		store := NewAnnouncementStore()
+		a1, _ := store.Add("x", 5*time.Minute)
+		_, _ = store.Add("x", 5*time.Minute)
+		store.Clear()
+		if n := aliasCount(store); n != 0 {
+			t.Errorf("expected Clear to drop the alias, got %d", n)
+		}
+		if found, _ := store.Remove(a1.ID); found {
+			t.Error("a1 must not be found after Clear")
+		}
+	})
+
+	t.Run("replaced by Set", func(t *testing.T) {
+		store := NewAnnouncementStore()
+		a1, _ := store.Add("x", 5*time.Minute)
+		_, _ = store.Add("x", 5*time.Minute)
+		store.Set("y", 5*time.Minute)
+		if n := aliasCount(store); n != 0 {
+			t.Errorf("expected Set to drop the alias, got %d", n)
+		}
+		if found, _ := store.Remove(a1.ID); found {
+			t.Error("a1 must not be found after Set replaced the list")
+		}
+	})
+}
+
+// TestAnnouncementStore_AliasGoesWithAnEvictedTarget: the cap evicts the oldest
+// announcement, and an alias that pointed at it must go too, or the map would
+// keep ids nothing can reach.
+func TestAnnouncementStore_AliasGoesWithAnEvictedTarget(t *testing.T) {
+	store := NewAnnouncementStore()
+	a1, _ := store.Add("x", 30*time.Minute)
+	a2, _ := store.Add("x", 30*time.Minute)
+	if n := aliasCount(store); n != 1 {
+		t.Fatalf("expected one alias after the replacement, got %d", n)
+	}
+
+	// "x" (a2) is the oldest announcement; fill the store, then add one more.
+	for i := range maxActiveAnnouncements {
+		_, _ = store.Add(fmt.Sprintf("msg %d", i), 30*time.Minute)
+	}
+	for _, a := range store.List() {
+		if a.ID == a2.ID {
+			t.Fatal("expected the cap to have evicted a2")
+		}
+	}
+
+	if n := aliasCount(store); n != 0 {
+		t.Errorf("expected the alias to go with the evicted target, got %d", n)
+	}
+	if found, _ := store.Remove(a1.ID); found {
+		t.Error("a1 resolved to the evicted a2: it must not be found")
+	}
+}
diff --git a/internal/state/match_groups.go b/internal/state/match_groups.go
index 2cd8ee0d3..8b9f776e4 100644
--- a/internal/state/match_groups.go
+++ b/internal/state/match_groups.go
@@ -25,6 +25,8 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
 )
 
 // The scalar groups. A team match additionally has one group per bout row,
@@ -43,12 +45,45 @@ const (
 	GroupFlags = "flags"
 	// GroupRep holds the pool daihyosen/tiebreaker representative players.
 	GroupRep = "rep"
+	// GroupRepPickA and GroupRepPickB hold ONE side's representative for a team
+	// match's representative bout each: SideAMemberID (side A, Aka) and
+	// SideBMemberID (side B, Shiro) of the row at DaihyosenSubPosition. Each
+	// side's pick is a change of its own, dated and ordered apart from the other
+	// side's pick and from the bout row they sit on (bout:-1), which keeps the
+	// bout's score and result: two captains picking at about the same moment on
+	// their own phones both land, a point struck on the bout never alters who
+	// was picked, and a pick never alters the score. The row's WinnerMemberID
+	// moves with the bout (CopyGroup copies the row), but it is derived state:
+	// no group's comparison includes it, and the merge works it out again from
+	// the winner's name and the stored picks after every write
+	// (SubMatchResult.ReconcileWinnerMemberID). Not to be confused with
+	// GroupRep, the pool daihyosen/tiebreaker players. RepPickGroup names the
+	// group of a side.
+	GroupRepPickA = "repPickA"
+	GroupRepPickB = "repPickB"
 
 	boutGroupPrefix = "bout:"
 )
 
 // ScalarGroups lists the scalar groups in their fixed order.
-var ScalarGroups = []string{GroupPoints, GroupResult, GroupEncho, GroupFlags, GroupRep}
+var ScalarGroups = []string{GroupPoints, GroupResult, GroupEncho, GroupFlags, GroupRep, GroupRepPickA, GroupRepPickB}
+
+// RepPickGroup names the group of side's representative pick, "" for a value
+// that is neither side.
+func RepPickGroup(side domain.MatchSide) string {
+	switch side {
+	case domain.MatchSideA:
+		return GroupRepPickA
+	case domain.MatchSideB:
+		return GroupRepPickB
+	}
+	return ""
+}
+
+// isRepPickGroup reports whether group is one side's representative pick.
+func isRepPickGroup(group string) bool {
+	return group == GroupRepPickA || group == GroupRepPickB
+}
 
 // BoutGroup names the group of the bout row at position (1..n, or
 // DaihyosenSubPosition for the representative bout).
@@ -115,6 +150,71 @@ func subAt(subs []SubMatchResult, position int) *SubMatchResult {
 	return nil
 }
 
+// SubResultAt is subAt as a value: a copy of the first bout row at position,
+// the empty row when subs has none (a position a match lacks holds no member id,
+// which is what a caller comparing a row with the stored one wants).
+func SubResultAt(subs []SubMatchResult, position int) SubMatchResult {
+	if row := subAt(subs, position); row != nil {
+		return *row
+	}
+	return SubMatchResult{}
+}
+
+// repPicksOf returns the two representatives the row at DaihyosenSubPosition
+// of subs names, empty when there is no such row.
+func repPicksOf(subs []SubMatchResult) (sideA, sideB string) {
+	if row := subAt(subs, DaihyosenSubPosition); row != nil {
+		return row.SideAMemberID, row.SideBMemberID
+	}
+	return "", ""
+}
+
+// withRepPick returns a copy of subs whose row at DaihyosenSubPosition names id
+// as side's representative, and subs itself when there is no such row or side
+// is neither side. The list is copied, never edited in place, so a row another
+// copy of the match shares is never written through.
+func withRepPick(subs []SubMatchResult, side domain.MatchSide, id string) []SubMatchResult {
+	if side != domain.MatchSideA && side != domain.MatchSideB {
+		return subs
+	}
+	for i := range subs {
+		if subs[i].Position != DaihyosenSubPosition {
+			continue
+		}
+		out := append([]SubMatchResult(nil), subs...)
+		if side == domain.MatchSideA {
+			out[i].SideAMemberID = id
+		} else {
+			out[i].SideBMemberID = id
+		}
+		return out
+	}
+	return subs
+}
+
+// RepPicks returns the two representatives the row at DaihyosenSubPosition
+// names, empty when the match has no such row.
+func (m *MatchResult) RepPicks() (sideA, sideB string) {
+	return repPicksOf(m.SubResults)
+}
+
+// SetRepPick puts id on the row at DaihyosenSubPosition as side's
+// representative. It does nothing when the match has no such row: a pick has no
+// bout to land on. The list is replaced, not edited in place (withRepPick).
+func (m *MatchResult) SetRepPick(side domain.MatchSide, id string) {
+	m.SubResults = withRepPick(m.SubResults, side, id)
+}
+
+// RepPicks is MatchResult.RepPicks for a bracket match.
+func (bm *BracketMatch) RepPicks() (sideA, sideB string) {
+	return repPicksOf(bm.SubResults)
+}
+
+// SetRepPick is MatchResult.SetRepPick for a bracket match.
+func (bm *BracketMatch) SetRepPick(side domain.MatchSide, id string) {
+	bm.SubResults = withRepPick(bm.SubResults, side, id)
+}
+
 // boutOrderKey sorts bout rows the way every writer appends them: numbered
 // bouts ascending, the representative bout (and any other negative) after.
 func boutOrderKey(position int) int {
@@ -176,9 +276,25 @@ func CopyGroup(dst, src *MatchResult, group string) {
 		dst.FlagsA, dst.FlagsB = src.FlagsA, src.FlagsB
 	case GroupRep:
 		dst.RepPlayerA, dst.RepPlayerB = src.RepPlayerA, src.RepPlayerB
+	case GroupRepPickA:
+		a, _ := src.RepPicks()
+		dst.SetRepPick(domain.MatchSideA, a)
+	case GroupRepPickB:
+		_, b := src.RepPicks()
+		dst.SetRepPick(domain.MatchSideB, b)
 	default:
 		if pos, ok := ParseBoutGroup(group); ok {
-			dst.SubResults = setSubAt(dst.SubResults, pos, subAt(src.SubResults, pos))
+			row := subAt(src.SubResults, pos)
+			// The representatives are not the bout's: a copy of the bout keeps the
+			// picks the destination row already holds (GroupRepPickA and
+			// GroupRepPickB move them), so the copies give the same result in
+			// any order.
+			if dstRow := subAt(dst.SubResults, pos); pos == DaihyosenSubPosition && row != nil && dstRow != nil {
+				kept := *row
+				kept.SideAMemberID, kept.SideBMemberID = dstRow.SideAMemberID, dstRow.SideBMemberID
+				row = &kept
+			}
+			dst.SubResults = setSubAt(dst.SubResults, pos, row)
 		}
 	}
 }
@@ -222,6 +338,16 @@ type flagsGroup struct {
 	FlagsB int `json:"flagsB"`
 }
 
+// repPickAGroup and repPickBGroup hold ONE key each, named as the row's field,
+// so a pick kept in the history reads as the field it was.
+type repPickAGroup struct {
+	SideAMemberID string `json:"sideAMemberId"`
+}
+
+type repPickBGroup struct {
+	SideBMemberID string `json:"sideBMemberId"`
+}
+
 type repGroup struct {
 	RepPlayerA string `json:"repPlayerA"`
 	RepPlayerB string `json:"repPlayerB"`
@@ -248,6 +374,12 @@ func groupProjection(m *MatchResult, group string) any {
 		return flagsGroup{FlagsA: m.FlagsA, FlagsB: m.FlagsB}
 	case GroupRep:
 		return repGroup{RepPlayerA: m.RepPlayerA, RepPlayerB: m.RepPlayerB}
+	case GroupRepPickA:
+		a, _ := m.RepPicks()
+		return repPickAGroup{SideAMemberID: a}
+	case GroupRepPickB:
+		_, b := m.RepPicks()
+		return repPickBGroup{SideBMemberID: b}
 	}
 	if pos, ok := ParseBoutGroup(group); ok {
 		row := subAt(m.SubResults, pos)
@@ -256,6 +388,16 @@ func groupProjection(m *MatchResult, group string) any {
 		}
 		c := CloneSubResults([]SubMatchResult{*row})[0]
 		c.IpponsA, c.IpponsB = nonNilStrings(c.IpponsA), nonNilStrings(c.IpponsB)
+		if pos == DaihyosenSubPosition {
+			// The representatives are GroupRepPickA's and GroupRepPickB's, not
+			// the bout's. The row's WinnerMemberID is derived from the winner's
+			// name and those picks after every merge
+			// (SubMatchResult.ReconcileWinnerMemberID), and the client's bout
+			// comparison leaves it out, so it is no change of the bout's: a
+			// write that echoes the row with another id (or none) has changed
+			// nothing.
+			c.SideAMemberID, c.SideBMemberID, c.WinnerMemberID = "", "", ""
+		}
 		return &c
 	}
 	return nil
@@ -295,7 +437,13 @@ func groupStampOf(stamps map[string]int64, modifiedAt int64, group string) int64
 	if stamps == nil {
 		return modifiedAt
 	}
-	return stamps[group]
+	if v, ok := stamps[group]; ok || !isRepPickGroup(group) {
+		return v
+	}
+	// A map written before the representatives had a group of their own dated
+	// them with the bout row they sit on: until they are stamped themselves,
+	// that is their date.
+	return stamps[BoutGroup(DaihyosenSubPosition)]
 }
 
 // GroupStamp is the stored stamp of group on m (see groupStampOf).
@@ -314,13 +462,33 @@ func (bm *BracketMatch) GroupStamp(group string) int64 {
 // stamped, or every other group would start reading the new ModifiedAt.
 func MaterializedGroupStamps(stamps map[string]int64, modifiedAt int64, positions []int) map[string]int64 {
 	if stamps != nil {
-		return CloneGroupStamps(stamps)
+		out := CloneGroupStamps(stamps)
+		// Fix the fallback groupStampOf reads, or a side's pick date would
+		// follow the bout row's every later stamp. A side without a key of its
+		// own takes the bout row's stamp.
+		for _, g := range []string{GroupRepPickA, GroupRepPickB} {
+			if _, ok := out[g]; ok {
+				continue
+			}
+			if v, ok := out[BoutGroup(DaihyosenSubPosition)]; ok {
+				out[g] = v
+			}
+		}
+		return out
 	}
 	out := map[string]int64{}
 	if modifiedAt <= 0 {
 		return out
 	}
+	hasRepBout := slices.Contains(positions, DaihyosenSubPosition)
 	for _, g := range ScalarGroups {
+		// The representatives' groups live on the representative bout's row:
+		// a match without that row has nothing to date, so a legacy match is
+		// not given a key it never held (a stamp a write NAMED is another
+		// matter: stampGroups adds it itself).
+		if isRepPickGroup(g) && !hasRepBout {
+			continue
+		}
 		out[g] = modifiedAt
 	}
 	for _, p := range positions {
diff --git a/internal/state/match_groups_table_test.go b/internal/state/match_groups_table_test.go
index 30dc73614..045262f09 100644
--- a/internal/state/match_groups_table_test.go
+++ b/internal/state/match_groups_table_test.go
@@ -8,6 +8,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/gitrgoliveira/bracket-creator/internal/domain"
 )
 
 // TestMatchGroups_SharedTable is the Go half of the shared Go/JS table of
@@ -148,3 +150,168 @@ func TestMergeReport_HeldDecisionRequiresTheDefaultWinStandsReason(t *testing.T)
 
 	assert.Empty(t, (*MergeReport)(nil).HeldDecision(), "a nil report names no decision")
 }
+
+// Each side's representative of the representative bout is a change of its own
+// (GroupRepPickA, GroupRepPickB), apart from the other side's and from the bout
+// row they sit on (bout:-1): a pick added or cleared differs in its side's pick
+// and not in the bout or the other side's, a point differs in the bout and not
+// in the picks, and each copy moves only its own fields, in any order.
+func TestRepPicks_AreAChangeApartFromTheBout(t *testing.T) {
+	bout := BoutGroup(DaihyosenSubPosition)
+	row := func(a, b string, ippons ...string) SubMatchResult {
+		return SubMatchResult{Position: DaihyosenSubPosition, SideA: "TeamA", SideB: "TeamB", Decision: "daihyosen",
+			SideAMemberID: a, SideBMemberID: b, IpponsA: ippons}
+	}
+	match := func(r SubMatchResult) *MatchResult { return &MatchResult{SubResults: []SubMatchResult{r}} }
+
+	// Side B's pick is a change of side B's group and of nothing else.
+	picked, cleared, scored := match(row("", "rep-b")), match(row("", "")), match(row("", "", "M"))
+	assert.True(t, GroupDiffers(picked, cleared, GroupRepPickB), "a side B pick cleared is a change of side B's pick")
+	assert.False(t, GroupDiffers(picked, cleared, GroupRepPickA), "and not of side A's")
+	assert.False(t, GroupDiffers(picked, cleared, bout), "and not of the bout")
+	assert.True(t, GroupDiffers(cleared, scored, bout), "a point is a change of the bout")
+	assert.False(t, GroupDiffers(cleared, scored, GroupRepPickA), "and not of either pick")
+	assert.False(t, GroupDiffers(cleared, scored, GroupRepPickB))
+	assert.JSONEq(t, `{"sideBMemberId":"rep-b"}`, string(GroupValue(picked, GroupRepPickB)), "a side's value holds that side's id alone")
+	assert.JSONEq(t, `{"sideAMemberId":""}`, string(GroupValue(picked, GroupRepPickA)))
+	assert.JSONEq(t, `null`, string(GroupValue(&MatchResult{}, bout)), "a removed bout has no value")
+	assert.JSONEq(t, `{"sideAMemberId":""}`, string(GroupValue(&MatchResult{}, GroupRepPickA)), "no bout, no picks")
+	assert.JSONEq(t, `{"sideBMemberId":""}`, string(GroupValue(&MatchResult{}, GroupRepPickB)), "no bout, no picks")
+
+	// And side A's pick of side A's group alone.
+	pickedA := match(row("rep-a", ""))
+	assert.True(t, GroupDiffers(pickedA, cleared, GroupRepPickA))
+	assert.False(t, GroupDiffers(pickedA, cleared, GroupRepPickB))
+
+	// Picks from one match, the bout from another: each copy takes only its own
+	// fields, so the result is the same in any order.
+	orders := [][]string{
+		{GroupRepPickA, GroupRepPickB, bout},
+		{bout, GroupRepPickA, GroupRepPickB},
+		{GroupRepPickB, bout, GroupRepPickA},
+	}
+	for i, order := range orders {
+		dst, stored := match(row("carol", "gus", "K")), match(row("dana", "hal", "M"))
+		for _, g := range order {
+			CopyGroup(dst, stored, g)
+		}
+		assert.Equal(t, []string{"M"}, dst.SubResults[0].IpponsA, "order %d", i)
+		assert.Equal(t, "dana", dst.SubResults[0].SideAMemberID, "order %d", i)
+		assert.Equal(t, "hal", dst.SubResults[0].SideBMemberID, "order %d", i)
+	}
+	// One side's copy moves only that side.
+	dst := match(row("carol", "gus"))
+	CopyGroup(dst, match(row("dana", "hal")), GroupRepPickB)
+	assert.Equal(t, "carol", dst.SubResults[0].SideAMemberID, "side A was not copied")
+	assert.Equal(t, "hal", dst.SubResults[0].SideBMemberID)
+	// And a bout copy alone leaves the picks where they are.
+	dst = match(row("carol", "gus", "K"))
+	CopyGroup(dst, match(row("dana", "hal", "M")), bout)
+	assert.Equal(t, "carol", dst.SubResults[0].SideAMemberID, "the bout's copy leaves the picks alone")
+	assert.Equal(t, "gus", dst.SubResults[0].SideBMemberID)
+
+	// A copy of the bout onto a match with no such row brings the row whole,
+	// picks included; a copy of a pick onto no row lands nowhere.
+	empty := &MatchResult{}
+	CopyGroup(empty, picked, GroupRepPickA)
+	CopyGroup(empty, picked, GroupRepPickB)
+	assert.Empty(t, empty.SubResults, "a pick has no bout to land on")
+	CopyGroup(empty, picked, bout)
+	require.Len(t, empty.SubResults, 1)
+	assert.Equal(t, "rep-b", empty.SubResults[0].SideBMemberID)
+	// A removal removes the row, picks and all.
+	CopyGroup(empty, &MatchResult{}, bout)
+	assert.Empty(t, empty.SubResults)
+
+	// RepPickGroup names a side's group, and no other value has one.
+	assert.Equal(t, GroupRepPickA, RepPickGroup(domain.MatchSideA))
+	assert.Equal(t, GroupRepPickB, RepPickGroup(domain.MatchSideB))
+	assert.Empty(t, RepPickGroup(domain.MatchSideNone))
+}
+
+// A match written before the picks had a stamp of their own dates each side's
+// pick with the bout row they sit on, and that date is fixed the first time the
+// map is materialized, so a later stamp of the bout does not move it.
+func TestRepPicks_LegacyStampFollowsTheBoutOnceThenStandsAlone(t *testing.T) {
+	bout := BoutGroup(DaihyosenSubPosition)
+	m := &MatchResult{ModifiedAt: 50, GroupStamps: map[string]int64{bout: 40, GroupPoints: 50}}
+	for _, g := range []string{GroupRepPickA, GroupRepPickB} {
+		assert.Equal(t, int64(40), m.GroupStamp(g), "%s: no entry yet: the bout row's date", g)
+		assert.Equal(t, int64(0), (&MatchResult{GroupStamps: map[string]int64{}}).GroupStamp(g), "%s: never written", g)
+	}
+
+	m.StampGroups(90, bout)
+	assert.Equal(t, int64(90), m.GroupStamp(bout))
+	for _, g := range []string{GroupRepPickA, GroupRepPickB} {
+		assert.Equal(t, int64(40), m.GroupStamp(g), "%s: the point did not date the picks", g)
+	}
+
+	// Stamping one side's pick leaves the other on the bout's old date.
+	m.StampGroups(95, GroupRepPickA)
+	assert.Equal(t, int64(95), m.GroupStamp(GroupRepPickA))
+	assert.Equal(t, int64(40), m.GroupStamp(GroupRepPickB), "the other side is not dated by it")
+
+	legacy := &MatchResult{ModifiedAt: 30, SubResults: []SubMatchResult{{Position: DaihyosenSubPosition}}}
+	for _, g := range []string{GroupRepPickA, GroupRepPickB} {
+		assert.Equal(t, int64(30), legacy.GroupStamp(g), "%s: a match with no map reads ModifiedAt", g)
+	}
+	legacy.StampGroups(60, bout)
+	for _, g := range []string{GroupRepPickA, GroupRepPickB} {
+		assert.Equal(t, int64(30), legacy.GroupStamp(g), "%s: materialized with every other group", g)
+	}
+}
+
+// A legacy (map-less) match is given the pick entries when it materializes only
+// if it holds a representative bout row: the picks live on that row, so a match
+// without one has nothing to date and gains no key it never held.
+func TestMaterializedGroupStamps_RepPicksOnlyWithARepresentativeRow(t *testing.T) {
+	t.Run("a match without the row gets every other scalar group, not the pick groups", func(t *testing.T) {
+		got := MaterializedGroupStamps(nil, 70, []int{1, 2})
+		assert.NotContains(t, got, GroupRepPickA)
+		assert.NotContains(t, got, GroupRepPickB)
+		for _, g := range ScalarGroups {
+			if g != GroupRepPickA && g != GroupRepPickB {
+				assert.Equal(t, int64(70), got[g], g)
+			}
+		}
+		assert.Equal(t, int64(70), got[BoutGroup(1)])
+		assert.Equal(t, int64(70), got[BoutGroup(2)])
+	})
+	t.Run("a match with the row gets both pick groups at its ModifiedAt", func(t *testing.T) {
+		got := MaterializedGroupStamps(nil, 70, []int{1, DaihyosenSubPosition})
+		assert.Equal(t, int64(70), got[GroupRepPickA])
+		assert.Equal(t, int64(70), got[GroupRepPickB])
+		assert.Equal(t, int64(70), got[BoutGroup(DaihyosenSubPosition)])
+	})
+	t.Run("a stamp a write named is kept on a match with no row", func(t *testing.T) {
+		m := &MatchResult{ModifiedAt: 70}
+		m.StampGroups(90, GroupRepPickA)
+		assert.Equal(t, int64(90), m.GroupStamps[GroupRepPickA], "naming the group stamps it, row or not")
+		assert.Equal(t, int64(90), m.GroupStamp(GroupRepPickA))
+		assert.NotContains(t, m.GroupStamps, GroupRepPickB, "and only that side")
+	})
+}
+
+// TestSubResultAt_IsTheFirstRowAtThePositionAsAValue pins what the self-run
+// member judge relies on when it compares a landed row with the stored one at
+// the same position: the FIRST row at the position, copied (the caller reads
+// it, never edits the stored list), and the empty row when the match lacks the
+// position, since a position a match lacks holds no member id.
+func TestSubResultAt_IsTheFirstRowAtThePositionAsAValue(t *testing.T) {
+	t.Parallel()
+
+	subs := []SubMatchResult{
+		{Position: 1, SideAMemberID: "first"},
+		{Position: DaihyosenSubPosition, SideAMemberID: "rep"},
+		{Position: 1, SideAMemberID: "second"},
+	}
+
+	assert.Equal(t, "first", SubResultAt(subs, 1).SideAMemberID, "the first row at a position wins")
+	assert.Equal(t, "rep", SubResultAt(subs, DaihyosenSubPosition).SideAMemberID)
+	assert.Equal(t, SubMatchResult{}, SubResultAt(subs, 7), "a position the match lacks is the empty row")
+	assert.Equal(t, SubMatchResult{}, SubResultAt(nil, 1))
+
+	got := SubResultAt(subs, 1)
+	got.SideAMemberID = "edited"
+	assert.Equal(t, "first", subs[0].SideAMemberID, "the answer is a copy: editing it leaves the stored list alone")
+}
diff --git a/internal/state/models.go b/internal/state/models.go
index 7806b9568..f1c72c5c1 100644
--- a/internal/state/models.go
+++ b/internal/state/models.go
@@ -1431,6 +1431,35 @@ func (s *SubMatchResult) ResolveMemberWinnerID() bool {
 	return false
 }
 
+// ReconcileWinnerMemberID keeps a representative-bout row's WinnerMemberID
+// consistent with the two representatives it names: WinnerMemberID belongs to
+// the bout's result and each representative to its own change
+// (GroupRepPickA, GroupRepPickB), so a merge can leave a winner id that
+// disagrees with them.
+// The id is always cleared and derived again by ResolveMemberWinnerID, from
+// the winner's NAME alone and the side's stored pick, so afterwards it is
+// exactly the pick of the side the Winner name names, or empty. It is empty
+// when there is no Winner, when the Winner names neither side, when the
+// winning side has no pick, and when the two side names are equal (two
+// same-named teams are forbidden by rule, so that row is legacy data and the
+// name cannot say who won; there is no special case for it).
+//
+// A stored id is never consulted to decide the winning side: SubBoutWinnerSide
+// and Attribution read WinnerMemberID first, so a stale id would decide its own
+// verdict, and an id naming the LOSING side's pick, which a test of "is it one
+// of the two picks" accepts, would credit the wrong side id-first. It reports
+// whether the id changed.
+//
+// The rule is the representative bout's only. The numbered and kachinuki rows
+// are not reconciled here: their winner id is the editor's (a same-name fighter
+// pair cannot be told apart by name, see ResolveMemberWinnerID).
+func (s *SubMatchResult) ReconcileWinnerMemberID() bool {
+	before := s.WinnerMemberID
+	s.WinnerMemberID = ""
+	s.ResolveMemberWinnerID()
+	return s.WinnerMemberID != before
+}
+
 // IneligibleSidesAnnotation names which side(s) of a SCHEDULED match are
 // currently barred by a withdrawal recorded on a DIFFERENT match (bc-cse).
 // Both fields are optional and independent: either, both, or neither may be
@@ -1627,9 +1656,8 @@ type MatchResult struct {
 	//
 	// SERVER-OWNED. MatchResult binds straight from the score request body, so
 	// a client could otherwise plant or clear the flag; the handler overwrites
-	// it from the STORED value on every write (see
-	// applyCorrectionReasonUnderTx in mobileapp/handlers_match.go) and is the
-	// only thing that moves it.
+	// it from the STORED value on every write (see applyCorrectionReason in
+	// mobileapp/handlers_match.go) and is the only thing that moves it.
 	//
 	// Append-only CSV column (rec index 24, after FlagsB at 22/23); older files
 	// with the column absent load as false. Bracket matches mirror it on
diff --git a/internal/state/models_test.go b/internal/state/models_test.go
index 824212a63..f0c2021d7 100644
--- a/internal/state/models_test.go
+++ b/internal/state/models_test.go
@@ -220,6 +220,64 @@ func TestSubMatchResult_ResolveMemberWinnerID(t *testing.T) {
 	})
 }
 
+// TestSubMatchResult_ReconcileWinnerMemberID pins the representative-bout rule
+// (bc-mrgc, GroupRepPickA and GroupRepPickB): after a merge, WinnerMemberID is EXACTLY the stored
+// pick of the side the Winner NAME names, or empty. It is derived from the name
+// alone and never decided through the stored id (SubBoutWinnerSide and
+// Attribution read WinnerMemberID first, so a stale id would decide its own
+// verdict): an id that names the LOSING side's pick is as wrong as one naming
+// nobody, and id-first attribution would credit the wrong side.
+func TestSubMatchResult_ReconcileWinnerMemberID(t *testing.T) {
+	row := func(winner, winnerID string) SubMatchResult {
+		return SubMatchResult{
+			Position: DaihyosenSubPosition, SideA: "Kyoto", SideB: "Osaka",
+			SideAMemberID: "pick-a", SideBMemberID: "pick-b",
+			Winner: winner, WinnerMemberID: winnerID,
+		}
+	}
+	cases := []struct {
+		name      string
+		sub       SubMatchResult
+		want      string
+		wantMoved bool
+	}{
+		{"an id naming the winning side's pick stands", row("Kyoto", "pick-a"), "pick-a", false},
+		{"an id naming the LOSING side's pick is replaced by the winning side's", row("Kyoto", "pick-b"), "pick-a", true},
+		{"an id naming the losing side's pick, side B winning", row("Osaka", "pick-a"), "pick-b", true},
+		{"an id naming nobody is replaced by the winning side's pick", row("Osaka", "gone"), "pick-b", true},
+		{"no id is derived from the winning side's pick", row("Kyoto", ""), "pick-a", true},
+		{"no winner: a stored id is cleared", row("", "pick-a"), "", true},
+		{"no winner and no id: nothing to do", row("", ""), "", false},
+		{"a winner naming neither side: the id is cleared", row("Nagoya", "pick-a"), "", true},
+		{"the winning side has no pick: the other side's id is cleared, not kept", func() SubMatchResult {
+			s := row("Kyoto", "pick-b")
+			s.SideAMemberID = ""
+			return s
+		}(), "", true},
+		{"the winning side has no pick and no id: still empty", func() SubMatchResult {
+			s := row("Kyoto", "")
+			s.SideAMemberID = ""
+			return s
+		}(), "", false},
+		// Two same-named teams are forbidden by rule (team names are unique,
+		// helper.DuplicateNamesWithKeys), so this is legacy data: the name
+		// cannot say which side won, and the id is left empty rather than
+		// guessed, with no special case here.
+		{"same-named sides cannot be told apart: the id is cleared", func() SubMatchResult {
+			s := row("Kyoto", "pick-b")
+			s.SideB = "Kyoto"
+			return s
+		}(), "", true},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			sub := tc.sub
+			assert.Equal(t, tc.wantMoved, sub.ReconcileWinnerMemberID())
+			assert.Equal(t, tc.want, sub.WinnerMemberID)
+		})
+	}
+}
+
 // TestSubMatchResult_HanteiRoundTrip pins the wire/storage contract for the
 // per-bout hantei flag the viewer reads (mp-8sw). The flag is TRI-STATE
 // (*bool): true and explicit false both serialize (a withdrawal must reach
diff --git a/internal/state/team_result_test.go b/internal/state/team_result_test.go
index 04c9e967c..23258cc34 100644
--- a/internal/state/team_result_test.go
+++ b/internal/state/team_result_test.go
@@ -527,3 +527,19 @@ func TestTeamResultFrom_DefaultWinCredit(t *testing.T) {
 		assert.Equal(t, &TeamResultLine{ShiroIV: 1, ShiroPW: 2}, got, "only position 1 counts, credited to TeamB")
 	})
 }
+
+// bc-dhrp: the representative bout names the two TEAMS and carries each side's
+// representative as a member id. The winner is the side the bout was won for,
+// read by the winner's id when one is stamped and by the team name when not.
+func TestSubBoutWinnerSide_RepresentativeBoutWithMemberIDs(t *testing.T) {
+	rep := func(winner, winnerID string) SubMatchResult {
+		return SubMatchResult{
+			Position: -1, SideA: "TeamA", SideB: "TeamB",
+			SideAMemberID: "rep-a", SideBMemberID: "rep-b",
+			Winner: winner, WinnerMemberID: winnerID, Decision: "daihyosen",
+		}
+	}
+	assert.Equal(t, domain.MatchSideB, SubBoutWinnerSide(rep("TeamB", "rep-b"), "TeamA", "TeamB"), "by the winner's id")
+	assert.Equal(t, domain.MatchSideB, SubBoutWinnerSide(rep("TeamB", ""), "TeamA", "TeamB"), "by the team name when no id is stamped")
+	assert.Equal(t, domain.MatchSideA, SubBoutWinnerSide(rep("TeamA", "rep-a"), "TeamA", "TeamB"), "side A by its id")
+}
diff --git a/internal/state/testdata/match_groups.json b/internal/state/testdata/match_groups.json
index efbbe7e84..34d8d4a94 100644
--- a/internal/state/testdata/match_groups.json
+++ b/internal/state/testdata/match_groups.json
@@ -1,11 +1,11 @@
 {
-  "_comment": "Shared Go/JS table of the groups a match write is merged by (bc-mrgc). Go half: TestMatchGroups_SharedTable (internal/state/match_groups_table_test.go) against state.ScalarGroups, BoutGroup, ParseBoutGroup and ValidGroup. JS half: web-mobile/js/__tests__/match_groups_table.test.jsx against match_groups.jsx's SCALAR_GROUPS, boutGroup, parseBoutGroup and isValidGroup. A client write names its groups by these exact strings in `changed`, and the server refuses a name it does not know, so the two lists must never drift.",
-  "scalarGroups": ["points", "result", "encho", "flags", "rep"],
+  "_comment": "Shared Go/JS table of the groups a match write is merged by (bc-mrgc). Go half: TestMatchGroups_SharedTable (internal/state/match_groups_table_test.go) against state.ScalarGroups (repPickA and repPickB: each side's representative of the representative bout, a change of its own, dated apart from the other side's and from bout:-1), BoutGroup, ParseBoutGroup and ValidGroup. JS half: web-mobile/js/__tests__/match_groups_table.test.jsx against match_groups.jsx's SCALAR_GROUPS, boutGroup, parseBoutGroup and isValidGroup. A client write names its groups by these exact strings in `changed`, and the server refuses a name it does not know, so the two lists must never drift.",
+  "scalarGroups": ["points", "result", "encho", "flags", "rep", "repPickA", "repPickB"],
   "bouts": [
     { "position": 1, "group": "bout:1" },
     { "position": 2, "group": "bout:2" },
     { "position": 9, "group": "bout:9" },
     { "position": -1, "group": "bout:-1" }
   ],
-  "invalid": ["", "score", "points ", "Bout:1", "bout:", "bout:x", "bout:1.5"]
+  "invalid": ["", "score", "points ", "Bout:1", "bout:", "bout:x", "bout:1.5", "repPicks"]
 }
diff --git a/knockout-example-large-seeded.xlsx b/knockout-example-large-seeded.xlsx
index 2c0a13015..184563bb3 100644
Binary files a/knockout-example-large-seeded.xlsx and b/knockout-example-large-seeded.xlsx differ
diff --git a/knockout-example-large.xlsx b/knockout-example-large.xlsx
index 32465aa9b..3e18b3c2a 100644
Binary files a/knockout-example-large.xlsx and b/knockout-example-large.xlsx differ
diff --git a/knockout-example-medium-seeded.xlsx b/knockout-example-medium-seeded.xlsx
index 437df65b1..336fb85a7 100644
Binary files a/knockout-example-medium-seeded.xlsx and b/knockout-example-medium-seeded.xlsx differ
diff --git a/knockout-example-medium.xlsx b/knockout-example-medium.xlsx
index 1cec46c10..87d097332 100644
Binary files a/knockout-example-medium.xlsx and b/knockout-example-medium.xlsx differ
diff --git a/knockout-example-small.xlsx b/knockout-example-small.xlsx
index 1cef743fa..f13796f02 100644
Binary files a/knockout-example-small.xlsx and b/knockout-example-small.xlsx differ
diff --git a/pools-example-large-max-size.xlsx b/pools-example-large-max-size.xlsx
index d872d75ce..2fbed8ebe 100644
Binary files a/pools-example-large-max-size.xlsx and b/pools-example-large-max-size.xlsx differ
diff --git a/pools-example-large-seeded.xlsx b/pools-example-large-seeded.xlsx
index e766459b8..53834ca62 100644
Binary files a/pools-example-large-seeded.xlsx and b/pools-example-large-seeded.xlsx differ
diff --git a/pools-example-large-teams-max-size.xlsx b/pools-example-large-teams-max-size.xlsx
index 84ef25ac6..129459376 100644
Binary files a/pools-example-large-teams-max-size.xlsx and b/pools-example-large-teams-max-size.xlsx differ
diff --git a/pools-example-large-teams.xlsx b/pools-example-large-teams.xlsx
index a4239d0f0..c68d0a750 100644
Binary files a/pools-example-large-teams.xlsx and b/pools-example-large-teams.xlsx differ
diff --git a/pools-example-medium-seeded-one-qualifier.xlsx b/pools-example-medium-seeded-one-qualifier.xlsx
index b39a40eb8..140f299c9 100644
Binary files a/pools-example-medium-seeded-one-qualifier.xlsx and b/pools-example-medium-seeded-one-qualifier.xlsx differ
diff --git a/pools-example-medium-seeded.xlsx b/pools-example-medium-seeded.xlsx
index 5f06892c1..d79b6d4fc 100644
Binary files a/pools-example-medium-seeded.xlsx and b/pools-example-medium-seeded.xlsx differ
diff --git a/pools-example-medium.xlsx b/pools-example-medium.xlsx
index d70f8a550..134bfc5a9 100644
Binary files a/pools-example-medium.xlsx and b/pools-example-medium.xlsx differ
diff --git a/pools-example-single-pool-8-round-robin.xlsx b/pools-example-single-pool-8-round-robin.xlsx
index edd326fd1..8ea634c62 100644
Binary files a/pools-example-single-pool-8-round-robin.xlsx and b/pools-example-single-pool-8-round-robin.xlsx differ
diff --git a/pools-example-single-pool-8.xlsx b/pools-example-single-pool-8.xlsx
index 1f10ee7db..37e9dbbcf 100644
Binary files a/pools-example-single-pool-8.xlsx and b/pools-example-single-pool-8.xlsx differ
diff --git a/pools-example-small-3-teams.xlsx b/pools-example-small-3-teams.xlsx
index 52037ce8e..3076ecea7 100644
Binary files a/pools-example-small-3-teams.xlsx and b/pools-example-small-3-teams.xlsx differ
diff --git a/pools-example-small.xlsx b/pools-example-small.xlsx
index 0d04d5816..3982ebc34 100644
Binary files a/pools-example-small.xlsx and b/pools-example-small.xlsx differ
diff --git a/pools-example-teams-of-3-round-robin.xlsx b/pools-example-teams-of-3-round-robin.xlsx
index f759a03cd..0fb393fa2 100644
Binary files a/pools-example-teams-of-3-round-robin.xlsx and b/pools-example-teams-of-3-round-robin.xlsx differ
diff --git a/specs/openapi.yaml b/specs/openapi.yaml
index b1adc581d..f4b8e5533 100644
--- a/specs/openapi.yaml
+++ b/specs/openapi.yaml
@@ -51,7 +51,30 @@ info:
     not have (a sheet a moment behind a remove made elsewhere) is dropped from the
     write and the rest is written as usual, unless the write finishes the match,
     which may take its winner from that row and is refused with 409 `no_daihyosen`; a write listing
-    two is refused with 400 `duplicate_daihyosen`. Nor does it remove one: a write listing
+    two is refused with 400 `duplicate_daihyosen`, a representative pick that names a member the
+    side's team does not hold is refused with 400 `team_member_not_in_team` (the organiser's
+    picks are judged the same way, see `PUT .../score`). The row's winner member id
+    is not judged: the merge keeps it naming one of the two stored representatives. A numbered
+    bout row is judged for what the write introduces against the stored row at the same position:
+    a fighter whose member id the side's team does not hold is refused with 400
+    `team_member_not_in_team`, and a `winnerMemberId` that is not one of the row's two fighters
+    is refused with 400 `winner_member_not_in_bout`; an id the stored row already holds is never
+    judged, and the organiser's numbered rows are not judged at all. A member a write would seat
+    (a participant's numbered row fighter or winner, a representative pick from anyone) is judged
+    on what the write LANDS, after the merge, in the same transaction: the match is read back as
+    stored, and a refused write lands nothing (no change to the match, no history entry). A stale
+    change the merge holds is therefore not judged: a pick or a row the write names (in `changed`,
+    or by default every group its row carries) and stamps before the stored one is kept in the
+    match's history and answered in `heldGroups`, e.g. `["bout:1"]`, never refused, while one the
+    write does not name (and the engine does not rewrite, as it does a kachinuki write's bout log)
+    is copied from the stored match, neither written nor reported: it is in neither `heldGroups`
+    nor the history. When the competition's `team-members.yaml` cannot be read,
+    a write that needs it to judge a choice (a pick, a numbered row's fighter, or the lineup
+    save) is refused with 409 `team_members_unreadable` and nothing is written, so the offline
+    queue does not retry it; a write that introduces no member id never reads the file. The rest of the write is
+    ordered by its own stamps, so it is applied and answered with `heldGroups` naming the held
+    side's group, e.g. `["repPickA"]`; it is answered as superseded only when every group it
+    changes is held. Nor does it remove one: a write listing
     the bouts without the representative bout the match has (a sheet a moment behind an
     add made elsewhere) keeps the stored row, scored or not, unless it finishes the match,
     which is refused with 409 `daihyosen_added`. It carries only what the competitors saw: a match
@@ -934,7 +957,10 @@ paths:
         Sends a transient text announcement to all connected viewer screens via SSE.
         The announcement is stored in-memory only (not persisted to disk); a server
         restart clears it. Late-connecting viewers can retrieve the active announcement
-        via `GET /api/tournament/announcement`.
+        via `GET /api/tournament/announcement`. A message identical to one still active
+        replaces it (new id, fresh duration) rather than adding a second entry.
+        The replaced id stays valid for `DELETE /api/announcements/{id}` while the
+        announcement that replaced it is active: it takes that announcement down.
 
         **Validation:**
         - `message` must be non-empty after trimming whitespace.
@@ -979,6 +1005,72 @@ paths:
               schema:
                 $ref: '#/components/schemas/Error'
 
+  /api/tournament/announcements:
+    get:
+      tags: [tournament]
+      summary: List active announcements
+      description: |
+        Returns every announcement still active, oldest first (`[]` when none).
+        No authentication required.
+      responses:
+        '200':
+          description: Active announcements.
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Announcement'
+
+  /api/announcements/{id}:
+    delete:
+      tags: [tournament]
+      summary: Withdraw one announcement
+      description: |
+        Takes one announcement down and pushes the remaining list to viewers
+        over SSE. An id that an identical announcement replaced stays valid
+        while the replacing announcement is active, and takes that one down.
+      security:
+        - TournamentPassword: []
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '204':
+          description: Announcement withdrawn.
+        '401':
+          description: Missing or invalid X-Tournament-Password.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '404':
+          description: No active announcement has this id.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+
+  /api/announcements:
+    delete:
+      tags: [tournament]
+      summary: Withdraw every announcement
+      description: Clears all announcements and pushes the empty list to viewers over SSE.
+      security:
+        - TournamentPassword: []
+      responses:
+        '204':
+          description: All announcements withdrawn.
+        '401':
+          description: Missing or invalid X-Tournament-Password.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+
   # ── Competitions (Admin, requires auth) ────────────────────────────────────
 
   /api/competitions:
@@ -2397,8 +2489,15 @@ paths:
           tie, an engi count that is not valid), the finish is applied on its
           own scoreline, as in stamp order, and that newer scoring is moved to
           the match's history as held; the answer names it in
-          `displacedGroups`, with the same `heldReason`. A finish that carries
-          no scoreline of its own is held instead. A points change whose write does not apply
+          `displacedGroups`, with `heldReason: needs_winner`. A finish that carries
+          no scoreline of its own is held instead. A write that removes the
+          representative bout (a write that names it and carries no row, such
+          as the daihyosen DELETE) likewise moves a representative pick
+          (`repPickA`, `repPickB`) stamped AFTER the removal to the history,
+          since in stamp order the pick landed on a bout that no longer
+          existed; the answer names it in `displacedGroups` with NO
+          `heldReason` (it is no question of the winner), and the history
+          keeps it with the reason "the representative bout was removed". A points change whose write does not apply
           `result` keeps a recorded judges' decision (hantei mark). A scoring change made on a
           running board after a recorded kiken, fusenpai, or fusensho clears
           it (points scored mean the withdrawal was a mistake), and the competitor
@@ -2423,7 +2522,11 @@ paths:
             An applied finish that moved stored, NEWER scoring into the
             match's history (it would have left the match without a winner,
             and in stamp order came after this finish) carries
-            `displacedGroups` naming those groups, with the same `heldReason`.
+            `displacedGroups` naming those groups, with `heldReason:
+            needs_winner`. An applied removal of the representative bout that
+            moved a representative pick stamped after it into the history
+            carries `displacedGroups` naming the pick's group (`repPickA` or
+            `repPickB`) with no `heldReason`.
             A running write the rev-guard finds older than one the same client
             session already sent (a lower rev, e.g. an out-of-order reconnect
             flush) is not applied and not dropped: the whole write is kept in
@@ -2476,6 +2579,61 @@ paths:
             participant: "A team match has one representative bout, and this
             score lists more than one. Check the scores and try again."
 
+            A request whose representative bout (position `-1`) names a member
+            the side's team does not hold (a pick the stored row does not
+            already hold) is refused with `error: team_member_not_in_team`, with
+            a `message` to show, whoever sends it: a participant (an empty
+            password) or the organiser, so the two never disagree about which
+            pick is valid. The `message` is "The representative chosen is not
+            on this team. Pick again from the list." The organiser is judged on
+            that pick and on nothing else of the row: the match's status is not
+            asked (a pick on a finished match is judged, never refused for the
+            finish, and the organiser can pick again at once), a start
+            (`startOnly`) is not judged, and a match with no representative bout
+            is judged against an empty row, since the organiser's write can
+            create it. The row's winner member id is not judged: the
+            merge keeps it naming one of the two stored representatives, or empty.
+            A pick is judged on what the write LANDS, after the merge, in the same
+            transaction: the match is read back as stored, and a pick it now holds
+            that the stored row did not is refused when its side's team does not
+            hold the member. A refused write lands nothing: no change to the
+            match and no history entry. A pick the merge holds is not judged: one
+            the write names (in `changed`, or by default every group its row
+            carries) and stamps strictly before the stored representative, or one
+            carried by a finish the merge holds whole (stamped before the stored
+            verdict and naming another winner), is kept in the match's history and
+            answered in `heldGroups`, never refused (an equal stamp applies, so it
+            is judged). A pick the write does not name in `changed` is copied from
+            the stored match, neither written nor reported: it is in neither
+            `heldGroups` nor the history.
+            The rest of the write is ordered by its own stamps,
+            so it is applied and answered with `heldGroups` naming the held side's
+            group, e.g. `["repPickA"]`; it is answered as superseded, with nothing
+            written, only when every group it changes is held.
+
+            A request with an empty password (self-run) is also judged on every
+            numbered bout row (position 1 and up) for what it introduces against
+            the stored row at the same position. A `sideAMemberId` or
+            `sideBMemberId` the side's team does not hold is refused with
+            `error: team_member_not_in_team` and the `message` "The fighter chosen
+            is not on this team. Pick again from the list." A `winnerMemberId`
+            that is neither empty nor one of the row's two fighters (the row's own
+            ids, or the stored row's for a side the row is silent about) is refused
+            with `error: winner_member_not_in_bout` and the `message` "The winner
+            recorded is not one of the two fighters in this bout." An id the
+            stored row already holds is never judged. A row is judged as it
+            LANDS (see the pick above), not as its payload reads: the engine
+            rewrites a kachinuki write before its merge (it merges the bout log by
+            position and fills in member ids), so a row the payload does not name
+            in `changed` can still land, and is judged then; a refused write lands
+            nothing. A row the merge holds (named in `changed`, or by default, and
+            stamped before the stored one) is not judged: it is kept in the
+            match's history, and the rest of the write is applied and answered
+            with `heldGroups`, e.g. `["bout:1"]`. A row the write does not name
+            and the engine does not rewrite is copied from the stored match,
+            neither written nor reported. The organiser's numbered rows are not
+            judged.
+
             A `completed` write whose `decision` is empty or `hikiwake` on a
             match whose stored result is a completed withdrawal (kiken or
             fusenpai) is a score sheet's correction, which cannot state a
@@ -2504,7 +2662,19 @@ paths:
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/Error'
+                type: object
+                required: [error]
+                properties:
+                  error:
+                    type: string
+                    description: >
+                      The reason the payload was refused, or for the refusals that
+                      carry a `message` the machine-readable code
+                      (`duplicate_daihyosen`, `team_member_not_in_team`,
+                      `winner_member_not_in_bout`).
+                  message:
+                    type: string
+                    description: The sentence the page shows as it is, for those refusals.
         '401':
           description: >
             `invalid tournament password`: the password is missing or wrong in an
@@ -2516,7 +2686,7 @@ paths:
                 $ref: '#/components/schemas/Error'
         '409':
           description: |
-            Conflict; one of nine codes returned in the `error` field:
+            Conflict; one of eleven codes returned in the `error` field:
             - `court_busy`: court already has a running match in this or another competition.
               Extra fields: `court`, `matchId`, `compId`, `label`, `message`.
             - `ineligible_competitor`: a participant is ineligible (kiken/fusenpai in a prior match, or barred by
@@ -2558,6 +2728,13 @@ paths:
               the stored row and is written as usual. Extra fields: `message`, "A
               representative bout was added to this match on another device. Check the
               scores and finish again."
+            - `team_members_unreadable`: the competition's `team-members.yaml` cannot be
+              read, and the write introduces a member id to judge against it (a
+              representative pick, or a numbered bout row's fighter). Nothing is
+              written, and unlike a 500 the offline queue does not retry it. A write that
+              introduces no member id never reads the file. Extra fields: `message`, "The
+              team members could not be read, so this choice cannot be checked. The
+              organiser needs to check team-members.yaml in the tournament data."
             - `side_mismatch`: the submitted winner does not match either side of the match.
               Extra fields: `message`.
             - `downstream_knockout_played`: the write would change who a
@@ -2595,6 +2772,7 @@ paths:
                       - hantei_organiser_only
                       - no_daihyosen
                       - daihyosen_added
+                      - team_members_unreadable
                       - side_mismatch
                       - downstream_knockout_played
                       - downstream_knockout_running
@@ -2616,7 +2794,7 @@ paths:
                       `engine.OperatorMatchLabel`.
                   message:
                     type: string
-                    description: Human-readable detail (court_busy, result_finalized, hantei_organiser_only, no_daihyosen, daihyosen_added, side_mismatch, downstream_knockout_played, downstream_knockout_running); for the self-run codes, the sentence the public page shows as it is.
+                    description: Human-readable detail (court_busy, result_finalized, hantei_organiser_only, no_daihyosen, daihyosen_added, team_members_unreadable, side_mismatch, downstream_knockout_played, downstream_knockout_running); for the self-run codes, the sentence the public page shows as it is.
                   playerId:
                     type: string
                     description: Ineligible participant ID (ineligible_competitor / already_ineligible).
@@ -3338,6 +3516,14 @@ paths:
         "Bout 5 (Taisho) has no result. Record a score, a Tie, or a Fusensho before finishing."
         Nothing is written for that entry, and other entries are unaffected.
 
+        An entry is written in its own transaction and its representative bout (position `-1`)
+        is judged on what it lands, as on PUT /score: a pick the stored row did not hold that
+        names a member the side's team does not hold is refused, reported in `errors` with
+        `reason: team_member_not_in_team` and the page's sentence in `error`. When the
+        competition's `team-members.yaml` cannot be read, an entry that needs it is refused with
+        `reason: team_members_unreadable`. Nothing is written for a refused entry, its history
+        entry included, and other entries are unaffected. Numbered bout rows are not judged.
+
 
         Stays main-password-gated in self-run mode (401 without it): it writes results
         without PUT /score's self-run checks.
@@ -3380,7 +3566,7 @@ paths:
                             classes `reason` names below.
                         reason:
                           type: string
-                          enum: [superseded, clock_skew, corrupt_overrides, downstream_knockout_played, downstream_knockout_running]
+                          enum: [superseded, clock_skew, corrupt_overrides, downstream_knockout_played, downstream_knockout_running, team_member_not_in_team, team_members_unreadable]
                           description: >
                             Machine-readable discriminator, present only for the
                             classes named here and omitted for every other failure, so
@@ -3409,7 +3595,12 @@ paths:
                             fought now, or a knockout correction whose new winner would
                             change a side of a later knockout match being fought now;
                             `forceDownstreamReopen` does not get past it; finish or
-                            requeue that match, then retry. In
+                            requeue that match, then retry.
+                            `team_member_not_in_team`: the entry's representative pick
+                            names a member the side's team does not hold; `error` carries
+                            the sentence to show. `team_members_unreadable`: the
+                            competition's team-members.yaml could not be read, so the
+                            pick could not be judged. In
                             every case the entry is excluded from `succeeded` and never
                             broadcast. Other entries in the batch are unaffected.
                         heldGroups:
@@ -3707,6 +3898,11 @@ paths:
         with no id (an unresolved feeder or a bye) has nothing to bar it.
 
 
+        The new representative-bout row is stored with the match's team names
+        as `sideA` and `sideB`, so it is never nameless between the add and the
+        first score write.
+
+
         The add competes on timestamps like a score write when it carries
         `modifiedAt`: the match it writes takes that stamp, so a copy of the
         match read before the add is older than the one it returns.
@@ -3858,7 +4054,9 @@ paths:
             `clock_skew`); nothing is applied to the match and no SSE event is
             emitted. A superseded remove carries `heldGroups` and is kept in
             the match's history. The removed bout keeps its stamp, so an older
-            write still carrying it cannot bring it back.
+            write still carrying it cannot bring it back. An applied remove may
+            carry `displacedGroups` with no `heldReason`: a representative pick
+            made after the removal was moved to the match's history.
           content:
             application/json:
               schema:
@@ -3876,6 +4074,14 @@ paths:
                           Present when the remove applied in part: the groups
                           held and kept in the match's history. As
                           RefusedWrite.heldGroups.
+                      displacedGroups:
+                        type: array
+                        items:
+                          $ref: '#/components/schemas/MergeGroup'
+                        description: >
+                          Present when a representative pick stamped after the
+                          removal was moved to the match's history, with no
+                          `heldReason`. As MatchResult.displacedGroups.
                       heldReason:
                         type: string
                         enum: [needs_winner, default_win_stands]
@@ -4181,9 +4387,12 @@ paths:
         bout's fighter (bc-dhas). Such a request is refused for a match that
         does not exist (404), for a team the match does not hold by id (404
         `team_not_in_match`), for a member id the team does not hold among the
-        positions the save writes (400 `team_member_not_in_team`), or for a match
+        positions the save writes (400 `team_member_not_in_team`), for a match
         that has finished (409 `result_finalized`, the score endpoint's own
-        refusal); the organiser, sending the password, keeps the always-editable
+        refusal), or when the competition's `team-members.yaml` cannot be read and
+        the save names a member id to check (409 `team_members_unreadable`, which
+        the offline queue does not retry; a save that names no member id never
+        reads the file); the organiser, sending the password, keeps the always-editable
         rule above, and a password that is sent but wrong gets 401 before the
         body is read.
       security:
@@ -4237,7 +4446,9 @@ paths:
         '409':
           description: |
             Self-run, an empty password: the match has finished
-            (`error: result_finalized`, with a `message` to show).
+            (`error: result_finalized`, with a `message` to show), or the
+            team members could not be read to check a member id
+            (`error: team_members_unreadable`, with a `message` to show).
           content:
             application/json:
               schema:
@@ -4245,7 +4456,7 @@ paths:
                 properties:
                   error:
                     type: string
-                    enum: [result_finalized]
+                    enum: [result_finalized, team_members_unreadable]
                   message:
                     type: string
         '500':
@@ -5299,9 +5510,12 @@ components:
         door:
           type: string
           description: >
-            What made the write (`displaced`: a stored change a finish made
-            before it moved to the history, see MatchResult.displacedGroups):
-            score, bulk-score, quick-score, decision,
+            What made the write (`displaced`: a stored change that a finish or
+            a removal of the representative bout, arriving after it but stamped
+            earlier, moved to the history, see MatchResult.displacedGroups;
+            `reseat`: a side of the match was given another team by a
+            correction to an earlier match, and the side's representative pick
+            went with it): score, bulk-score, quick-score, decision,
             daihyosen-add, daihyosen-remove, reopen, requeue, override-winner,
             engi, kachinuki-advance, kachinuki-remove-bout, downstream-reopen,
             or engine for a write the server made itself.
@@ -5350,9 +5564,11 @@ components:
             for a match one of those decisions already closed; the answer
             carries `heldReason: default_win_stands` and `heldDecision`), "a
             knockout match needs a winner" (a change that would leave a
-            finished knockout match tied), or "an engi result needs a valid
+            finished knockout match tied), "an engi result needs a valid
             flag count" (a recount that would leave a finished engi match with
-            none). Absent when each group was judged by its own stamp.
+            none), or "the representative bout was removed" (a representative
+            pick stamped after the bout's removal, moved here by the removal).
+            Absent when each group was judged by its own stamp.
         clearedWithdrawal:
           type: object
           description: The kiken, fusenpai, or fusensho a later scoring change cleared (the result group as it was), when one was.
@@ -5367,11 +5583,18 @@ components:
         decision, decisionBy, decisionReason, and the correctionReason and
         resultSource that describe it); `encho` the match-level overtime;
         `flags` the engi flag counts; `rep` the pool representative players;
-        and `bout:<position>` one bout row (1..n, or -1 for the representative
-        bout). The sides, court, schedule and round are not groups. A write
+        `repPickA` and `repPickB` the two representatives of a team match's
+        representative bout (the member ids `sideAMemberId` and `sideBMemberId`
+        on its `-1` row), one group per side: each is a change of its own,
+        dated apart from the other side's, that a point struck on the bout
+        never alters and that never alters the bout's score; and `bout:<position>`
+        one bout row (1..n, or -1 for the representative bout, without the
+        two representatives or the winner's member id, which the server
+        derives). The sides, court, schedule and round are not
+        groups. A write
         names the groups it changes in `changed`; the match records the stamp
         of the last applied change to each in `groupStamps`.
-      pattern: '^(points|result|encho|flags|rep|bout:-?[0-9]+)$'
+      pattern: '^(points|result|encho|flags|rep|repPickA|repPickB|bout:-?[0-9]+)$'
 
     DaihyosenWriteStamp:
       type: object
@@ -6242,6 +6465,9 @@ components:
             needs, or because a decision (a kiken or a fusenpai of this
             match, or a fusensho awarded for a bar recorded on a DIFFERENT
             match) already closed the match (see RefusedWrite.heldReason).
+            Absent when the groups were held by their stamps alone, and
+            absent beside a `displacedGroups` that names a representative
+            pick moved by a removal of the representative bout.
         heldDecision:
           type: string
           readOnly: true
@@ -6253,11 +6479,16 @@ components:
             $ref: '#/components/schemas/MergeGroup'
           description: >
             On a write's response only: groups whose STORED values this
-            (applied) finish moved to the match's history, held. They were
-            changed after the finish was made and would have left the match
-            without the winner it needs, so in stamp order they could not
-            apply after it. The history keeps them, at their own stamp, with
-            door `displaced`.
+            (applied) write moved to the match's history, held. The history
+            keeps them, at their own stamp, with door `displaced`. Two cases.
+            A finish moves scoring changed after the finish was made that
+            would have left the match without the winner it needs, so in
+            stamp order it could not apply after it; the answer then carries
+            `heldReason: needs_winner`. A removal of the representative bout
+            moves a representative pick (`repPickA`, `repPickB`) stamped after
+            the removal, since in stamp order the pick landed on a bout that
+            no longer existed; the answer then carries NO `heldReason`, and
+            the history reason is "the representative bout was removed".
         sideA:
           type: string
           maxLength: 100
diff --git a/web-mobile/check-imports.mjs b/web-mobile/check-imports.mjs
index 6fc960ba0..e2419e34b 100644
--- a/web-mobile/check-imports.mjs
+++ b/web-mobile/check-imports.mjs
@@ -49,6 +49,9 @@ const CHECK_MODULES = [
   'admin_scoring_team.jsx',
   'admin_scoring_shared.jsx',
   'admin_scoring_autosave.jsx',
+  // The one owner of how a match start is judged (both the court console and
+  // the Scores tab import it).
+  'start_match.jsx',
   'bracket.jsx',
   'match_scoreboard.jsx',
   'admin_setup.jsx',
@@ -82,6 +85,14 @@ const CHECK_MODULES = [
   'app.jsx',
   'ui.jsx',
   'admin_shiaijo.jsx',
+  // The result-mark placement leaf (sideMarks, placeMarks, winnerSideLR,
+  // teamMatchMarks): bracket.jsx, admin_shiaijo.jsx and the Scores tab import it
+  // by name, so a renamed export would otherwise pass transpile-only.
+  'side_marks.jsx',
+  // The Scores tab imports from start_match.jsx, write_result.jsx, pool_ids.jsx
+  // and side_marks.jsx; a typo'd or renamed export in any of them would fail
+  // only in a native browser.
+  'admin_schedule_score_editor.jsx',
 ];
 
 // ---------------------------------------------------------------------------
diff --git a/web-mobile/check-write-result.mjs b/web-mobile/check-write-result.mjs
index 0218b10f5..0c1d86a1c 100644
--- a/web-mobile/check-write-result.mjs
+++ b/web-mobile/check-write-result.mjs
@@ -98,7 +98,7 @@ export const FORBIDDEN = [
     // whole rule exists to prevent. A copy constant read off `window` is worse
     // still: it renders as the literal text "undefined" in an operator banner.
     // Import from write_result.jsx; do not re-add a mirror.
-    re: /window\.(writeDidNotLand|writeWasSuperseded|writeWasRefused|writeWasRefusedForClock|writeRetryable|notLandedBanner|SUPERSEDED_LEAD|SUPERSEDED_REASON|SUPERSEDED_ADVICE|supersededAlertText|writeHeldGroups|writePartlyHeld|CLOCK_SKEW_REASON_TEXT|CLOCK_SKEW_ADVICE|QUEUED_NOTICE|QUEUED_UNSAVED_NOTICE|queuedNotice|queuedWritesNoun|heldWritesText|writeNeedsWinner|writeDisplacedGroups|supersededBanner|displacedAlertText)\b/,
+    re: /window\.(writeDidNotLand|writeWasSuperseded|writeWasRefused|writeWasRefusedForClock|writeRetryable|notLandedBanner|SUPERSEDED_LEAD|SUPERSEDED_REASON|SUPERSEDED_ADVICE|supersededAlertText|writeHeldGroups|writePartlyHeld|CLOCK_SKEW_REASON_TEXT|CLOCK_SKEW_ADVICE|QUEUED_NOTICE|QUEUED_UNSAVED_NOTICE|queuedNotice|queuedWritesNoun|heldWritesText|writeNeedsWinner|writeDisplacedGroups|writeDisplacedForWinner|supersededBanner|displacedAlertText)\b/,
     why: 'reads an owned predicate/copy off window; those mirrors are deleted, import from write_result.jsx instead',
   },
   {
diff --git a/web-mobile/css/styles.css b/web-mobile/css/styles.css
index 6cc8d4843..9b6a2a6fd 100644
--- a/web-mobile/css/styles.css
+++ b/web-mobile/css/styles.css
@@ -3129,7 +3129,8 @@ a.vlist-item {
   background: var(--red-soft);
 }
 
-.vsched-item__side--w {
+.vsched-item__side--w,
+.shiaijo-qrow__side--win .shiaijo-qrow__name {
   color: var(--accent);
   font-weight: 700;
 }
@@ -7274,6 +7275,8 @@ button.vsched-item:not([data-clickable]) {
 .msb-name--labelled .msb-member-label,
 .msb-name--labelled .sb-result-mark,
 .msb-name--labelled .barred-chip { flex-shrink: 0; }
+/* The row's gap spaces the tick; its bracket-card margin would double it. */
+.msb-name--labelled .bc-winner-tick { flex-shrink: 0; margin-right: 0; }
 /* The decided winner's name. .msb-slots--win marks only an ippon-LESS result
    (hantei, or a default win), so without this an ordinary 2-0 or 1-0 win is
    emphasised nowhere. Set by IndividualScore from the same id-first winner key
@@ -9876,6 +9879,10 @@ abbr.msb-lab { text-decoration: none; cursor: help; }
 .shiaijo-qrow__side { display: flex; align-items: center; gap: 6px; min-width: 0; padding: 4px 8px; }
 .shiaijo-qrow__side--shiro { border-radius: 6px 0 0 6px; }
 .shiaijo-qrow__side--aka { flex-direction: row-reverse; text-align: right; border-radius: 0 6px 6px 0; }
+/* The winner tick is a flex child here, so the side's gap spaces it. Its own
+   margin-right (for the bracket card's inline use) would double that gap on
+   Shiro and push Aka's tick in from its outer edge. */
+.shiaijo-qrow__side .bc-winner-tick { margin-right: 0; }
 .shiaijo-qrow__name { font-weight: 600; font-size: 14px; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .shiaijo-qrow__vs { font-size: 11px; color: var(--ink-3); }
 /* Completed result, centred on its own line below the names (the names keep the
diff --git a/web-mobile/js/__tests__/admin_schedule_surface.test.jsx b/web-mobile/js/__tests__/admin_schedule_surface.test.jsx
index 7ec263f82..7eb50d6af 100644
--- a/web-mobile/js/__tests__/admin_schedule_surface.test.jsx
+++ b/web-mobile/js/__tests__/admin_schedule_surface.test.jsx
@@ -56,7 +56,6 @@ const WINDOW_NAMES = [
   'AdminScoreEditor',
   'AdminExport',
   'filterMatchesByCourt',
-  'startPatch',
   'MatchLineupPanel',
 ];
 
diff --git a/web-mobile/js/__tests__/admin_shiaijo.test.jsx b/web-mobile/js/__tests__/admin_shiaijo.test.jsx
index e95123f8f..4301b5e68 100644
--- a/web-mobile/js/__tests__/admin_shiaijo.test.jsx
+++ b/web-mobile/js/__tests__/admin_shiaijo.test.jsx
@@ -141,16 +141,60 @@ describe('ShiaijoQueueRow; completed result placement', () => {
   };
 
   beforeEach(async () => {
-    orig.fmt = window.formatIpponsScore; orig.iv = window.teamIVScore;
+    orig.fmt = window.formatIpponsScore;
+    orig.iv = window.teamIVScore;
+    orig.winnerSideLR = window.winnerSideLR;
+    orig.teamMatchMarks = window.teamMatchMarks;
+
     window.formatIpponsScore = () => '·;MK';
     window.teamIVScore = () => null;
+
+    // bc-tmwn: stubs for winner and team marks, based on sameCompetitor from competitor_identity.jsx
+    const competitorKey = (c) => c && (c.id ? c.id : (c.name && c.dojo ? `${c.name}|${c.dojo}` : null));
+    const sameCompetitor = (a, b) => {
+      const ka = competitorKey(a);
+      return !!ka && ka === competitorKey(b);
+    };
+
+    window.winnerSideLR = (m) => {
+      if (!m || !m.winner) return null;
+      if (sameCompetitor(m.winner, m.sideB)) return "left";  // Shiro = left = sideB
+      if (sameCompetitor(m.winner, m.sideA)) return "right"; // Aka = right = sideA
+      return null;
+    };
+
+    window.teamMatchMarks = (m, _isTeam) => {
+      if (!m) return { shiro: "", aka: "" };
+
+      let shiroMark = "", akaMark = "";
+      if (m.decision && m.decision.startsWith("kiken")) {
+        // Kiken: mark the side that withdrew
+        if (m.decisionBy === "shiro" || sameCompetitor(m.decisionBy, m.sideB)) {
+          shiroMark = "Kiken";
+        } else if (m.decisionBy === "aka" || sameCompetitor(m.decisionBy, m.sideA)) {
+          akaMark = "Kiken";
+        }
+      } else if (m.decision === "fusenpai") {
+        // Fusenpai: mark the side that no-showed
+        if (m.decisionBy === "shiro" || sameCompetitor(m.decisionBy, m.sideB)) {
+          shiroMark = "Fus.";
+        } else if (m.decisionBy === "aka" || sameCompetitor(m.decisionBy, m.sideA)) {
+          akaMark = "Fus.";
+        }
+      }
+      return { shiro: shiroMark, aka: akaMark };
+    };
+
     runtime = makeReactive();
     global.React = runtime.React;
     ({ ShiaijoQueueRow } = await import('../admin_shiaijo.jsx'));
   });
   afterEach(() => {
     runtime.unmount(); global.React = realReact;
-    window.formatIpponsScore = orig.fmt; window.teamIVScore = orig.iv;
+    window.formatIpponsScore = orig.fmt;
+    window.teamIVScore = orig.iv;
+    window.winnerSideLR = orig.winnerSideLR;
+    window.teamMatchMarks = orig.teamMatchMarks;
   });
 
   it('puts the score in a centred result line below the names, not the corner', () => {
@@ -180,6 +224,148 @@ describe('ShiaijoQueueRow; completed result placement', () => {
     expect(byClass(tree, 'shiaijo-qrow__result').length).toBe(0);
     expect(byClass(tree, 'shiaijo-qrow__vs').length).toBe(1);
   });
+
+  // bc-tmwn: tests for winner display on completed rows
+  it('W1: shows winner class and tick for daihyosen-decided team match (sideA winner)', () => {
+    runtime.mount(ShiaijoQueueRow, {
+      m: {
+        id: 'm-dh1', compId: 'c1', status: 'completed', teamSize: 3,
+        compKind: 'team',
+        sideA: { id: 'a1', name: 'Team A' },
+        sideB: { id: 'b1', name: 'Team B' },
+        winner: { id: 'a1', name: 'Team A' },  // sideA won (Aka)
+        score: [],
+        subResults: [
+          { position: 1, sideA: 'M1', sideB: 'M2', winner: 'M1' },
+          { position: 2, sideA: 'M3', sideB: 'M4', winner: 'M4' },
+        ]
+      },
+      scheduled: [], courts: ['A'],
+    });
+    const tree = runtime.currentTree();
+    const sides = byClass(tree, 'shiaijo-qrow__side');
+    expect(sides.length).toBe(2);
+
+    // Find Aka side (sideA, should be second side, but order depends on implementation)
+    // The Aka side should have the winner class and tick
+    const akaSide = sides[1];
+    expect(akaSide.props.className).toContain('shiaijo-qrow__side--aka');
+    expect(akaSide.props.className).toContain('shiaijo-qrow__side--win');
+
+    // The tick is the WinnerTick component (side_cell.jsx). This runtime does not
+    // expand components, so it is found by name and rendered to reach the sr-only
+    // word a screen reader hears.
+    let hasTick = false;
+    walk(akaSide, (n) => {
+      if (n && n.type?.name === 'WinnerTick') {
+        walk(n.type(n.props), (c) => {
+          // The separator is part of the announced text: without it a screen
+          // reader reads the tick run into the name ("WinnerK1 Alice").
+          if (c && c.props?.className === 'sr-only' && text(c) === 'Winner: ') hasTick = true;
+        });
+      }
+    });
+    expect(hasTick).toBe(true);
+
+    // Shiro side should NOT have winner class
+    const shiroSide = sides[0];
+    expect(shiroSide.props.className).not.toContain('shiaijo-qrow__side--win');
+  });
+
+  it('W2: shows team mark and winner cue for kiken-decided team match', () => {
+    runtime.mount(ShiaijoQueueRow, {
+      m: {
+        id: 'm-kiken1', compId: 'c1', status: 'completed', teamSize: 3,
+        compKind: 'team',
+        sideA: { id: 'a1', name: 'Team A' },
+        sideB: { id: 'b1', name: 'Team B' },
+        winner: { id: 'a1', name: 'Team A' },  // sideA won (Aka), sideB withdrew
+        decision: 'kiken-voluntary',
+        decisionBy: 'shiro',  // sideB withdrew (shiro is sideB)
+        score: [],
+        subResults: []
+      },
+      scheduled: [], courts: ['A'],
+    });
+    const tree = runtime.currentTree();
+    const sides = byClass(tree, 'shiaijo-qrow__side');
+    expect(sides.length).toBe(2);
+
+    // Shiro side should have the Kiken mark
+    const shiroSide = sides[0];
+    expect(shiroSide.props.className).toContain('shiaijo-qrow__side--shiro');
+    let kikenMarkFound = false;
+    walk(shiroSide, (n) => {
+      if (n && n.props?.['data-testid'] === 'team-summary-mark-shiro') {
+        kikenMarkFound = true;
+      }
+    });
+    expect(kikenMarkFound).toBe(true);
+
+    // Aka side should have winner cue
+    const akaSide = sides[1];
+    expect(akaSide.props.className).toContain('shiaijo-qrow__side--aka');
+    expect(akaSide.props.className).toContain('shiaijo-qrow__side--win');
+  });
+
+  it('W3: shows winner cue on individual kiken match without team mark', () => {
+    runtime.mount(ShiaijoQueueRow, {
+      m: {
+        id: 'm-ind-kiken', compId: 'c1', status: 'completed', teamSize: 0,
+        sideA: { id: 'p1', name: 'Player A' },
+        sideB: { id: 'p2', name: 'Player B' },
+        winner: { id: 'p1', name: 'Player A' },
+        decision: 'kiken-voluntary',
+        decisionBy: 'p2',
+        score: []
+      },
+      scheduled: [], courts: ['A'],
+    });
+    const tree = runtime.currentTree();
+    const sides = byClass(tree, 'shiaijo-qrow__side');
+
+    // Aka side (sideA) should have winner cue
+    const akaSide = sides[1];
+    expect(akaSide.props.className).toContain('shiaijo-qrow__side--win');
+
+    // Should NOT have team mark (individual match)
+    let hasTeamMark = false;
+    walk(akaSide, (n) => {
+      if (n && n.props?.['data-testid']?.startsWith('team-summary-mark-')) {
+        hasTeamMark = true;
+      }
+    });
+    expect(hasTeamMark).toBe(false);
+  });
+
+  it('W4: shows no winner cue for hikiwake (drawn) match', () => {
+    runtime.mount(ShiaijoQueueRow, {
+      m: {
+        id: 'm-draw', compId: 'c1', status: 'completed', teamSize: 0,
+        sideA: { id: 'p1', name: 'Player A' },
+        sideB: { id: 'p2', name: 'Player B' },
+        winner: null,  // No winner
+        decision: 'hikiwake',
+        score: []
+      },
+      scheduled: [], courts: ['A'],
+    });
+    const tree = runtime.currentTree();
+    const sides = byClass(tree, 'shiaijo-qrow__side');
+
+    // Neither side should have winner class
+    expect(sides[0].props.className).not.toContain('shiaijo-qrow__side--win');
+    expect(sides[1].props.className).not.toContain('shiaijo-qrow__side--win');
+
+    // No tick on either side
+    let tickCount = 0;
+    walk(tree, (n) => {
+      if (n && n.type?.name === 'WinnerTick') {
+        tickCount++;
+      }
+    });
+    expect(tickCount).toBe(0);
+  });
 });
 
 // mp-tidg: viewer competition tab routing; /competition/:id/:tab gives
diff --git a/web-mobile/js/__tests__/api.test.jsx b/web-mobile/js/__tests__/api.test.jsx
index 924d18d0f..703ff679c 100644
--- a/web-mobile/js/__tests__/api.test.jsx
+++ b/web-mobile/js/__tests__/api.test.jsx
@@ -1902,7 +1902,7 @@ describe('normalizeMatch: same-name winner attribution is arbitrary but CONSISTE
 // operator clearing every mark.
 describe('startOnly reaches the wire only from startPatch (bc-sbq)', () => {
   it('startPatch is flagged, and the serializer carries the flag', async () => {
-    const { startPatch } = await import('../admin_schedule_score_editor.jsx');
+    const { startPatch } = await import('../start_match.jsx');
     const patch = startPatch();
     expect(patch.startOnly).toBe(true);
     const wire = toBackendMatchResult(patch, { sideA: 'Alice', sideB: 'Bob' });
diff --git a/web-mobile/js/__tests__/bout_side_squad_member.test.jsx b/web-mobile/js/__tests__/bout_side_squad_member.test.jsx
index 2b7c93351..73c8a13b7 100644
--- a/web-mobile/js/__tests__/bout_side_squad_member.test.jsx
+++ b/web-mobile/js/__tests__/bout_side_squad_member.test.jsx
@@ -60,11 +60,22 @@ describe('resolveBoutSideMemberId (mirrors resolveBoutSideName priority)', () =>
     })).toBe('mem-recorded');
   });
 
-  it('daihyosen row is lineup-first even in a kachinuki match', () => {
+  it('daihyosen row reads only its own pick, never a lineup position, even in a kachinuki match', () => {
     expect(resolveBoutSideMemberId({
       isKachinuki: true, isDaihyosen: true,
       existingMemberId: 'mem-old', lineupMemberId: 'mem-rep',
-    })).toBe('mem-rep');
+    })).toBe('mem-old');
+    expect(resolveBoutSideMemberId({
+      isKachinuki: false, isDaihyosen: true,
+      existingMemberId: 'mem-pick', lineupMemberId: 'mem-lineup',
+    })).toBe('mem-pick');
+  });
+
+  it('daihyosen row with no pick of its own has no id, though a lineup position holds a member', () => {
+    expect(resolveBoutSideMemberId({
+      isKachinuki: false, isDaihyosen: true,
+      existingMemberId: '', lineupMemberId: 'mem-lineup',
+    })).toBe('');
   });
 
   it('returns "" when neither source has an id', () => {
diff --git a/web-mobile/js/__tests__/delete_announcement.test.jsx b/web-mobile/js/__tests__/delete_announcement.test.jsx
new file mode 100644
index 000000000..13d8a885b
--- /dev/null
+++ b/web-mobile/js/__tests__/delete_announcement.test.jsx
@@ -0,0 +1,22 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { API } from '../api_client.jsx';
+
+// Taking an announcement down is asked for its OUTCOME: the banner is gone. A
+// 404 says it already is (it expired, another console withdrew it, or the
+// identical call that replaced it was withdrawn first), so it is not a failure
+// for either caller: the court console's withdrawal of its own call, and the
+// organiser's Dismiss, which refreshes the list after it.
+describe('deleteAnnouncement', () => {
+  const realFetch = global.fetch;
+  afterEach(() => { global.fetch = realFetch; });
+
+  it('resolves when the announcement is already gone (404)', async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404, json: async () => ({ error: 'Announcement not found' }) });
+    await expect(API.deleteAnnouncement('gone', 'pw')).resolves.toBeUndefined();
+  });
+
+  it('still throws on any other failure', async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 401, json: async () => ({ error: 'Invalid password' }) });
+    await expect(API.deleteAnnouncement('x', 'bad')).rejects.toThrow('Invalid password');
+  });
+});
diff --git a/web-mobile/js/__tests__/displaced_groups_note.test.jsx b/web-mobile/js/__tests__/displaced_groups_note.test.jsx
new file mode 100644
index 000000000..be4dc8531
--- /dev/null
+++ b/web-mobile/js/__tests__/displaced_groups_note.test.jsx
@@ -0,0 +1,47 @@
+// The note for a write that was recorded and moved a later change of the match to its
+// history (match_groups.jsx displacedGroupsNote, through keptInHistoryNote). The server
+// gives two reasons for it, and the note must word each as it is:
+//   - heldReason "needs_winner": the later change would have left the finished match
+//     without a winner, so it was moved (a knockout tie, an engi count that is not valid);
+//   - no heldReason: a representative's pick stamped after the representative bout's
+//     removal, which leaves it nothing to stand on. The match lacks no winner, and the
+//     note must not say it does.
+import { describe, it, expect } from 'vitest';
+import { displacedGroupsNote, keptInHistoryNote } from '../match_groups.jsx';
+
+const WITH_A_WINNER = "Saved. A later change to points would have left the finished match without a winner, so it was moved to the match's history.";
+
+describe('displacedGroupsNote', () => {
+  it('words a change moved because the match needs a winner as it always did', () => {
+    expect(displacedGroupsNote(['points'], true)).toBe(WITH_A_WINNER);
+  });
+
+  it('words a change moved for any other reason without a winner the match does not lack', () => {
+    expect(displacedGroupsNote(['repPickB'], false))
+      .toBe("Saved. A later change to Shiro's pick for the representative bout was moved to the match's history.");
+    expect(displacedGroupsNote(['repPickA', 'repPickB']))
+      .toBe("Saved. A later change to Aka's pick for the representative bout and Shiro's pick for the representative bout was moved to the match's history.");
+  });
+
+  it('says nothing when nothing was moved', () => {
+    expect(displacedGroupsNote([], true)).toBeNull();
+    expect(displacedGroupsNote([])).toBeNull();
+  });
+});
+
+describe('keptInHistoryNote, by the reason the answer gives', () => {
+  it('needs_winner keeps today\'s wording', () => {
+    expect(keptInHistoryNote({ id: 'm1', status: 'completed', displacedGroups: ['points'], heldReason: 'needs_winner' })).toBe(WITH_A_WINNER);
+  });
+
+  it('a displacement with no reason (the representative bout was removed) is worded plainly', () => {
+    expect(keptInHistoryNote({ id: 'm1', status: 'running', displacedGroups: ['repPickB'] }))
+      .toBe("Saved. A later change to Shiro's pick for the representative bout was moved to the match's history.");
+  });
+
+  it('a part held and a part moved for no reason say both', () => {
+    expect(keptInHistoryNote({ id: 'm1', status: 'completed', heldGroups: ['encho'], displacedGroups: ['bout:2'] })).toBe(
+      "Kept in the match's history, not applied: overtime. A newer change to the same thing was recorded first. "
+      + "Saved. A later change to bout 2 was moved to the match's history.");
+  });
+});
diff --git a/web-mobile/js/__tests__/match_groups_table.test.jsx b/web-mobile/js/__tests__/match_groups_table.test.jsx
index e2cccd756..7a9449270 100644
--- a/web-mobile/js/__tests__/match_groups_table.test.jsx
+++ b/web-mobile/js/__tests__/match_groups_table.test.jsx
@@ -114,6 +114,8 @@ describe('groupLabel', () => {
     ['encho', 'overtime'],
     ['flags', 'flags'],
     ['rep', 'the representative players'],
+    ['repPickA', 'Aka\'s pick for the representative bout'],
+    ['repPickB', 'Shiro\'s pick for the representative bout'],
     ['bout:2', 'bout 2'],
     ['bout:-1', 'the representative bout'],
   ])('%s reads "%s"', (g, words) => {
@@ -152,3 +154,97 @@ describe('the serializer', () => {
     expect(changedGroups(write, matchWire(held))).toEqual([]);
   });
 });
+
+// The two representatives of the representative bout (the member ids on the -1 row)
+// are a change of their own for each side, `repPickA` (Aka) and `repPickB` (Shiro), each
+// dated apart from the other side's and from the bout row they sit on.
+// A pick never alters the score and a point never alters the pick, so a write names
+// the one it changed and not the other. Numbered rows keep the rule they always had.
+describe('the representatives of the representative bout (repPickA, repPickB)', () => {
+  const bout = (position, extra = {}) => ({
+    position, sideA: 'Team A', sideB: 'Team B', ipponsA: [], ipponsB: [], winner: '', decision: 'daihyosen', ...extra,
+  });
+
+  it('a side B pick cleared (key omitted) names repPickB and not bout:-1 or repPickA', () => {
+    const stored = { subResults: [bout(-1, { sideBMemberId: 'm1b' })] };
+    const next = { subResults: [bout(-1)] };
+    expect(changedGroups(next, stored)).toEqual(['repPickB']);
+  });
+
+  it('a side B pick added names repPickB and not bout:-1 or repPickA', () => {
+    const stored = { subResults: [bout(-1)] };
+    const next = { subResults: [bout(-1, { sideBMemberId: 'm1b' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickB']);
+  });
+
+  it('a side A pick names repPickA alone: a side B pick the write leaves out is not a change', () => {
+    // The two-captain race: this device never saw side B's pick, so its write carries side A only.
+    const stored = { subResults: [bout(-1)] };
+    const next = { subResults: [bout(-1, { sideAMemberId: 'm1a' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickA']);
+  });
+
+  it('a side A pick leaves a side B pick the editor kept unnamed', () => {
+    const stored = { subResults: [bout(-1, { sideBMemberId: 'm1b' })] };
+    const next = { subResults: [bout(-1, { sideAMemberId: 'm1a', sideBMemberId: 'm1b' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickA']);
+  });
+
+  it('a side B pick cleared leaves a side A pick the editor kept unnamed', () => {
+    const stored = { subResults: [bout(-1, { sideAMemberId: 'm1a', sideBMemberId: 'm1b' })] };
+    const next = { subResults: [bout(-1, { sideAMemberId: 'm1a' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickB']);
+  });
+
+  it('a point struck on the representative bout names bout:-1 and neither pick, whatever ids the row carries', () => {
+    // A board that never saw the pick holds the row without it, and sends it so.
+    expect(changedGroups({ subResults: [bout(-1, { ipponsA: ['M'] })] }, { subResults: [bout(-1)] })).toEqual(['bout:-1']);
+    // A board that did see it holds it and sends it back.
+    const seen = { subResults: [bout(-1, { sideAMemberId: 'm1a' })] };
+    expect(changedGroups({ subResults: [bout(-1, { ipponsA: ['M'], sideAMemberId: 'm1a' })] }, seen)).toEqual(['bout:-1']);
+  });
+
+  it('a side B pick and a point together name both', () => {
+    const stored = { subResults: [bout(-1)] };
+    const next = { subResults: [bout(-1, { ipponsA: ['M'], sideBMemberId: 'm1b' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickB', 'bout:-1']);
+  });
+
+  it('a decided representative bout whose side A pick is swapped names repPickA and not bout:-1 or repPickB', () => {
+    // The server re-derives the winner's member id from the stored picks, so a swap that
+    // moves it moves no bout: the score and the winner stand.
+    const stored = { subResults: [bout(-1, { ipponsA: ['M'], winner: 'Team A', winnerMemberId: 'm1a', sideAMemberId: 'm1a', sideBMemberId: 'm1b' })] };
+    const next = { subResults: [bout(-1, { ipponsA: ['M'], winner: 'Team A', winnerMemberId: 'm2a', sideAMemberId: 'm2a', sideBMemberId: 'm1b' })] };
+    expect(changedGroups(next, stored)).toEqual(['repPickA']);
+  });
+
+  it('a decided representative bout whose winning side changes names bout:-1, and neither pick when the picks stand', () => {
+    const stored = { subResults: [bout(-1, { winner: 'Team A', winnerMemberId: 'm1a', sideAMemberId: 'm1a', sideBMemberId: 'm1b' })] };
+    const next = { subResults: [bout(-1, { winner: 'Team B', winnerMemberId: 'm1b', sideAMemberId: 'm1a', sideBMemberId: 'm1b' })] };
+    expect(changedGroups(next, stored)).toEqual(['bout:-1']);
+  });
+
+  it('a write with no representative row names no picks', () => {
+    expect(changedGroups({ subResults: [bout(1, { decision: '' })] }, { subResults: [bout(1, { decision: '' })] })).toEqual([]);
+  });
+
+  it('a numbered row whose id is left out is not a change, as before', () => {
+    const stored = { subResults: [bout(1, { sideBMemberId: 'm1b', decision: '' })] };
+    const next = { subResults: [bout(1, { decision: '' })] };
+    expect(changedGroups(next, stored)).toEqual([]);
+  });
+
+  // The server stores NO side names on the representative row (engine.AddDaihyosen builds
+  // {Position: -1, Decision: "daihyosen"}), while the editor restates the match's team names
+  // on it so the hantei mark can be placed. The names are the match's sides, never a change of
+  // the bout, so they must not name it.
+  it('the team names the editor states on the representative row, which the server stores empty, are not a change of the bout', () => {
+    const stored = { subResults: [bout(-1, { sideA: '', sideB: '' })] };
+    expect(changedGroups({ subResults: [bout(-1)] }, stored)).toEqual([]);
+  });
+
+  it('a point struck on a representative row the server stores without side names still names bout:-1', () => {
+    const stored = { subResults: [bout(-1, { sideA: '', sideB: '' })] };
+    expect(changedGroups({ subResults: [bout(-1, { ipponsA: ['M'] })] }, stored)).toEqual(['bout:-1']);
+  });
+});
diff --git a/web-mobile/js/__tests__/queue_alert_message.test.jsx b/web-mobile/js/__tests__/queue_alert_message.test.jsx
index c19f87c71..5e61cfea3 100644
--- a/web-mobile/js/__tests__/queue_alert_message.test.jsx
+++ b/web-mobile/js/__tests__/queue_alert_message.test.jsx
@@ -64,11 +64,30 @@ describe('queueAlertMessage', () => {
     // A held finish landed and moved a later change of its match to the
     // history: recorded, so information, not an error.
     it('a held finish that moved a later change aside: saved, as information', () => {
-        const alert = { kind: 'displaced', count: 1, terminalCount: 1 };
+        const alert = { kind: 'displaced', count: 1, terminalCount: 1, forWinner: 1 };
         expect(queueAlertMessage(alert)).toMatch(/^A held result was saved\./);
         expect(queueAlertToastType(alert)).toBe('info');
     });
 
+    // The reason is per replayed answer: the alert says "without a winner"
+    // only for the changes the server moved for one (forWinner), and plainly
+    // otherwise (a representative's pick stamped after the bout's removal).
+    it('names a winner only when the moved change was moved for one', () => {
+        const none = queueAlertMessage({ kind: 'displaced', count: 1, terminalCount: 1, forWinner: 0 });
+        expect(none).toMatch(/^A held result was saved\./);
+        expect(none).not.toMatch(/without a winner/);
+        expect(queueAlertMessage({ kind: 'displaced', count: 1, terminalCount: 1, forWinner: 1 })).toMatch(/without a winner/);
+        // An alert without the count reads as none for a winner.
+        expect(queueAlertMessage({ kind: 'displaced', count: 1, terminalCount: 1 })).not.toMatch(/without a winner/);
+        const manyNone = queueAlertMessage({ kind: 'displaced', count: 2, terminalCount: 2, forWinner: 0 });
+        expect(manyNone).toMatch(/^2 held results were saved\./);
+        expect(manyNone).not.toMatch(/without a winner/);
+        expect(queueAlertMessage({ kind: 'displaced', count: 2, terminalCount: 2, forWinner: 2 })).toMatch(/^2 held results were saved\. .*without a winner/);
+        expect(queueAlertMessage({ kind: 'displaced', count: 2, terminalCount: 2, forWinner: 1 })).toBe(
+            "2 held results were saved. Later changes to those matches were moved to each match's history. 1 of those changes would have left a match without a winner.");
+        expect(queueAlertToastType({ kind: 'displaced', count: 2, terminalCount: 2, forWinner: 0 })).toBe('info');
+    });
+
     it('returns null for an unknown kind, so nothing is toasted', () => {
         expect(queueAlertMessage({ kind: 'not-a-kind', count: 1, terminalCount: 1 })).toBeNull();
     });
diff --git a/web-mobile/js/__tests__/queue_ordered_writes.test.jsx b/web-mobile/js/__tests__/queue_ordered_writes.test.jsx
index 30a07e40c..e540005d4 100644
--- a/web-mobile/js/__tests__/queue_ordered_writes.test.jsx
+++ b/web-mobile/js/__tests__/queue_ordered_writes.test.jsx
@@ -710,6 +710,28 @@ describe('a queued finish that moved a later change to the history', () => {
         unsubAlert();
         expect(failed).toEqual([]);
         expect(alerts.map((a) => a.kind)).toEqual(['sent', 'displaced']);
+        expect(alerts.find((a) => a.kind === 'displaced')).toEqual(expect.objectContaining({ count: 1, forWinner: 1 }));
+        expect(localStorage.getItem('bc_write_queue')).toBeNull();
+    });
+
+    // A change can also be moved for another reason (a representative's pick
+    // stamped after the representative bout's removal): the answer carries no
+    // heldReason, and the alert counts it as moved, not as moved for a winner.
+    it('a change moved with no reason is told as moved, not as moved for a winner', async () => {
+        const s = server({ answer: () => ({ id: 'm1', status: 'completed', displacedGroups: ['repPickB'] }) });
+        await API.recordScore('c1', 'm1', { status: 'completed', winner: 'A', ipponsA: ['M'] }, 'pw', null);
+        await settleOfflinePass();
+        const failed = [];
+        const alerts = [];
+        const unsubFail = mod.subscribeTerminalWriteFailed((i) => failed.push(i));
+        const unsubAlert = mod.subscribeQueueAlert((a) => alerts.push(a));
+        s.online();
+        await tick(50);
+        unsubFail();
+        unsubAlert();
+        expect(failed).toEqual([]);
+        expect(alerts.map((a) => a.kind)).toEqual(['sent', 'displaced']);
+        expect(alerts.find((a) => a.kind === 'displaced')).toEqual(expect.objectContaining({ count: 1, forWinner: 0 }));
         expect(localStorage.getItem('bc_write_queue')).toBeNull();
     });
 });
diff --git a/web-mobile/js/__tests__/render/admin_scores_auto_start_refusal.render.test.jsx b/web-mobile/js/__tests__/render/admin_scores_auto_start_refusal.render.test.jsx
new file mode 100644
index 000000000..632556ba5
--- /dev/null
+++ b/web-mobile/js/__tests__/render/admin_scores_auto_start_refusal.render.test.jsx
@@ -0,0 +1,501 @@
+// PR #463 round 13 (gap C, bc-aadv on the Scores tab): the Scores tab's own
+// auto-advance (Finish + Start Next, and the start after a decision) used to
+// swallow a refused start. A thrown 409 (eligibility, court_busy,
+// already_ineligible) hit `catch (_startErr) {}`, a clock_skew refusal (HTTP 200
+// {applied:false}) was never read and was taken for a start that landed, and
+// nothing stopped a second start while one was out. The court console had all
+// three (admin_shiaijo.jsx startMatch). Both now ask start_match.jsx.
+//
+// What the operator sees on a refusal: a toast (the moment's signal), a
+// persistent notice on the REFUSED match's list row (role=status, the
+// full-width slot BarredMatchNotice uses), and the editor open on that match in
+// pre-match so they see which match and why.
+import React from 'react';
+import { render, act, fireEvent } from '@testing-library/react';
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import { installWindowStubs } from '../helpers/stub_globals.js';
+import { CLOCK_SKEW_REASON_TEXT, startWhileStartingMessage, startWasBlockedByStartMessage, markToasted } from '../../write_result.jsx';
+import { scoreRowMatchName } from '../../pool_ids.jsx';
+import { START_SUPERSEDED_MESSAGE } from '../../start_match.jsx';
+
+const side = (id, name) => ({ id, name });
+
+const mk = (id, status, scheduledAt, a, b) => ({
+  id, compId: 'c1', compName: 'Cup', status, court: 'A', scheduledAt, phase: 'pool', poolName: 'Pool A',
+  sideA: side(`${id}-a`, a), sideB: side(`${id}-b`, b),
+});
+const M1 = mk('m-1', 'running', '09:00', 'Yamada', 'Tanaka');
+const M2 = mk('m-2', 'scheduled', '09:05', 'Alice', 'Bob');
+const M3 = mk('m-3', 'scheduled', '09:10', 'Carol', 'Dan');
+
+// The matches the (stubbed) compMatches hands the page; a test swaps them to
+// show a refused match leaving `scheduled`.
+let matches;
+
+// Captures the LATEST ScoreEditorModal props so a test can drive
+// onSubmitAndNext / onAfterDecision directly, as the court console's suite does.
+const probe = { props: null };
+
+const STUBS = {
+  ScoreEditorModal: (props) => { probe.props = props; return <div data-testid="score-editor" data-match={props.match.id} />; },
+  AdminTopbar: ({ children }) => <div>{children}</div>,
+  Breadcrumbs: () => null,
+  CourtPicker: () => null,
+  getScoreBtnClass: () => 'test-score-open',
+  matchScoreStr: () => '',
+  filterMatchesByCourt: (m) => m,
+  tournamentMatches: () => [],
+  compMatches: () => matches,
+  confirmDialog: vi.fn().mockResolvedValue(true),
+  pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || s + 's')}`,
+  API: { fetchCompetitionDetails: vi.fn().mockResolvedValue(null), recordDecision: vi.fn() },
+};
+
+let restore, AdminScoreEditor, AdminScoreEditorPage;
+
+beforeAll(async () => {
+  window.scrollTo = vi.fn();
+  restore = installWindowStubs(STUBS);
+  const mod = await import('../../admin_schedule_score_editor.jsx');
+  AdminScoreEditor = mod.AdminScoreEditor;
+  AdminScoreEditorPage = mod.AdminScoreEditorPage;
+});
+afterAll(() => restore());
+beforeEach(() => { matches = [M1, M2, M3]; probe.props = null; });
+
+const tournament = () => ({ competitions: [{ id: 'c1', name: 'Cup' }] });
+
+function ui(onEditScore, showToast) {
+  return (
+    <AdminScoreEditor t={tournament()} onEditScore={onEditScore} onMoveCourt={null} password="pw" showToast={showToast} />
+  );
+}
+
+async function mountAndOpenRunning(onEditScore, showToast) {
+  let utils;
+  await act(async () => { utils = render(ui(onEditScore, showToast)); });
+  // Rows sort running first: the first Score button is m-1's.
+  const scoreBtns = [...utils.container.querySelectorAll('button.test-score-open')];
+  await act(async () => { fireEvent.click(scoreBtns[0]); });
+  expect(probe.props.match.id).toBe('m-1');
+  return utils;
+}
+
+const isStart = (call) => call[2] && call[2].startOnly === true;
+const rowOf = (utils, name) => [...utils.container.querySelectorAll('.score-edit-row')].find((r) => r.textContent.includes(name));
+const noticeIn = (row) => row && row.querySelector('[data-testid="start-refusal-notice"]');
+
+const WITHDREW = 'Alice withdrew in Pool A · Match 2 and cannot fight again. Record the fusensho for Bob.';
+
+describe('Finish + Start Next on the Scores tab says why the next match did not start', () => {
+  it('a thrown refusal is noted on the refused match\'s row, toasted, and the editor lands on it in pre-match', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) throw new Error(WITHDREW);
+      return { status: 'ok' };
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the refused match shows why on its own row').toBeTruthy();
+    expect(note.textContent).toBe(WITHDREW);
+    expect(note.getAttribute('role')).toBe('status');
+    // No other row carries it.
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(1);
+    expect(showToast).toHaveBeenCalledWith(WITHDREW, 'error');
+    // The operator lands on the refused match, not started.
+    expect(probe.props.match.id).toBe('m-2');
+    expect(probe.props.match.status).toBe('scheduled');
+  });
+
+  // editMatchScore (admin.jsx) toasts what it throws and marks the error; the host
+  // that catches it must not toast the same sentence again, which replaced the
+  // single-slot toast and restarted its timer. The row still says it. The case
+  // above is the unmarked one: a host whose onEditScore does not toast does.
+  it('a thrown refusal onEditScore already toasted is not toasted again, and the row still says it', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) throw markToasted(new Error(WITHDREW));
+      return { status: 'ok' };
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    expect(showToast).not.toHaveBeenCalled();
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the refused match still says why on its own row').toBeTruthy();
+    expect(note.textContent).toBe(WITHDREW);
+    expect(probe.props.match.id).toBe('m-2');
+  });
+
+  it('a clock_skew refusal (HTTP 200 applied:false) is a refused start, not a landed one', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => (id === 'm-2' && patch.startOnly
+      ? { applied: false, reason: 'clock_skew' }
+      : { status: 'ok' }));
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    const sentence = `Could not start: ${CLOCK_SKEW_REASON_TEXT}. The clock has been resynced; try again.`;
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the clock refusal is shown, not treated as a start that landed').toBeTruthy();
+    expect(note.textContent).toBe(sentence);
+    expect(showToast).toHaveBeenCalledWith(sentence, 'error');
+    expect(probe.props.match.id).toBe('m-2');
+  });
+
+  it('a start that lands raises no notice and no toast', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ status: 'ok' });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-1', 'm-2']);
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(0);
+    expect(showToast).not.toHaveBeenCalled();
+    expect(probe.props.match.id).toBe('m-2');
+  });
+
+  it('a queued start lands on reconnect, so it is not a refusal', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => (id === 'm-2' && patch.startOnly ? { queued: true } : { status: 'ok' }));
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(0);
+    expect(showToast).not.toHaveBeenCalled();
+  });
+
+  // PR #463 round 18 (this REPLACES the round-17 pin that asserted "no notice and
+  // no toast", which encoded the opposite rule). A superseded start that holds
+  // the result group (HTTP 200 applied:false, reason superseded, heldGroups
+  // ['result']) wrote nothing: a different result is stored. It is a REFUSED start, through the same path a thrown or
+  // clock_skew refusal takes: the sentence is stored on the refused match's row,
+  // toasted once, and the editor lands on that match in pre-match.
+  it('a superseded start is a refused start: its notice on the next match\'s row, one toast, the editor on that match', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => (id === 'm-2' && patch.startOnly
+      ? { applied: false, reason: 'superseded', heldGroups: ['result'] }
+      : { status: 'ok' }));
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-1', 'm-2']);
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the refused match says why on its own row').toBeTruthy();
+    expect(note.textContent).toBe(START_SUPERSEDED_MESSAGE);
+    expect(note.getAttribute('role')).toBe('status');
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(1);
+    expect(showToast.mock.calls).toEqual([[START_SUPERSEDED_MESSAGE, 'error']]);
+    expect(probe.props.match.id).toBe('m-2');
+    expect(probe.props.match.status).toBe('scheduled');
+  });
+
+  // PR #463 round 19 (S1). The same answer WITHOUT heldGroups is an echo-hold:
+  // another device's start of m-2 landed first, so m-2 IS running. That is a start
+  // that went out, treated as a landed one ('a start that lands raises no notice
+  // and no toast' above): no notice, no toast, the editor on the next match.
+  it('a superseded start with no held group is an echo of a start that landed: no notice, no toast', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => (id === 'm-2' && patch.startOnly
+      ? { applied: false, reason: 'superseded' }
+      : { status: 'ok' }));
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-1', 'm-2']);
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(0);
+    expect(showToast).not.toHaveBeenCalled();
+    expect(probe.props.match.id).toBe('m-2');
+  });
+});
+
+describe('one start at a time on the Scores tab', () => {
+  it('a Finish + Start Next while another match is still being started is refused, and says so on the refused match', async () => {
+    let releaseStart;
+    const onEditScore = vi.fn((_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) return new Promise((resolve) => { releaseStart = resolve; });
+      return Promise.resolve({ status: 'ok' });
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    // First advance: m-1 finishes, the editor lands on m-2 and its start hangs.
+    await act(async () => { probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(probe.props.match.id).toBe('m-2');
+    expect(onEditScore.mock.calls.filter(isStart).map((c) => c[1])).toEqual(['m-2']);
+
+    // Second advance, from the editor now on m-2: its finish goes out, but m-3's
+    // start is refused because m-2's is still out.
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+
+    const sentence = startWhileStartingMessage({ label: scoreRowMatchName(M2) });
+    expect(onEditScore.mock.calls.filter(isStart).map((c) => c[1]), 'no second start went out').toEqual(['m-2']);
+    const note = noticeIn(rowOf(utils, 'Carol'));
+    expect(note, 'the refused match says why').toBeTruthy();
+    expect(note.textContent).toBe(sentence);
+    expect(showToast).toHaveBeenCalledWith(sentence, 'error');
+    expect(probe.props.match.id).toBe('m-3');
+
+    // That sentence describes the start still out. When it lands the court has a
+    // running bout, so m-3 is not started on its own, and nothing else would say
+    // it was asked for and never started: the row keeps the refusal, in the past
+    // tense (bc-aadv, item 4).
+    await act(async () => { releaseStart({ status: 'ok' }); });
+    const kept = noticeIn(rowOf(utils, 'Carol'));
+    expect(kept, 'the refusal does not vanish when the start lands').toBeTruthy();
+    expect(kept.textContent).toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(M2) }));
+    expect(kept.getAttribute('role')).toBe('status');
+    expect(onEditScore.mock.calls.filter(isStart).map((c) => c[1]), 'and m-3 was not started on its own').toEqual(['m-2']);
+
+    // It is bound to m-3 like any stored refusal here: it goes when m-3 leaves
+    // scheduled in the live data.
+    matches = [M1, M2, { ...M3, status: 'running' }];
+    await act(async () => { utils.rerender(ui(onEditScore, showToast)); });
+    expect(noticeIn(rowOf(utils, 'Carol'))).toBeFalsy();
+  });
+});
+
+describe('a start that was waited for and then refused', () => {
+  // The same rule as the court console's: a start that does not land leaves the
+  // court free, so the waiting match gets no past-tense sentence, and the failed
+  // start's own refusal (stored for it before the wait ends) is what stays.
+  it('keeps its own refusal on its row, and the waiting row shows nothing', async () => {
+    let failStart;
+    const onEditScore = vi.fn((_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) return new Promise((_resolve, reject) => { failStart = reject; });
+      return Promise.resolve({ status: 'ok' });
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { probe.props.onSubmitAndNext({ status: 'completed' }); });
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(noticeIn(rowOf(utils, 'Carol'))?.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(M2) }));
+
+    await act(async () => { failStart(new Error(WITHDREW)); });
+    expect(noticeIn(rowOf(utils, 'Alice'))?.textContent, 'the failed start keeps its own refusal').toBe(WITHDREW);
+    expect(noticeIn(rowOf(utils, 'Carol')), 'the court is free: no past-tense notice').toBeFalsy();
+  });
+
+  // PR #463 round 18: a SUPERSEDED start is a start that wrote nothing, so it
+  // ends like the thrown one above: the court is free, "was being started" would
+  // be false, and its own refusal (the superseded sentence) is stored for it,
+  // which replaces the refusal that waited on it (refuseStart keeps a single
+  // slot and clears `waitingOn`, so the finally has nothing left to rewrite).
+  it('a start that is superseded keeps its own refusal on its row, and the waiting row gets no past-tense notice', async () => {
+    let releaseStart;
+    const onEditScore = vi.fn((_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) return new Promise((resolve) => { releaseStart = resolve; });
+      return Promise.resolve({ status: 'ok' });
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { probe.props.onSubmitAndNext({ status: 'completed' }); });
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(noticeIn(rowOf(utils, 'Carol'))?.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(M2) }));
+
+    await act(async () => { releaseStart({ applied: false, reason: 'superseded', heldGroups: ['result'] }); });
+    expect(noticeIn(rowOf(utils, 'Alice'))?.textContent, 'the superseded start keeps its own refusal').toBe(START_SUPERSEDED_MESSAGE);
+    expect(noticeIn(rowOf(utils, 'Carol')), 'nothing was started: no past-tense notice on the waiting row').toBeFalsy();
+    expect(utils.container.textContent).not.toContain('was being started');
+    expect(onEditScore.mock.calls.filter(isStart).map((c) => c[1]), 'and m-3 was not started on its own').toEqual(['m-2']);
+    expect(showToast.mock.calls.map((c) => c[0])).toEqual([startWhileStartingMessage({ label: scoreRowMatchName(M2) }), START_SUPERSEDED_MESSAGE]);
+    expect(probe.props.match.id, 'the editor lands on the match that did not start').toBe('m-2');
+  });
+
+  // S1: the echo-hold is a start that went out, so the refusal that waited on it
+  // is still accurate and is worded in the past tense, as for a landed start.
+  it('a start held as an echo went out, so the waiting row gets the past-tense notice', async () => {
+    let releaseStart;
+    const onEditScore = vi.fn((_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) return new Promise((resolve) => { releaseStart = resolve; });
+      return Promise.resolve({ status: 'ok' });
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { probe.props.onSubmitAndNext({ status: 'completed' }); });
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(noticeIn(rowOf(utils, 'Carol'))?.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(M2) }));
+
+    await act(async () => { releaseStart({ applied: false, reason: 'superseded' }); });
+    expect(noticeIn(rowOf(utils, 'Carol'))?.textContent, 'the waiting refusal was accurate: it is rewritten, not cleared')
+      .toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(M2) }));
+    expect(noticeIn(rowOf(utils, 'Alice')), 'm-2 started: it has no refusal of its own').toBeFalsy();
+    expect(utils.container.textContent).not.toContain(START_SUPERSEDED_MESSAGE);
+    expect(showToast.mock.calls.map((c) => c[0])).toEqual([startWhileStartingMessage({ label: scoreRowMatchName(M2) })]);
+  });
+});
+
+describe('the start after a decision says why too', () => {
+  it('onAfterDecision lands on the refused match with the notice', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) throw new Error(WITHDREW);
+      return { status: 'ok' };
+    });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onAfterDecision({ winner: side('m-1-a', 'Yamada') }); });
+
+    expect(onEditScore).toHaveBeenCalledTimes(1);
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the decision path shows the refusal too').toBeTruthy();
+    expect(note.textContent).toBe(WITHDREW);
+    expect(showToast).toHaveBeenCalledWith(WITHDREW, 'error');
+    // Today it left the operator where they were; the console lands them on the match.
+    expect(probe.props.match.id).toBe('m-2');
+  });
+
+  it('a clock_skew refusal after a decision is a refusal as well', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: false, reason: 'clock_skew' });
+    const utils = await mountAndOpenRunning(onEditScore, vi.fn());
+
+    await act(async () => { await probe.props.onAfterDecision({ winner: side('m-1-a', 'Yamada') }); });
+
+    expect(noticeIn(rowOf(utils, 'Alice')).textContent).toContain(CLOCK_SKEW_REASON_TEXT);
+    expect(probe.props.match.id).toBe('m-2');
+  });
+
+  // See the superseded case above (round 18: it replaces the round-17 pin that
+  // asserted no notice and no toast). refuseStart opens the refused match, so
+  // onAfterDecision lands on m-2 either way; what changed is that the operator is
+  // told why it is still scheduled.
+  it('a superseded start after a decision lands on the next match with its notice and one toast', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: false, reason: 'superseded', heldGroups: ['result'] });
+    const showToast = vi.fn();
+    const utils = await mountAndOpenRunning(onEditScore, showToast);
+
+    await act(async () => { await probe.props.onAfterDecision({ winner: side('m-1-a', 'Yamada') }); });
+
+    expect(onEditScore).toHaveBeenCalledTimes(1);
+    const note = noticeIn(rowOf(utils, 'Alice'));
+    expect(note, 'the decision path shows the refusal too').toBeTruthy();
+    expect(note.textContent).toBe(START_SUPERSEDED_MESSAGE);
+    expect(utils.container.querySelectorAll('[data-testid="start-refusal-notice"]')).toHaveLength(1);
+    expect(showToast.mock.calls).toEqual([[START_SUPERSEDED_MESSAGE, 'error']]);
+    expect(probe.props.match.id).toBe('m-2');
+  });
+});
+
+describe('the refusal notice goes when it stops being true', () => {
+  async function refused() {
+    const onEditScore = vi.fn(async (_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) throw new Error(WITHDREW);
+      return { status: 'ok' };
+    });
+    const utils = await mountAndOpenRunning(onEditScore, vi.fn());
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(noticeIn(rowOf(utils, 'Alice'))).toBeTruthy();
+    return { utils, onEditScore };
+  }
+
+  it('when the refused match leaves scheduled in the live data', async () => {
+    const { utils, onEditScore } = await refused();
+    matches = [M1, { ...M2, status: 'running' }, M3];
+    await act(async () => { utils.rerender(ui(onEditScore, vi.fn())); });
+    expect(noticeIn(rowOf(utils, 'Alice'))).toBeFalsy();
+  });
+
+  // PR #463 round 15 (F): the court console keeps a refusal across an empty list
+  // (a list that is empty while it loads says nothing about the match), and the
+  // Scores tab asks the same rule (start_match.jsx startRefusalStands).
+  it('but not across an empty list: it says nothing about the match', async () => {
+    const { utils, onEditScore } = await refused();
+    matches = [];
+    await act(async () => { utils.rerender(ui(onEditScore, vi.fn())); });
+    matches = [M1, M2, M3];
+    await act(async () => { utils.rerender(ui(onEditScore, vi.fn())); });
+    expect(noticeIn(rowOf(utils, 'Alice')), 'the same refusal is still there').toBeTruthy();
+    expect(noticeIn(rowOf(utils, 'Alice')).textContent).toBe(WITHDREW);
+  });
+
+  it('when a list that still holds matches no longer holds the refused one', async () => {
+    const { utils, onEditScore } = await refused();
+    matches = [M1, M3];
+    await act(async () => { utils.rerender(ui(onEditScore, vi.fn())); });
+    matches = [M1, M2, M3];
+    await act(async () => { utils.rerender(ui(onEditScore, vi.fn())); });
+    expect(noticeIn(rowOf(utils, 'Alice')), 'moved away and back is a new situation').toBeFalsy();
+  });
+
+  it('when the operator opens another match', async () => {
+    const { utils } = await refused();
+    const carolScore = rowOf(utils, 'Carol').querySelector('button.test-score-open');
+    await act(async () => { fireEvent.click(carolScore); });
+    expect(probe.props.match.id).toBe('m-3');
+    expect(noticeIn(rowOf(utils, 'Alice'))).toBeFalsy();
+  });
+
+  it('but not when the editor is only closed: the row is where it stays visible', async () => {
+    const { utils } = await refused();
+    await act(async () => { probe.props.onClose(); });
+    expect(utils.container.querySelector('[data-testid="score-editor"]')).toBeNull();
+    expect(noticeIn(rowOf(utils, 'Alice'))).toBeTruthy();
+  });
+});
+
+describe('the Scores page hands its toast down', () => {
+  // AdminScoreEditor took a showToast prop that no host passed, so the toast
+  // this fix adds would have reached nobody: the page must hand its own down.
+  it('AdminScoreEditorPage passes showToast to the editor', async () => {
+    const onEditScore = vi.fn(async (_c, id, patch) => {
+      if (id === 'm-2' && patch.startOnly) throw new Error(WITHDREW);
+      return { status: 'ok' };
+    });
+    const showToast = vi.fn();
+    let utils;
+    await act(async () => {
+      utils = render(
+        <AdminScoreEditorPage
+          tournament={tournament()} onBack={() => {}} onEditScore={onEditScore} onMoveCourt={null}
+          onLogout={() => {}} onViewerMode={() => {}} password="pw" showToast={showToast}
+        />,
+      );
+    });
+    await act(async () => { fireEvent.click(utils.container.querySelector('button.test-score-open')); });
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed' }); });
+    expect(showToast).toHaveBeenCalledWith(WITHDREW, 'error');
+  });
+});
+
+// PR #463 batch 14, item 2: the Scores tab's completed team row asks
+// teamMatchMarks by ES import from the side_marks.jsx leaf. It used to read
+// window.teamMatchMarks and, with the global missing, painted no mark and no
+// error. This suite never publishes the global, which is the point.
+describe('a completed team row marks the withdrawn team without any window global', () => {
+  const saved = {};
+  beforeEach(() => {
+    saved.teamMatchMarks = window.teamMatchMarks;
+    delete window.teamMatchMarks;
+  });
+  afterEach(() => { if (saved.teamMatchMarks) window.teamMatchMarks = saved.teamMatchMarks; });
+
+  it('keeps Kiken beside the withdrawn team and the winner cue on the other', async () => {
+    matches = [{
+      ...mk('m-4', 'completed', '09:15', 'Hana', 'Ichi'),
+      // This surface's own team-row signal is a non-empty subResults (a bout
+      // fought before the withdrawal), the default teamMatchMarks applies.
+      compKind: 'team', teamSize: 3, decision: 'kiken-voluntary', decisionBy: 'shiro',
+      subResults: [{ position: 1, sideA: 'Hana-1', sideB: 'Ichi-1', winner: 'Hana-1' }],
+      winner: side('m-4-a', 'Hana'),
+    }];
+    let utils;
+    await act(async () => { utils = render(ui(vi.fn(), vi.fn())); });
+    const row = rowOf(utils, 'Hana');
+    expect(row, 'the completed row is listed').toBeTruthy();
+    expect(row.querySelector('[data-testid="team-summary-mark-shiro"]')?.textContent).toBe('Kiken');
+    expect(row.querySelector('[data-testid="team-summary-mark-aka"]')).toBeNull();
+    expect(row.querySelector('.score-edit-row__side--aka').classList.contains('score-edit-row__side--win')).toBe(true);
+  });
+});
diff --git a/web-mobile/js/__tests__/render/admin_scores_row_name_mark_clip.render.test.jsx b/web-mobile/js/__tests__/render/admin_scores_row_name_mark_clip.render.test.jsx
index b6741b1be..758a8e0b4 100644
--- a/web-mobile/js/__tests__/render/admin_scores_row_name_mark_clip.render.test.jsx
+++ b/web-mobile/js/__tests__/render/admin_scores_row_name_mark_clip.render.test.jsx
@@ -35,7 +35,6 @@ const STUBS = {
   filterMatchesByCourt: (matches) => matches,
   tournamentMatches: () => [],
   compMatches: () => [TEAM_MATCH],
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || s + 's')}`,
   API: {
diff --git a/web-mobile/js/__tests__/render/admin_shiaijo.render.test.jsx b/web-mobile/js/__tests__/render/admin_shiaijo.render.test.jsx
index 9d202dc00..353b0e8aa 100644
--- a/web-mobile/js/__tests__/render/admin_shiaijo.render.test.jsx
+++ b/web-mobile/js/__tests__/render/admin_shiaijo.render.test.jsx
@@ -2,8 +2,9 @@ import React from 'react';
 import { render, act, fireEvent, within } from '@testing-library/react';
 import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
 import { installWindowStubs } from '../helpers/stub_globals.js';
-import { DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED, startWhileCorrectingMessage, correctWhileRunningMessage } from '../../write_result.jsx';
+import { DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED, startWhileCorrectingMessage, startWhileStartingMessage, correctWhileRunningMessage, CLOCK_SKEW_REASON_TEXT, markToasted, startWasBlockedByStartMessage } from '../../write_result.jsx';
 import { scoreRowMatchName } from '../../pool_ids.jsx';
+import { START_SUPERSEDED_MESSAGE } from '../../start_match.jsx';
 // Window globals required by admin_shiaijo.jsx.
 // MODULE-EVAL-TIME entries (e.g. `const AdminTopbar = window.AdminTopbar;`)
 // must be set before the dynamic import, or the module captures undefined.
@@ -55,7 +56,8 @@ const STUBBED_GLOBALS = {
     recordDecision: vi.fn().mockResolvedValue({ applied: true }),
     reinstateCompetitor: vi.fn().mockResolvedValue({}),
   },
-  startPatch: vi.fn(),
+  // No startPatch: the console imports it from start_match.jsx (a bare vi.fn()
+  // here used to make every console start in this suite send `undefined`).
   confirmDialog: vi.fn().mockResolvedValue(true),
   PoolsViewer: () => null,
   compMatches: () => [],
@@ -98,7 +100,7 @@ function renderPage(tournament, court = 'A', props = {}) {
       onLogout={vi.fn()}
       onViewerMode={vi.fn()}
       password=""
-      showToast={vi.fn()}
+      showToast={props.showToast || vi.fn()}
       tweaks={{}}
       onSwitchCourt={vi.fn()}
     />
@@ -858,9 +860,10 @@ describe('AdminShiaijoPage render-smoke', () => {
   // ("kiken-voluntary at Pool A-2") stayed on screen after the withdrawal was
   // cleared and eligibility restored, and after that match started it sat
   // under the NEXT match. It must go once it may no longer apply (an
-  // eligibility change in its competition, or ANY change of Up next), and
-  // stay while it still does.
-  it('a refused Start is dropped when eligibility changes or Up next moves on, and kept while it still applies', async () => {
+  // eligibility change in its competition, or its match leaving scheduled), and
+  // stay while it still does. A change of Up next by itself no longer drops it:
+  // 'a stored Start refusal is bound to the refused match', below, pins that.
+  it('a refused Start is dropped when eligibility changes or its match leaves scheduled, and kept while it still applies', async () => {
     const side = (id, name) => ({ id, name });
     const m1 = {
       id: 'm1', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
@@ -882,7 +885,7 @@ describe('AdminShiaijoPage render-smoke', () => {
     try {
       let utils;
       await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
-      const refusal = () => utils.container.querySelector('.shiaijo-upnext__error');
+      const refusal = () => utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
       // The Up next card's own Start (an Upcoming row carries one too).
       const start = async () => {
         const card = utils.container.querySelector('.shiaijo-upnext__card');
@@ -912,8 +915,8 @@ describe('AdminShiaijoPage render-smoke', () => {
       await send({ type: 'competitor_status_updated', data: { competitionId: 'c1', status: { eligible: true } } });
       expect(refusal()).toBeNull();
 
-      // Refused again, then m1 starts elsewhere: Up next is now m2, and the
-      // refusal must not sit under it.
+      // Refused again, then m1 starts elsewhere: the refusal was about m1, which
+      // has left scheduled, so it must not sit under the match Up next is now.
       await start();
       expect(refusal()).not.toBeNull();
       current = [{ ...m1, status: 'running' }, m2];
@@ -933,11 +936,13 @@ describe('AdminShiaijoPage render-smoke', () => {
   });
 
   // A Start refused for a match picked from further down the queue (here its
-  // competitor is fighting on another court) is kept keyed to that match. It
-  // used to come back when that match later reached Up next, although its
-  // cause was gone by then and nothing else clears it: a finished match sends
-  // no competitor_status_updated. Any change of Up next drops it.
-  it('a refused Start for a match further down the queue does not reappear when it becomes Up next', async () => {
+  // competitor is fighting on another court) is kept keyed to that match, and
+  // belongs to it: it stays on that match's row, and is on the card once the
+  // match reaches Up next, for as long as the match is still scheduled here. It
+  // used to be dropped by any change of Up next, which also took away a notice
+  // whose cause still held. The cost is accepted: a cause that is gone is not
+  // noticed until the operator taps Start again, which asks the server again.
+  it('a refused Start for a match further down the queue is still there when it becomes Up next', async () => {
     const side = (id, name) => ({ id, name });
     const m1 = {
       id: 'm1', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
@@ -958,7 +963,7 @@ describe('AdminShiaijoPage render-smoke', () => {
     try {
       let utils;
       await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
-      const refusal = () => utils.container.querySelector('.shiaijo-upnext__error');
+      const refusal = () => utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
       const refresh = async () => { await act(async () => { utils.getByRole('button', { name: /refresh/i }).click(); }); };
 
       // Picked from the queue below Up next and refused: not shown under Up
@@ -968,12 +973,102 @@ describe('AdminShiaijoPage render-smoke', () => {
       expect(onEditScore.mock.calls[0][1]).toBe('m2');
       expect(refusal()).toBeNull();
 
-      // m1 starts, so m2 is now Up next. The old refusal must not come back
-      // with it.
+      // m1 starts, so m2 is now Up next. The refusal is about m2, which is still
+      // scheduled here, so it is on the card with it.
       current = [{ ...m1, status: 'running' }, m2];
       await refresh();
       expect(utils.container.querySelector('.shiaijo-upnext__card').textContent).toContain('Sato');
-      expect(refusal()).toBeNull();
+      expect(refusal()?.textContent).toBe('Sato is fighting on shiaijo B');
+    } finally {
+      window.API.fetchCourtMatches = prevFetch;
+      window.API.subscribeToEvents = prevSub;
+    }
+  });
+
+  // The advance's own start (here the one after a decision) refused for the
+  // next match: the refusal stays on the card once a refetch makes that match
+  // Up next. The refetch is the very event a change of Up next used to drop it
+  // on (an effect since removed: the refusal is bound to its match now).
+  it('a refused advance start for the next match stays on Up next once that match becomes Up next', async () => {
+    const side = (id, name) => ({ id, name });
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    // Up next before the decision. It involves the withdrawing Yamada, so the
+    // advance passes over it to m3.
+    const m2 = {
+      id: 'm2', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:05', sideA: side('p1', 'Yamada'), sideB: side('p5', 'Endo'),
+    };
+    const m3 = {
+      id: 'm3', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:10', sideA: side('p4', 'Doi'), sideB: side('p6', 'Fujii'),
+    };
+    let current = [mRun, m2, m3];
+    window.tournamentMatches = () => current;
+    window.filterMatchesByCourt = (matches) => matches;
+    const prevFetch = window.API.fetchCourtMatches;
+    const prevSub = window.API.subscribeToEvents;
+    window.API.fetchCourtMatches = vi.fn().mockImplementation(() => Promise.resolve([{ id: 'c1', name: 'Cup' }]));
+    window.API.subscribeToEvents = () => () => {};
+    const onEditScore = vi.fn().mockRejectedValue(new Error('Doi is fighting on shiaijo B'));
+    try {
+      let utils;
+      await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+      expect(probe.props.match?.id).toBe('m-run');
+      await act(async () => {
+        await probe.props.onAfterDecision({
+          id: 'm-run', sideA: 'Yamada', sideB: 'Tanaka', sideAId: 'p1', sideBId: 'p2', winner: 'Tanaka', winnerId: 'p2',
+          status: 'completed', decision: 'kiken-voluntary', decisionBy: 'aka',
+        });
+      });
+      // The advance's start of m3 is refused. Up next is still m2, so the
+      // refusal is not on the card yet.
+      expect(onEditScore).toHaveBeenCalledTimes(1);
+      expect(onEditScore.mock.calls[0][1]).toBe('m3');
+      const upNextCard = () => utils.container.querySelector('.shiaijo-upnext__card');
+      expect(upNextCard().querySelector('.shiaijo-upnext__error')).toBeNull();
+
+      // The refetch: m2 carries the barred stamp the server writes, so Up next
+      // moves onto m3, the match the refused start was for.
+      current = [{ ...mRun, status: 'completed' }, { ...m2, ineligibleSides: { a: 'kiken-voluntary' } }, m3];
+      await act(async () => { utils.getByRole('button', { name: /refresh/i }).click(); });
+      expect(upNextCard().textContent).toContain('Doi');
+      expect(upNextCard().querySelector('.shiaijo-upnext__error')?.textContent).toBe('Doi is fighting on shiaijo B');
+    } finally {
+      window.API.fetchCourtMatches = prevFetch;
+      window.API.subscribeToEvents = prevSub;
+    }
+  });
+
+  // A refused Start for a queue row's match (not Up next) shows on that row,
+  // so the operator sees why it did not start where they tapped it.
+  it('a refused Start shows on the queue row of the match it refused, not on Up next', async () => {
+    const side = (id, name) => ({ id, name });
+    const m1 = {
+      id: 'm1', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:00', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    const m2 = {
+      id: 'm2', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:05', sideA: side('p3', 'Sato'), sideB: side('p4', 'Kato'),
+    };
+    window.tournamentMatches = () => [m1, m2];
+    window.filterMatchesByCourt = (matches) => matches;
+    const prevFetch = window.API.fetchCourtMatches;
+    const prevSub = window.API.subscribeToEvents;
+    window.API.fetchCourtMatches = vi.fn().mockImplementation(() => Promise.resolve([{ id: 'c1', name: 'Cup' }]));
+    window.API.subscribeToEvents = () => () => {};
+    const onEditScore = vi.fn().mockRejectedValue(new Error('Kato is fighting on shiaijo B'));
+    try {
+      let utils;
+      await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+      const rowOf = (name) => [...utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(name));
+      await act(async () => { rowOf('Sato').querySelector('.shiaijo-row__pick').click(); });
+      expect(onEditScore.mock.calls[0][1]).toBe('m2');
+      expect(rowOf('Sato').querySelector('.shiaijo-upnext__error')?.textContent).toBe('Kato is fighting on shiaijo B');
+      expect(utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error')).toBeNull();
     } finally {
       window.API.fetchCourtMatches = prevFetch;
       window.API.subscribeToEvents = prevSub;
@@ -1081,6 +1176,198 @@ describe('a barred match is skipped by every auto-pick (bc-cse)', () => {
     expect(onEditScore.mock.calls[1][1]).toBe('m-open');
   });
 
+  // Every host hands the editor back what its write came back with: the finish
+  // write's answer, a partial apply's held groups included, is the return value.
+  it('Finish + Start Next hands the finish write\'s answer back to the editor', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch];
+    window.filterMatchesByCourt = (m) => m;
+    const answer = { applied: true, heldGroups: ['points'] };
+    const onEditScore = vi.fn()
+      .mockResolvedValueOnce(answer)
+      .mockResolvedValueOnce({ status: 'ok' });
+    await act(async () => { renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    let ret;
+    await act(async () => { ret = await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+    // The start-next write still went out after the finish.
+    expect(onEditScore).toHaveBeenCalledTimes(2);
+    expect(ret).toEqual(answer);
+  });
+
+  // bc-aadv: Finish + Start Next keeps a refused start on the Up next card,
+  // instead of swallowing the error silently.
+  it('Finish + Start Next keeps a refused start on the Up next card', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch];
+    window.filterMatchesByCourt = (m) => m;
+    const onEditScore = vi.fn()
+      .mockResolvedValueOnce({ status: 'ok' })
+      .mockRejectedValueOnce(new Error('Sato is fighting on Shiaijo B.'));
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    expect(probe.props.match?.id).toBe('m-run');
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+    // The finishing write succeeds; the start-next write fails.
+    expect(onEditScore).toHaveBeenCalledTimes(2);
+    // The error is recorded on the Up next card.
+    const errorEl = utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
+    expect(errorEl).toBeTruthy();
+    expect(errorEl.textContent).toContain('Sato is fighting on Shiaijo B.');
+  });
+
+  it('onAfterDecision keeps a refused start on the Up next card', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch];
+    window.filterMatchesByCourt = (m) => m;
+    const onEditScore = vi.fn()
+      .mockRejectedValueOnce(new Error('Could not start the match: check eligibility and try again.'));
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    expect(probe.props.match?.id).toBe('m-run');
+    await act(async () => { await probe.props.onAfterDecision({ winner: side('p1', 'Yamada') }); });
+    // The start-next write fails.
+    expect(onEditScore).toHaveBeenCalledTimes(1);
+    // The error is recorded on the Up next card.
+    const errorEl = utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
+    expect(errorEl).toBeTruthy();
+    expect(errorEl.textContent).toContain('Could not start the match');
+  });
+
+  it('clock_skew on the auto-start is reported on the Up next card', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch];
+    window.filterMatchesByCourt = (m) => m;
+    const onEditScore = vi.fn()
+      .mockResolvedValueOnce({ status: 'ok' })
+      .mockResolvedValueOnce({ applied: false, reason: 'clock_skew' });
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    expect(probe.props.match?.id).toBe('m-run');
+    await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+    // The finishing write succeeds; the start-next write returns clock_skew.
+    expect(onEditScore).toHaveBeenCalledTimes(2);
+    // The clock-skew error is recorded on the Up next card.
+    const errorEl = utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
+    expect(errorEl).toBeTruthy();
+    expect(errorEl.textContent).toContain(CLOCK_SKEW_REASON_TEXT);
+  });
+
+  // A Finish + Start Next that asks for Up next while a start of ANOTHER match
+  // is still out is refused by the one-start guard. That refusal must say so on
+  // Up next, not vanish (bc-aadv).
+  it('Finish + Start Next says why Up next was not started while another match is being started', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    const mLater = {
+      id: 'm-later', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:15', sideA: side('q1', 'Ito'), sideB: side('q2', 'Ishii'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch, mLater];
+    window.filterMatchesByCourt = (m) => m;
+    const prevRevert = window.API.revertMatchToQueue;
+    window.API.revertMatchToQueue = vi.fn().mockResolvedValue({});
+    // The queued row's start hangs; the finish of the running bout lands.
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm-later' ? new Promise(() => {}) : Promise.resolve({ status: 'ok' })));
+    const showToast = vi.fn();
+    try {
+      let utils;
+      await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore, showToast }); });
+      expect(probe.props.match?.id).toBe('m-run');
+      await act(async () => { utils.container.querySelector('.shiaijo-row__pick').click(); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-later']);
+      expect(probe.props.match?.id).toBe('m-run');
+      await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+      // The finish landed and no second start went out: Up next was refused.
+      expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-later', 'm-run']);
+      const note = utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
+      expect(note).toBeTruthy();
+      expect(note.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(mLater) }));
+      // The refusal is toasted as well as noted, the same as a refused tap.
+      expect(showToast).toHaveBeenCalledWith(startWhileStartingMessage({ label: scoreRowMatchName(mLater) }), 'error');
+    } finally {
+      window.API.revertMatchToQueue = prevRevert;
+    }
+  });
+
+  // The refusal is derived from the start in flight while that start is out, so
+  // the present-tense sentence goes once it lands. The match the operator asked
+  // for was never started, though, and nothing else says so: the refusal is kept
+  // on the refused match in the past tense (bc-aadv).
+  it('the Up next note for a refused advance becomes a past-tense note once the blocking start lands', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    const mLater = {
+      id: 'm-later', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+      court: 'A', scheduledAt: '09:15', sideA: side('q1', 'Ito'), sideB: side('q2', 'Ishii'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch, mLater];
+    window.filterMatchesByCourt = (m) => m;
+    const prevRevert = window.API.revertMatchToQueue;
+    window.API.revertMatchToQueue = vi.fn().mockResolvedValue({});
+    let landQueued;
+    const queuedStart = new Promise((resolve) => { landQueued = resolve; });
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm-later' ? queuedStart : Promise.resolve({ status: 'ok' })));
+    try {
+      let utils;
+      await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+      await act(async () => { utils.container.querySelector('.shiaijo-row__pick').click(); });
+      await act(async () => {});
+      await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+      const note = () => utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error');
+      expect(note()?.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(mLater) }));
+      await act(async () => { landQueued({ status: 'ok' }); });
+      await act(async () => {});
+      expect(note()?.textContent).toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(mLater) }));
+    } finally {
+      window.API.revertMatchToQueue = prevRevert;
+    }
+  });
+
+  // The one-start guard stays silent for a repeat advance to the match already
+  // being started: that match is simply on its way.
+  it('a repeat Finish + Start Next to the match already being started stays silent', async () => {
+    const mRun = {
+      id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+      court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+    };
+    window.tournamentMatches = () => [mRun, openMatch];
+    window.filterMatchesByCourt = (m) => m;
+    const prevRevert = window.API.revertMatchToQueue;
+    window.API.revertMatchToQueue = vi.fn().mockResolvedValue({});
+    // Up next's own start hangs; the finish of the running bout lands.
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm-open' ? new Promise(() => {}) : Promise.resolve({ status: 'ok' })));
+    try {
+      let utils;
+      await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+      const upNextStart = [...utils.container.querySelector('.shiaijo-upnext__card').querySelectorAll('button')].find((b) => /start match/i.test(b.textContent));
+      await act(async () => { upNextStart.click(); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-open']);
+      await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: side('p1', 'Yamada') }); });
+      expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-open', 'm-run']);
+      expect(utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error')).toBeNull();
+    } finally {
+      window.API.revertMatchToQueue = prevRevert;
+    }
+  });
+
   it('offers Reinstate for a reinstateable (kiken-injury) withdrawal', async () => {
     window.tournamentMatches = () => [barredMatch({ ineligibleSides: { b: 'kiken-injury' } }), openMatch];
     window.filterMatchesByCourt = (m) => m;
@@ -1726,3 +2013,709 @@ describe('a running match and an open correction never coexist on the console (b
     } finally { c.restore(); }
   });
 });
+
+// One start at a time (bc-aadv): while a Start is still out, a Start of another
+// match is refused on its own row BEFORE the defer, so the running bout is not
+// sent back to the queue for a start that never happens (the bc-crpn rule,
+// applied to starts). A repeat for the match already being started is silent.
+describe('a Start tapped while another start is still out is refused before anything is sent back (bc-aadv)', () => {
+  const rowOf = (c, text) => [...c.utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(text));
+  const startButton = (el) => [...el.querySelectorAll('button')].find((b) => /^start/i.test(b.textContent.trim()));
+  // m1 runs on the court; m2 (Up next) and m3 wait. Up next's start is held in
+  // flight until the test calls land().
+  const setup = async () => {
+    let land;
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm2'
+      ? new Promise((r) => { land = r; })
+      : Promise.resolve({ applied: true })));
+    const c = await mountCourt([courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled')], { onEditScore });
+    await act(async () => { startButton(c.utils.container.querySelector('.shiaijo-upnext__card')).click(); });
+    await act(async () => {});
+    expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m2']);
+    // m1 was sent back for m2's start; the assertions below are about what a
+    // later tap does, so the count starts again from here.
+    window.API.revertMatchToQueue.mockClear();
+    return { c, onEditScore, land: (res) => land(res) };
+  };
+
+  it('a) a Start on another row is refused on that row: the running bout is not sent back and no second start goes out', async () => {
+    const { c, onEditScore } = await setup();
+    try {
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      const text = startWhileStartingMessage({ label: scoreRowMatchName(courtMatch('m2', 'scheduled')) });
+      expect(window.API.revertMatchToQueue).not.toHaveBeenCalled();
+      expect(onEditScore).toHaveBeenCalledTimes(1);
+      expect(c.editorMatch()).toBe('m1');
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]').textContent).toBe(text);
+      expect(c.showToast).toHaveBeenCalledWith(text, 'error');
+    } finally { c.restore(); }
+  });
+
+  it('b) the refusal becomes a past-tense notice on that row once the held start lands, and a Start there clears it', async () => {
+    const { c, onEditScore, land } = await setup();
+    try {
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      const label = scoreRowMatchName(courtMatch('m2', 'scheduled'));
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]').textContent).toBe(startWhileStartingMessage({ label }));
+      await act(async () => { land({ applied: true }); });
+      await act(async () => {});
+      // m3 was asked for and never started; the court is not free, so it is not
+      // started on its own, and the row says so.
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]').textContent).toBe(startWasBlockedByStartMessage({ label }));
+      expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m2']);
+      // The operator starts it: the sentence goes and the start is sent.
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m2', 'm3']);
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]')).toBeNull();
+    } finally { c.restore(); }
+  });
+
+  // The start a refused tap waited for can FAIL instead of landing. Then the court
+  // is free, so "was being started when this match was asked for" would be false,
+  // and the failed start's OWN refusal is the thing the operator needs: it stays on
+  // its card, and the waiting match shows nothing.
+  it('b2) a held start that is refused keeps its own refusal on its card, and the waiting row shows nothing', async () => {
+    const { c, onEditScore, land } = await setup();
+    try {
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]')).toBeTruthy();
+      await act(async () => { land({ applied: false, reason: 'clock_skew' }); });
+      await act(async () => {});
+      expect(c.utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error')?.textContent)
+        .toContain(CLOCK_SKEW_REASON_TEXT);
+      expect(rowOf(c, 'Aka m3').querySelector('[role="alert"]'), 'the court is free: no past-tense notice').toBeNull();
+      expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m2']);
+    } finally { c.restore(); }
+  });
+
+  it('c) a repeat Start on the match already being started does nothing: no revert, no notice', async () => {
+    const { c, onEditScore } = await setup();
+    try {
+      // While its start is out, Up next's own button reads "Starting…" and is disabled.
+      const card = c.utils.container.querySelector('.shiaijo-upnext__card');
+      const again = startButton(card);
+      expect(again.disabled).toBe(true);
+      await act(async () => { again.click(); });
+      await act(async () => {});
+      expect(window.API.revertMatchToQueue).not.toHaveBeenCalled();
+      expect(onEditScore).toHaveBeenCalledTimes(1);
+      expect(card.querySelector('[role="alert"]')).toBeNull();
+      expect(c.showToast).not.toHaveBeenCalled();
+    } finally { c.restore(); }
+  });
+
+  // A pick that defers the running bout is a start in flight from the moment
+  // it is made, not from the moment the deferred bout's revert answers: a second
+  // Start on another row during that wait must not send the running bout back
+  // a second time.
+  it('d) a second Start tapped while a pick is still deferring the running bout is refused, and the bout is not reverted twice', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const c = await mountCourt([courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled'), courtMatch('m4', 'scheduled')], { onEditScore });
+    let landRevert;
+    window.API.revertMatchToQueue = vi.fn(() => new Promise((r) => { landRevert = r; }));
+    try {
+      // The first pick: a queue row's Start, which reverts m1 and waits on it.
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      expect(window.API.revertMatchToQueue).toHaveBeenCalledTimes(1);
+
+      // A second Start on another row while that wait is out.
+      await act(async () => { startButton(rowOf(c, 'Aka m4')).click(); });
+      await act(async () => {});
+      expect(window.API.revertMatchToQueue).toHaveBeenCalledTimes(1);
+      expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]').textContent)
+        .toBe(startWhileStartingMessage({ label: scoreRowMatchName(courtMatch('m3', 'scheduled')) }));
+
+      // Once the revert answers, the first pick starts and only it.
+      await act(async () => { landRevert(true); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m3']);
+    } finally { c.restore(); }
+  });
+
+  // The past-tense sentence says the blocker WAS being started, so it is written only
+  // for a start that went out. A pick whose deferral of the running bout fails never
+  // starts anything: the court is exactly as it was, and "m3 was being started" would
+  // be false.
+  describe('the past-tense notice follows a start that happened', () => {
+    const pickBlocker = async (onEditScore) => {
+      const c = await mountCourt([courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled'), courtMatch('m4', 'scheduled')], { onEditScore });
+      let settleRevert;
+      window.API.revertMatchToQueue = vi.fn(() => new Promise((resolve, reject) => { settleRevert = { resolve, reject }; }));
+      // The pick: a queue row's Start, which sends m1 back and waits on it.
+      await act(async () => { startButton(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      // A Start on another row while that wait is out is refused as "still being started".
+      await act(async () => { startButton(rowOf(c, 'Aka m4')).click(); });
+      await act(async () => {});
+      expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]').textContent)
+        .toBe(startWhileStartingMessage({ label: scoreRowMatchName(courtMatch('m3', 'scheduled')) }));
+      return { c, settleRevert: () => settleRevert };
+    };
+
+    it('e) a pick whose deferral fails never started, so the refused row gets no past-tense notice', async () => {
+      const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+      const { c, settleRevert } = await pickBlocker(onEditScore);
+      try {
+        await act(async () => { settleRevert().reject(new Error('Could not defer the current bout')); });
+        await act(async () => {});
+        expect(onEditScore, 'the pick was abandoned: nothing was started').not.toHaveBeenCalled();
+        expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]'), 'the court is as it was: no sentence about a start').toBeNull();
+        expect(c.utils.container.textContent).not.toContain('was being started');
+      } finally { c.restore(); }
+    });
+
+    it('f) a pick that does start leaves the past-tense notice on the refused row', async () => {
+      const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+      const { c, settleRevert } = await pickBlocker(onEditScore);
+      try {
+        await act(async () => { settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m3']);
+        expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]').textContent)
+          .toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(courtMatch('m3', 'scheduled')) }));
+      } finally { c.restore(); }
+    });
+
+    // A superseded start that HOLDS its result group is HTTP 200
+    // {applied:false, reason:'superseded', heldGroups:['result']}: a different
+    // result is already stored (a send-back, a correction) and nothing of the start
+    // was written. (Round 19: the same answer WITHOUT heldGroups is an echo of a
+    // start that already landed, a start that went out; see the echo tests below.)
+    // For a PICK that is not "as it was": the running bout was sent back
+    // to the queue before the start, so the court is IDLE (and m3 shows the
+    // superseded refusal like any refused start; see the describe below). "m3 was
+    // being started" would be false, and the pick must not pin the panel on a
+    // match the server did not start.
+    const supersededStartOfM3 = () => vi.fn((_compId, matchId) => Promise.resolve(
+      matchId === 'm3' ? { applied: false, reason: 'superseded', heldGroups: ['result'] } : { applied: true }
+    ));
+
+    it('g) a pick whose start is superseded wrote nothing, so the refused row gets no past-tense notice', async () => {
+      const onEditScore = supersededStartOfM3();
+      const { c, settleRevert } = await pickBlocker(onEditScore);
+      try {
+        await act(async () => { settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(onEditScore.mock.calls.map((x) => x[1]), 'the pick did send its start').toEqual(['m3']);
+        expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]'), 'the start wrote nothing: no sentence about a start').toBeNull();
+        expect(c.utils.container.textContent).not.toContain('was being started');
+      } finally { c.restore(); }
+    });
+
+    it('h) a pick whose start is superseded does not pin the panel on the match the server did not start', async () => {
+      const landedPick = await pickBlocker(vi.fn().mockResolvedValue({ applied: true }));
+      try {
+        await act(async () => { landedPick.settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(landedPick.c.editorMatch(), 'a start that went out pins the panel on the picked match').toBe('m3');
+      } finally { landedPick.c.utils.unmount(); landedPick.c.restore(); }
+
+      const { c, settleRevert } = await pickBlocker(supersededStartOfM3());
+      try {
+        await act(async () => { settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(c.editorMatch(), 'nothing was started: the panel stays where it was').not.toBe('m3');
+      } finally { c.restore(); }
+    });
+
+    // PR #463 round 19 (S1). The same answer WITHOUT heldGroups is an echo-hold:
+    // the stored result already equals the start, so another device's start of m3
+    // landed first and m3 IS running. That start went out, exactly like a landed
+    // one (tests f and the landed half of h): the refused row waiting on it gets
+    // the past-tense notice, and the pick pins the panel on m3.
+    const echoStartOfM3 = () => vi.fn((_compId, matchId) => Promise.resolve(
+      matchId === 'm3' ? { applied: false, reason: 'superseded' } : { applied: true }
+    ));
+
+    it('i) a pick whose start is held as an echo went out, so the refused row gets the past-tense notice', async () => {
+      const onEditScore = echoStartOfM3();
+      const { c, settleRevert } = await pickBlocker(onEditScore);
+      try {
+        await act(async () => { settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m3']);
+        expect(rowOf(c, 'Aka m4').querySelector('[role="alert"]').textContent)
+          .toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(courtMatch('m3', 'scheduled')) }));
+        expect(c.utils.container.textContent).not.toContain(START_SUPERSEDED_MESSAGE);
+      } finally { c.restore(); }
+    });
+
+    it('j) a pick whose start is held as an echo pins the panel on the match, which is running', async () => {
+      const { c, settleRevert } = await pickBlocker(echoStartOfM3());
+      try {
+        await act(async () => { settleRevert().resolve(true); });
+        await act(async () => {});
+        expect(c.editorMatch(), 'a start that went out pins the panel on the picked match').toBe('m3');
+      } finally { c.restore(); }
+    });
+  });
+});
+
+// The one-start guard is judged from the start in flight NOW. An advance awaits
+// its finish write and then starts the next match from the render that began the
+// await, so a guard that reads that render's state sees a start begun meanwhile
+// as absent, and one that has since landed as still out.
+describe('the one-start guard reads the start in flight now, not the render that began an advance', () => {
+  const deferred = () => {
+    let resolve;
+    const promise = new Promise((r) => { resolve = r; });
+    return { promise, resolve };
+  };
+  const side = (id, name) => ({ id, name });
+  const runM = {
+    id: 'm-run', compId: 'c1', compName: 'Cup', status: 'running', phase: 'pool', poolName: 'Pool A',
+    court: 'A', sideA: side('p1', 'Yamada'), sideB: side('p2', 'Tanaka'),
+  };
+  const openM = {
+    id: 'm-open', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+    court: 'A', scheduledAt: '09:10', sideA: side('s', 'Sato'), sideB: side('k', 'Kato'),
+  };
+  const laterM = {
+    id: 'm-later', compId: 'c1', compName: 'Cup', status: 'scheduled', phase: 'pool', poolName: 'Pool A',
+    court: 'A', scheduledAt: '09:15', sideA: side('q1', 'Ito'), sideB: side('q2', 'Ishii'),
+  };
+  const winner = side('p1', 'Yamada');
+  // The queue row's Start button for the match whose side carries `name`.
+  const queueStart = (utils, name) => {
+    const row = [...utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(name));
+    return [...row.querySelectorAll('button')].find((b) => /^start match$/i.test(b.textContent.trim()));
+  };
+  let prevRevert;
+  beforeEach(() => {
+    prevRevert = window.API.revertMatchToQueue;
+    window.API.revertMatchToQueue = vi.fn().mockResolvedValue({});
+    window.tournamentMatches = () => [runM, openM, laterM];
+    window.filterMatchesByCourt = (m) => m;
+  });
+  afterEach(() => {
+    window.API.revertMatchToQueue = prevRevert;
+  });
+
+  it('a) a finish that answers after a queue start began sends no second start, and says why Up next was not started', async () => {
+    const finish = deferred();
+    // The queue start hangs; the finish of the running bout waits on `finish`.
+    const onEditScore = vi.fn((_compId, matchId) => {
+      if (matchId === 'm-run') return finish.promise;
+      if (matchId === 'm-later') return new Promise(() => {});
+      return Promise.resolve({ applied: true });
+    });
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    expect(probe.props.match?.id).toBe('m-run');
+    // The editor holds this closure while its finish is out.
+    const advance = probe.props.onSubmitAndNext;
+    let pending;
+    await act(async () => { pending = advance({ status: 'completed', winner }); });
+    await act(async () => { queueStart(utils, 'Ito').click(); });
+    await act(async () => {});
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-run', 'm-later']);
+    await act(async () => { finish.resolve({ applied: true }); await pending; });
+    // No second start went out: the advance was refused, and the refusal shows.
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-run', 'm-later']);
+    expect(utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error').textContent)
+      .toBe(startWhileStartingMessage({ label: scoreRowMatchName(laterM) }));
+  });
+
+  it('b) a finish that answers after a start that has since landed is not refused as still starting', async () => {
+    const laterStart = deferred();
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm-later' ? laterStart.promise : Promise.resolve({ applied: true })));
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    await act(async () => { queueStart(utils, 'Ito').click(); });
+    await act(async () => {});
+    // The editor holds this closure while the queue start is still out.
+    const advance = probe.props.onSubmitAndNext;
+    await act(async () => { laterStart.resolve({ applied: true }); });
+    await act(async () => {});
+    await act(async () => { await advance({ status: 'completed', winner }); });
+    // The next match was started: the start that had landed no longer blocks it.
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-later', 'm-run', 'm-open']);
+    expect(utils.container.querySelector('.shiaijo-upnext__card .shiaijo-upnext__error')).toBeNull();
+  });
+
+  // A Start refused while another start is out names that start. Once that start
+  // has landed the refusal is a past-tense notice on the refused match, and the
+  // next start the operator makes, an advance included, clears it: it never
+  // names the second start of the same match.
+  it('c) the notice made when a start landed goes when that match is started again by an advance, and never names the second start', async () => {
+    const firstStart = deferred();
+    const secondStart = deferred();
+    const openStarts = [firstStart, secondStart];
+    const onEditScore = vi.fn((_compId, matchId) => (matchId === 'm-open'
+      ? openStarts.shift().promise
+      : Promise.resolve({ applied: true })));
+    let utils;
+    await act(async () => { utils = renderPage(makeMinimalTournament(), 'A', { onEditScore }); });
+    // Finishing the running bout advances to m-open, and that start is held.
+    let firstAdvance;
+    await act(async () => { firstAdvance = probe.props.onSubmitAndNext({ status: 'completed', winner }); });
+    await act(async () => {});
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-run', 'm-open']);
+    // A Start of the queue row below is refused while m-open's start is out.
+    const itoRow = () => [...utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes('Ito'));
+    await act(async () => { queueStart(utils, 'Ito').click(); });
+    await act(async () => {});
+    expect(itoRow().querySelector('[role="alert"]')?.textContent).toBe(startWhileStartingMessage({ label: scoreRowMatchName(openM) }));
+    // The start lands: Ito was asked for and never started, so the refusal is
+    // kept, in the past tense, on Ito's row.
+    await act(async () => { firstStart.resolve({ applied: true }); await firstAdvance; });
+    await act(async () => {});
+    expect(itoRow().querySelector('[role="alert"]')?.textContent).toBe(startWasBlockedByStartMessage({ label: scoreRowMatchName(openM) }));
+    // m-open is started again by an advance, and that start is still out.
+    await act(async () => { probe.props.onSubmitAndNext({ status: 'completed', winner }); });
+    await act(async () => {});
+    expect(onEditScore.mock.calls.map((c) => c[1])).toEqual(['m-run', 'm-open', 'm-run', 'm-open']);
+    expect(itoRow().querySelector('[role="alert"]'), 'the old notice must not name the second start').toBeNull();
+  });
+});
+
+// PR #463 batch 14, item 2: the queue row asks winnerSideLR and teamMatchMarks
+// by ES import from the side_marks.jsx leaf, not off window. The old `?.` guard
+// painted NOTHING when the global was missing: no winner cue and no Kiken mark,
+// with no error to say why. This suite never publishes either global, which is
+// the point: the row must not need them.
+describe('a completed queue row marks its winner and the withdrawn team without any window global', () => {
+  const saved = {};
+  beforeEach(() => {
+    saved.winnerSideLR = window.winnerSideLR;
+    saved.teamMatchMarks = window.teamMatchMarks;
+    delete window.winnerSideLR;
+    delete window.teamMatchMarks;
+  });
+  afterEach(() => {
+    if (saved.winnerSideLR) window.winnerSideLR = saved.winnerSideLR;
+    if (saved.teamMatchMarks) window.teamMatchMarks = saved.teamMatchMarks;
+  });
+  const completedRow = (utils, name) => [...utils.container.querySelectorAll('.shiaijo-qrow--complete')]
+    .find((r) => r.textContent.includes(name));
+
+  it('a completed team row carries the winner cue on the winner and Kiken beside the withdrawn team', async () => {
+    const c = await mountCourt([
+      courtMatch('m1', 'completed', {
+        compKind: 'team', teamSize: 3, subResults: [], modifiedAt: 1000,
+        winner: courtSide('m1-a', 'Aka m1'), decision: 'kiken-voluntary', decisionBy: 'shiro',
+      }),
+      courtMatch('m2', 'scheduled'),
+    ]);
+    try {
+      const row = completedRow(c.utils, 'Aka m1');
+      expect(row, 'the completed row is listed').toBeTruthy();
+      expect(row.querySelector('.shiaijo-qrow__side--aka').classList.contains('shiaijo-qrow__side--win')).toBe(true);
+      expect(row.querySelector('.shiaijo-qrow__side--shiro').classList.contains('shiaijo-qrow__side--win')).toBe(false);
+      expect(row.querySelector('[data-testid="team-summary-mark-shiro"]')?.textContent).toBe('Kiken');
+      expect(row.querySelector('[data-testid="team-summary-mark-aka"]')).toBeNull();
+    } finally { c.restore(); }
+  });
+});
+
+// PR #463 batch 14, item 10: a refusal the host's onEditScore already toasted
+// (editMatchScore, admin.jsx, marks every error it toasts) is not toasted a second
+// time by the console's Start, which replaced the single-slot toast and restarted
+// its timer. The card or row still says it. An error nobody marked is the console's
+// to toast (a mocked onEditScore that does not toast, a clock_skew answer).
+describe('the console toasts a thrown Start refusal once', () => {
+  const SENTENCE = 'Kato is fighting on shiaijo B';
+  const startButton = (el) => [...el.querySelectorAll('button')].find((b) => /^start/i.test(b.textContent.trim()));
+  const rowOf = (c, text) => [...c.utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(text));
+  const mountRefused = (error) => mountCourt(
+    [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled')],
+    { onEditScore: vi.fn().mockRejectedValue(error) },
+  );
+
+  it('the Up next card: a marked refusal toasts nothing here and shows on the card', async () => {
+    const c = await mountRefused(markToasted(new Error(SENTENCE)));
+    try {
+      const card = c.utils.container.querySelector('.shiaijo-upnext__card');
+      await act(async () => { startButton(card).click(); });
+      await act(async () => {});
+      expect(c.showToast).not.toHaveBeenCalled();
+      expect(card.querySelector('.shiaijo-upnext__error')?.textContent).toBe(SENTENCE);
+    } finally { c.restore(); }
+  });
+
+  it('a queue row: a marked refusal toasts nothing here and shows on that row', async () => {
+    const c = await mountRefused(markToasted(new Error(SENTENCE)));
+    try {
+      await act(async () => { startButton(rowOf(c, 'Aka m2')).click(); });
+      await act(async () => {});
+      expect(c.showToast).not.toHaveBeenCalled();
+      expect(rowOf(c, 'Aka m2').querySelector('.shiaijo-upnext__error')?.textContent).toBe(SENTENCE);
+    } finally { c.restore(); }
+  });
+
+  it('an error nobody marked is toasted once by the console, on the card and on a row', async () => {
+    const c = await mountRefused(new Error(SENTENCE));
+    try {
+      await act(async () => { startButton(c.utils.container.querySelector('.shiaijo-upnext__card')).click(); });
+      await act(async () => {});
+      expect(c.showToast.mock.calls).toEqual([[SENTENCE, 'error']]);
+      c.showToast.mockClear();
+      await act(async () => { startButton(rowOf(c, 'Aka m2')).click(); });
+      await act(async () => {});
+      expect(c.showToast.mock.calls).toEqual([[SENTENCE, 'error']]);
+    } finally { c.restore(); }
+  });
+});
+
+// PR #463 round 18: a Start the server answered SUPERSEDED (HTTP 200
+// {applied:false, reason:'superseded'}: a newer change to the match is stored,
+// nothing of the start was written) is a REFUSED start on the console, through
+// the path a thrown or clock_skew refusal takes: the sentence is stored on the
+// refused match (its Up next card or its queue row, shown while it is still
+// scheduled), toasted once, and the panel is not pinned on a match the server
+// did not start. Before this it said nothing at all.
+describe('the console reports a superseded Start that holds its result as a refused one', () => {
+  const startButton = (el) => [...el.querySelectorAll('button')].find((b) => /^start/i.test(b.textContent.trim()));
+  const rowOf = (c, text) => [...c.utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(text));
+  const mountSuperseded = () => mountCourt(
+    [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled')],
+    { onEditScore: vi.fn().mockResolvedValue({ applied: false, reason: 'superseded', heldGroups: ['result'] }) },
+  );
+
+  it('the Up next card: the superseded sentence on the card, one toast, the panel not pinned', async () => {
+    const c = await mountSuperseded();
+    try {
+      const card = c.utils.container.querySelector('.shiaijo-upnext__card');
+      await act(async () => { startButton(card).click(); });
+      await act(async () => {});
+      expect(card.querySelector('.shiaijo-upnext__error[role="alert"]')?.textContent).toBe(START_SUPERSEDED_MESSAGE);
+      expect(c.showToast.mock.calls).toEqual([[START_SUPERSEDED_MESSAGE, 'error']]);
+      expect(c.editorMatch(), 'nothing was started: the panel is not pinned on m1').toBeNull();
+    } finally { c.restore(); }
+  });
+
+  it('a queue row: the superseded sentence on that row, one toast, the panel not pinned', async () => {
+    const c = await mountSuperseded();
+    try {
+      await act(async () => { startButton(rowOf(c, 'Aka m2')).click(); });
+      await act(async () => {});
+      expect(rowOf(c, 'Aka m2').querySelector('.shiaijo-upnext__error[role="alert"]')?.textContent).toBe(START_SUPERSEDED_MESSAGE);
+      expect(c.showToast.mock.calls).toEqual([[START_SUPERSEDED_MESSAGE, 'error']]);
+      expect(c.editorMatch()).toBeNull();
+    } finally { c.restore(); }
+  });
+
+  // The notice is bound to the match like every stored Start refusal: when the
+  // other device's change that superseded the start leaves the match running (it
+  // started there), the notice drops (startRefusalStands) and the toast was the
+  // only thing the operator saw.
+  it('the notice goes when the match is no longer scheduled in the live data', async () => {
+    const c = await mountSuperseded();
+    try {
+      const card = c.utils.container.querySelector('.shiaijo-upnext__card');
+      await act(async () => { startButton(card).click(); });
+      await act(async () => {});
+      expect(c.utils.container.textContent).toContain(START_SUPERSEDED_MESSAGE);
+      c.feed.current = [courtMatch('m1', 'running'), courtMatch('m2', 'scheduled')];
+      await c.refresh();
+      await act(async () => {});
+      expect(c.utils.container.textContent).not.toContain(START_SUPERSEDED_MESSAGE);
+    } finally { c.restore(); }
+  });
+
+  // PR #463 round 19 (S1). A superseded start WITHOUT heldGroups is an echo-hold:
+  // another device's start of this match landed first with a later stamp, so the
+  // match IS running. It is a start that went out, like a landed one: no sentence,
+  // no toast, and the panel pins on the match. (A PICK's echo is tests i and j in
+  // the past-tense describe above.)
+  describe('an echo-held superseded Start (no heldGroups) is a start that went out', () => {
+    const mountEcho = () => mountCourt(
+      [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled')],
+      { onEditScore: vi.fn().mockResolvedValue({ applied: false, reason: 'superseded' }) },
+    );
+
+    it('the Up next card: no sentence, no toast, the panel pinned on the match', async () => {
+      const c = await mountEcho();
+      try {
+        const card = c.utils.container.querySelector('.shiaijo-upnext__card');
+        await act(async () => { startButton(card).click(); });
+        await act(async () => {});
+        expect(card.querySelector('.shiaijo-upnext__error'), 'no refusal sentence on the card').toBeNull();
+        expect(c.utils.container.textContent).not.toContain('Not started');
+        expect(c.showToast, 'no toast').not.toHaveBeenCalled();
+        expect(c.editorMatch(), 'the start went out: the panel is pinned on m1').toBe('m1');
+      } finally { c.restore(); }
+    });
+
+    it('a queue row: no sentence, no toast, the panel pinned on the match', async () => {
+      const c = await mountEcho();
+      try {
+        await act(async () => { startButton(rowOf(c, 'Aka m2')).click(); });
+        await act(async () => {});
+        expect(rowOf(c, 'Aka m2').querySelector('.shiaijo-upnext__error'), 'no refusal sentence on the row').toBeNull();
+        expect(c.utils.container.textContent).not.toContain('Not started');
+        expect(c.showToast, 'no toast').not.toHaveBeenCalled();
+        expect(c.editorMatch(), 'the start went out: the panel is pinned on m2').toBe('m2');
+      } finally { c.restore(); }
+    });
+  });
+});
+
+// PR #463 batch 14, item 4 (bc-aadv): a stored Start refusal belongs to the match
+// it was refused for. It stays on that match's card or queue row for as long as
+// the match is still scheduled on this court, and goes when the match leaves
+// scheduled, when a NON-EMPTY court list no longer holds it, when eligibility
+// moves in its competition (the adapted test above) or when the operator starts
+// another match. Up next changing by itself no longer drops it, and a Finish +
+// Start Next refusal is no different from a tap's.
+describe('a stored Start refusal is bound to the refused match', () => {
+  const REFUSAL = 'Kato is fighting on shiaijo B';
+  const refusing = () => vi.fn().mockRejectedValue(new Error(REFUSAL));
+  const three = () => [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled')];
+  const rowOf = (c, text) => [...c.utils.container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes(text));
+  const card = (c) => c.utils.container.querySelector('.shiaijo-upnext__card');
+  const startIn = (el) => [...el.querySelectorAll('button')].find((b) => /^start/i.test(b.textContent.trim()));
+  const noteIn = (el) => el?.querySelector('.shiaijo-upnext__error')?.textContent ?? null;
+  const refuseOnRow = async (c, text) => {
+    await act(async () => { startIn(rowOf(c, text)).click(); });
+    await act(async () => {});
+  };
+
+  it('stays on its queue row when Up next moves on to another match while it is still scheduled', async () => {
+    const c = await mountCourt(three(), { onEditScore: refusing() });
+    try {
+      await refuseOnRow(c, 'Aka m3');
+      expect(noteIn(rowOf(c, 'Aka m3'))).toBe(REFUSAL);
+      // m1 starts elsewhere: Up next is now m2, and m3 is still waiting here.
+      c.feed.current = [courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled')];
+      await c.refresh();
+      expect(card(c).textContent).toContain('Aka m2');
+      expect(noteIn(card(c)), 'the refusal is about m3, not about Up next').toBeNull();
+      expect(noteIn(rowOf(c, 'Aka m3'))).toBe(REFUSAL);
+    } finally { c.restore(); }
+  });
+
+  it('goes when the refused match leaves scheduled, and does not come back when it is sent back to the queue', async () => {
+    const c = await mountCourt(three(), { onEditScore: refusing() });
+    try {
+      await refuseOnRow(c, 'Aka m3');
+      expect(noteIn(rowOf(c, 'Aka m3'))).toBe(REFUSAL);
+      c.feed.current = [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'running')];
+      await c.refresh();
+      c.feed.current = three();
+      await c.refresh();
+      expect(rowOf(c, 'Aka m3'), 'm3 is back in the queue').toBeTruthy();
+      expect(noteIn(rowOf(c, 'Aka m3')), 'a stale refusal never revives').toBeNull();
+    } finally { c.restore(); }
+  });
+
+  it('goes when a non-empty court list no longer holds the match (moved), and does not come back', async () => {
+    const c = await mountCourt(three(), { onEditScore: refusing() });
+    try {
+      await refuseOnRow(c, 'Aka m3');
+      c.feed.current = [courtMatch('m1', 'scheduled'), courtMatch('m2', 'scheduled')];
+      await c.refresh();
+      c.feed.current = three();
+      await c.refresh();
+      expect(noteIn(rowOf(c, 'Aka m3')), 'moved away and back is a new situation').toBeNull();
+    } finally { c.restore(); }
+  });
+
+  it('stays across a refetch that answers an empty list and then the same list again', async () => {
+    const c = await mountCourt(three(), { onEditScore: refusing() });
+    try {
+      await refuseOnRow(c, 'Aka m3');
+      // The list is empty while a feed loads; a transient empty answer says
+      // nothing about the match, so the refusal is left where it is.
+      c.feed.current = [];
+      await c.refresh();
+      c.feed.current = three();
+      await c.refresh();
+      expect(noteIn(rowOf(c, 'Aka m3'))).toBe(REFUSAL);
+    } finally { c.restore(); }
+  });
+
+  it('is bound the same way when it is a Finish + Start Next that was refused', async () => {
+    // m2 is Up next after m1 finishes, and its start is refused. No `advance`
+    // option is left to pass: the refusal outlives a change of Up next exactly
+    // as a tap's does, while m2 is still scheduled.
+    const onEditScore = vi.fn(async (_c, id) => { if (id === 'm2') throw new Error(REFUSAL); return { applied: true }; });
+    const c = await mountCourt([courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled')], { onEditScore });
+    try {
+      await act(async () => { await probe.props.onSubmitAndNext({ status: 'completed', winner: courtSide('m1-a', 'Aka m1') }); });
+      expect(noteIn(card(c))).toBe(REFUSAL);
+      // The refetch: m1 done, and m3 is now scheduled ahead of m2.
+      c.feed.current = [courtMatch('m1', 'completed'), courtMatch('m2', 'scheduled', { scheduledAt: '09:09' }), courtMatch('m3', 'scheduled')];
+      await c.refresh();
+      expect(card(c).textContent).toContain('Aka m3');
+      expect(noteIn(card(c))).toBeNull();
+      expect(noteIn(rowOf(c, 'Aka m2'))).toBe(REFUSAL);
+      // And it goes with the match, as a tap's does.
+      c.feed.current = [courtMatch('m1', 'completed'), courtMatch('m2', 'running'), courtMatch('m3', 'scheduled')];
+      await c.refresh();
+      c.feed.current = [courtMatch('m1', 'completed'), courtMatch('m2', 'scheduled', { scheduledAt: '09:09' }), courtMatch('m3', 'scheduled')];
+      await c.refresh();
+      expect(noteIn(rowOf(c, 'Aka m2'))).toBeNull();
+    } finally { c.restore(); }
+  });
+
+  // (ii) An advance refused because another start was still out says so while
+  // that start is out. When it lands, the court has a running bout, so the
+  // refused match is NOT started on its own (one start at a time), and nothing
+  // else would tell the operator it was asked for and never started: the refusal
+  // is kept, in the past tense, on the refused match.
+  it('an advance refused for a start still out keeps a past-tense notice on the refused match once that start lands', async () => {
+    let landLater;
+    const onEditScore = vi.fn((_c, id) => (id === 'm3'
+      ? new Promise((r) => { landLater = r; })
+      : Promise.resolve({ applied: true })));
+    const c = await mountCourt([courtMatch('m1', 'running'), courtMatch('m2', 'scheduled'), courtMatch('m3', 'scheduled')], { onEditScore });
+    try {
+      // The editor holds this closure while its finish is out; m3's start is
+      // begun from the queue meanwhile and hangs.
+      const advance = probe.props.onSubmitAndNext;
+      await act(async () => { startIn(rowOf(c, 'Aka m3')).click(); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((x) => x[1])).toEqual(['m3']);
+      await act(async () => { await advance({ status: 'completed', winner: courtSide('m1-a', 'Aka m1') }); });
+      // m2 is Up next and was asked for while m3's start was out: refused, present tense.
+      const label = scoreRowMatchName(courtMatch('m3', 'scheduled'));
+      expect(noteIn(card(c))).toBe(startWhileStartingMessage({ label }));
+      expect(onEditScore.mock.calls.map((x) => x[1])).not.toContain('m2');
+
+      await act(async () => { landLater({ applied: true }); });
+      await act(async () => {});
+      expect(noteIn(card(c)), 'the refusal does not vanish when the start lands').toBe(startWasBlockedByStartMessage({ label }));
+      expect(onEditScore.mock.calls.map((x) => x[1]), 'and m2 was not started on its own').not.toContain('m2');
+
+      // A Start on it clears the sentence and sends the start.
+      await act(async () => { startIn(card(c)).click(); });
+      await act(async () => {});
+      expect(onEditScore.mock.calls.map((x) => x[1])).toContain('m2');
+      expect(noteIn(card(c))).toBeNull();
+    } finally { c.restore(); }
+  });
+});
+
+// PR #463 batch 14, item 11: the console imports startPatch from start_match.jsx
+// (the one owner of how a Start is written) instead of wrapping window.startPatch,
+// which threw "admin_schedule.jsx not loaded" when the global was absent. This
+// suite publishes none (it used to publish a bare vi.fn()); the test removes any
+// another file left behind, so the console cannot be reading it.
+describe('the console writes a Start without any window.startPatch', () => {
+  it('Start on the Up next card sends the real start patch', async () => {
+    const saved = window.startPatch;
+    delete window.startPatch;
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const c = await mountCourt([courtMatch('m1', 'scheduled')], { onEditScore });
+    try {
+      const start = [...c.utils.container.querySelector('.shiaijo-upnext__card').querySelectorAll('button')]
+        .find((b) => /^start/i.test(b.textContent.trim()));
+      await act(async () => { start.click(); });
+      await act(async () => {});
+      expect(onEditScore).toHaveBeenCalledTimes(1);
+      const patch = onEditScore.mock.calls[0][2];
+      expect(patch?.status).toBe('running');
+      expect(patch?.startOnly).toBe(true);
+      expect(c.showToast, 'no "factory unavailable" toast').not.toHaveBeenCalled();
+    } finally {
+      c.restore();
+      if (saved) window.startPatch = saved;
+    }
+  });
+});
diff --git a/web-mobile/js/__tests__/render/admin_shiaijo_superseded_advance.render.test.jsx b/web-mobile/js/__tests__/render/admin_shiaijo_superseded_advance.render.test.jsx
index 005cf7904..6fe788ace 100644
--- a/web-mobile/js/__tests__/render/admin_shiaijo_superseded_advance.render.test.jsx
+++ b/web-mobile/js/__tests__/render/admin_shiaijo_superseded_advance.render.test.jsx
@@ -43,7 +43,6 @@ const STUBBED_GLOBALS = {
     updateMatchTime: vi.fn(),
     startMatch: vi.fn(),
   },
-  startPatch: vi.fn(() => ({ status: 'running' })),
   confirmDialog: vi.fn().mockResolvedValue(true),
   PoolsViewer: () => null,
   compMatches: () => [],
diff --git a/web-mobile/js/__tests__/render/call_to_court_double_tap.render.test.jsx b/web-mobile/js/__tests__/render/call_to_court_double_tap.render.test.jsx
new file mode 100644
index 000000000..ab8ebd8ae
--- /dev/null
+++ b/web-mobile/js/__tests__/render/call_to_court_double_tap.render.test.jsx
@@ -0,0 +1,415 @@
+// bc-cdbl: a double tap on "Call to court" sends ONE announcement, and starting
+// the called match withdraws that call.
+//
+// The tap is checked with acceptTap (tap_guard.jsx) before anything else in
+// callToCourt, so the bounce of a tap is never sent. The callingKey disabled
+// state stays the in-flight guard, and a deliberate tap after the bounce window
+// still calls again. The call's announcement id is kept per match and deleted
+// once the console's list shows that match out of scheduled, however it got
+// there (started here, started elsewhere, or closed by a decision).
+//
+// Pointer taps pass detail: 1 (helpers/tap_events.js), or the guard exempts
+// them and these tests could never go red.
+
+import React from 'react';
+import { render, act, screen, cleanup, within } from '@testing-library/react';
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import { installWindowStubs } from '../helpers/stub_globals.js';
+import { TAP_BOUNCE_MS } from '../../tap_guard.jsx';
+import { pointerTap, keyboardClick } from '../helpers/tap_events.js';
+
+const CALL_TITLE = 'Announce this match to spectators and competitors';
+
+const STUBBED_GLOBALS = {
+  AdminTopbar: ({ children }) => <div data-testid="topbar">{children}</div>,
+  Breadcrumbs: () => null,
+  ScoreEditorModal: (props) => <div data-testid="score-editor" data-match={props.match ? props.match.id : ''} />,
+  // One button per OTHER court, calling onChange as the real picker does, so a
+  // test can reach the move confirm from a queue row.
+  CourtPicker: ({ value, courts, onChange }) => (
+    <span>
+      {(courts || []).filter((cc) => cc !== value).map((cc) => (
+        <button type="button" key={cc} data-testid={`move-to-${cc}`} onClick={() => onChange(cc)}>{`Move to ${cc}`}</button>
+      ))}
+    </span>
+  ),
+  BracketTree: () => null,
+  Icon: ({ name }) => <span>{name}</span>,
+  filterMatchesByCourt: (matches) => matches,
+  tournamentMatches: () => [],
+  API: {
+    fetchCompetitionDetails: vi.fn().mockResolvedValue(null),
+    sendAnnouncement: vi.fn(),
+    deleteAnnouncement: vi.fn(),
+    updateMatchTime: vi.fn(),
+    recordDecision: vi.fn().mockResolvedValue({ applied: true }),
+    reinstateCompetitor: vi.fn().mockResolvedValue({}),
+  },
+  confirmDialog: vi.fn().mockResolvedValue(true),
+  PoolsViewer: () => null,
+  compMatches: () => [],
+};
+
+let restoreGlobals;
+let AdminShiaijoPage;
+
+beforeAll(async () => {
+  restoreGlobals = installWindowStubs(STUBBED_GLOBALS);
+  await import('../../admin_shiaijo.jsx');
+  AdminShiaijoPage = window.AdminShiaijoPage;
+});
+
+afterAll(() => restoreGlobals());
+
+// Each call gets its own id, so a test can tell which announcement was deleted.
+let nextAnnId = 0;
+
+beforeEach(() => {
+  nextAnnId = 0;
+  window.API.sendAnnouncement = vi.fn(async () => ({ id: `ann-${++nextAnnId}`, message: 'x' }));
+  window.API.deleteAnnouncement = vi.fn(async () => {});
+  window.API.recordDecision = vi.fn(async () => ({ applied: true }));
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  cleanup();
+  window.tournamentMatches = STUBBED_GLOBALS.tournamentMatches;
+  window.filterMatchesByCourt = STUBBED_GLOBALS.filterMatchesByCourt;
+  vi.useRealTimers();
+});
+
+const wait = (ms) => act(async () => { vi.advanceTimersByTime(ms); });
+
+function twoScheduledMatches() {
+  const base = { compId: 'c1', court: 'A', status: 'scheduled', phase: 'pool', poolName: 'Pool 1' };
+  return [
+    { ...base, id: 'm1', sideA: { id: 'p1', name: 'Yamada' }, sideB: { id: 'p2', name: 'Tanaka' } },
+    { ...base, id: 'm2', sideA: { id: 'p3', name: 'Suzuki' }, sideB: { id: 'p4', name: 'Sato' } },
+  ];
+}
+
+// A new tournament object on every call, so rerender() re-derives the court's
+// matches from window.tournamentMatches (the console memoises on it).
+function consoleElement(onEditScore, onMoveCourt = vi.fn()) {
+  return (
+    <AdminShiaijoPage
+      tournament={{ name: 'Test Tournament', courts: ['A', 'B'], competitions: [] }}
+      court="A"
+      onBack={vi.fn()}
+      onEditScore={onEditScore}
+      onMoveCourt={onMoveCourt}
+      onLogout={vi.fn()}
+      onViewerMode={vi.fn()}
+      password=""
+      showToast={vi.fn()}
+      tweaks={{}}
+      onSwitchCourt={vi.fn()}
+    />
+  );
+}
+
+function renderConsole(props = {}) {
+  window.tournamentMatches = () => twoScheduledMatches();
+  window.filterMatchesByCourt = (matches) => matches;
+  const onEditScore = props.onEditScore || vi.fn().mockResolvedValue({ applied: true });
+  return render(consoleElement(onEditScore, props.onMoveCourt));
+}
+
+// The console's match list as the next refetch shows it: a rerender with a new
+// tournament object re-derives the court's matches from window.tournamentMatches.
+function showMatches(rerender, onEditScore, matches) {
+  window.tournamentMatches = () => matches;
+  rerender(consoleElement(onEditScore));
+}
+
+// The two scheduled matches with the first one changed, as a refetch shows it
+// once it has been started or closed.
+function firstMatchWith(patch) {
+  const [m1, m2] = twoScheduledMatches();
+  return [{ ...m1, ...patch }, m2];
+}
+
+// Every "Call to court" control on the page, in DOM order: the Up next card's
+// first, then one per queue row.
+const callButtons = () => screen.getAllByTitle(CALL_TITLE);
+
+describe('Call to court double tap (bc-cdbl)', () => {
+  it('a double tap on the Up next card sends one announcement', async () => {
+    renderConsole();
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    // The first request has settled (pointerTap flushes microtasks); the second
+    // tap lands inside the bounce window of the first.
+    await wait(30);
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+  });
+
+  it('a deliberate tap after the bounce window calls again ("Call again")', async () => {
+    renderConsole();
+    await pointerTap(callButtons()[0]);
+    await wait(TAP_BOUNCE_MS + 50);
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(2);
+  });
+
+  it('a double tap on a queue row sends one announcement, for that row', async () => {
+    renderConsole();
+    // callButtons()[1] is the queue row: the Up next card holds m1, so the queue
+    // lists m2 (Suzuki v Sato) alone.
+    const rowButton = callButtons()[1];
+    await pointerTap(rowButton);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.sendAnnouncement.mock.calls[0][0]).toContain('Suzuki');
+    await wait(30);
+    await pointerTap(rowButton);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+  });
+
+  it('a keyboard activation (detail 0) is never read as a bounce', async () => {
+    renderConsole();
+    await keyboardClick(callButtons()[0]);
+    await keyboardClick(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(2);
+  });
+
+  it('starting the called match withdraws its announcement once the list shows it running', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    expect(onEditScore).toHaveBeenCalled();
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-1', '');
+  });
+
+  it('a match started on another device withdraws its call', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-1', '');
+  });
+
+  it('a call stays up while its match is scheduled or missing from the list', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    showMatches(rerender, onEditScore, twoScheduledMatches());
+    await act(async () => {});
+    // The list is empty while it loads: an absent match is not judged.
+    showMatches(rerender, onEditScore, []);
+    await act(async () => {});
+    showMatches(rerender, onEditScore, twoScheduledMatches());
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+  });
+
+  it('a failed withdrawal does not fail the start', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    window.API.deleteAnnouncement = vi.fn(async () => { throw new Error('network down'); });
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    expect(onEditScore).toHaveBeenCalled();
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it('a start that lands before the call is answered still withdraws it', async () => {
+    let answer;
+    window.API.sendAnnouncement = vi.fn(() => new Promise((resolve) => { answer = resolve; }));
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    // The call's request is still out when the match starts.
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+    await act(async () => { answer({ id: 'ann-late', message: 'x' }); });
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-late', '');
+  });
+
+  it('recording the fusensho for a barred match withdraws its call', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+
+    // Yamada's withdrawal reaches the console after the call went out: the
+    // match is barred, its call button goes, and the notice offers the fusensho.
+    window.tournamentMatches = () => {
+      const [m1, m2] = twoScheduledMatches();
+      return [{ ...m1, ineligibleSides: { a: 'kiken-voluntary' } }, m2];
+    };
+    rerender(consoleElement(onEditScore));
+    await pointerTap(screen.getByTestId('barred-match-record-fusensho'));
+    await act(async () => {});
+    expect(window.API.recordDecision).toHaveBeenCalledTimes(1);
+    // The decision lands and the next refetch shows the match closed.
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'completed', decision: 'fusensho' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-1', '');
+  });
+
+  it('a second deliberate call withdraws the first banner once the second is answered, and starting the match withdraws the second', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    await wait(TAP_BOUNCE_MS + 50);
+    // A side's name resolved between the two calls, so the second announcement's
+    // text differs. The server replaces only an announcement with identical text,
+    // so the first banner must come down here, not wait out its expiry. It comes
+    // down only once the second call is answered, so the banner is never taken
+    // down for a call that did not go out.
+    let answerSecond;
+    window.API.sendAnnouncement.mockImplementationOnce(() => new Promise((resolve) => { answerSecond = resolve; }));
+    const [m1, m2] = twoScheduledMatches();
+    showMatches(rerender, onEditScore, [{ ...m1, sideA: { id: 'p1', name: 'Yamada Taro' } }, m2]);
+    await act(async () => {});
+    await pointerTap(callButtons()[0]);
+    await act(async () => {});
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(2);
+    expect(window.API.sendAnnouncement.mock.calls[1][0]).toContain('Yamada Taro');
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+    await act(async () => { answerSecond({ id: 'ann-2', message: 'x' }); });
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenLastCalledWith('ann-1', '');
+
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running', sideA: { id: 'p1', name: 'Yamada Taro' } }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(2);
+    expect(window.API.deleteAnnouncement).toHaveBeenLastCalledWith('ann-2', '');
+  });
+
+  it('a failed re-send leaves the first call in place: nothing is withdrawn, and starting the match still takes it down', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    await wait(TAP_BOUNCE_MS + 50);
+    window.API.sendAnnouncement.mockImplementationOnce(async () => { throw new Error('network down'); });
+    const [m1, m2] = twoScheduledMatches();
+    showMatches(rerender, onEditScore, [{ ...m1, sideA: { id: 'p1', name: 'Yamada Taro' } }, m2]);
+    await act(async () => {});
+    await pointerTap(callButtons()[0]);
+    await act(async () => {});
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(2);
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+    // The first banner is still up, so starting its match takes it down.
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running', sideA: { id: 'p1', name: 'Yamada Taro' } }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-1', '');
+  });
+
+  it('a re-call with unchanged text deletes nothing: the server already replaced the first banner, and starting the match withdraws the new one', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    await wait(TAP_BOUNCE_MS + 50);
+    // The same text again. The server removes the active announcement with
+    // identical text and answers with a new id, so the earlier id is already gone
+    // and a DELETE of it would 404 ("Could not withdraw the court call").
+    await pointerTap(callButtons()[0]);
+    await act(async () => {});
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(2);
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    showMatches(rerender, onEditScore, firstMatchWith({ status: 'running' }));
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-2', '');
+  });
+
+  it('after an unchanged re-call, a changed re-call takes down the banner that is up, once it is answered', async () => {
+    const onEditScore = vi.fn().mockResolvedValue({ applied: true });
+    const { rerender } = renderConsole({ onEditScore });
+    await pointerTap(callButtons()[0]);
+    await wait(TAP_BOUNCE_MS + 50);
+    await pointerTap(callButtons()[0]);
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+
+    await wait(TAP_BOUNCE_MS + 50);
+    let answerThird;
+    window.API.sendAnnouncement.mockImplementationOnce(() => new Promise((resolve) => { answerThird = resolve; }));
+    const [m1, m2] = twoScheduledMatches();
+    showMatches(rerender, onEditScore, [{ ...m1, sideA: { id: 'p1', name: 'Yamada Taro' } }, m2]);
+    await act(async () => {});
+    await pointerTap(callButtons()[0]);
+    await act(async () => {});
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(3);
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+    await act(async () => { answerThird({ id: 'ann-3', message: 'x' }); });
+    await act(async () => {});
+    // ann-2 is the banner up for this match; ann-1 was replaced by the server.
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-2', '');
+  });
+
+  it('starting a match that was never called withdraws nothing', async () => {
+    renderConsole();
+    await pointerTap(screen.getAllByRole('button', { name: 'Start match' })[0]);
+    await act(async () => {});
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+  });
+
+  // Calls m2 from its queue row, then moves m2 to shiaijo B from the same row.
+  // The move confirm is the console's own dialog (requestMoveCourt, then
+  // confirmMoveCourt), so it is driven through the row's court picker.
+  const callThenMoveSuzuki = async (onMoveCourt) => {
+    const { container } = renderConsole({ onMoveCourt });
+    await pointerTap(callButtons()[1]);
+    expect(window.API.sendAnnouncement).toHaveBeenCalledTimes(1);
+    const row = [...container.querySelectorAll('.shiaijo-qrow')].find((r) => r.textContent.includes('Suzuki'));
+    await pointerTap(within(row).getByTestId('move-to-B'));
+    await wait(TAP_BOUNCE_MS + 50);
+    await pointerTap(screen.getByRole('button', { name: 'Move to Shiaijo B' }));
+    await act(async () => {});
+  };
+
+  it('moving the called match to another court from this console withdraws its call', async () => {
+    // The host answers true once the move has landed (admin.jsx moveMatchCourt).
+    const onMoveCourt = vi.fn(async () => true);
+    await callThenMoveSuzuki(onMoveCourt);
+    expect(onMoveCourt).toHaveBeenCalledWith('c1', 'm2', 'B');
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledTimes(1);
+    expect(window.API.deleteAnnouncement).toHaveBeenCalledWith('ann-1', '');
+  });
+
+  it('a move that fails leaves the call up', async () => {
+    // The real host catches the failed move, toasts it and resolves false.
+    const onMoveCourt = vi.fn(async () => false);
+    await callThenMoveSuzuki(onMoveCourt);
+    expect(onMoveCourt).toHaveBeenCalledWith('c1', 'm2', 'B');
+    expect(window.API.deleteAnnouncement).not.toHaveBeenCalled();
+  });
+});
diff --git a/web-mobile/js/__tests__/render/changed_groups_every_editor.render.test.jsx b/web-mobile/js/__tests__/render/changed_groups_every_editor.render.test.jsx
index 5cc7fefee..4c6ad0883 100644
--- a/web-mobile/js/__tests__/render/changed_groups_every_editor.render.test.jsx
+++ b/web-mobile/js/__tests__/render/changed_groups_every_editor.render.test.jsx
@@ -21,7 +21,7 @@ import { installWindowStubs } from '../helpers/stub_globals.js';
 import { AUTOSAVE_DEBOUNCE_MS } from '../../admin_scoring_autosave.jsx';
 import { TAP_BOUNCE_MS } from '../../tap_guard.jsx';
 import { pointerTap } from '../helpers/tap_events.js';
-import { startPatch } from '../../admin_schedule_score_editor.jsx';
+import { startPatch } from '../../start_match.jsx';
 
 let writes;
 
@@ -394,6 +394,21 @@ describe('a write applied in part', () => {
       "Saved. A later change to points would have left the finished match without a winner, so it was moved to the match's history.");
   });
 
+  // A later change moved for another reason (a representative's pick stamped after the
+  // representative bout's removal) carries no needs_winner reason: the match lacks no
+  // winner, and the note must not say it does.
+  it('a write that moved a later change to the history for no winner reason says only that', async () => {
+    window.API.recordScore.mockImplementation((_c, _m, patch) => {
+      writes.push(patch);
+      return Promise.resolve({ id: 'm-ind', status: 'running', displacedGroups: ['repPickB'] });
+    });
+    await mount(individual());
+    await pointerTap(ipponBtn('aka', 'M'));
+    await settle();
+    expect(note()?.textContent).toBe(
+      "Saved. A later change to Shiro's pick for the representative bout was moved to the match's history.");
+  });
+
   it('a superseded write shows the banner, not the note', async () => {
     window.API.recordScore.mockImplementation((_c, _m, patch) => {
       writes.push(patch);
@@ -405,3 +420,214 @@ describe('a write applied in part', () => {
     expect(note()).toBeNull();
   });
 });
+
+// A value the editor ADOPTED from the server is the value it agrees with, and it is the
+// last value the editor "sent" for that group, so:
+//   - taking it back here is a change (B): the server keeps the other device's value
+//     unless the write names the group, and the editor's mount-time value is not the
+//     baseline any more;
+//   - an edit of something else never names it (F): it is not a change, and naming it
+//     would put the adopted value back under a newer stamp, over whatever was recorded
+//     meanwhile.
+// A value the editor HELD over a newer server value is neither (the existing tests above).
+describe('an adopted value is agreed, never re-sent', () => {
+  it('individual: a point adopted from another device and then taken back here is named (B)', async () => {
+    const { rerender } = await mount(individual());
+    await act(async () => { rerender(editorFor(individual({ ipponsB: ['K'] }))); });
+    expect(slotWith('Shiro', 'K'), 'the point recorded elsewhere is shown').toBeTruthy();
+    await pointerTap(slotWith('Shiro', 'K'));
+    await settle();
+    expect(lastWrite().ipponsB).toEqual([]);
+    expect(lastWrite().changed, 'the server keeps the other device\'s point unless the write names the points').toContain('points');
+  });
+
+  it('individual: an unrelated edit after a point was adopted does not name the points (F)', async () => {
+    const { rerender } = await mount(individual());
+    await pointerTap(ipponBtn('aka', 'M'));
+    await settle();
+    // Its own write comes back, then another device scores Shiro's point.
+    await act(async () => { rerender(editorFor(individual({ ipponsA: ['M'] }))); });
+    await act(async () => { rerender(editorFor(individual({ ipponsA: ['M'], ipponsB: ['K'] }))); });
+    expect(slotWith('Shiro', 'K'), 'the point recorded elsewhere is shown').toBeTruthy();
+    await startOvertime();
+    await settle();
+    expect(lastWrite().changed).toEqual(['encho']);
+  });
+
+  it('individual: an overtime count adopted and then switched off here is named (B)', async () => {
+    const { rerender } = await mount(individual());
+    await act(async () => { rerender(editorFor(individual({ encho: { periodCount: 1 } }))); });
+    await click(screen.getByTestId('scoring-modal-encho-checkbox'));
+    await settle();
+    expect(lastWrite().encho).toBeUndefined();
+    expect(lastWrite().changed).toContain('encho');
+  });
+
+  it('individual: a hantei verdict adopted from another device and then cancelled here names the points that carried it (B)', async () => {
+    const tied = (over = {}) => individual({ ipponsA: ['M'], ipponsB: ['K'], ...over });
+    const { rerender } = await mount(tied());
+    // Another device records Yamada's win by hantei: the Ht mark rides in Aka's ippons.
+    await act(async () => { rerender(editorFor(tied({ decidedByHantei: true, winner: { id: 'p1', name: 'Yamada' } }))); });
+    await click(screen.getByTestId('scoring-modal-hantei-cancel'));
+    await finish();
+    expect(lastWrite().status).toBe('completed');
+    expect(lastWrite().changed, 'the server keeps the Ht mark unless the write names the points it rides in').toContain('points');
+    expect(lastWrite().changed).toContain('result');
+  });
+
+  // An adopt agrees a change group only for what it took. Agreeing moves BOTH baselines to
+  // the server's value, so a group the adopt did not take whole (a point or a pick of
+  // ours still being saved) would then read as unchanged when it is taken back.
+  describe('an adopt that took only part of a group does not agree the whole', () => {
+    // A recorded verdict whose winner the match cannot place (a legacy row): its points
+    // carry no Ht mark, so the editor's markless running body can equal the baseline.
+    const unplaced = (over = {}) => individual({ decidedByHantei: true, ...over });
+
+    it('a hantei adopted while a point is still being saved: taking the point back is named (B)', async () => {
+      const { rerender } = await mount(individual());
+      await pointerTap(ipponBtn('aka', 'M'));
+      await settle();
+      expect(lastWrite().changed).toEqual(['points']);
+      // Another device's verdict arrives before the write's answer, then the point lands.
+      await act(async () => { rerender(editorFor(unplaced())); });
+      await act(async () => { rerender(editorFor(unplaced({ ipponsA: ['M'] }))); });
+      // The armed verdict locks the slots: cancel it, then take the point back.
+      await click(screen.getByTestId('scoring-modal-hantei-cancel'));
+      await pointerTap(slotWith('Aka', 'M'));
+      await settle();
+      expect(lastWrite().ipponsA).toEqual([]);
+      expect(lastWrite().changed, 'the server keeps the point unless the write names the points').toContain('points');
+    });
+
+    describe('the two picks of a representative bout are one group', () => {
+      const repBout = (over = {}) => individual({
+        id: 'Pool 1-DH-1', sideA: { id: 'team-kyoto', name: 'Kyoto' }, sideB: { id: 'team-osaka', name: 'Osaka' },
+        repIsTeam: true, repRosterA: ['Kato', 'Mori'], repRosterB: ['Sato', 'Ito'], ...over,
+      });
+      const pick = (testId, value) => act(async () => { fireEvent.change(screen.getByTestId(testId), { target: { value } }); });
+
+      it('a pick adopted on one side while the other side\'s pick is still being saved: putting it back is named (B)', async () => {
+        const { rerender } = await mount(repBout({ repPlayerB: 'Sato' }));
+        await pick('rep-shiro-select', 'Ito');
+        await settle();
+        expect(lastWrite().repPlayerB).toBe('Ito');
+        await act(async () => { rerender(editorFor(repBout({ repPlayerA: 'Mori', repPlayerB: 'Sato' }))); });
+        await act(async () => { rerender(editorFor(repBout({ repPlayerA: 'Mori', repPlayerB: 'Ito' }))); });
+        await pick('rep-shiro-select', 'Sato');
+        await settle();
+        expect(lastWrite()).toMatchObject({ repPlayerA: 'Mori', repPlayerB: 'Sato' });
+        expect(lastWrite().changed, 'the server keeps Ito unless the write names the picks').toContain('rep');
+      });
+
+      it('both picks adopted in one update are agreed: an unrelated edit does not name them (F)', async () => {
+        const { rerender } = await mount(repBout({ repPlayerA: 'Kato', repPlayerB: 'Sato' }));
+        await act(async () => { rerender(editorFor(repBout({ repPlayerA: 'Mori', repPlayerB: 'Ito' }))); });
+        expect(screen.getByTestId('rep-aka-select').value).toBe('Mori');
+        expect(screen.getByTestId('rep-shiro-select').value).toBe('Ito');
+        await pointerTap(ipponBtn('aka', 'M'));
+        await settle();
+        expect(lastWrite().changed).toEqual(['points']);
+      });
+    });
+  });
+
+  it('engi: flags adopted from another device and then set back here are named (B)', async () => {
+    const engiMatch = (over = {}) => ({
+      id: 'm-engi', compId: 'comp1', status: 'running', phase: 'pool', poolName: 'Pool 1', court: 'A',
+      compEngi: true,
+      sideA: { id: 'p1', name: 'Ito - Abe' }, sideB: { id: 'p2', name: 'Ono - Sato' },
+      ...over,
+    });
+    const view = (m) => <EngiScoreEditorModal match={m} onClose={vi.fn()} onSubmit={onSubmit} />;
+    let utils;
+    await act(async () => { utils = render(view(engiMatch())); });
+    await act(async () => { utils.rerender(view(engiMatch({ flagsA: 1 }))); });
+    expect(screen.getByTestId('engi-aka-count').textContent, 'the count recorded elsewhere is shown').toBe('1');
+    await click(screen.getByTestId('engi-aka-dec'));
+    await settle();
+    expect(lastWrite().flagsA).toBe(0);
+    expect(lastWrite().changed).toContain('flags');
+  });
+
+  describe('team', () => {
+    const team = (over = {}) => ({
+      id: 'm-team', compId: 'comp1', status: 'running', phase: 'pool', poolName: 'Pool 1', court: 'A',
+      compKind: 'team', teamSize: 3,
+      sideA: { id: 'team-kyoto', name: 'Kyoto' }, sideB: { id: 'team-osaka', name: 'Osaka' },
+      ...over,
+    });
+    const bout = (position, over = {}) => ({ position, sideA: '', sideB: '', ipponsA: [], ipponsB: [], winner: '', decision: '', ...over });
+    const kyotoWins = (position) => bout(position, { ipponsA: ['M'], winner: 'Kyoto' });
+    const osakaWins = (position) => bout(position, { ipponsB: ['K'], winner: 'Osaka' });
+    const row = (i) => [...document.querySelectorAll('.team-sub-match')][i];
+    const boutBtn = (i, side, letter) => [...row(i).querySelectorAll(`.team-sub-match__side--${side} button.ipt-btn`)].find((b) => b.textContent === letter);
+    const placed = (i, color) => [...row(i).querySelectorAll(`.tsm-center-pts--${color} button.editor-side__pt`)].map((b) => b.textContent.trim());
+    const markBtn = (i, color, letter) => [...row(i).querySelectorAll(`.tsm-center-pts--${color} button.editor-side__pt`)].find((b) => b.textContent.trim() === letter);
+    const mountTeam = async (match) => {
+      let utils;
+      await act(async () => { utils = render(editorFor(match)); });
+      return (m) => act(async () => { utils.rerender(editorFor(m)); });
+    };
+
+    it('a bout adopted from another device and then cleared here is named (B)', async () => {
+      const rerenderWith = await mountTeam(team());
+      await rerenderWith(team({ subResults: [osakaWins(2)] }));
+      expect(placed(1, 'shiro'), 'the bout recorded elsewhere is shown').toContain('K');
+      await pointerTap(markBtn(1, 'shiro', 'K'));
+      await settle();
+      expect(placed(1, 'shiro')).not.toContain('K');
+      expect(lastWrite().changed, 'the server keeps the other device\'s bout unless the write names it').toContain('bout:2');
+    });
+
+    it('scoring one bout after another was adopted names the scored bout alone (F)', async () => {
+      const rerenderWith = await mountTeam(team());
+      await pointerTap(boutBtn(0, 'shiro', 'K'));
+      await settle();
+      expect(lastWrite().changed).toEqual(['bout:1']);
+      // Its own write comes back, then another device scores bout 2.
+      await rerenderWith(team({ subResults: [osakaWins(1)] }));
+      await rerenderWith(team({ subResults: [osakaWins(1), kyotoWins(2)] }));
+      expect(placed(1, 'aka'), 'the bout recorded elsewhere is shown').toContain('M');
+      await pointerTap(boutBtn(2, 'aka', 'D'));
+      await settle();
+      expect(lastWrite().changed).toEqual(['bout:3']);
+    });
+
+    it('a bout the operator holds is named and a bout adopted beside it is not (held and agreed)', async () => {
+      const rerenderWith = await mountTeam(team());
+      await pointerTap(boutBtn(0, 'shiro', 'K'));
+      await settle();
+      // Another device moves bout 1 (the operator keeps the point struck here) and scores bout 2.
+      await rerenderWith(team({ subResults: [kyotoWins(1), kyotoWins(2)] }));
+      expect(placed(0, 'shiro'), 'the point struck here is still shown').toContain('K');
+      expect(placed(1, 'aka'), 'the bout recorded elsewhere is shown').toContain('M');
+      await startOvertime();
+      await settle();
+      expect(lastWrite().changed).toContain('bout:1');
+      expect(lastWrite().changed, 'bout 2 is the other device\'s, adopted and not changed here').not.toContain('bout:2');
+    });
+
+    it('a bout whose point was struck and taken back here stays the other device\'s (held, not agreed)', async () => {
+      const rerenderWith = await mountTeam(team());
+      await pointerTap(boutBtn(0, 'shiro', 'K'));
+      await settle();
+      await pointerTap(markBtn(0, 'shiro', 'K'));
+      await settle();
+      // Another device scores bout 1 meanwhile: the row stays the operator's, which reads as it was.
+      await rerenderWith(team({ subResults: [kyotoWins(1)] }));
+      expect(placed(0, 'aka'), 'the row is still the operator\'s').not.toContain('M');
+      await startOvertime();
+      await settle();
+      expect(lastWrite().changed, 'an edit held over a newer value is not put back').toEqual(['encho']);
+    });
+
+    it('an overtime count adopted from another device and then switched off here is named (B)', async () => {
+      const rerenderWith = await mountTeam(team());
+      await rerenderWith(team({ encho: { periodCount: 1 } }));
+      await click(screen.getByTestId('scoring-modal-encho-checkbox'));
+      await settle();
+      expect(lastWrite().encho).toBeUndefined();
+      expect(lastWrite().changed).toContain('encho');
+    });
+  });
+});
diff --git a/web-mobile/js/__tests__/render/edit_match_score_toast_once.render.test.jsx b/web-mobile/js/__tests__/render/edit_match_score_toast_once.render.test.jsx
new file mode 100644
index 000000000..801fee24e
--- /dev/null
+++ b/web-mobile/js/__tests__/render/edit_match_score_toast_once.render.test.jsx
@@ -0,0 +1,94 @@
+// PR #463 batch 14, item 10: editMatchScore (admin.jsx), the chokepoint every
+// score write goes through, toasts the error it throws and MARKS it
+// (write_result.jsx markToasted), so the two hosts that catch it to show it on a
+// card or a row (the court console's Start, the Scores tab's automatic start) can
+// ask wasToasted and not toast the same sentence a second time. Those hosts' own
+// suites mock onEditScore, so this is the test that the mark is really put on
+// what the real editMatchScore throws, on BOTH branches it toasts.
+//
+// AdminApp is mounted with the Scores view and a stub page, which hands back the
+// onEditScore it was given: the real editMatchScore.
+import React from 'react';
+import { render, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from 'vitest';
+import { installWindowStubs } from '../helpers/stub_globals.js';
+import { DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED, wasToasted } from '../../write_result.jsx';
+
+const probe = { props: null };
+
+const STUBBED_GLOBALS = {
+  // MODULE-EVAL-TIME: captured at import by admin.jsx.
+  AdminScoreEditorPage: (props) => { probe.props = props; return <div data-testid="score-page" />; },
+  confirmDialog: vi.fn(),
+  API: {
+    recordScore: vi.fn(),
+    subscribeToEvents: vi.fn(() => () => {}),
+    fetchCompetitions: vi.fn().mockResolvedValue([]),
+  },
+};
+
+let restore;
+let AdminApp;
+
+beforeAll(async () => {
+  restore = installWindowStubs(STUBBED_GLOBALS);
+  await import('../../admin.jsx');
+  AdminApp = window.AdminApp;
+});
+afterAll(() => restore());
+beforeEach(() => {
+  probe.props = null;
+  window.API.recordScore.mockReset();
+  window.confirmDialog.mockReset();
+});
+
+async function mountScoresView() {
+  const showToast = vi.fn();
+  await act(async () => {
+    render(
+      <AdminApp
+        tournament={{ name: 'Cup', courts: ['A'], competitions: [] }}
+        onUpdate={vi.fn()} onLogout={vi.fn()} onViewerMode={vi.fn()} onPasswordChange={vi.fn()}
+        tweaks={{}} password="pw" view={{ kind: 'scoreEditor' }} setView={vi.fn()}
+        showToast={showToast} authConfig={{}}
+      />,
+    );
+  });
+  expect(probe.props?.onEditScore, 'the page was handed the real editMatchScore').toBeTypeOf('function');
+  return { showToast, onEditScore: probe.props.onEditScore };
+}
+
+describe('editMatchScore marks every error it toasts', () => {
+  it('a thrown refusal is toasted once, by it, and carries the mark', async () => {
+    const { showToast, onEditScore } = await mountScoresView();
+    const refusal = new Error('Kato is fighting on shiaijo B');
+    window.API.recordScore.mockRejectedValue(refusal);
+
+    let caught;
+    await act(async () => {
+      try { await onEditScore('c1', 'm1', { status: 'running' }, { id: 'm1' }); } catch (e) { caught = e; }
+    });
+
+    expect(caught).toBe(refusal);
+    expect(showToast.mock.calls).toEqual([['Kato is fighting on shiaijo B', 'error']]);
+    expect(wasToasted(caught)).toBe(true);
+  });
+
+  it('a declined downstream override is toasted once, with its own words, and carries the mark', async () => {
+    const { showToast, onEditScore } = await mountScoresView();
+    const refusal = Object.assign(new Error('a later match was played'), {
+      downstreamKnockoutPlayed: { blockingMatchId: 'm9', blockingMatches: [], displaced: [] },
+    });
+    window.API.recordScore.mockRejectedValue(refusal);
+    window.confirmDialog.mockResolvedValue(false);
+
+    let caught;
+    await act(async () => {
+      try { await onEditScore('c1', 'm1', { status: 'completed' }, { id: 'm1' }); } catch (e) { caught = e; }
+    });
+
+    expect(caught).toBe(refusal);
+    expect(showToast.mock.calls).toEqual([[DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED]]);
+    expect(wasToasted(caught)).toBe(true);
+  });
+});
diff --git a/web-mobile/js/__tests__/render/lineup_panel_hosts.render.test.jsx b/web-mobile/js/__tests__/render/lineup_panel_hosts.render.test.jsx
index e1a1519da..8b17c717c 100644
--- a/web-mobile/js/__tests__/render/lineup_panel_hosts.render.test.jsx
+++ b/web-mobile/js/__tests__/render/lineup_panel_hosts.render.test.jsx
@@ -41,7 +41,6 @@ const STUBS = {
   filterMatchesByCourt: (all) => all,
   tournamentMatches: () => matches,
   compMatches: () => matches,
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || `${s}s`)}`,
   API: {
diff --git a/web-mobile/js/__tests__/render/match_history_view.render.test.jsx b/web-mobile/js/__tests__/render/match_history_view.render.test.jsx
index 8c11895d5..a2d6f17e9 100644
--- a/web-mobile/js/__tests__/render/match_history_view.render.test.jsx
+++ b/web-mobile/js/__tests__/render/match_history_view.render.test.jsx
@@ -155,11 +155,104 @@ describe('heldValueText', () => {
     ['result', { status: 'completed', decision: 'fusensho', decisionBy: 'shiro' }, 'Fusensho against Shiro'],
     ['result', { status: 'completed', winner: 'Tanaka' }, 'Tanaka won'],
     ['bout:-1', null, 'no bout'],
+    ['repPickA', { sideAMemberId: 'm1a' }, 'picked'],
+    ['repPickA', { sideAMemberId: '' }, 'not picked'],
+    ['repPickB', { sideBMemberId: 'm1b' }, 'picked'],
+    ['repPickB', { sideBMemberId: '' }, 'not picked'],
+    ['repPickA', null, 'not picked'],
+    ['repPickB', null, 'not picked'],
   ])('%s %j reads "%s"', (group, value, words) => {
     expect(view.heldValueText(group, value)).toBe(words);
   });
 });
 
+// A representative pick is a member id. When the editor holds the team's members the
+// history names the representative instead of saying only that a side was picked; the
+// resolver is the editor's: (side, memberId) => a label, null for an id the team's
+// members do not hold, undefined when it has no members to look in.
+describe('a representative pick names the representative', () => {
+  const MEMBERS = { a: { m1a: 'Alice' }, b: { m1b: 'Bob', m2b: '' } };
+  const resolve = (side, id) => {
+    const list = MEMBERS[side];
+    return id in list ? (list[id] || 'T9.2') : null;
+  };
+
+  it.each([
+    ['repPickA', { sideAMemberId: 'm1a' }, 'picked Alice'],
+    ['repPickB', { sideBMemberId: 'm1b' }, 'picked Bob'],
+    // A member with no name yet reads by its label.
+    ['repPickB', { sideBMemberId: 'm2b' }, 'picked T9.2'],
+    // An id the side's team no longer holds (a correction seated another team).
+    ['repPickA', { sideAMemberId: 'gone' }, 'picked (not on the team now)'],
+    // The id is looked up in its own side's team.
+    ['repPickA', { sideAMemberId: 'm1b' }, 'picked (not on the team now)'],
+    ['repPickA', { sideAMemberId: '' }, 'not picked'],
+    ['repPickB', null, 'not picked'],
+  ])('%s %j reads "%s"', (group, value, words) => {
+    expect(view.heldValueText(group, value, resolve)).toBe(words);
+  });
+
+  it('says only that a side was picked when it has no members to look in', () => {
+    expect(view.heldValueText('repPickA', { sideAMemberId: 'm1a' })).toBe('picked');
+    expect(view.heldValueText('repPickA', { sideAMemberId: 'm1a' }, () => undefined)).toBe('picked');
+  });
+
+  it('a pick moved to the history names the representative', () => {
+    const v = view.historyEntryView({
+      matchId: 'm-ko', door: 'displaced', stamp: at(10, 5, 0), receivedAt: at(10, 6, 0), changed: ['repPickB'],
+      outcomes: { repPickB: 'held' }, held: { repPickB: { sideBMemberId: 'm1b' } },
+      reason: 'the representative bout was removed',
+    }, resolve);
+    expect(v.reason).toBe('Moved to history: the representative bout was removed');
+    expect(v.held.map((h) => h.text)).toEqual(["Moved to history: Shiro's pick for the representative bout, picked Bob"]);
+  });
+
+  it('a removal held for a newer point records the pick it kept, which reads sensibly empty', () => {
+    const v = view.historyEntryView({
+      matchId: 'm-ko', door: 'daihyosen-remove', stamp: at(10, 5, 0), receivedAt: at(10, 6, 0), changed: ['bout:-1', 'repPickA'],
+      outcomes: { 'bout:-1': 'applied', repPickA: 'held' }, held: { repPickA: { sideAMemberId: '' } },
+    }, resolve);
+    expect(v.held.map((h) => h.text)).toEqual(["Kept in history: Aka's pick for the representative bout, not picked"]);
+  });
+
+  it('the disclosure on the team editor lists it with the members the editor holds', async () => {
+    window.API.fetchMatchHistory.mockResolvedValue([{
+      matchId: 'm-ko', door: 'displaced', stamp: at(10, 5, 0), receivedAt: at(10, 6, 0), changed: ['repPickA'],
+      outcomes: { repPickA: 'held' }, held: { repPickA: { sideAMemberId: 'm1a' } },
+      reason: 'the representative bout was removed',
+    }]);
+    await act(async () => {
+      render(<view.MatchHistoryDisclosure match={match()} password="pw" members={resolve} />);
+    });
+    await openHistory();
+    expect(screen.getByTestId('match-history-held').textContent)
+      .toBe("Moved to history: Aka's pick for the representative bout, picked Alice");
+  });
+
+  it('the disclosure on an editor that holds no members keeps today\'s words', async () => {
+    window.API.fetchMatchHistory.mockResolvedValue([{
+      matchId: 'm-ko', door: 'score', stamp: at(10, 5, 0), receivedAt: at(10, 6, 0), changed: ['repPickA'],
+      outcomes: { repPickA: 'held' }, held: { repPickA: { sideAMemberId: 'm1a' } },
+    }]);
+    await act(async () => {
+      render(<view.MatchHistoryDisclosure match={match()} password="pw" />);
+    });
+    await openHistory();
+    expect(screen.getByTestId('match-history-held').textContent)
+      .toBe("Kept in history: Aka's pick for the representative bout, picked");
+  });
+});
+
+describe('historyDoorWords', () => {
+  it('names the door of a side given another team by a correction to an earlier match', () => {
+    expect(view.historyDoorWords('reseat')).toBe('Side given another team by a correction to an earlier match');
+  });
+
+  it('falls back for a door it does not know', () => {
+    expect(view.historyDoorWords('something-new')).toBe('Updated');
+  });
+});
+
 // bc-mrgc phase 3: a write kept whole by one rule (the server's rev guard:
 // an older revision of this board) says why, in the server's own words.
 describe('historyEntryView: the reason a whole write was kept', () => {
diff --git a/web-mobile/js/__tests__/render/score_editor_barred_match.render.test.jsx b/web-mobile/js/__tests__/render/score_editor_barred_match.render.test.jsx
index aeab5b5b4..5ee6c0c48 100644
--- a/web-mobile/js/__tests__/render/score_editor_barred_match.render.test.jsx
+++ b/web-mobile/js/__tests__/render/score_editor_barred_match.render.test.jsx
@@ -37,7 +37,6 @@ const STUBS = {
   filterMatchesByCourt: (matches) => matches,
   tournamentMatches: () => [],
   compMatches: () => [RUNNING, BARRED, OPEN],
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || s + 's')}`,
   API: {
diff --git a/web-mobile/js/__tests__/render/score_editor_filter_finds_a_number.render.test.jsx b/web-mobile/js/__tests__/render/score_editor_filter_finds_a_number.render.test.jsx
index 11d3ff501..d009ae925 100644
--- a/web-mobile/js/__tests__/render/score_editor_filter_finds_a_number.render.test.jsx
+++ b/web-mobile/js/__tests__/render/score_editor_filter_finds_a_number.render.test.jsx
@@ -44,7 +44,6 @@ const STUBS = {
   filterMatchesByCourt: (matches) => matches,
   tournamentMatches: () => [],
   compMatches: () => MATCHES,
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || s + 's')}`,
   API: { fetchCompetitionDetails: vi.fn().mockResolvedValue(null) },
diff --git a/web-mobile/js/__tests__/render/score_editor_mount_sites.render.test.jsx b/web-mobile/js/__tests__/render/score_editor_mount_sites.render.test.jsx
index 9570b7d2b..d4dd59d08 100644
--- a/web-mobile/js/__tests__/render/score_editor_mount_sites.render.test.jsx
+++ b/web-mobile/js/__tests__/render/score_editor_mount_sites.render.test.jsx
@@ -76,7 +76,6 @@ const STUBBED_GLOBALS = {
   filterMatchesByCourt: (matches) => matches,
   tournamentMatches: () => [],
   compMatches: () => [],
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   PoolsViewer: () => null, // per-test override drives pools open
   LeagueStandingsViewer: () => null,
diff --git a/web-mobile/js/__tests__/render/score_editor_team_default_win_mark.render.test.jsx b/web-mobile/js/__tests__/render/score_editor_team_default_win_mark.render.test.jsx
index b5f1bb954..980221992 100644
--- a/web-mobile/js/__tests__/render/score_editor_team_default_win_mark.render.test.jsx
+++ b/web-mobile/js/__tests__/render/score_editor_team_default_win_mark.render.test.jsx
@@ -49,7 +49,6 @@ const STUBS = {
   filterMatchesByCourt: (matches) => matches,
   tournamentMatches: () => [],
   compMatches: () => MATCHES,
-  startPatch: () => ({ status: 'running', winner: null }),
   confirmDialog: vi.fn().mockResolvedValue(true),
   pluralize: (n, s, p) => `${n} ${n === 1 ? s : (p || s + 's')}`,
   API: { fetchCompetitionDetails: vi.fn().mockResolvedValue(null) },
diff --git a/web-mobile/js/__tests__/render/superseded_call_sites.render.test.jsx b/web-mobile/js/__tests__/render/superseded_call_sites.render.test.jsx
index 47d1a76ae..902e49684 100644
--- a/web-mobile/js/__tests__/render/superseded_call_sites.render.test.jsx
+++ b/web-mobile/js/__tests__/render/superseded_call_sites.render.test.jsx
@@ -59,7 +59,6 @@ const STUBBED_GLOBALS = {
   getScoreBtnClass: () => 'test-score-open',
   matchScoreStr: () => '',
   compMatches: () => [],
-  startPatch: () => ({ status: 'running', winner: null }),
   API: {
     recordScore: vi.fn(),
   },
diff --git a/web-mobile/js/__tests__/render/team_daihyosen_representative.render.test.jsx b/web-mobile/js/__tests__/render/team_daihyosen_representative.render.test.jsx
new file mode 100644
index 000000000..3680c501f
--- /dev/null
+++ b/web-mobile/js/__tests__/render/team_daihyosen_representative.render.test.jsx
@@ -0,0 +1,822 @@
+// bc-dhrp: the daihyosen (representative bout) row lets the operator pick each
+// team's representative by member id. The row keeps the TEAM names in sideA/sideB
+// (placeHt compares the winner against them); the picks ride sideAMemberId /
+// sideBMemberId. These tests mount the REAL ScoreEditorModal dispatcher, the same
+// route every production mount uses, as team_daihyosen_silence.render.test.jsx does.
+import React from 'react';
+import { render, act, fireEvent, screen, waitFor, within } from '@testing-library/react';
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from 'vitest';
+import { installWindowStubs } from '../helpers/stub_globals.js';
+import { toBackendMatchResult } from '../../api_serializers.jsx';
+import { FETCH_TIMEOUT_MS } from '../../write_result.jsx';
+import { AUTOSAVE_DEBOUNCE_MS } from '../../admin_scoring_autosave.jsx';
+
+const SQUADS = {
+  t1: [{ id: 'm1a', name: 'Alice', index: 1 }, { id: 'm2a', name: 'Brenda', index: 2 }],
+  t2: [{ id: 'm1b', name: 'Carol', index: 1 }, { id: 'm2b', name: 'Dana', index: 2 }],
+};
+
+const STUBBED_GLOBALS = {
+  isHikiwake: (_type) => false,
+  arraysEqual: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]),
+  isKikenDecision: (_kind) => false,
+  isTextEntry: () => false,
+  isInteractiveTarget: () => false,
+  confirmDialog: vi.fn().mockResolvedValue(true),
+  API: {
+    fetchCompetitionDetails: vi.fn().mockResolvedValue(null),
+    fetchSquads: vi.fn(),
+    fetchTeamLineup: vi.fn().mockResolvedValue({ saved: false, positions: {} }),
+    fetchLineupInForce: vi.fn().mockResolvedValue({ saved: false, positions: {} }),
+    recordScore: vi.fn().mockResolvedValue(undefined),
+    recordDaihyosen: vi.fn(),
+    removeDaihyosen: vi.fn(),
+    putMatchLineup: vi.fn().mockResolvedValue({}),
+    recordDecision: vi.fn(),
+    addTeamMember: vi.fn(),
+    renameTeamMember: vi.fn(),
+    fetchMatchHistory: vi.fn().mockResolvedValue([]),
+  },
+  AdminLineupHelpers: { rosterFor: vi.fn().mockReturnValue([]) },
+  compMatches: () => [],
+  Term: ({ children }) => <span>{children}</span>,
+  GlossaryHint: ({ name }) => <span title={name} />,
+};
+
+let restoreGlobals;
+let ScoreEditorModal;
+
+beforeAll(async () => {
+  restoreGlobals = installWindowStubs(STUBBED_GLOBALS);
+  await import('../../admin_scoring_modal.jsx');
+  // The real member resolver (resolveMemberIdsForPositions) is the one mint and
+  // rename path a typed representative name takes; it is not re-stubbed here.
+  await import('../../admin_lineup.jsx');
+  ScoreEditorModal = window.ScoreEditorModal;
+});
+
+afterAll(() => restoreGlobals());
+
+beforeEach(() => {
+  window.API.fetchSquads.mockReset().mockResolvedValue(SQUADS);
+  window.API.fetchLineupInForce.mockReset().mockResolvedValue({ saved: false, positions: {} });
+  window.API.recordScore.mockClear();
+  window.API.addTeamMember.mockReset();
+  window.API.renameTeamMember.mockReset();
+  window.API.putMatchLineup.mockClear();
+});
+
+// Numbered bouts 1..3 are recorded as ties so Finish is allowed (bc-tmfn), as in
+// the silence test. The daihyosen row is the one under test.
+const FOUGHT_BOUTS = [1, 2, 3].map((position) => ({
+  position, sideA: '', sideB: '', ipponsA: [], ipponsB: [], winner: '', decision: 'hikiwake',
+}));
+
+const DH_EMPTY = { position: -1, sideA: 'Team A', sideB: 'Team B', decision: 'daihyosen' };
+
+// The representative row AS THE SERVER SENDS IT right after an add: engine.AddDaihyosen
+// (daihyosen.go) builds {Position: -1, Decision: "daihyosen"} and nothing fills the sides,
+// so Go's JSON gives nil ippon arrays and empty side names. DH_EMPTY states the team names,
+// which the server never stores on this row, and so cannot show what a pick does to it.
+const DH_ADDED = { position: -1, sideA: '', sideB: '', ipponsA: null, ipponsB: null, hansokuA: 0, hansokuB: 0, winner: '', decision: 'daihyosen' };
+
+function makeMatch(overrides = {}, { fought = true } = {}) {
+  const { subResults = [], ...rest } = overrides;
+  return {
+    id: 'm-ko-1',
+    compId: 'comp1',
+    status: 'running',
+    phase: 'knockout',
+    court: 'A',
+    compKind: 'team',
+    teamSize: 3,
+    sideA: { id: 't1', name: 'Team A' },
+    sideB: { id: 't2', name: 'Team B' },
+    ...rest,
+    subResults: [...(fought ? FOUGHT_BOUTS : []), ...subResults],
+  };
+}
+
+function dhEntryOf(patch) {
+  return (patch.subResults || []).find((s) => s.position === -1);
+}
+
+async function mount(match, { selfReport = false, onClose = vi.fn(), prevMatch, nextMatch, onPrev, onNext } = {}) {
+  const onSubmit = vi.fn();
+  const view = (m) => (
+    <ScoreEditorModal match={m} onClose={onClose} onSubmit={onSubmit} password="" selfReport={selfReport}
+      prevMatch={prevMatch} nextMatch={nextMatch} onPrev={onPrev} onNext={onNext} />
+  );
+  let utils;
+  await act(async () => { utils = render(view(match)); });
+  return { ...utils, onSubmit, onClose, rerenderWith: async (m) => { await act(async () => { utils.rerender(view(m)); }); } };
+}
+
+// The daihyosen row's two name boxes, by their aria-label ("Daihyosen SHIRO player").
+function dhInputs() {
+  return screen.queryAllByLabelText(/^Daihyosen (SHIRO|AKA) player$/);
+}
+function dhInput(side) {
+  return dhInputs().find((el) => el.getAttribute('aria-label').includes(side));
+}
+
+async function openDh(side) {
+  const input = dhInput(side);
+  await act(async () => { fireEvent.focus(input); fireEvent.click(input); });
+}
+
+async function pickFromDh(side, name) {
+  await openDh(side);
+  const opt = await screen.findByText(name, { selector: '.pmf__opt-name' });
+  await act(async () => { fireEvent.click(opt.closest('button')); });
+  // Let the pick's member wait and write settle.
+  await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+}
+
+async function clickFinishTwice() {
+  // First tap arms the button; the second commits (buildPatch -> onSubmit).
+  await act(async () => { fireEvent.click(screen.getByText('Finish')); });
+  await act(async () => { fireEvent.click(screen.getByText('Tap again to finish')); });
+}
+
+// The FINISH write: the one onSubmit call whose patch completes the match. A pick
+// arms the editor's autosave, a RUNNING write sent through the same onSubmit, and
+// its debounce is real time: under load it can land between the pick and Finish.
+// So a test that means the finish cannot read calls[0] or count every call.
+function finishPatchOf(onSubmit) {
+  const finishes = onSubmit.mock.calls.map(([patch]) => patch).filter((patch) => patch.status === 'completed');
+  expect(finishes).toHaveLength(1);
+  return finishes[0];
+}
+
+describe('team daihyosen representative picker (bc-dhrp)', () => {
+  it('R1: the daihyosen row renders a name box on each side, and never the team name in it', async () => {
+    await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    await waitFor(() => expect(dhInputs().length).toBe(2));
+    expect(dhInput('SHIRO').value).toBe('');
+    expect(dhInput('AKA').value).toBe('');
+  });
+
+  it('R2: picking a member records its id on the -1 row, keeps the team names, and names repPickB', async () => {
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    await pickFromDh('SHIRO', 'Carol');
+    expect(dhInput('SHIRO').value).toBe('Carol');
+    await clickFinishTwice();
+    const patch = finishPatchOf(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect(dh.sideBMemberId).toBe('m1b');
+    expect(dh.sideA).toBe('Team A');
+    expect(dh.sideB).toBe('Team B');
+    // The wire the server gets: the id rides the row and the write names its group.
+    const wire = toBackendMatchResult(patch, match);
+    const wireDh = wire.subResults.find((s) => s.position === -1);
+    expect(wireDh.sideBMemberId).toBe('m1b');
+    expect(wireDh.sideB).toBe('Team B');
+    expect(wire.changed).toContain('repPickB');
+    expect(wire.changed, 'a pick is not a change of the bout').not.toContain('bout:-1');
+    expect(wire.changed, 'Aka\'s pick was not touched here').not.toContain('repPickA');
+    // A pick is never a lineup write: "daihyosen" is not a lineup key.
+    expect(window.API.putMatchLineup).not.toHaveBeenCalled();
+  });
+
+  it('R3: a point recorded elsewhere is adopted after the pick round-trips', async () => {
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit, rerenderWith } = await mount(match);
+    await pickFromDh('SHIRO', 'Carol');
+    // The server echoes the pick back (stamped after it), then another device scores a point.
+    const echoed = makeMatch({
+      modifiedAt: Date.now() + 60000,
+      subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b' }],
+    });
+    await rerenderWith(echoed);
+    const scored = makeMatch({
+      modifiedAt: Date.now() + 120000,
+      subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b', ipponsB: ['M'] }],
+    });
+    await rerenderWith(scored);
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.ipponsB).toEqual(['M']);
+    expect(dh.sideBMemberId).toBe('m1b');
+    expect(dh.sideB).toBe('Team B');
+  });
+
+  it('R4: clearing a stored pick omits the id and names repPickB on the next write', async () => {
+    const match = makeMatch({ subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b' }] });
+    const { onSubmit } = await mount(match);
+    // The stored pick shows as the member's own name, never the team's.
+    expect(dhInput('SHIRO').value).toBe('Carol');
+    const wrap = dhInput('SHIRO').closest('.lineup-name');
+    const clear = within(wrap).getByRole('button', { name: 'Clear player' });
+    await act(async () => { fireEvent.click(clear); });
+    await clickFinishTwice();
+    const patch = finishPatchOf(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect('sideBMemberId' in dh).toBe(false);
+    expect(dh.sideB).toBe('Team B');
+    const cleared = toBackendMatchResult(patch, match).changed;
+    expect(cleared).toContain('repPickB');
+    expect(cleared).not.toContain('bout:-1');
+    expect(cleared, 'Aka\'s pick was never set here').not.toContain('repPickA');
+  });
+
+  it('R5: the representative roster includes a member already placed at a numbered position', async () => {
+    // Carol is fielded at position 1 of the team's lineup for this match: a placed
+    // member the numbered pickers filter out, and the representative picker must not.
+    window.API.fetchLineupInForce.mockImplementation(async (_compId, teamId) => (teamId === 't2'
+      ? { saved: true, positions: { 1: 'Carol' }, memberIds: { 1: 'm1b' }, sourceMatchId: 'm-ko-1' }
+      : { saved: false, positions: {} }));
+    const match = makeMatch({
+      subResults: [
+        { position: 1, sideA: 'Alice', sideB: 'Carol', sideAMemberId: 'm1a', sideBMemberId: 'm1b', ipponsA: [], ipponsB: [], decision: '' },
+        DH_EMPTY,
+      ],
+    }, { fought: false });
+    await mount(match);
+    await openDh('SHIRO');
+    expect(await screen.findByText('Carol', { selector: '.pmf__opt-name' })).toBeTruthy();
+  });
+
+  it('R6: a typed name matching no team member mints one through the member resolver and records its id on the row', async () => {
+    window.API.addTeamMember.mockResolvedValue({ id: 'm9', name: 'Eve', index: 3 });
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.sideBMemberId).toBe('m9');
+    expect(dh.sideB).toBe('Team B');
+    expect(window.API.putMatchLineup).not.toHaveBeenCalled();
+  });
+
+  it('R7: under selfReport the representative picker is offered while the match runs', async () => {
+    await mount(makeMatch({ subResults: [DH_EMPTY] }), { selfReport: true });
+    await waitFor(() => expect(dhInputs().length).toBe(2));
+  });
+
+  it('R8: a name typed over a picked blank member renames that member and keeps its id', async () => {
+    window.API.fetchSquads.mockResolvedValue({ ...SQUADS, t2: [...SQUADS.t2, { id: 'm3b', name: '', index: 3 }] });
+    window.API.renameTeamMember.mockResolvedValue({ id: 'm3b', name: 'Frank', index: 3, modifiedAt: 5 });
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    await openDh('SHIRO');
+    const blank = await screen.findByText('no name yet', { selector: '.pmf__opt-name' });
+    await act(async () => { fireEvent.click(blank.closest('button')); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Frank' } }); });
+    const add = await screen.findByText(/Add “Frank”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.renameTeamMember).toHaveBeenCalledWith('comp1', 't2', 'm3b', 'Frank', ''));
+    expect(window.API.addTeamMember).not.toHaveBeenCalled();
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.sideBMemberId).toBe('m3b');
+    expect(dh.sideB).toBe('Team B');
+  });
+
+  it('R9: a typed name with the team members unreadable goes on and says so in the row, as a lineup name does', async () => {
+    window.API.fetchSquads.mockRejectedValue(new TypeError('Failed to fetch'));
+    window.API.addTeamMember.mockResolvedValue({ id: 'm9', name: 'Eve', index: 3 });
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    await waitFor(() => expect(screen.getByTestId('team-editor-lineup-warning').textContent).toContain('may have been added as a new team member'));
+    expect(screen.getByTestId('team-editor-lineup-warning').getAttribute('data-tone')).toBe('warn');
+    expect(screen.getByTestId('team-editor-lineup-warning').textContent).not.toContain('Lineup saved');
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.sideBMemberId).toBe('m9');
+    expect(dh.sideB).toBe('Team B');
+  });
+
+  it('R10: a side given another team drops the representative it picked, so the write stops naming the old team\'s member', async () => {
+    const match = makeMatch({ subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { onSubmit, rerenderWith } = await mount(match);
+    expect(dhInput('AKA').value).toBe('Alice');
+    // A correction elsewhere seats team t3 on side A. The server's write clears the side's
+    // stored pick in the same change, so the push that brings the new team has no pick.
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('AKA').value).toBe('');
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect('sideAMemberId' in dh, 'the old team\'s member is not sent').toBe(false);
+    expect(dh.sideA, 'the row names the team now on the side').toBe('Team C');
+  });
+
+  it('R11: two typed names for one side: the newer pick wins even when the older name resolves last', async () => {
+    let resolveEve;
+    const eveAnswer = new Promise((resolve) => { resolveEve = resolve; });
+    window.API.addTeamMember.mockImplementation((_c, _t, name) => (name === 'Eve'
+      ? eveAnswer
+      : Promise.resolve({ id: 'm-frank', name, index: 3 })));
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const addEve = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(addEve.closest('button')); });
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Frank' } }); });
+    const addFrank = await screen.findByText(/Add “Frank”/);
+    await act(async () => { fireEvent.click(addFrank.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Frank', ''));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    // The older name answers last.
+    await act(async () => { resolveEve({ id: 'm-eve', name: 'Eve', index: 4 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('SHIRO').value).toBe('Frank');
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.sideBMemberId, 'the later pick, not the older name that resolved last').toBe('m-frank');
+  });
+
+  it('R12: Finish and Close wait while a typed representative is still being named, and the finishing write carries the pick', async () => {
+    let answerEve;
+    window.API.addTeamMember.mockImplementation(() => new Promise((resolve) => { answerEve = resolve; }));
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit } = await mount(match);
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    // The member POST is still out. Finish or Close now would send or drop the pick
+    // while the member may already exist on the server, so both wait for it.
+    expect(screen.getByText('Finish').closest('button').disabled).toBe(true);
+    expect(screen.getByText('✕ Close').closest('button').disabled).toBe(true);
+    await act(async () => { answerEve({ id: 'm9', name: 'Eve', index: 3 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(screen.getByText('Finish').closest('button').disabled).toBe(false);
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect(dh.sideBMemberId).toBe('m9');
+    expect(dh.sideB).toBe('Team B');
+  });
+
+  it('R13: a side given another team with no representative picked leaves the sheet clean: nothing is autosaved', async () => {
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit, rerenderWith } = await mount(match);
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    // Past the autosave debounce: a sheet the side change left dirty would be written here.
+    await act(async () => { await new Promise((r) => setTimeout(r, 500)); });
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+
+  it('R14: on a read-only representative row an unpicked side shows its team name, and a picked side shows the representative', async () => {
+    // selfReport on a completed match: the row offers no picker, so it is read-only.
+    const match = makeMatch({ status: 'completed', subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b' }] });
+    await mount(match, { selfReport: true });
+    expect(screen.getByText('Carol', { selector: '.tsm-name__static' })).toBeTruthy();
+    expect(screen.getByText('Team A', { selector: '.tsm-name__static' })).toBeTruthy();
+    expect(screen.queryByText('-', { selector: '.tsm-name__static' })).toBeNull();
+  });
+
+  it('R15: a side given another team clears a stored pick and sends nothing: the clear is the server following, not an operator edit', async () => {
+    window.confirmDialog.mockClear();
+    const match = makeMatch({ subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { onSubmit, onClose, rerenderWith } = await mount(match);
+    expect(dhInput('AKA').value).toBe('Alice');
+    // The server's shape: the push that seats the new team has already cleared the side's pick.
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    expect(dhInput('AKA').value).toBe('');
+    // Past the autosave debounce: a clear that marked the sheet dirty would be written here.
+    await act(async () => { await new Promise((r) => setTimeout(r, 500)); });
+    expect(onSubmit).not.toHaveBeenCalled();
+    // The board agrees with the server, so the sheet is not dirty: Close asks nothing.
+    await act(async () => { fireEvent.click(screen.getByText('✕ Close')); });
+    expect(window.confirmDialog).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('R16: a side given another team leaves an armed Finish armed', async () => {
+    const match = makeMatch({ subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { rerenderWith } = await mount(match);
+    await act(async () => { fireEvent.click(screen.getByText('Finish')); });
+    expect(screen.getByText('Tap again to finish')).toBeTruthy();
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] }));
+    expect(screen.getByText('Tap again to finish')).toBeTruthy();
+  });
+
+  it('R17: under selfReport the members-unavailable warning tells a participant to ask the organizer, not to open the Lineups page', async () => {
+    window.API.fetchSquads.mockRejectedValue(new TypeError('Failed to fetch'));
+    window.API.addTeamMember.mockResolvedValue({ id: 'm9', name: 'Eve', index: 3 });
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    await mount(match, { selfReport: true });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(screen.getByTestId('team-editor-lineup-warning').textContent).toContain('may have been added as a new team member'));
+    const text = screen.getByTestId('team-editor-lineup-warning').textContent;
+    expect(text).toContain('Ask the tournament organizer to check the team.');
+    expect(text).not.toContain('Lineups page');
+  });
+
+  it('R18: Remove daihyosen is disabled while a typed representative is still being named, and offered again once it is', async () => {
+    let answerEve;
+    window.API.addTeamMember.mockImplementation(() => new Promise((resolve) => { answerEve = resolve; }));
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    await mount(match);
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    expect(screen.getByTestId('team-daihyosen-remove').disabled).toBe(true);
+    await act(async () => { answerEve({ id: 'm9', name: 'Eve', index: 3 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(screen.getByTestId('team-daihyosen-remove').disabled).toBe(false);
+  });
+
+  it('R18b: Prev and Next are disabled, like Close, while a typed representative is still being named, and offered again once it is', async () => {
+    let answerEve;
+    window.API.addTeamMember.mockImplementation(() => new Promise((resolve) => { answerEve = resolve; }));
+    const neighbour = makeMatch();
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    await mount(match, { prevMatch: neighbour, nextMatch: neighbour, onPrev: vi.fn(), onNext: vi.fn() });
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    // leaveEditor does nothing while the member POST is out, so the buttons must not look available.
+    expect(screen.getByText('← Prev').closest('button').disabled).toBe(true);
+    expect(screen.getByText('Next →').closest('button').disabled).toBe(true);
+    await act(async () => { answerEve({ id: 'm9', name: 'Eve', index: 3 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(screen.getByText('← Prev').closest('button').disabled).toBe(false);
+    expect(screen.getByText('Next →').closest('button').disabled).toBe(false);
+  });
+
+  it('R19: a completed match whose side was given another team clears the stored pick, and Close closes at once with no discard prompt', async () => {
+    window.confirmDialog.mockClear();
+    const match = makeMatch({ status: 'completed', subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { rerenderWith, onClose } = await mount(match);
+    expect(dhInput('AKA').value).toBe('Alice');
+    // A correction elsewhere seats team t3 on side A. The push that brings it has cleared the
+    // side's pick; adopting that is the server following, not an edit.
+    await rerenderWith(makeMatch({ status: 'completed', sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('AKA').value).toBe('');
+    await act(async () => { fireEvent.click(screen.getByText('✕ Close')); });
+    expect(window.confirmDialog).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('R20: after a side is given another team, an operator pick on that side is an unsaved change, and Close asks first', async () => {
+    window.confirmDialog.mockClear();
+    window.confirmDialog.mockResolvedValueOnce(false);
+    window.API.fetchSquads.mockResolvedValue({ ...SQUADS, t3: [{ id: 'm1c', name: 'Erin', index: 1 }] });
+    const match = makeMatch({ status: 'completed', subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { rerenderWith, onClose } = await mount(match);
+    await rerenderWith(makeMatch({ status: 'completed', sideA: { id: 't3', name: 'Team C' }, subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await pickFromDh('AKA', 'Erin');
+    expect(dhInput('AKA').value).toBe('Erin');
+    await act(async () => { fireEvent.click(screen.getByText('✕ Close')); });
+    expect(window.confirmDialog).toHaveBeenCalledWith(expect.objectContaining({ message: 'Discard unsaved scoring changes?' }));
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('R21: a side given another team clears the stored pick without making the representative row a touched one: the next Finish leaves its scoreline unstated', async () => {
+    const match = makeMatch({ subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { onSubmit, rerenderWith } = await mount(match);
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect('sideAMemberId' in dh, 'the cleared pick is not sent').toBe(false);
+    expect(dh.ipponsA, 'an untouched row states no scoreline, so a stored verdict is not overwritten').toBeUndefined();
+    expect(dh.ipponsB).toBeUndefined();
+  });
+
+  it('R22: after a side is given another team, a pick the operator puts on that side and then clears is their own edit: Close asks first', async () => {
+    window.confirmDialog.mockClear();
+    window.confirmDialog.mockResolvedValueOnce(false);
+    window.API.fetchSquads.mockResolvedValue({ ...SQUADS, t3: [{ id: 'm1c', name: 'Erin', index: 1 }] });
+    const match = makeMatch({ status: 'completed', subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] });
+    const { rerenderWith, onClose } = await mount(match);
+    await rerenderWith(makeMatch({ status: 'completed', sideA: { id: 't3', name: 'Team C' }, subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await pickFromDh('AKA', 'Erin');
+    const wrap = dhInput('AKA').closest('.lineup-name');
+    await act(async () => { fireEvent.click(within(wrap).getByRole('button', { name: 'Clear player' })); });
+    expect(dhInput('AKA').value).toBe('');
+    await act(async () => { fireEvent.click(screen.getByText('✕ Close')); });
+    expect(window.confirmDialog).toHaveBeenCalledWith(expect.objectContaining({ message: 'Discard unsaved scoring changes?' }));
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('R23: a representative typed while the members are still being read is not named once the editor has closed', async () => {
+    // The member list never answers while the editor is open, so the typed name waits for it.
+    window.API.fetchSquads.mockImplementation(() => new Promise(() => {}));
+    window.API.addTeamMember.mockResolvedValue({ id: 'm9', name: 'Eve', index: 3 });
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { unmount } = await mount(match);
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    // The members wait's deadline is a setTimeout: faked from the Add tap, so the wait can end
+    // after the editor has unmounted (a cancelled read never answers it, only the deadline does).
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+    try {
+      await act(async () => { fireEvent.click(add.closest('button')); });
+      await act(async () => { await Promise.resolve(); });
+      expect(window.API.addTeamMember).not.toHaveBeenCalled();
+      await act(async () => { unmount(); });
+      await act(async () => {
+        vi.advanceTimersByTime(FETCH_TIMEOUT_MS);
+        for (let i = 0; i < 50; i += 1) await Promise.resolve();
+      });
+      expect(window.API.addTeamMember, 'the editor is gone, so no member is minted for nobody\'s pick').not.toHaveBeenCalled();
+      expect(window.API.renameTeamMember).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('R24: a representative typed on a row that then leaves the sheet lands nothing, and a bout added again shows no pick from it', async () => {
+    // The member POST is still out when another device removes the representative bout.
+    let answerEve;
+    window.API.addTeamMember.mockImplementation(() => new Promise((resolve) => { answerEve = resolve; }));
+    const t0 = Date.now();
+    const { onSubmit, rerenderWith } = await mount(makeMatch({ modifiedAt: t0, subResults: [DH_EMPTY] }));
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    // Another device removes the representative bout: the row is gone from the sheet.
+    await rerenderWith(makeMatch({ modifiedAt: t0 + 1000 }));
+    expect(dhInputs(), 'the representative row has left the sheet').toHaveLength(0);
+    // The POST answers late. The pick belonged to a row that is gone, so it lands nothing.
+    await act(async () => { answerEve({ id: 'm9', name: 'Eve', index: 3 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    // Past the autosave debounce: a pick that landed (and marked the sheet dirty) would be written here.
+    await act(async () => { await new Promise((r) => setTimeout(r, 500)); });
+    expect(onSubmit, 'a pick on a row that is gone arms no autosave').not.toHaveBeenCalled();
+    // The representative bout is added again (a fresh, empty row, stamped later).
+    await rerenderWith(makeMatch({ modifiedAt: t0 + 2000, subResults: [DH_EMPTY] }));
+    expect(dhInput('SHIRO').value, 'the new bout shows no pick from the old one').toBe('');
+    await clickFinishTwice();
+    const dh = dhEntryOf(finishPatchOf(onSubmit));
+    expect('sideBMemberId' in dh, 'the old pick is not sent on the new bout').toBe(false);
+  });
+
+  it('R25: a representative typed before the bout was removed and added again lands nothing on the new bout, even if it answers after the add', async () => {
+    let answerEve;
+    window.API.addTeamMember.mockImplementation(() => new Promise((resolve) => { answerEve = resolve; }));
+    const t0 = Date.now();
+    const { onSubmit, rerenderWith } = await mount(makeMatch({ modifiedAt: t0, subResults: [DH_EMPTY] }));
+    const input = dhInput('SHIRO');
+    await act(async () => { fireEvent.focus(input); fireEvent.change(input, { target: { value: 'Eve' } }); });
+    const add = await screen.findByText(/Add “Eve”/);
+    await act(async () => { fireEvent.click(add.closest('button')); });
+    await waitFor(() => expect(window.API.addTeamMember).toHaveBeenCalledWith('comp1', 't2', 'Eve', ''));
+    await rerenderWith(makeMatch({ modifiedAt: t0 + 1000 }));
+    await rerenderWith(makeMatch({ modifiedAt: t0 + 2000, subResults: [DH_EMPTY] }));
+    // The POST answers only now, with the new representative bout already on the sheet.
+    await act(async () => { answerEve({ id: 'm9', name: 'Eve', index: 3 }); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await act(async () => { await new Promise((r) => setTimeout(r, 500)); });
+    expect(dhInput('SHIRO').value, 'the answer of a pick typed on the removed bout names no one on the new one').toBe('');
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+
+  // The representative row follows the server per PART: the score and each side's pick
+  // are separate edits (bc-mrgc orders the picks apart from the bout row).
+  const dhRow = () => [...document.querySelectorAll('.team-sub-match')].pop();
+  const dhIppon = (color, letter) => [...dhRow().querySelectorAll(`.team-sub-match__side--${color} button.ipt-btn`)].find((b) => b.textContent === letter);
+  const dhMarks = (color) => [...dhRow().querySelectorAll(`.tsm-center-pts--${color} button.editor-side__pt`)].map((b) => b.textContent.trim());
+  const pastDebounce = () => act(async () => { await new Promise((r) => setTimeout(r, AUTOSAVE_DEBOUNCE_MS + 150)); });
+  const lastSubmitted = (onSubmit) => {
+    expect(onSubmit).toHaveBeenCalled();
+    const calls = onSubmit.mock.calls;
+    return calls[calls.length - 1][0];
+  };
+
+  it('R26: a pick made here does not hold another device\'s point on the bout, and a point struck here does not drop the pick', async () => {
+    const { onSubmit, rerenderWith } = await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    await pickFromDh('AKA', 'Alice');
+    expect(dhInput('AKA').value).toBe('Alice');
+    // Another device scores Shiro's point. The pick has not landed there, so the push carries none.
+    await rerenderWith(makeMatch({ modifiedAt: Date.now() + 60000, subResults: [{ ...DH_EMPTY, ipponsB: ['M'] }] }));
+    expect(dhMarks('shiro'), 'the point scored elsewhere is shown').toContain('M');
+    expect(dhInput('AKA').value, 'the pick is still the operator\'s until the server holds it').toBe('Alice');
+    // Strike Aka's point here: the write carries both points and the pick, and names both groups.
+    await act(async () => { fireEvent.click(dhIppon('aka', 'M')); });
+    await pastDebounce();
+    const patch = lastSubmitted(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect(dh.ipponsB, 'Shiro\'s point is not written over').toEqual(['M']);
+    expect(dh.ipponsA).toEqual(['M']);
+    expect(dh.sideAMemberId).toBe('m1a');
+    expect(patch.changed).toContain('bout:-1');
+    expect(patch.changed).toContain('repPickA');
+    expect(patch.changed, 'Shiro\'s side was not picked here').not.toContain('repPickB');
+  });
+
+  it('R27: a pick adopted from another device and then cleared here is named in the next write', async () => {
+    // The editor MUST mount before the pick exists (R4 mounts with it, so its mount-time
+    // baseline already holds the pick and the clear is a change against it).
+    const match = makeMatch({ subResults: [DH_EMPTY] });
+    const { onSubmit, rerenderWith } = await mount(match);
+    await rerenderWith(makeMatch({ modifiedAt: Date.now() + 60000, subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1a' }] }));
+    expect(dhInput('AKA').value).toBe('Alice');
+    const wrap = dhInput('AKA').closest('.lineup-name');
+    await act(async () => { fireEvent.click(within(wrap).getByRole('button', { name: 'Clear player' })); });
+    await clickFinishTwice();
+    const patch = finishPatchOf(onSubmit);
+    expect('sideAMemberId' in dhEntryOf(patch)).toBe(false);
+    expect(toBackendMatchResult(patch, match).changed, 'the server keeps the other device\'s pick unless repPickA is named').toContain('repPickA');
+    expect(toBackendMatchResult(patch, match).changed, 'Shiro\'s pick was not touched here').not.toContain('repPickB');
+  });
+
+  it('R28: a pick adopted for one side does not hide the pick kept on the other: the next write names only the side picked here and carries both', async () => {
+    const { onSubmit, rerenderWith } = await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    await pickFromDh('AKA', 'Alice');
+    // Another device picks Carol for Shiro; Alice has not landed.
+    await rerenderWith(makeMatch({ modifiedAt: Date.now() + 60000, subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b' }] }));
+    expect(dhInput('SHIRO').value, 'the other side follows the server').toBe('Carol');
+    expect(dhInput('AKA').value, 'the side the operator picked stays theirs').toBe('Alice');
+    await clickFinishTwice();
+    const patch = finishPatchOf(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect(dh.sideAMemberId).toBe('m1a');
+    expect(dh.sideBMemberId).toBe('m1b');
+    expect(patch.changed).toContain('repPickA');
+    expect(patch.changed, 'the side adopted from the server is not a change').not.toContain('repPickB');
+  });
+
+  it('R33: a pick adopted for one side is not named again by a point struck here afterwards', async () => {
+    const { onSubmit, rerenderWith } = await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    // The editor's first write: a point struck on the representative bout.
+    await act(async () => { fireEvent.click(dhIppon('aka', 'M')); });
+    await pastDebounce();
+    expect(lastSubmitted(onSubmit).changed).toEqual(['bout:-1']);
+    // Another device picks Carol for Shiro; the point struck here has not come back yet.
+    await rerenderWith(makeMatch({ modifiedAt: Date.now() + 60000, subResults: [{ ...DH_EMPTY, sideBMemberId: 'm1b' }] }));
+    expect(dhInput('SHIRO').value, 'the pick made elsewhere is shown').toBe('Carol');
+    // A second point struck here: the pick is the other device's, adopted and not changed here, so
+    // the write must not put it back under a newer stamp.
+    await act(async () => { fireEvent.click(dhIppon('shiro', 'K')); });
+    await pastDebounce();
+    const patch = lastSubmitted(onSubmit);
+    expect(dhEntryOf(patch).sideBMemberId, 'the pick rides the row as it is').toBe('m1b');
+    expect(patch.changed).toEqual(['bout:-1']);
+  });
+
+  // PR #463 round 15 (G): Remove <decision> then Undo puts the whole board back to the
+  // server's, the representative picks included, so the editor agrees with the picks
+  // the server holds (useWithdrawalRemoval's onUndo). The agreement matters when a
+  // pick was built into a write earlier and has not echoed back: the next build would
+  // otherwise compare the board the Undo restored (no pick) against that write's pick,
+  // find them different, and name the group with an EMPTY pick under a newer stamp,
+  // clearing the editor's own pick on the server.
+  it('R35: Undo of a withdrawal removal agrees the picks: a pick written before it, undone, is not named again', async () => {
+    const { onSubmit } = await mount(makeMatch({
+      status: 'completed', phase: 'bracket', round: 'Round 1',
+      decision: 'kiken-voluntary', decisionBy: 'aka', decisionReason: 'knee',
+      winner: { id: 't2', name: 'Team B' },
+      subResults: [DH_ADDED],
+    }));
+    // The first Save correction asks for the reason; the editor keeps it, so the next
+    // one is sent straight away.
+    const saveCorrection = async () => {
+      await act(async () => {
+        fireEvent.click([...document.querySelectorAll('.score-nav button')].find((b) => b.textContent === 'Save correction'));
+      });
+      const confirm = [...document.querySelectorAll('.reason-prompt button')].find((b) => b.textContent === 'Confirm');
+      if (confirm) await act(async () => { fireEvent.click(confirm); });
+    };
+    await pickFromDh('AKA', 'Alice');
+    expect(dhInput('AKA').value).toBe('Alice');
+    await saveCorrection();
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+    expect(onSubmit.mock.calls[0][0].changed, 'the first save carries Aka\'s pick').toContain('repPickA');
+    // The pick has not echoed back: the match prop still holds no pick when the operator
+    // removes the withdrawal and takes the removal back.
+    await act(async () => { fireEvent.click(screen.getByTestId('remove-withdrawal')); });
+    await act(async () => { fireEvent.click(screen.getByTestId('remove-withdrawal-undo')); });
+    expect(dhInput('AKA').value, 'Undo put the server\'s row back, without the pick').not.toBe('Alice');
+    await saveCorrection();
+    expect(onSubmit).toHaveBeenCalledTimes(2);
+    const second = onSubmit.mock.calls[1][0].changed || [];
+    expect(second, 'the pick was taken back with the board, not changed again').not.toContain('repPickA');
+    expect(second).not.toContain('repPickB');
+  });
+
+  // PR #463 round 15 (I): a team member with no name is labelled by the team's number and
+  // the member's number, as every other surface labels one (squadLabelFor).
+  it('R36: the History labels a member who has no name by the team number and the member number', async () => {
+    const at = Date.now();
+    window.API.fetchSquads.mockResolvedValue({ t1: [{ id: 'm3a', name: '', index: 3 }], t2: SQUADS.t2 });
+    window.API.fetchMatchHistory.mockResolvedValue([
+      { matchId: 'm-ko-1', door: 'score', stamp: at, receivedAt: at, changed: ['repPickA'], outcomes: { repPickA: 'held' }, held: { repPickA: { sideAMemberId: 'm3a' } } },
+    ]);
+    await mount(makeMatch({ sideA: { id: 't1', name: 'Team A', number: 'K1' }, subResults: [DH_EMPTY] }));
+    await waitFor(() => expect(window.API.fetchSquads).toHaveBeenCalled());
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await act(async () => { fireEvent.click(screen.getByTestId('match-history-toggle')); });
+    const lines = (await screen.findAllByTestId('match-history-held')).map((el) => el.textContent);
+    expect(lines).toEqual(["Kept in history: Aka's pick for the representative bout, picked K1.3"]);
+  });
+
+  it('R34: the History names the representatives the sheet holds the members of, and an id the team no longer holds', async () => {
+    const at = Date.now();
+    window.API.fetchMatchHistory.mockResolvedValue([
+      { matchId: 'm-ko-1', door: 'daihyosen-remove', stamp: at, receivedAt: at, changed: ['repPickB'], outcomes: { repPickB: 'held' }, held: { repPickB: { sideBMemberId: 'm1b' } } },
+      { matchId: 'm-ko-1', door: 'displaced', stamp: at, receivedAt: at, changed: ['repPickA'], outcomes: { repPickA: 'held' }, held: { repPickA: { sideAMemberId: 'm1a' } }, reason: 'the representative bout was removed' },
+      // Aka's team never held m1b: Shiro's team did.
+      { matchId: 'm-ko-1', door: 'score', stamp: at, receivedAt: at, changed: ['repPickA'], outcomes: { repPickA: 'held' }, held: { repPickA: { sideAMemberId: 'm1b' } } },
+    ]);
+    await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    // The members are read when the sheet opens.
+    await waitFor(() => expect(window.API.fetchSquads).toHaveBeenCalled());
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    await act(async () => { fireEvent.click(screen.getByTestId('match-history-toggle')); });
+    const lines = (await screen.findAllByTestId('match-history-held')).map((el) => el.textContent);
+    expect(lines).toEqual([
+      "Kept in history: Shiro's pick for the representative bout, picked Carol",
+      "Moved to history: Aka's pick for the representative bout, picked Alice",
+      "Kept in history: Aka's pick for the representative bout, picked (not on the team now)",
+    ]);
+  });
+
+  it('R29: a pick made here and not yet written is dropped when its side is given another team: nothing is sent for it, and the sheet is not dirty', async () => {
+    window.confirmDialog.mockClear();
+    const { onSubmit, onClose, rerenderWith } = await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    await pickFromDh('AKA', 'Alice');
+    expect(dhInput('AKA').value).toBe('Alice');
+    // The server never received the pick, so the push that seats team t3 cannot clear it.
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('AKA').value).toBe('');
+    // The pick armed an autosave that still fires; whatever it writes names no member of the old team.
+    await pastDebounce();
+    for (const [patch] of onSubmit.mock.calls) {
+      expect('sideAMemberId' in (dhEntryOf(patch) || {}), 'the dropped pick is not sent').toBe(false);
+      expect(patch.changed || [], 'the picks did not change').not.toContain('repPickA');
+      expect(patch.changed || [], 'the picks did not change').not.toContain('repPickB');
+    }
+    await act(async () => { fireEvent.click(screen.getByText('✕ Close')); });
+    expect(window.confirmDialog).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('R30: the dropped pick takes its edit stamp with it: a pick another device makes for the new team is followed even when its push is stamped before the dropped pick', async () => {
+    window.API.fetchSquads.mockResolvedValue({ ...SQUADS, t3: [{ id: 'm1c', name: 'Erin', index: 1 }] });
+    const { rerenderWith } = await mount(makeMatch({ subResults: [DH_EMPTY] }));
+    await pickFromDh('AKA', 'Alice');
+    const pickedAt = Date.now();
+    await rerenderWith(makeMatch({ sideA: { id: 't3', name: 'Team C' }, subResults: [DH_EMPTY] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('AKA').value).toBe('');
+    // The correction that seated team t3 reached this device late: the other device's pick for t3
+    // was made after it but before the pick dropped here, so its stamp is older than that pick's.
+    await rerenderWith(makeMatch({ modifiedAt: pickedAt - 500, sideA: { id: 't3', name: 'Team C' }, subResults: [{ ...DH_EMPTY, sideAMemberId: 'm1c' }] }));
+    await act(async () => { await new Promise((r) => setTimeout(r, 0)); });
+    expect(dhInput('AKA').value).toBe('Erin');
+  });
+
+  it('R31: a pick on a representative bout nobody has scored names the pick alone and leaves the bout\'s scoreline unstated', async () => {
+    // A pick is its own change group (repPickB). Naming bout:-1 as well would stamp the
+    // bout at the pick, so a device that had not yet seen a point struck elsewhere would
+    // send its stale scoreline under the newer stamp and erase that point.
+    const { onSubmit } = await mount(makeMatch({ subResults: [DH_ADDED] }));
+    await pickFromDh('SHIRO', 'Carol');
+    await pastDebounce();
+    const patch = lastSubmitted(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect(patch.changed, 'the pick is the only change').toEqual(['repPickB']);
+    expect(dh.sideBMemberId).toBe('m1b');
+    expect('ipponsA' in dh, 'the untouched bout states no scoreline').toBe(false);
+    expect('ipponsB' in dh, 'the untouched bout states no scoreline').toBe(false);
+  });
+
+  it('R32: a point struck here on the same bout is still named with the pick, and carries the scoreline', async () => {
+    const { onSubmit } = await mount(makeMatch({ subResults: [DH_ADDED] }));
+    await act(async () => { fireEvent.click(dhIppon('aka', 'M')); });
+    await pickFromDh('SHIRO', 'Carol');
+    await pastDebounce();
+    const patch = lastSubmitted(onSubmit);
+    const dh = dhEntryOf(patch);
+    expect(patch.changed).toContain('bout:-1');
+    expect(patch.changed).toContain('repPickB');
+    expect(patch.changed, 'Aka\'s side was not picked here').not.toContain('repPickA');
+    expect(dh.ipponsA).toEqual(['M']);
+    expect(dh.sideBMemberId).toBe('m1b');
+  });
+});
diff --git a/web-mobile/js/__tests__/render/winner_tick_reads_in_order.render.test.jsx b/web-mobile/js/__tests__/render/winner_tick_reads_in_order.render.test.jsx
new file mode 100644
index 000000000..649218c64
--- /dev/null
+++ b/web-mobile/js/__tests__/render/winner_tick_reads_in_order.render.test.jsx
@@ -0,0 +1,69 @@
+// The winner tick's screen-reader words follow the tick's place in the row.
+// Before the name (Shiro on Recent results, the bracket card, the queue row)
+// the words are "Winner: "; after the name (Aka on Recent results, where the
+// tick sits at the outer edge) they are ", winner", so the row is spoken as
+// "Aka: Tanaka, winner" and not "Aka: Tanaka Winner:".
+import React from 'react';
+import { render } from '@testing-library/react';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+
+let WinnerTick, VSchedItem, normalizeMatch;
+
+beforeAll(async () => {
+  window.matchScoreStr = vi.fn(() => '');
+  ({ WinnerTick } = await import('../../side_cell.jsx'));
+  ({ normalizeMatch } = await import('../../api_serializers.jsx'));
+  ({ VSchedItem } = await import('../../viewer_match.jsx'));
+});
+
+afterAll(() => {
+  delete window.matchScoreStr;
+});
+
+// What a screen reader would say for an element: its text with the
+// aria-hidden glyphs left out.
+function spoken(el) {
+  const copy = el.cloneNode(true);
+  copy.querySelectorAll('[aria-hidden="true"]').forEach((n) => n.remove());
+  return copy.textContent;
+}
+
+function completedBout(winner) {
+  return normalizeMatch({
+    id: 'm-recent-1',
+    status: 'completed',
+    court: 'A',
+    phase: 'bracket',
+    round: 'Final',
+    sideA: 'Tanaka',
+    sideB: 'Sato',
+    winner,
+  }, {});
+}
+
+describe('WinnerTick sr-only words follow the tick position', () => {
+  it('a tick after the name reads ", winner"', () => {
+    const { container } = render(<span>Tanaka<WinnerTick trailing /></span>);
+    expect(container.querySelector('.sr-only').textContent).toBe(', winner');
+    expect(spoken(container.firstChild)).toBe('Tanaka, winner');
+  });
+
+  it('a tick before the name keeps "Winner: "', () => {
+    const { container } = render(<span><WinnerTick />Tanaka</span>);
+    expect(container.querySelector('.sr-only').textContent).toBe('Winner: ');
+    expect(spoken(container.firstChild)).toBe('Winner: Tanaka');
+  });
+
+  it('Recent results: Aka (tick after the name) reads ", winner"; Shiro keeps "Winner: "', () => {
+    const akaWins = render(<VSchedItem m={completedBout('Tanaka')} tweaks={{}} winnerTick />);
+    const aka = akaWins.container.querySelector('.vsched-item__side--aka');
+    expect(aka.querySelector('.bc-winner-tick .sr-only').textContent).toBe(', winner');
+    expect(spoken(aka)).toBe('Aka: Tanaka, winner');
+    akaWins.unmount();
+
+    const shiroWins = render(<VSchedItem m={completedBout('Sato')} tweaks={{}} winnerTick />);
+    const shiro = shiroWins.container.querySelector('.vsched-item__side--shiro');
+    expect(shiro.querySelector('.bc-winner-tick .sr-only').textContent).toBe('Winner: ');
+    expect(spoken(shiro)).toBe('Shiro: Winner: Sato');
+  });
+});
diff --git a/web-mobile/js/__tests__/rule_gates.test.jsx b/web-mobile/js/__tests__/rule_gates.test.jsx
index 08bc4fffb..2db3c1f10 100644
--- a/web-mobile/js/__tests__/rule_gates.test.jsx
+++ b/web-mobile/js/__tests__/rule_gates.test.jsx
@@ -127,6 +127,7 @@ describe('the write-result rule is importable without running the gate', () => {
     // the history are told apart by the owner alone.
     expect(trips('window.writeNeedsWinner(res)')).toBe(true);
     expect(trips('window.writeDisplacedGroups(res)')).toBe(true);
+    expect(trips('window.writeDisplacedForWinner(res)')).toBe(true);
     expect(trips('<span>{QUEUED_NOTICE}</span>')).toBe(false);
     expect(trips('if (writeDidNotLand(res)) return;')).toBe(false);
   });
diff --git a/web-mobile/js/__tests__/side_marks_leaf.test.jsx b/web-mobile/js/__tests__/side_marks_leaf.test.jsx
new file mode 100644
index 000000000..9d740682a
--- /dev/null
+++ b/web-mobile/js/__tests__/side_marks_leaf.test.jsx
@@ -0,0 +1,44 @@
+// side_marks.jsx is a LEAF: the court console (admin_shiaijo.jsx) imports the
+// result-mark placement helpers from it, and the console must not reach
+// bracket.jsx. Its render suite stubs window.BracketTree before importing the
+// console, the console reads that global at module eval, and bracket.jsx
+// reassigns window.BracketTree in its own module body; an import's
+// dependencies evaluate FIRST, so a path from the console to bracket.jsx would
+// overwrite the stub (see the header of admin_shiaijo.jsx).
+//
+// So the leaf's one import is competitor_identity.jsx, itself a leaf. This test
+// reads the source rather than the module graph because a graph walk would need
+// a bundler; the rule is small enough to state as "the only `import` lines in
+// the file name competitor_identity.jsx", and a second import fails it loudly.
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { stripComments } from '../../check-helpers.mjs';
+
+const JS = resolve(__dirname, '..');
+const read = (name) => readFileSync(resolve(JS, name), 'utf8');
+
+function importSpecifiers(src) {
+  const out = [];
+  const re = /^\s*import\s[^;]*?from\s+['"]([^'"]+)['"]|^\s*import\s+['"]([^'"]+)['"]/gm;
+  let m;
+  while ((m = re.exec(stripComments(src))) !== null) out.push(m[1] || m[2]);
+  return out;
+}
+
+describe('side_marks.jsx stays a leaf', () => {
+  it('its only import is ./competitor_identity.jsx', () => {
+    expect(importSpecifiers(read('side_marks.jsx'))).toEqual(['./competitor_identity.jsx']);
+  });
+
+  it('competitor_identity.jsx, the one module it reaches, imports nothing', () => {
+    expect(importSpecifiers(read('competitor_identity.jsx'))).toEqual([]);
+  });
+
+  it('exports the six helpers the console and bracket.jsx read', () => {
+    const src = read('side_marks.jsx');
+    for (const name of ['isKikenDecisionBC', 'joinSp', 'placeMarks', 'sideMarks', 'winnerSideLR', 'teamMatchMarks']) {
+      expect(src, name).toMatch(new RegExp(`export\\s+(?:function|const)\\s+${name}\\b|export\\s*\\{[^}]*\\b${name}\\b`));
+    }
+  });
+});
diff --git a/web-mobile/js/__tests__/start_match.test.jsx b/web-mobile/js/__tests__/start_match.test.jsx
new file mode 100644
index 000000000..da77294a2
--- /dev/null
+++ b/web-mobile/js/__tests__/start_match.test.jsx
@@ -0,0 +1,174 @@
+// bc-aadv / PR #463 round 13 (gap C): the ONE owner of "what did a Start write
+// come back with" (start_match.jsx). The court console and the Scores tab both
+// start a match, and before this leaf only the console read the answer: a
+// clock_skew refusal (HTTP 200 {applied:false}) was taken for a start that
+// landed on the Scores tab, a thrown 409 was swallowed, and nothing stopped a
+// second start while one was out.
+
+import { describe, it, expect } from 'vitest';
+import { CLOCK_SKEW_REASON_TEXT, SUPERSEDED_REASON, SUPERSEDED_ADVICE, notSavedText } from '../write_result.jsx';
+import {
+    classifyStartOutcome, startFailureMessage, createStartGuard, startPatch, startRefusalStands,
+    START_CLOCK_SKEW_MESSAGE, START_FAILED_MESSAGE, START_SUPERSEDED_MESSAGE,
+} from '../start_match.jsx';
+
+describe('classifyStartOutcome', () => {
+    it('a clock_skew refusal is a start that did not happen, in the console\'s own words', () => {
+        const out = classifyStartOutcome({ applied: false, reason: 'clock_skew' });
+        expect(out.ok).toBe(false);
+        expect(out.msg).toBe(`Could not start: ${CLOCK_SKEW_REASON_TEXT}. The clock has been resynced; try again.`);
+        expect(out.msg).toBe(START_CLOCK_SKEW_MESSAGE);
+    });
+
+    it('a queued start lands on reconnect, so it counts as started', () => {
+        expect(classifyStartOutcome({ queued: true })).toEqual({ ok: true });
+    });
+
+    it('a landed start, an answer with no body and nothing at all are all started', () => {
+        expect(classifyStartOutcome({ status: 'ok' })).toEqual({ ok: true });
+        expect(classifyStartOutcome({ applied: true })).toEqual({ ok: true });
+        expect(classifyStartOutcome(undefined)).toEqual({ ok: true });
+        expect(classifyStartOutcome(null)).toEqual({ ok: true });
+    });
+
+    // PR #463 round 19 (S1). A start names the `result` group alone, and the server
+    // lists a held group in `heldGroups` only when its incoming value DIFFERS from
+    // the stored one (reportHeld: an equal one is a HeldEcho, neither listed nor
+    // kept), and omits `heldGroups` from the answer when it would be empty
+    // (respondSuperseded). So a superseded start with NO heldGroups is an echo-hold:
+    // the stored result already equals the start, which is another device's start of
+    // this same match having landed first with a later stamp. The match IS running.
+    it('a superseded start that holds no group is an echo-hold: the start went out', () => {
+        expect(classifyStartOutcome({ applied: false, reason: 'superseded' })).toEqual({ ok: true });
+        expect(classifyStartOutcome({ applied: false, reason: 'superseded', heldGroups: [] })).toEqual({ ok: true });
+    });
+
+    // PIN (green by design since round 18): a superseded start that DID hold its
+    // result group means a different result is stored (a send-back, a correction),
+    // so nothing of the start was written and the match is not running.
+    it('PIN: a superseded start that holds the result group is a refused start, in its own words', () => {
+        const out = classifyStartOutcome({ applied: false, reason: 'superseded', heldGroups: ['result'] });
+        expect(out.ok).toBe(false);
+        expect(out.msg).toBe(START_SUPERSEDED_MESSAGE);
+    });
+
+    // S2: the refusal's words are write_result.jsx's (SUPERSEDED_REASON and
+    // SUPERSEDED_ADVICE, composed by notSavedText as the clock sentence composes
+    // CLOCK_SKEW_REASON_TEXT), under the start sentences' own "Not started" lead.
+    it('the superseded sentence is composed from the write_result.jsx owner, with the start lead', () => {
+        expect(START_SUPERSEDED_MESSAGE).toBe(notSavedText({ lead: 'Not started', reason: SUPERSEDED_REASON, advice: SUPERSEDED_ADVICE }));
+        expect(START_SUPERSEDED_MESSAGE).toBe(
+            'Not started: a newer change to the same thing was recorded first, so this one was kept in the match\'s history and nothing is lost. '
+            + 'Check the match and its history before entering anything again: entering it again would replace the newer change.');
+    });
+
+    it('only a clock_skew or a held-group superseded answer is a refusal: landed, queued, echo-held and body-less starts did go out', () => {
+        for (const res of [{ applied: true }, { queued: true }, { status: 'ok' }, { applied: false, reason: 'superseded' }, undefined, null]) {
+            expect(classifyStartOutcome(res).ok, JSON.stringify(res)).toBe(true);
+        }
+    });
+});
+
+describe('startFailureMessage', () => {
+    it('is the thrown error\'s own sentence', () => {
+        expect(startFailureMessage(new Error('Alice withdrew in Pool A · Match 1 and cannot fight again.')))
+            .toBe('Alice withdrew in Pool A · Match 1 and cannot fight again.');
+    });
+
+    it('falls back to one sentence when the error says nothing', () => {
+        expect(startFailureMessage(new Error(''))).toBe(START_FAILED_MESSAGE);
+        expect(startFailureMessage(undefined)).toBe(START_FAILED_MESSAGE);
+        expect(START_FAILED_MESSAGE).toBe('Could not start the match: check eligibility and try again.');
+    });
+});
+
+describe('the start copy follows the house words', () => {
+    it('carries no em-dash and never says mat', () => {
+        const all = START_CLOCK_SKEW_MESSAGE + START_FAILED_MESSAGE + START_SUPERSEDED_MESSAGE;
+        expect(all).not.toMatch(/—/);
+        expect(all).not.toMatch(/\bmats?\b/i);
+    });
+
+    // The two refusals give opposite advice: after a clock refusal the clock has
+    // been resynced and a second tap normally succeeds, but a superseded start
+    // means a NEWER change to the match is stored, and starting it again blind
+    // is what the sentence must not invite.
+    it('the superseded sentence never says "try again": it sends the operator to the match', () => {
+        expect(START_SUPERSEDED_MESSAGE).not.toMatch(/try again/i);
+        expect(START_SUPERSEDED_MESSAGE).toMatch(/Check the match/);
+        expect(START_CLOCK_SKEW_MESSAGE).toMatch(/try again/);
+    });
+});
+
+describe('createStartGuard', () => {
+    it('starts nothing out until begin is called', () => {
+        expect(createStartGuard().inFlight()).toBeNull();
+    });
+
+    it('takes one start at a time: another match is refused while one is out, naming it', () => {
+        const g = createStartGuard();
+        const a = { id: 'a' };
+        expect(g.begin('a', a)).toEqual({ started: true });
+        const refused = g.begin('b', { id: 'b' });
+        expect(refused.started).toBe(false);
+        expect(refused.repeat).toBe(false);
+        expect(refused.blocker).toEqual({ key: 'a', match: a });
+        expect(g.inFlight()).toEqual({ key: 'a', match: a });
+    });
+
+    it('a repeat for the match already being started is refused silently', () => {
+        const g = createStartGuard();
+        g.begin('a', { id: 'a' });
+        const again = g.begin('a', { id: 'a' });
+        expect(again.started).toBe(false);
+        expect(again.repeat).toBe(true);
+    });
+
+    it('end frees it, and only the start that holds it can end it', () => {
+        const g = createStartGuard();
+        g.begin('a', { id: 'a' });
+        g.end('b');
+        expect(g.inFlight().key).toBe('a');
+        g.end('a');
+        expect(g.inFlight()).toBeNull();
+        expect(g.begin('b', { id: 'b' })).toEqual({ started: true });
+    });
+});
+
+describe('startPatch', () => {
+    it('is a result-only, start-only write (bc-sbq, bc-mrgc)', () => {
+        const p = startPatch();
+        expect(p.startOnly).toBe(true);
+        expect(p.changed).toEqual(['result']);
+        expect(p.status).toBe('running');
+        expect(p.winner).toBeNull();
+    });
+
+    it('hands out a fresh object each call', () => {
+        expect(startPatch()).not.toBe(startPatch());
+    });
+});
+
+// PR #463 round 15 (F): how long a refused Start notice lives is ONE rule, asked
+// by the court console and the Scores tab alike.
+describe('startRefusalStands', () => {
+    it('stands while the refused match is still scheduled in the list', () => {
+        expect(startRefusalStands({ row: { status: 'scheduled' }, listHoldsMatches: true })).toBe(true);
+    });
+
+    it('falls when the refused match has left scheduled', () => {
+        for (const status of ['running', 'completed']) {
+            expect(startRefusalStands({ row: { status }, listHoldsMatches: true })).toBe(false);
+        }
+    });
+
+    it('falls when a list that holds matches no longer holds the refused one', () => {
+        expect(startRefusalStands({ row: null, listHoldsMatches: true })).toBe(false);
+        expect(startRefusalStands({ row: undefined, listHoldsMatches: true })).toBe(false);
+    });
+
+    it('stands across an empty list: it says nothing about the match', () => {
+        expect(startRefusalStands({ row: null, listHoldsMatches: false })).toBe(true);
+        expect(startRefusalStands({ row: undefined, listHoldsMatches: false })).toBe(true);
+    });
+});
diff --git a/web-mobile/js/__tests__/viewer_competition_recent_order.test.jsx b/web-mobile/js/__tests__/viewer_competition_recent_order.test.jsx
index 73e08fc55..528e429da 100644
--- a/web-mobile/js/__tests__/viewer_competition_recent_order.test.jsx
+++ b/web-mobile/js/__tests__/viewer_competition_recent_order.test.jsx
@@ -165,3 +165,197 @@ describe('ViewerCompetition Recent results orders by result-write time (mp-jnvl)
     expect(rows.map((m) => m.id)).toEqual(['late-slot', 'middle-slot', 'early-slot']);
   });
 });
+
+describe('ViewerCompetition Recent results includes completed hikiwake (drawn) bouts (bc-rrdr)', () => {
+  const realReact = global.React;
+  let runtime, saved;
+  let ViewerCompetition, ViewerOverview, VSchedItem, normalizeCompetitionDetail;
+
+  beforeEach(async () => {
+    runtime = makeReactive();
+    global.React = runtime.React;
+    saved = installStubs();
+    vi.resetModules();
+    await import('../admin_helpers.jsx');
+    await import('../bracket.jsx');
+    ({ ViewerCompetition, ViewerOverview, VSchedItem } = await import('../viewer.jsx'));
+    ({ normalizeCompetitionDetail } = await import('../api_serializers.jsx'));
+  });
+
+  afterEach(() => {
+    runtime.unmount();
+    global.React = realReact;
+    restoreStubs(saved);
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  const rawDetail = () => ({
+    id: 'c1',
+    name: 'Pool Tournament',
+    kind: 'individual',
+    teamSize: 0,
+    format: 'pools',
+    status: 'knockout',
+    startTime: '09:00',
+    courts: ['A'],
+    config: {
+      players: [
+        { id: 'p1', name: 'Aiko Tanaka', dojo: 'Dojo One' },
+        { id: 'p2', name: 'Bo Nakamura', dojo: 'Dojo Two' },
+        { id: 'p3', name: 'Chie Sato', dojo: 'Dojo Three' },
+        { id: 'p4', name: 'Dai Mori', dojo: 'Dojo Four' },
+      ],
+    },
+    pools: [
+      {
+        name: 'Pool A',
+        poolName: 'Pool A',
+        players: ['p1', 'p2', 'p3', 'p4'],
+      },
+    ],
+    // The viewer API sends pool bouts as a flat poolMatches list (compMatches
+    // reads it in preference to pools[].matches, so an empty [] would hide them).
+    poolMatches: [
+          {
+            id: 'Pool A-0',
+            phase: 'pool',
+            poolName: 'Pool A',
+            sideA: 'Aiko Tanaka',
+            sideB: 'Bo Nakamura',
+            status: 'completed',
+            court: 'A',
+            scheduledAt: '09:00',
+            ipponsA: ['K'],
+            ipponsB: ['M'],
+            decision: 'hikiwake',
+            modifiedAt: 2000,
+          },
+          {
+            id: 'Pool A-1',
+            phase: 'pool',
+            poolName: 'Pool A',
+            sideA: 'Chie Sato',
+            sideB: 'Dai Mori',
+            winner: 'Chie Sato',
+            status: 'completed',
+            court: 'A',
+            scheduledAt: '09:10',
+            ipponsA: ['M', 'K'],
+            ipponsB: ['D'],
+            modifiedAt: 1000,
+          },
+    ],
+    standings: {},
+    bracket: { preview: false, rounds: [] },
+  });
+
+  function mountCompetition(detail) {
+    const tree = runtime.mount(ViewerCompetition, {
+      tournament: { competitions: [detail], mode: 'public' },
+      competition: detail,
+      pools: detail.pools,
+      poolMatches: detail.poolMatches,
+      standings: detail.standings,
+      bracket: detail.bracket,
+      onBack: () => {},
+      tweaks: {},
+      activeTab: 'overview',
+    });
+    const overview = findInTree(tree, (n) => n.type === ViewerOverview);
+    expect(overview, 'expected the Overview tab to render ViewerOverview').not.toBeNull();
+    return overview.props;
+  }
+
+  function recentRows(overviewProps) {
+    const tree = runtime.mount(ViewerOverview, overviewProps);
+    const section = findInTree(tree, (n) => {
+      const kids = [].concat(n.props?.children || []).filter((k) => k && typeof k === 'object');
+      return kids.some((k) => hasClass(k, 'section-title') && collectText(k) === 'Recent results')
+        && kids.some((k) => hasClass(k, 'vsched'));
+    });
+    expect(section, 'expected a "Recent results" section with a match list').not.toBeNull();
+    return findAll(section, (n) => n.type === VSchedItem).map((n) => n.props.m);
+  }
+
+  it('a completed hikiwake pool bout (K X M, no winner) appears in Recent results, newest first', () => {
+    const detail = normalizeCompetitionDetail(rawDetail());
+    const rows = recentRows(mountCompetition(detail));
+    expect(rows.map((m) => m.id)).toEqual(['Pool A-0', 'Pool A-1']);
+    expect(rows[0].winner).toBeUndefined();
+    expect(rows[0].decision).toBe('hikiwake');
+  });
+
+  it('a completed hikiwake bout (K X M) renders with the X middle mark', () => {
+    const detail = normalizeCompetitionDetail(rawDetail());
+    const overviewProps = mountCompetition(detail);
+    const rows = recentRows(overviewProps);
+    const tree = runtime.mount(VSchedItem, {
+      m: rows[0],
+      tweaks: {},
+      winnerTick: true,
+    });
+    const scoreText = collectText(tree);
+    expect(scoreText).toMatch(/\bX\b/);
+  });
+
+  it('a 0-0 hikiwake (no ippons) renders as just "X"', () => {
+    const detail = normalizeCompetitionDetail({
+      id: 'c1',
+      name: 'Pool Tournament',
+      kind: 'individual',
+      teamSize: 0,
+      format: 'pools',
+      status: 'knockout',
+      startTime: '09:00',
+      courts: ['A'],
+      config: {
+        players: [
+          { id: 'p1', name: 'Aiko Tanaka', dojo: 'Dojo One' },
+          { id: 'p2', name: 'Bo Nakamura', dojo: 'Dojo Two' },
+        ],
+      },
+      pools: [{ name: 'Pool A', poolName: 'Pool A', players: ['p1', 'p2'] }],
+      poolMatches: [
+            {
+              id: 'Pool A-0',
+              phase: 'pool',
+              poolName: 'Pool A',
+              sideA: 'Aiko Tanaka',
+              sideB: 'Bo Nakamura',
+              status: 'completed',
+              court: 'A',
+              scheduledAt: '09:00',
+              ipponsA: [],
+              ipponsB: [],
+              decision: 'hikiwake',
+              modifiedAt: 1000,
+            },
+      ],
+      standings: {},
+      bracket: { preview: false, rounds: [] },
+    });
+    const overviewProps = mountCompetition(detail);
+    const rows = recentRows(overviewProps);
+    const tree = runtime.mount(VSchedItem, {
+      m: rows[0],
+      tweaks: {},
+      winnerTick: true,
+    });
+    const scoreText = collectText(tree);
+    expect(scoreText).toContain('X');
+  });
+
+  it('a hikiwake bout with winnerTick prop carries no bc-winner-tick (no winner)', () => {
+    const detail = normalizeCompetitionDetail(rawDetail());
+    const overviewProps = mountCompetition(detail);
+    const rows = recentRows(overviewProps);
+    const tree = runtime.mount(VSchedItem, {
+      m: rows[0],
+      tweaks: {},
+      winnerTick: true,
+    });
+    const ticks = findAll(tree, (n) => n.type?.name === 'WinnerTick');
+    expect(ticks).toHaveLength(0);
+  });
+});
diff --git a/web-mobile/js/__tests__/vsched_number_survives_truncation.test.jsx b/web-mobile/js/__tests__/vsched_number_survives_truncation.test.jsx
index 4251cdb7e..445027614 100644
--- a/web-mobile/js/__tests__/vsched_number_survives_truncation.test.jsx
+++ b/web-mobile/js/__tests__/vsched_number_survives_truncation.test.jsx
@@ -54,11 +54,16 @@ describe('the competitor number is a chip, not trailing text', () => {
     vi.resetModules();
   });
 
-  // The name cells, in DOM order: Shiro first, then Aka.
+  // The name cells, in DOM order: Shiro first, then Aka. The cell also holds
+  // the Recent results winner tick's slot (first on Shiro, last on Aka), which
+  // is `false` when no tick is drawn, so the name is the one child left.
   const nameCells = () => {
     const m = { id: 'm1', status: 'scheduled', court: 'A', sideA: AKA, sideB: SHIRO };
     const tree = runtime.mount(VSchedItem, { m, tweaks: {} });
-    return findAll(tree, n => hasClass(n, 'n')).map(n => n.props && n.props.children);
+    return findAll(tree, n => hasClass(n, 'n')).map((n) => {
+      const kids = [].concat(n.props && n.props.children).filter(Boolean);
+      return kids.length === 1 ? kids[0] : kids;
+    });
   };
 
   it('hands each side a NumberedName in clip mode, never a joined string', () => {
diff --git a/web-mobile/js/__tests__/vsched_winner_cue.test.jsx b/web-mobile/js/__tests__/vsched_winner_cue.test.jsx
index 09e58fd4a..42b17e83f 100644
--- a/web-mobile/js/__tests__/vsched_winner_cue.test.jsx
+++ b/web-mobile/js/__tests__/vsched_winner_cue.test.jsx
@@ -157,4 +157,67 @@ describe('T5: VSchedItem winner cue - completed team match', () => {
     const winners = sides.filter(n => hasClass(n, 'vsched-item__side--w'));
     expect(winners).toHaveLength(0);
   });
+
+  // bc-tmwn: W5 test for winner tick on Recent results
+  it('W5: winnerTick prop renders bc-winner-tick on the winning side only', () => {
+    const raw = {
+      id: 'm-team-4',
+      status: 'completed',
+      court: 'A',
+      phase: 'bracket',
+      round: 'Final',
+      sideA: 'Ryu',
+      sideB: 'Phoenix',
+      winner: 'Ryu',  // sideA (Aka) wins
+    };
+    const m = normalizeMatch(raw, {});
+
+    // Mount with winnerTick=true (as Recent results does)
+    const tree = runtime.mount(VSchedItem, { m, tweaks: {}, winnerTick: true });
+
+    const sides = findAll(tree, n => hasClass(n, 'vsched-item__side'));
+    const akaSide = sides.find(n => hasClass(n, 'vsched-item__side--aka'));
+    const shiroSide = sides.find(n => hasClass(n, 'vsched-item__side--shiro'));
+
+    // Find WinnerTick components
+    const ticks = findAll(tree, n => n.type?.name === 'WinnerTick');
+
+    // Should have exactly one tick
+    expect(ticks).toHaveLength(1);
+
+    // The tick should be inside the Aka side (winning side)
+    let akaHasTick = false;
+    const akaSideTicks = findAll(akaSide, n => n.type?.name === 'WinnerTick');
+    akaHasTick = akaSideTicks.length > 0;
+
+    // The tick should NOT be in the Shiro side
+    let shiroHasTick = false;
+    const shiroSideTicks = findAll(shiroSide, n => n.type?.name === 'WinnerTick');
+    shiroHasTick = shiroSideTicks.length > 0;
+
+    expect(akaHasTick).toBe(true);
+    expect(shiroHasTick).toBe(false);
+  });
+
+  it('W5b: without winnerTick prop, no bc-winner-tick is rendered', () => {
+    const raw = {
+      id: 'm-team-5',
+      status: 'completed',
+      court: 'A',
+      phase: 'bracket',
+      round: 'SF',
+      sideA: 'Ryu',
+      sideB: 'Phoenix',
+      winner: 'Ryu',
+    };
+    const m = normalizeMatch(raw, {});
+
+    // Mount WITHOUT winnerTick prop (as Up Next/Running do)
+    const tree = runtime.mount(VSchedItem, { m, tweaks: {} });
+
+    const ticks = findAll(tree, n => n.type?.name === 'WinnerTick');
+
+    // Should have no ticks
+    expect(ticks).toHaveLength(0);
+  });
 });
diff --git a/web-mobile/js/__tests__/write_result_banner.test.jsx b/web-mobile/js/__tests__/write_result_banner.test.jsx
index 83106a86e..9da8f1c4a 100644
--- a/web-mobile/js/__tests__/write_result_banner.test.jsx
+++ b/web-mobile/js/__tests__/write_result_banner.test.jsx
@@ -34,7 +34,12 @@ import {
     DEFAULT_WIN_STANDS_ADVICE,
     supersededAlertText,
     writeDisplacedGroups,
+    writeDisplacedForWinner,
     displacedAlertText,
+    markToasted,
+    wasToasted,
+    startWhileStartingMessage,
+    startWasBlockedByStartMessage,
 } from '../write_result.jsx';
 import { heldGroupsNote, keptInHistoryNote } from '../match_groups.jsx';
 import { closingHistoryToast } from '../admin.jsx';
@@ -304,6 +309,8 @@ describe('a change held because a decision for a bar elsewhere stands', () => {
         const all = [
             DEFAULT_WIN_STANDS_REASON('fusensho'), DEFAULT_WIN_STANDS_ADVICE('fusensho'),
             heldGroupsNote(['points'], false, true, 'fusensho'), supersededAlertText(2, false, false, true, 'fusensho'),
+            displacedAlertText(1, true, 1), displacedAlertText(2, false, 2), displacedAlertText(1, true, 0),
+            displacedAlertText(2, false, 0), displacedAlertText(3, false, 1),
         ].join(' ');
         expect(all).not.toMatch(/—/);
         expect(all).not.toMatch(/\bmats?\b/i);
@@ -337,7 +344,7 @@ describe('a finish recorded that moved a later change to the history', () => {
     });
 
     it('a write held in part and one that moved a later change says both', () => {
-        const both = { id: 'm1', status: 'completed', heldGroups: ['encho'], displacedGroups: ['bout:2'] };
+        const both = { id: 'm1', status: 'completed', heldGroups: ['encho'], displacedGroups: ['bout:2'], heldReason: 'needs_winner' };
         expect(keptInHistoryNote(both)).toBe(
             "Kept in the match's history, not applied: overtime. A newer change to the same thing was recorded first. "
             + "Saved. A later change to bout 2 would have left the finished match without a winner, so it was moved to the match's history.");
@@ -356,8 +363,57 @@ describe('a finish recorded that moved a later change to the history', () => {
     });
 
     it('the queue alert says the held result was saved', () => {
-        expect(displacedAlertText(1, true)).toMatch(/^A held result was saved\. .*moved to the match's history\.$/);
-        expect(displacedAlertText(2, false)).toMatch(/^2 held results were saved\./);
+        expect(displacedAlertText(1, true, 1)).toMatch(/^A held result was saved\. .*moved to the match's history\.$/);
+        expect(displacedAlertText(2, false, 2)).toMatch(/^2 held results were saved\./);
+    });
+
+    // The reason is per ANSWER: only an answer whose heldReason is needs_winner
+    // moved its change for a winner. A change moved for another reason (a
+    // representative's pick stamped after the representative bout's removal)
+    // carries no reason, and a decision that stands (default_win_stands) is
+    // not a winner reason either.
+    it('writeDisplacedForWinner is true only for a displaced answer that carries needs_winner', () => {
+        expect(writeDisplacedForWinner(displaced)).toBe(true);
+        expect(writeDisplacedForWinner({ ...displaced, heldReason: undefined })).toBe(false);
+        expect(writeDisplacedForWinner({ id: 'm1', status: 'completed', displacedGroups: ['repPickB'] })).toBe(false);
+        expect(writeDisplacedForWinner({ ...displaced, heldReason: 'default_win_stands' })).toBe(false);
+        expect(writeDisplacedForWinner({ id: 'm1', status: 'completed', heldReason: 'needs_winner' })).toBe(false);
+        expect(writeDisplacedForWinner({ ...displaced, displacedGroups: [] })).toBe(false);
+        expect(writeDisplacedForWinner(null)).toBe(false);
+        expect(writeDisplacedForWinner(undefined)).toBe(false);
+    });
+
+    it('a change moved for another reason is worded plainly, never with a winner the match does not lack', () => {
+        const removed = { id: 'm1', status: 'completed', displacedGroups: ['repPickB'] };
+        expect(keptInHistoryNote(removed)).not.toMatch(/without a winner/);
+        expect(keptInHistoryNote(removed)).toMatch(/^Saved\. A later change to .* was moved to the match's history\.$/);
+        expect(keptInHistoryNote({ ...removed, heldReason: 'default_win_stands' })).not.toMatch(/without a winner/);
+    });
+
+    // The queue alert follows the same rule over the replayed answers of one
+    // pass: all moved for a winner keeps the winner sentence, none says
+    // plainly that a later change was moved, and a mix says both.
+    it('the queue alert names a winner only for the changes that were moved for one', () => {
+        const FOR_ONE = "A held result was saved. A later change to that match would have left it without a winner, so the change was moved to the match's history.";
+        const FOR_MANY = "2 held results were saved. Later changes to those matches would have left them without a winner, so the changes were moved to each match's history.";
+        expect(displacedAlertText(1, true, 1)).toBe(FOR_ONE);
+        expect(displacedAlertText(2, false, 2)).toBe(FOR_MANY);
+
+        const NONE_ONE = "A held result was saved. A later change to that match was moved to the match's history.";
+        const NONE_MANY = "2 held results were saved. Later changes to those matches were moved to each match's history.";
+        expect(displacedAlertText(1, true, 0)).toBe(NONE_ONE);
+        expect(displacedAlertText(2, false, 0)).toBe(NONE_MANY);
+        expect(displacedAlertText(1, true, 0)).not.toMatch(/without a winner/);
+        expect(displacedAlertText(2, false, 0)).not.toMatch(/without a winner/);
+        // An alert that says nothing about a winner (an older caller, no
+        // third argument) reads as none for a winner.
+        expect(displacedAlertText(1, true)).toBe(NONE_ONE);
+        expect(displacedAlertText(2, false)).toBe(NONE_MANY);
+
+        expect(displacedAlertText(3, false, 1)).toBe(
+            "3 held results were saved. Later changes to those matches were moved to each match's history. 1 of those changes would have left a match without a winner.");
+        expect(displacedAlertText(3, false, 2)).toBe(
+            "3 held results were saved. Later changes to those matches were moved to each match's history. 2 of those changes would have left a match without a winner.");
     });
 });
 
@@ -395,3 +451,48 @@ describe('writeHeldDecision', () => {
         expect(writeHeldDecision(null)).toBeNull();
     });
 });
+
+// A start refused because another start was still out says so while that start
+// is out (startWhileStartingMessage, present tense). Once that start has landed
+// nothing else tells the operator the match they asked for was never started, so
+// the refusal is kept, in the past tense, on the refused match
+// (startWasBlockedByStartMessage). Both surfaces that refuse a start for this
+// reason (the court console and the Scores tab) read the sentence from here.
+describe('the sentence for a start that was blocked by another start', () => {
+    it('names the start that was out and says what to do, in the past tense', () => {
+        expect(startWasBlockedByStartMessage({ label: 'Pool A · Match 2' })).toBe(
+            'Not started: Pool A · Match 2 was being started when this match was asked for. Start it when the court is free.',
+        );
+    });
+    it('is the same label as the present-tense sentence names, and a different sentence', () => {
+        const label = 'Match 3 (Final)';
+        expect(startWhileStartingMessage({ label })).toContain(label);
+        expect(startWasBlockedByStartMessage({ label })).toContain(label);
+        expect(startWasBlockedByStartMessage({ label })).not.toBe(startWhileStartingMessage({ label }));
+    });
+});
+
+// A thrown refusal is toasted ONCE. editMatchScore (admin.jsx) toasts what it
+// throws; the two hosts that start a match catch the same error and used to toast
+// the same sentence again, which replaced the single-slot toast and restarted its
+// timer. editMatchScore marks the error it toasted, and a host asks before it does.
+describe('markToasted / wasToasted', () => {
+    it('an error marked toasted reads as toasted, and markToasted hands the same error back', () => {
+        const err = new Error('x');
+        expect(wasToasted(err)).toBe(false);
+        expect(markToasted(err)).toBe(err);
+        expect(wasToasted(err)).toBe(true);
+    });
+    it('anything that is not an error object reads as not toasted and does not throw', () => {
+        expect(wasToasted(undefined)).toBe(false);
+        expect(wasToasted(null)).toBe(false);
+        expect(wasToasted('string')).toBe(false);
+        expect(wasToasted(7)).toBe(false);
+        expect(wasToasted({})).toBe(false);
+    });
+    it('marking a non-object does not throw, and leaves it not toasted', () => {
+        expect(() => markToasted(undefined)).not.toThrow();
+        expect(() => markToasted('string')).not.toThrow();
+        expect(wasToasted(markToasted('string'))).toBe(false);
+    });
+});
diff --git a/web-mobile/js/__tests__/write_result_court_console_refusals.test.jsx b/web-mobile/js/__tests__/write_result_court_console_refusals.test.jsx
index 9aef82e11..eef8746b4 100644
--- a/web-mobile/js/__tests__/write_result_court_console_refusals.test.jsx
+++ b/web-mobile/js/__tests__/write_result_court_console_refusals.test.jsx
@@ -3,7 +3,7 @@
 // 2026-09-27). The words are the operator's, so they are pinned here once.
 
 import { describe, it, expect } from 'vitest';
-import { startWhileCorrectingMessage, correctWhileRunningMessage, courtBusyMessage } from '../write_result.jsx';
+import { startWhileCorrectingMessage, startWhileStartingMessage, correctWhileRunningMessage, courtBusyMessage } from '../write_result.jsx';
 
 describe('startWhileCorrectingMessage', () => {
     it('names the correction and the remedy', () => {
@@ -12,6 +12,13 @@ describe('startWhileCorrectingMessage', () => {
     });
 });
 
+describe('startWhileStartingMessage', () => {
+    it('names the start still on its way and when this match can start', () => {
+        expect(startWhileStartingMessage({ label: 'Pool A · Match 2 · Kato vs Sato' }))
+            .toBe('Pool A · Match 2 · Kato vs Sato is still being started on this court. Start this match once it has.');
+    });
+});
+
 describe('correctWhileRunningMessage', () => {
     it('names the court and the running bout, with the court-busy remedy', () => {
         const msg = correctWhileRunningMessage({ court: 'A', label: 'Match 3 · Ito vs Abe' });
@@ -23,7 +30,7 @@ describe('correctWhileRunningMessage', () => {
 
 describe('the refusal copy follows the house words', () => {
     it('carries no em-dash and never says mat', () => {
-        const all = startWhileCorrectingMessage({ label: 'x' }) + correctWhileRunningMessage({ court: 'A', label: 'x' });
+        const all = startWhileCorrectingMessage({ label: 'x' }) + startWhileStartingMessage({ label: 'x' }) + correctWhileRunningMessage({ court: 'A', label: 'x' });
         expect(all).not.toMatch(/—/);
         expect(all).not.toMatch(/\bmats?\b/i);
     });
diff --git a/web-mobile/js/admin.jsx b/web-mobile/js/admin.jsx
index ef96ce31f..83df45ae4 100644
--- a/web-mobile/js/admin.jsx
+++ b/web-mobile/js/admin.jsx
@@ -10,6 +10,7 @@ import {
   attemptScoreWrite,
   downstreamKnockoutReopenedNotice,
   writeKeepsEditorOpen,
+  markToasted,
 } from './write_result.jsx';
 import { keptInHistoryNote } from './match_groups.jsx';
 
@@ -17,8 +18,8 @@ const { useState: useStateA, useEffect: useEffectA, useRef: useRefA } = React;
 
 // closingHistoryToast (bc-mrgc): the toast editMatchScore shows for a write
 // that landed but kept something in the match's history (part of it held, or
-// a later change it moved there because that change would have left the
-// finished match without a winner), worded by keptInHistoryNote. Only when
+// a later change it moved there, worded by the reason the answer gives, if
+// any), through keptInHistoryNote. Only when
 // the write closes the editor: an editor that stays open says so itself
 // (useKeptInHistoryNote). A write that did not land keeps its editor open
 // too (writeKeepsEditorOpen), where its own banner reports it. null when
@@ -298,14 +299,17 @@ function AdminApp({ tournament, onUpdate, onLogout, onViewerMode, onPasswordChan
   //      real outcome.
   //   2. Post-mutation refresh: best-effort via refreshCompsBestEffort.
   //      A refresh failure cannot make the mutation "look failed."
+  // Resolves true when the move landed and false when it failed (the failure is
+  // toasted here), so a caller can tell the two apart.
   const moveMatchCourt = async (compId, matchId, newCourt) => {
     try {
       await window.API.moveMatchCourt(compId, matchId, newCourt, password);
     } catch (e) {
       showToast(e.message, "error");
-      return;
+      return false;
     }
     await refreshCompsBestEffort("Move");
+    return true;
   };
 
   // bc-kcdg: THE single chokepoint every score-editor host (the bracket
@@ -323,14 +327,17 @@ function AdminApp({ tournament, onUpdate, onLogout, onViewerMode, onPasswordChan
         compId, matchId, result, password, match,
       });
     } catch (e) {
+      // Every error toasted here is marked, so a host that catches it to show
+      // the same sentence on a card or a row does not toast it a second time
+      // (markToasted, write_result.jsx).
       if (e.downstreamKnockoutPlayedCancelled) {
         // Declining the override leaves everything as it was: neither this
         // match nor the later one it depends on was written.
         showToast(DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED);
-        throw e;
+        throw markToasted(e);
       }
       showToast(e.message, "error");
-      throw e;
+      throw markToasted(e);
     }
     // bc-kcdg: say what the confirmation actually did. The operator agreed to
     // reopen specific later matches; without this the only evidence is the
@@ -771,6 +778,7 @@ function AdminApp({ tournament, onUpdate, onLogout, onViewerMode, onPasswordChan
       onLogout={onLogout}
       onViewerMode={onViewerMode}
       password={password}
+      showToast={showToast}
     />;
   }
 
diff --git a/web-mobile/js/admin_competition.jsx b/web-mobile/js/admin_competition.jsx
index a3aba9541..bafb4cf04 100644
--- a/web-mobile/js/admin_competition.jsx
+++ b/web-mobile/js/admin_competition.jsx
@@ -504,7 +504,7 @@ function AdminCompetition({ tournament, competition, pools, poolMatches, standin
             )}
             {section === "pools" && <AdminPools c={c} pools={pools} poolMatches={poolMatches} standings={standings} tweaks={tweaks} onEditScore={onEditScore} password={password} />}
             {section === "bracket" && <AdminBracket c={c} t={t} bracket={bracket} onMoveCourt={onMoveCourt} onEditScore={onEditScore} tweaks={tweaks} password={password} />}
-            {section === "scores" && !isDrawReady && <AdminScoreEditor c={c} t={t} onEditScore={onEditScore} onMoveCourt={onMoveCourt} restrictToCompId={c.id} password={password} />}
+            {section === "scores" && !isDrawReady && <AdminScoreEditor c={c} t={t} onEditScore={onEditScore} onMoveCourt={onMoveCourt} restrictToCompId={c.id} password={password} showToast={showToast} />}
             {section === "export" && <AdminExport c={c} t={t} password={password} showToast={showToast} />}
           </div>
         </div>
diff --git a/web-mobile/js/admin_schedule.jsx b/web-mobile/js/admin_schedule.jsx
index 0b24f1fe5..c5769f1b6 100644
--- a/web-mobile/js/admin_schedule.jsx
+++ b/web-mobile/js/admin_schedule.jsx
@@ -21,7 +21,7 @@ import {
 } from './admin_schedule_pacing.jsx';
 import { MatchLineupPanel } from './admin_schedule_lineup.jsx';
 import { AdminExport } from './admin_schedule_export.jsx';
-import { startPatch, AdminScoreEditor, AdminScoreEditorPage } from './admin_schedule_score_editor.jsx';
+import { AdminScoreEditor, AdminScoreEditorPage } from './admin_schedule_score_editor.jsx';
 import { AdminSchedulePage } from './admin_schedule_page.jsx';
 
 // ES surface for the vitest suite: every symbol the unit tests import is
@@ -39,7 +39,6 @@ window.AdminScoreEditorPage = AdminScoreEditorPage;
 window.AdminScoreEditor = AdminScoreEditor;
 window.AdminExport = AdminExport;
 window.filterMatchesByCourt = filterMatchesByCourt;
-window.startPatch = startPatch;
 // Reused by the shiaijo operator console so team-match lineups can be set
 // without leaving that page (mp-c2yr).
 window.MatchLineupPanel = MatchLineupPanel;
diff --git a/web-mobile/js/admin_schedule_score_editor.jsx b/web-mobile/js/admin_schedule_score_editor.jsx
index 58dca3ddf..87e7c8438 100644
--- a/web-mobile/js/admin_schedule_score_editor.jsx
+++ b/web-mobile/js/admin_schedule_score_editor.jsx
@@ -1,14 +1,17 @@
 // Score editor components extracted from admin_schedule.jsx (mp-d7tl).
-// startPatch, ScoreEditCourtBtn (local), AdminScoreEditor, AdminScoreEditorPage.
+// ScoreEditCourtBtn (local), AdminScoreEditor, AdminScoreEditorPage.
 
-import { writeDidNotLand, writeKeepsEditorOpen } from './write_result.jsx';
+import { writeDidNotLand, writeKeepsEditorOpen, startWhileStartingMessage, startWasBlockedByStartMessage, wasToasted } from './write_result.jsx';
 import { matchMentions } from './competitor_search.jsx';
 import { SideCell } from './side_cell.jsx';
 import { allMatchesCompleted } from './admin_schedule_utils.jsx';
 import { MatchLineupPanel } from './admin_schedule_lineup.jsx';
 import { boutHansokuMark, teamNameMark } from './match_scoreboard.jsx';
 import { sameCompetitor } from './competitor_identity.jsx';
-import { scoreRowMatchLabel } from './pool_ids.jsx';
+// The withdrawn team's mark, imported from its leaf rather than read off
+// `window.teamMatchMarks` (a missing global painted no mark and no error).
+import { teamMatchMarks } from './side_marks.jsx';
+import { scoreRowMatchLabel, scoreRowMatchName } from './pool_ids.jsx';
 // NumberedName: single owner of the number-chip-on-the-outer-side rule
 // (bc-dnst); see that file's header for why this stays an ES import.
 import { NumberedName } from './numbered_name.jsx';
@@ -22,7 +25,11 @@ import { isBarredMatch, sideBarredByDecision, involvesCompetitor } from './ineli
 // matters for this file's own render suite.
 import { BarredMatchNotice } from './barred_match_notice.jsx';
 import { matchShowsScore } from './match_shows_score.jsx';
-import { GROUP_RESULT } from './match_groups.jsx';
+// PR #463 round 13 (gap C): how a Start is written (startPatch), what its
+// answer means (classifyStartOutcome, startFailureMessage) and the one-start-at-
+// a-time guard are start_match.jsx's, shared with the court console, which had
+// all three while this page swallowed a refused start.
+import { startPatch, classifyStartOutcome, startFailureMessage, createStartGuard, startRefusalStands } from './start_match.jsx';
 
 const { useState: useStateA, useMemo: useMemoA, useEffect: useEffectA, useRef: useRefA } = React;
 
@@ -49,7 +56,7 @@ const getScoreBtnClass = window.getScoreBtnClass;
 export { scoreRowMatchLabel };
 
 // ---------- Score editor ----------
-export function AdminScoreEditorPage({ tournament, onBack, onEditScore, onMoveCourt, onLogout, onViewerMode, password }) {
+export function AdminScoreEditorPage({ tournament, onBack, onEditScore, onMoveCourt, onLogout, onViewerMode, password, showToast }) {
   return (
     <div className="app">
       <AdminTopbar onLogout={onLogout} onViewerMode={onViewerMode} tournament={tournament} />
@@ -64,7 +71,7 @@ export function AdminScoreEditorPage({ tournament, onBack, onEditScore, onMoveCo
             <div className="page-head__sub">Update scores or correct past matches across the tournament. Changes propagate through the bracket.</div>
           </div>
         </div>
-        <AdminScoreEditor t={tournament} onEditScore={onEditScore} onMoveCourt={onMoveCourt} password={password} />
+        <AdminScoreEditor t={tournament} onEditScore={onEditScore} onMoveCourt={onMoveCourt} password={password} showToast={showToast} />
       </div>
     </div>
   );
@@ -84,25 +91,6 @@ function ScoreEditCourtBtn({ m, courts, onMoveCourt }) {
   );
 }
 
-// Module-level factory so admin_shiaijo.jsx can consume it via window.startPatch.
-// startOnly (bc-sbq): this write only starts the match, so the server keeps the
-// score the match already holds (a match sent back to the queue keeps one);
-// toBackendMatchResult leaves the empty scoreline below off the wire. The
-// editors' own Start sends their board unflagged, so an operator who cleared
-// every mark still clears it.
-//
-// bc-mrgc: a start changes the status and nothing else, so it names the result
-// group alone (match_groups.jsx): the server keeps every other group of the
-// match as stored, the score a send-back kept included.
-export function startPatch() {
-  return {
-    startOnly: true,
-    changed: [GROUP_RESULT],
-    status: "running", winner: null, ipponsA: [], ipponsB: [], hansokuA: 0, hansokuB: 0,
-    score: { type: "ippon", winnerPts: 0, loserPts: 0, ippons: [], fouls: { a: 0, b: 0 }, live: true, corrected: false },
-  };
-}
-
 export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCompId, password, showToast }) {
   const [filter, setFilter] = useStateA("");
   const [compFilter, setCompFilter] = useStateA(restrictToCompId || "all");
@@ -152,6 +140,121 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
   const openMatch = openKey ? allMatches.find((m) => scoreKeyOf(m) === openKey) || null : null;
   const lineupMatch = lineupKey ? allMatches.find((m) => scoreKeyOf(m) === lineupKey) || null : null;
 
+  // PR #463 round 13 (gap C, bc-aadv): the automatic start the server REFUSED
+  // (Finish + Start Next, or the start after a decision), kept as
+  // { key, msg, waitingOn } so the refused match's list row can say why for as
+  // long as it is true. The court console keeps the same on its Up next card
+  // (admin_shiaijo.jsx startError); this page has no Up next card, so the ROW is
+  // the persistent surface. It is not the editor: the modal covers the list, and
+  // the editor is the operator's scoring surface, not this page's to put a
+  // start notice into. The toast says it at the moment it happens; the row keeps
+  // saying it after the toast is gone and after the editor is closed.
+  // `waitingOn` is the key of the start that was still out when this one was
+  // refused for it, so the sentence is rewritten in the past tense when that
+  // start lands (startWasBlockedByStartMessage) and kept.
+  const [startRefusal, setStartRefusal] = useStateA(null);
+  // One start at a time (start_match.jsx createStartGuard), created once.
+  const startGuardRef = useRefA(null);
+  if (!startGuardRef.current) startGuardRef.current = createStartGuard();
+  // The notice is read from the LIVE row, never from a snapshot of it: it shows
+  // only while the refused match is still scheduled, so it cannot outlive the
+  // start that finally went through or a result recorded another way.
+  const startRefusalKey = startRefusal ? startRefusal.key : null;
+  const startRefusalRow = startRefusalKey ? allMatches.find((m) => scoreKeyOf(m) === startRefusalKey) : null;
+  const startRefusalHolds = startRefusalStands({ row: startRefusalRow, listHoldsMatches: allMatches.length > 0 });
+  // It is dropped when the refused match leaves `scheduled` or a list that holds
+  // matches no longer holds it (start_match.jsx startRefusalStands, the rule the
+  // court console asks too), or when the operator opens a DIFFERENT match, which
+  // only this page does. Closing the editor is neither: the row behind it is
+  // where the notice stays visible. A refusal is about one match at one moment,
+  // so a stale one never revives when that match is later sent back to the queue.
+  useEffectA(() => {
+    if (!startRefusalKey) return;
+    const openedAnother = openKey != null && openKey !== startRefusalKey;
+    if (openedAnother || !startRefusalHolds) setStartRefusal(null);
+  }, [openKey, startRefusalKey, startRefusalHolds]);
+  const startNoticeFor = (m) => (startRefusal && startRefusal.key === scoreKeyOf(m) && m.status === "scheduled" ? startRefusal.msg : null);
+
+  // A refused start: land the operator on the refused match in pre-match (the
+  // court console does, bc-aadv: they see WHICH match and why), keep the notice
+  // on its row and toast it. openKey is set first so the effect above, which
+  // drops a refusal when ANOTHER match opens, never sees the new refusal against
+  // the old openKey.
+  //
+  // `toasted` is true for a thrown refusal editMatchScore (admin.jsx) already
+  // toasted: the toast is a single slot (app.jsx), so saying it again would only
+  // replace it and restart its timer. The row notice is set either way. A
+  // refusal only this page sees (a clock_skew or held-group superseded answer, "still being started")
+  // carries no mark and is toasted here, once.
+  const refuseStart = (next, msg, waitingOn = null, toasted = false) => {
+    if (mountedRef.current) {
+      setOpenKey(scoreKeyOf(next));
+      setStartRefusal({ key: scoreKeyOf(next), msg, waitingOn });
+    }
+    if (showToast && !toasted) showToast(msg, "error");
+  };
+
+  // The ONE door both automatic starts go through: (a) refuses while another
+  // start is out, (b) reads the answer, (c) reports a refusal (refuseStart).
+  // Resolves true when the start went ahead (landed or queued), false otherwise;
+  // it never throws. A SUPERSEDED start that held its result group
+  // (classifyStartOutcome: nothing written, a different result is stored) is a
+  // REFUSED start like a clock_skew one: refuseStart stores its sentence on the refused match's row,
+  // toasts it once and opens that match, and the answer is false, so a caller
+  // does not move on as if the match had started. That replaces the refusal that
+  // waited on this start (`startRefusal` is a single slot and refuseStart clears
+  // `waitingOn`), which is why the finally below has nothing left to rewrite into
+  // a past-tense "was being started" for it: the same mechanism a thrown refusal
+  // relies on. `waitingOn` is this page's record of "a refusal is waiting on that
+  // start"; a start that wrote nothing replaces the refusal that carried it. A
+  // superseded start that held NOTHING is an echo of a start that landed (the match
+  // IS running): it answers ok, so it takes the landed path, the waiting refusal
+  // is rewritten in the past tense as for any start that went out, and the caller
+  // moves on.
+  // Every start-gating rule is the server's (StartMatchTx), so a thrown 409 only
+  // needs reporting.
+  const startNext = async (next) => {
+    const key = scoreKeyOf(next);
+    const guard = startGuardRef.current;
+    const began = guard.begin(key, next);
+    if (!began.started) {
+      // A repeat for the match already being started is silent: it is on its way.
+      if (!began.repeat) {
+        refuseStart(next, startWhileStartingMessage({ label: scoreRowMatchName(began.blocker.match) }), began.blocker.key);
+      }
+      return false;
+    }
+    if (mountedRef.current) setStartRefusal(null);
+    try {
+      const outcome = classifyStartOutcome(await onEditScore(next.compId, next.id, startPatch(), next));
+      if (outcome.ok) return true;
+      refuseStart(next, outcome.msg);
+      return false;
+    } catch (e) {
+      refuseStart(next, startFailureMessage(e), null, wasToasted(e));
+      return false;
+    } finally {
+      guard.end(key);
+      // A "still being started" notice names THIS start. When the start ends, the
+      // present-tense sentence stops being true, but the match the operator asked
+      // for was never started and nothing else says so, so the refusal is
+      // REWRITTEN in the past tense and kept on the refused match (bound to it like
+      // any stored refusal here: it goes when that match leaves scheduled or the
+      // operator opens another). The refused match is not started on its own: the
+      // court now has a running bout, and one start at a time is the rule.
+      // That holds only for a start that WENT OUT (landed or queued). One that
+      // wrote nothing (a thrown refusal, a clock_skew or a held-group superseded answer) has
+      // stored its own refusal through refuseStart, which replaced the waiting one
+      // and cleared `waitingOn`, so this finds nothing to rewrite: the court is
+      // free and "was being started" would be false.
+      if (mountedRef.current) {
+        setStartRefusal((prev) => (prev && prev.waitingOn === key
+          ? { key: prev.key, msg: startWasBlockedByStartMessage({ label: scoreRowMatchName(next) }), waitingOn: null }
+          : prev));
+      }
+    }
+  };
+
   const f = filter.trim().toLowerCase();
   const filtered = allMatches.filter((m) => {
     if (restrictToCompId && m.compId !== restrictToCompId) return false;
@@ -231,11 +334,11 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
           // teamIVPWScore) is deliberately free of marks, so the match-level
           // Kiken/Fus. a default win closed a team match with rides beside
           // the withdrawn team's NAME instead -- the ONE shared computation
-          // (window.teamMatchMarks, bracket.jsx), which derives its own
+          // (teamMatchMarks, side_marks.jsx), which derives its own
           // team-row signal from m.subResults (bc-cse) so an individual
           // match's own mark, already inline in its score string below, is
           // never doubled here.
-          const { shiro: teamShiroMark, aka: teamAkaMark } = window.teamMatchMarks ? window.teamMatchMarks(m) : { shiro: "", aka: "" };
+          const { shiro: teamShiroMark, aka: teamAkaMark } = teamMatchMarks(m);
           // Show the live ippon score for a running bout too (not just completed)
           // so the list reflects scoring in progress; "vs" only before it starts.
           // matchShowsScore is the one gate: a match sent back to the queue
@@ -252,6 +355,8 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
           // boutMiddle placeholder (normally "vs"). Live techniques show once present.
           const seScore = showScore ? window.matchScoreStr(m) : "";
           const matchNo = scoreRowMatchLabel(m);
+          // Why the automatic start of THIS match was refused (startNext), live.
+          const startNotice = startNoticeFor(m);
           return (
             <div key={`${m.compId}:${m.id}`} className={`score-edit-row ${m.status === "running" ? "score-edit-row--running is-running" : ""} ${m.status === "completed" ? "score-edit-row--complete" : ""}`}>
               <div>
@@ -337,6 +442,16 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
                   <BarredMatchNotice match={m} password={password} />
                 </div>
               )}
+              {/* PR #463 round 13: a Start the server refused for this match
+                  (Finish + Start Next, or the start after a decision), in the
+                  same full-width slot. role="status", not "alert": the toast is
+                  the assertive signal at the moment it happens; this stays
+                  where the operator can read it again. */}
+              {startNotice && (
+                <div style={{ gridColumn: "1 / -1" }}>
+                  <div className="alert alert--error" role="status" data-testid="start-refusal-notice">{startNotice}</div>
+                </div>
+              )}
             </div>
           );
         })}
@@ -393,13 +508,10 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
           ? sameCourt.slice(openIdx + 1).find(m => m.compId === openMatch.compId && m.status !== 'completed' && !isBarredMatch(m) && !involvesCompetitor(m, withdrawn)) || null
           : null;
         const nextActiveMatch = nextActiveFrom();
-        // Minimal "start" patch (status → running, empty score). Mirrors the
-        // modal's own buildPatch("running") for an unscored match and works for
-        // both individual and team matches (subResults is omitted, which the
-        // serializer treats as "no bouts scored yet"). The server routes this
-        // through eng.StartMatchTx, so all start-gating (eligibility 409,
-        // ≥players checks) still runs: a 409 throws and is caught below.
-        // Defined at module level as window.startPatch for reuse across admin_*.jsx.
+        // The automatic start (startNext, above) writes start_match.jsx's
+        // startPatch: the server routes it through eng.StartMatchTx, so all
+        // start-gating (eligibility 409, ≥players checks) still runs, and a
+        // refusal is reported by startNext.
         return (
           <ScoreEditorModal
             key={openKey}
@@ -475,16 +587,14 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
                 // shiaijo in the SAME competition AND actually start it
                 // (honest to the label). If the
                 // next match is already running/completed, just open it. Start
-                // gating runs server-side (StartMatchTx); a 409 throws: we
-                // catch it so the operator still lands on the next match (in
-                // pre-match) to resolve the eligibility issue manually.
+                // gating runs server-side (StartMatchTx): startNext reports a
+                // refusal (a thrown 409, or a clock_skew or held-group superseded answer) on
+                // that match's row and by toast, and the operator stays on it in
+                // pre-match to
+                // resolve the issue. The live lookup shows a started match:
+                // editMatchScore awaits its refresh.
                 setOpenKey(scoreKeyOf(nextActiveMatch));
-                if (nextActiveMatch.status === "scheduled") {
-                  try {
-                    await onEditScore(nextActiveMatch.compId, nextActiveMatch.id, startPatch(), nextActiveMatch);
-                    /* the live lookup shows the started match: editMatchScore awaits its refresh */
-                  } catch (_startErr) { /* gate rejected the start; stay on the next match in pre-match */ }
-                }
+                if (nextActiveMatch.status === "scheduled") await startNext(nextActiveMatch);
               } catch (_err) { /* keep modal open on error */ }
             } : null}
             onAfterDecision={nextActiveMatch ? async (result) => {
@@ -496,11 +606,12 @@ export function AdminScoreEditor({ t, c, onEditScore, onMoveCourt, restrictToCom
               // no next match does.
               const next = nextActiveFrom(sideBarredByDecision(result, openMatch));
               if (!next) { if (mountedRef.current) setOpenKey(null); return; }
+              // A refused start lands the operator on that match with the
+              // reason, as the court console does (startNext); a start that goes
+              // ahead opens it.
               if (next.status === "scheduled") {
-                try {
-                  await onEditScore(next.compId, next.id, startPatch(), next);
-                  if (mountedRef.current) setOpenKey(scoreKeyOf(next));
-                } catch (_startErr) { /* gate rejected the start; leave the operator where they are */ }
+                const started = await startNext(next);
+                if (started && mountedRef.current) setOpenKey(scoreKeyOf(next));
               }
             } : null}
             password={password}
diff --git a/web-mobile/js/admin_scoring_autosave.jsx b/web-mobile/js/admin_scoring_autosave.jsx
index 9a497be10..5390386fa 100644
--- a/web-mobile/js/admin_scoring_autosave.jsx
+++ b/web-mobile/js/admin_scoring_autosave.jsx
@@ -43,7 +43,7 @@ export function useChangedGroups(match) {
   const finished = !!(match && match.status === "completed");
   // The editor moving to another match starts over from that match.
   if (!stateRef.current || stateRef.current.key !== keyOf(match)) {
-    stateRef.current = { key: keyOf(match), seed: matchWire(match), agreed: {}, last: null, finished };
+    stateRef.current = { key: keyOf(match), seed: matchWire(match), agreed: {}, last: {}, finished };
   }
   // A reopen is a write the server makes, not one the editor builds, so no build
   // moves the result the editor agrees with off the finished one. Once the server
@@ -56,19 +56,44 @@ export function useChangedGroups(match) {
   // named no result for it: the server kept the match as it was, with no error.
   if (!finished && stateRef.current.finished) stateRef.current.agreed[GROUP_RESULT] = matchWire(match);
   stateRef.current.finished = finished;
-  return (patch) => {
+  // `agreed[g]` is the server value the editor last AGREED with for g; `last[g]` is
+  // the value it last built or took for g. Both are kept per group: a group a build
+  // did not state says nothing about it, and a group the editor took from the server
+  // is, from then on, the value its next edit is judged against.
+  const claim = (patch) => {
     if (!patch) return patch;
     const m = matchRef.current;
     const st = stateRef.current;
     const next = toBackendMatchResult(patch, m);
     const current = matchWire(m);
-    for (const g of statedGroupsOf(next)) {
+    const stated = statedGroupsOf(next);
+    for (const g of stated) {
       if (groupMatches(g, next, current, next)) st.agreed[g] = current;
     }
-    const changed = changedGroups(next, (g) => st.agreed[g] || st.seed, st.last);
-    st.last = next;
+    const changed = changedGroups(next, (g) => st.agreed[g] || st.seed, (g) => st.last[g]);
+    for (const g of stated) st.last[g] = next;
     return { ...patch, changed };
   };
+  // claim.agree(group): the editor ADOPTED the server's value for `group`, so it
+  // agrees with the match as it now stands and that is the value it last had for the
+  // group. The hook cannot see an adopt, and the baseline moves only at a build where
+  // the editor's own state equals the prop (above), so without this an edit that puts
+  // the group back to the value the editor mounted with was compared against that
+  // mount-time seed and not named (the server kept the other device's value), and an
+  // edit of something else was compared against the value of the group the editor last
+  // BUILT, found it different from the adopted one, and re-sent the adopted value under
+  // a newer stamp. The caller states which group it took, from inside the adopt's
+  // `apply` (a skipped adopt, an editor holding an edit over a newer value, agrees
+  // nothing), and only for the part it took, never from the latest prop alone (an edit
+  // the editor holds over a newer prop must stay a change). The property rides on the
+  // function so the editors that only claim are unchanged.
+  claim.agree = (group) => {
+    const st = stateRef.current;
+    const adopted = matchWire(matchRef.current);
+    st.agreed[group] = adopted;
+    st.last[group] = adopted;
+  };
+  return claim;
 }
 
 // ---------------------------------------------------------------------------
diff --git a/web-mobile/js/admin_scoring_engi.jsx b/web-mobile/js/admin_scoring_engi.jsx
index ac110dbb1..b6c6d87e1 100644
--- a/web-mobile/js/admin_scoring_engi.jsx
+++ b/web-mobile/js/admin_scoring_engi.jsx
@@ -24,6 +24,7 @@ const { useState: useStateE, useEffect: useEffectE, useRef: useRefE } = React;
 import { ReasonPrompt, CORRECTION_PRESETS, useAdoptFromServer, HeldWriteDiscard, HeldWriteNotice, useClearPendingWhenNothingHeld } from './admin_scoring_shared.jsx';
 import { SyncStatusPill, useDebouncedRunningWrite, useChangedGroups, useKeptInHistoryNote, KeptInHistoryNote } from './admin_scoring_autosave.jsx';
 import { MatchHistoryDisclosure } from './match_history_view.jsx';
+import { GROUP_FLAGS } from './match_groups.jsx';
 import { useEscapeToClose, confirmDialog } from './ui.jsx';
 // NumberedName: single owner of the number-chip-on-the-outer-side rule.
 import { NumberedName } from './numbered_name.jsx';
@@ -179,7 +180,7 @@ export function EngiScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext
   // for as long as the match is open.
   useAdoptFromServer({
     signature: `${initialFlagsA}:${initialFlagsB}`,
-    apply: () => { setFlagsA(initialFlagsA); setFlagsB(initialFlagsB); },
+    apply: () => { setFlagsA(initialFlagsA); setFlagsB(initialFlagsB); claimChanged.agree(GROUP_FLAGS); },
     keepLocalEdits: true,
     isDirty,
   });
diff --git a/web-mobile/js/admin_scoring_individual.jsx b/web-mobile/js/admin_scoring_individual.jsx
index 6cead828e..ac4d7acc0 100644
--- a/web-mobile/js/admin_scoring_individual.jsx
+++ b/web-mobile/js/admin_scoring_individual.jsx
@@ -58,6 +58,7 @@ import { isBarredMatch } from './ineligible_match.jsx';
 
 import { SyncStatusPill, useDebouncedRunningWrite, useChangedGroups, useKeptInHistoryNote, KeptInHistoryNote } from './admin_scoring_autosave.jsx';
 import { MatchHistoryDisclosure } from './match_history_view.jsx';
+import { GROUP_POINTS, GROUP_RESULT, GROUP_ENCHO, GROUP_REP } from './match_groups.jsx';
 
 // isKoTieBlocked: import-only, from the team editor's shared module. bc-rawm
 // reuses it here for the SAME tie rule (a knockout match cannot finish with
@@ -65,6 +66,11 @@ import { MatchHistoryDisclosure } from './match_history_view.jsx';
 import { TeamScoreEditorModal, isKoTieBlocked } from './admin_scoring_team.jsx';
 import { EngiScoreEditorModal } from './admin_scoring_engi.jsx';
 
+// A representative pick the operator made that the server does not hold (yet). An empty
+// pick never counts: the server keeps a stored name over "", so it would read unsaved
+// forever. The pick adopts below and the claimed change group both ask this.
+const repPickHeld = (pick, served) => pick !== "" && pick !== (served || "");
+
 export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, onAfterDecision, started = false, prevMatch, nextMatch, onPrev, onNext, password, selfReport, teamMembers, variant = "modal", canClose = true }) {
   // bc-strt: a match whose start has landed is RUNNING, even while the host's
   // list still says scheduled (it refetches a moment after each save). The
@@ -145,6 +151,13 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
   const [aFouls, setAFouls] = useStateA(initialAFouls);
   const [bFouls, setBFouls] = useStateA(initialBFouls);
   const [enchoPeriodCount, setEnchoPeriodCount] = useStateA(initialEnchoPeriods);
+  // The points group (the ippons and the outstanding fouls) as this editor holds it
+  // against as the server does. An adopt that does not take the points agrees them
+  // only while this is false (see the hantei adopt below).
+  const pointsEdited = !window.arraysEqual(aPts, initialAPts) ||
+    !window.arraysEqual(bPts, initialBPts) ||
+    aFouls !== initialAFouls ||
+    bFouls !== initialBFouls;
   // The verdict the SERVER holds right now. A match has ONE result and every
   // surface asking for it must show the same one, and this editor is such a
   // surface: while it is open, the viewer card, the bracket, the TV board and
@@ -172,7 +185,19 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
   const [hanteiPick, setHanteiPick] = useStateA(recordedHtKey);
   useAdoptFromServer({
     signature: JSON.stringify([hanteiRecorded, recordedHtKey]),
-    apply: () => { setDecidedByHantei(hanteiRecorded); setHanteiPick(recordedHtKey); },
+    apply: () => {
+      setDecidedByHantei(hanteiRecorded);
+      setHanteiPick(recordedHtKey);
+      // The verdict rides in the ippons (the Ht mark on the winner's side) and in the
+      // result (the winner), so adopting it is agreeing with both groups: cancelling
+      // it here must then be named, and the points are not re-sent as they stood. The
+      // adopt takes the verdict and not the points, so it agrees the points only while
+      // the editor holds the server's: with a point of ours still being saved, agreeing
+      // would put both baselines on a scoreline without it, and taking it back after
+      // its save landed would read as unchanged.
+      if (!pointsEdited) claimChanged.agree(GROUP_POINTS);
+      claimChanged.agree(GROUP_RESULT);
+    },
   });
   // Which side ("a"/"b"/"") holds a RECORDED hantei verdict, for the display
   // chip in the slot grid. Gated on the SERVER's verdict — not the local armed
@@ -222,6 +247,20 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
   // = Aka (sideA), repPlayerB = Shiro (sideB). Only rendered when m.repIsTeam.
   const [repPlayerA, setRepPlayerA] = useStateA(m.repPlayerA || "");
   const [repPlayerB, setRepPlayerB] = useStateA(m.repPlayerB || "");
+  // The two picks are ONE change group (GROUP_REP), and claim.agree moves both
+  // baselines to the server's value, so a side's adopt agrees the group only when BOTH
+  // sides then hold what the server holds: a pick of ours still being saved on the
+  // other side must stay a change, or its save landing would make putting it back look
+  // unchanged and the server would keep the other value. `repAfter` is each side's
+  // pick as this commit's adopts leave it: the render's own picks (refreshed by the
+  // effect below, which runs before the adopts), then the served pick of each side
+  // whose adopt has run, so the second adopt of one update sees the first.
+  const repAfter = useRefA({ a: "", b: "" });
+  useEffectA(() => { repAfter.current = { a: repPlayerA, b: repPlayerB }; });
+  const adoptRepPick = (side, served) => {
+    repAfter.current[side] = served;
+    if (!repPickHeld(repAfter.current.a, m.repPlayerA) && !repPickHeld(repAfter.current.b, m.repPlayerB)) claimChanged.agree(GROUP_REP);
+  };
   // Follow a pick made on another device, same rule as every other channel.
   //
   // The narrow reading first, because it bounds what this is worth: an UNSET
@@ -240,15 +279,15 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
   // the server keeps a name over "", so it would read unsaved forever.
   useAdoptFromServer({
     signature: m.repPlayerA || "",
-    apply: () => setRepPlayerA(m.repPlayerA || ""),
+    apply: () => { setRepPlayerA(m.repPlayerA || ""); adoptRepPick("a", m.repPlayerA || ""); },
     keepLocalEdits: true,
-    isDirty: repPlayerA !== "" && repPlayerA !== (m.repPlayerA || ""),
+    isDirty: repPickHeld(repPlayerA, m.repPlayerA),
   });
   useAdoptFromServer({
     signature: m.repPlayerB || "",
-    apply: () => setRepPlayerB(m.repPlayerB || ""),
+    apply: () => { setRepPlayerB(m.repPlayerB || ""); adoptRepPick("b", m.repPlayerB || ""); },
     keepLocalEdits: true,
-    isDirty: repPlayerB !== "" && repPlayerB !== (m.repPlayerB || ""),
+    isDirty: repPickHeld(repPlayerB, m.repPlayerB),
   });
   // doSubmit's setSubmitting(false) in finally fires post-await; if the
   // parent unmounts the modal during the in-flight save (e.g.
@@ -630,6 +669,11 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
     setBFouls(initialBFouls);
     setEnchoPeriodCount(initialEnchoPeriods);
     setIsDrawToggled(initialIsDrawToggled);
+    // The scoreline, the overtime count and the draw (the result's hikiwake) are taken
+    // from the server together, so the editor agrees with all three groups.
+    claimChanged.agree(GROUP_POINTS);
+    claimChanged.agree(GROUP_ENCHO);
+    claimChanged.agree(GROUP_RESULT);
   };
 
   // Arranged as [left, right]: left is always SHIRO (White), right is always AKA (Red).
@@ -793,10 +837,7 @@ export function ScoreEditorModal({ match, onClose, onSubmit, onSubmitAndNext, on
   // changes?" on an editor nobody touched trains operators to dismiss the one
   // prompt that protects real work.
   const isDirty =
-    !window.arraysEqual(aPts, initialAPts) ||
-    !window.arraysEqual(bPts, initialBPts) ||
-    aFouls !== initialAFouls ||
-    bFouls !== initialBFouls ||
+    pointsEdited ||
     isDrawToggled !== initialIsDrawToggled ||
     enchoPeriodCount !== initialEnchoPeriods ||
     decidedByHantei !== hanteiRecorded ||
diff --git a/web-mobile/js/admin_scoring_shared.jsx b/web-mobile/js/admin_scoring_shared.jsx
index a5902d149..e32d2a46f 100644
--- a/web-mobile/js/admin_scoring_shared.jsx
+++ b/web-mobile/js/admin_scoring_shared.jsx
@@ -1024,7 +1024,7 @@ function lineupListPlacement({ pin, foot, clip }, bar) {
   return { up, maxHeight };
 }
 
-function LineupNameInput({ value, roster, onSelect, onListPick, disabled, ariaLabel, color, clearable, inputId }) {
+function LineupNameInput({ value, roster, onSelect, onListPick, disabled, ariaLabel, color, clearable, inputId, placeholder = "Add player…" }) {
   const [query, setQuery] = useStateA("");
   const [open, setOpen] = useStateA(false);
   const [active, setActive] = useStateA(-1); // -1 = no explicit selection yet
@@ -1184,7 +1184,7 @@ function LineupNameInput({ value, roster, onSelect, onListPick, disabled, ariaLa
         <input
           id={inputId}
           className="pmf__input"
-          placeholder={value || "Add player…"}
+          placeholder={value || placeholder}
           aria-label={ariaLabel}
           disabled={disabled}
           value={open ? query : (value || "")}
diff --git a/web-mobile/js/admin_scoring_team.jsx b/web-mobile/js/admin_scoring_team.jsx
index eeac5faa6..f4056d9e9 100644
--- a/web-mobile/js/admin_scoring_team.jsx
+++ b/web-mobile/js/admin_scoring_team.jsx
@@ -51,6 +51,7 @@ import { isOlderRunningCopy } from './patch.jsx';
 
 import { useDebouncedRunningWrite, SyncStatusPill, useChangedGroups, useKeptInHistoryNote, KeptInHistoryNote } from './admin_scoring_autosave.jsx';
 import { MatchHistoryDisclosure } from './match_history_view.jsx';
+import { GROUP_ENCHO, GROUP_RESULT, GROUP_REP_PICK_A, GROUP_REP_PICK_B, boutGroup } from './match_groups.jsx';
 import { serverNowMs } from './server_clock.jsx';
 import { publishHeight } from './published_height.jsx';
 import { SideLabel, sideWithColour } from './side_cell.jsx';
@@ -143,7 +144,7 @@ export function preserveStoredDaihyosenVerdict({ armed, pickedSide, tied, existi
 // StreamingOverlay). The implementations live in lineup_resolver.jsx;
 // re-exported here so existing imports from admin_scoring_modal.jsx (which
 // re-exports them onward) continue to work.
-import { resolveMatchLineup, resolveLineupTeamId, resolveBoutSideName, resolveBoutSideMemberId, resolveSquadMember, squadMemberIdForUniqueName, squadRosterEntries, rosterWithoutPlacedElsewhere, resolveBoutSideDisplayName, buildInlineLineupWrite, memberRefusalNote, alreadyPlacedNote, lineupPositionLabel, POS_KEYS_5, POS_LABELS_5 } from './lineup_resolver.jsx';
+import { resolveMatchLineup, resolveLineupTeamId, resolveBoutSideName, resolveBoutSideMemberId, resolveSquadMember, squadMemberIdForUniqueName, squadRosterEntries, rosterWithoutPlacedElsewhere, resolveBoutSideDisplayName, buildInlineLineupWrite, resolveTypedMemberName, memberRefusalNote, alreadyPlacedNote, lineupPositionLabel, POS_KEYS_5, POS_LABELS_5 } from './lineup_resolver.jsx';
 // The one owner of what a lineup save carries: the one position a name-box pick changes.
 import { changedLineupSave } from './lineup_save.jsx';
 // The one owner of what a list of team members that arrives does to the members
@@ -675,6 +676,86 @@ export async function pickManualBoutName({ sub, idx, sideKey, memberIdKey, squad
   }
 }
 
+// The daihyosen row's slot key: the key the member resolver answers a representative
+// under, and the slot the sheet lists that row as (positions, below). It names the
+// representative's slot, not a lineup position, and no lineup holds it.
+const REPRESENTATIVE_KEY = "daihyosen";
+
+// pickDaihyosenRepresentative: the write behind a representative picked, typed or
+// cleared on the daihyosen row (bc-dhrp). It stores ONLY the side's member id
+// (`${side}MemberIdOverride`): the row's names stay the TEAM names, which placeHt
+// and the wire need, and no `${side}Name` is ever written for it. `member` is
+// the squad member the caller resolved -- a list pick, or the member a typed
+// name was found, minted or renamed to -- or null to clear the pick. There is no
+// lineup write here: "daihyosen" is not a lineup key.
+function pickDaihyosenRepresentative({ idx, side, updateSub }, member) {
+  const memberIdKey = `${side}MemberIdOverride`;
+  // A pick is an edit of that side's pick alone, not of the row (updateSub's repPickSide).
+  updateSub(idx, prev => ({ ...prev, [memberIdKey]: (member && member.id) || "" }), { repPickSide: side });
+}
+
+// The representative row (position -1) follows the server per PART, not per row
+// (bc-mrgc: the server orders a representative's picks apart from the bout row).
+// A part is the score (everything on the row but the picks) or one side's pick
+// (`aMemberIdOverride` / `bMemberIdOverride`). A pick the operator makes here is an
+// edit of that side's pick alone, so another device's point on the bout is still
+// shown, and a point struck here does not hold another device's pick.
+const REP_PICK_KEYS = ["aMemberIdOverride", "bMemberIdOverride"];
+
+// withoutRepPicks: the row's score part, as a string to compare.
+function withoutRepPicks(row) {
+  const rest = { ...row };
+  for (const key of REP_PICK_KEYS) delete rest[key];
+  return JSON.stringify(rest);
+}
+
+// rowTakenFromServer: does the adopt take the server's copy of a bout row (true), or keep
+// the operator's (false)? The ONE rule, asked both by the updater that rebuilds the board
+// and by the pass that tells useChangedGroups which rows were taken (a row taken is a row
+// the editor then agrees with; a row kept stays the operator's edit), so the two cannot
+// drift. `editedAt` is when the operator last edited the row here and `modifiedAt` the
+// match's stamp, both in the server's clock frame. With no local row there is nothing of
+// the operator's to keep. A snapshot written BEFORE the operator's last edit to the row
+// cannot know that edit, so the row stays theirs whatever it now equals (bc-kclr: striking
+// a point and taking it back returns the row to the value the server showed before the
+// strike, which would otherwise read as untouched). Otherwise a row that still equals what
+// the server last said (`prior`) has nothing of theirs in it.
+function rowTakenFromServer(local, prior, editedAt, modifiedAt) {
+  if (!local) return true;
+  if (editedAt !== undefined && (modifiedAt || 0) < editedAt) return false;
+  return !!prior && JSON.stringify(local) === JSON.stringify(prior);
+}
+
+// repRowTakes: which parts of the representative row the adopt takes from the server
+// (true) and which stay the operator's (false), each by the rule a whole row follows:
+// a snapshot written BEFORE the part's last edit here cannot know that edit (`stamps`,
+// in the server's clock frame, against the match's `modifiedAt`), and a part that
+// still equals what the server last said (`prior`) has nothing of the operator's in
+// it. `stamps` is { score, a, b }; a part never edited here has none. With no prior
+// row nothing is known to be untouched, so every part stays.
+function repRowTakes(local, prior, stamps, modifiedAt) {
+  const held = (stamp) => stamp !== undefined && (modifiedAt || 0) < stamp;
+  const pick = (side, key) => !held(stamps[side]) && !!prior && (local[key] || "") === (prior[key] || "");
+  return {
+    score: !held(stamps.score) && !!prior && withoutRepPicks(local) === withoutRepPicks(prior),
+    a: pick("a", REP_PICK_KEYS[0]),
+    b: pick("b", REP_PICK_KEYS[1]),
+  };
+}
+
+// composeRepRow: the representative row after the adopt, each part from the server's
+// row where `takes` says so and from the operator's otherwise. Either row keeps its
+// identity when every part comes from it, so an untouched board is not rebuilt.
+function composeRepRow(local, served, takes) {
+  if (takes.score && takes.a && takes.b) return served;
+  if (!takes.score && !takes.a && !takes.b) return local;
+  return {
+    ...(takes.score ? served : local),
+    [REP_PICK_KEYS[0]]: (takes.a ? served : local)[REP_PICK_KEYS[0]],
+    [REP_PICK_KEYS[1]]: (takes.b ? served : local)[REP_PICK_KEYS[1]],
+  };
+}
+
 // fusenshoSideFromSub: which side ("a" / "b" / "") a persisted fusensho sub-bout
 // was awarded to, for re-seeding the local editor state on a reopen or remount.
 // The winner is stored as the bout competitor's OWN name — for a KACHINUKI bout
@@ -961,7 +1042,6 @@ function useMatchLineups(compId, matchId) {
       sync.writing[side] += 1;
       const epoch = sync.epoch[side];
       return {
-        sideChanged: sync.watchSide(side),
         isRead: () => isRead(side),
         read: (teamId) => read(side, teamId),
         held: () => sync.held[side],
@@ -1133,12 +1213,12 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // sub-match" (handlers_daihyosen.go) but is NOT an individual victory: 
   // it breaks an IV/PW tie. Render it as a trailing scoreable row,
   // exclude it from the IV/PW tally, and let its winner decide the
-  // encounter. The "daihyosen" slot sentinel maps to DAIHYOSEN_POSITION in
+  // encounter. The REPRESENTATIVE_KEY slot maps to DAIHYOSEN_POSITION in
   // buildPatch. It is the ONLY team sub-bout that may carry encho/hantei
   // (validation.go validateSubBout).
   const existingDaihyosen = (m.subResults || []).find(s => s.position === DAIHYOSEN_POSITION);
   const hasDaihyosen = !!existingDaihyosen;
-  const positions = hasDaihyosen ? [...numberedPositions, "daihyosen"] : numberedPositions;
+  const positions = hasDaihyosen ? [...numberedPositions, REPRESENTATIVE_KEY] : numberedPositions;
   const daihyosenIdx = hasDaihyosen ? numberedPositions.length : -1;
   // FR-033: encho counter for team matches (overtime period count rides
   // alongside the score on the wire: same shape as ScoreEditorModal).
@@ -1163,7 +1243,13 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // does (its adopt below).
   useAdoptFromServer({
     signature: initialEnchoPeriods,
-    apply: () => setEnchoPeriodCount(initialEnchoPeriods),
+    apply: () => {
+      setEnchoPeriodCount(initialEnchoPeriods);
+      claimChanged.agree(GROUP_ENCHO);
+      // With a representative bout the count is read off its row and written on it, so
+      // taking the count is agreeing with that row too.
+      agreeRepBoutIfNotHeld();
+    },
     keepLocalEdits: true,
     isDirty: enchoPeriodCount !== initialEnchoPeriods,
   });
@@ -1264,6 +1350,29 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // given another team). A pick writes for the team the side has when it goes on, and
   // stops when the side was given another team since it began (watchLineupSide).
   const sideSeen = useRefA(null);
+  // The number of each side's latest representative pick (a list pick, a clear, or a
+  // typed name). A typed name still resolving when a newer pick is made on its side lands
+  // nothing (submitRepresentative), whichever answers first: the newer pick wins.
+  const repPickSeq = useRefA({ a: 0, b: 0 });
+  const newRepPick = (side) => ++repPickSeq.current[side];
+  // The representative bout leaving the sheet supersedes every pick typed on it, whichever
+  // device removed it (this one's own remove bumps both sides too: runRepBoutChange). A name
+  // still being resolved then lands nothing: no pick, no dirty mark, no autosave, and no row
+  // rebuilt by the updateSub of the render the name was typed in, which a bout added again
+  // would adopt over the server's fresh row. A layout effect, so the bump is in place at the
+  // commit that drops the row, before any answer resumed after it. Only the true-to-false
+  // edge counts: an added bout, or none on mount, supersedes nothing.
+  const hadDaihyosen = useRefA(hasDaihyosen);
+  useLayoutEffectA(() => {
+    if (hadDaihyosen.current && !hasDaihyosen) { newRepPick("a"); newRepPick("b"); }
+    hadDaihyosen.current = hasDaihyosen;
+  }, [hasDaihyosen]);
+  // How many typed representatives are still being named (submitRepresentative). A typed
+  // name is resolved by a member POST that may already have created the member when it
+  // answers, and the pick lands only while the sheet is mounted, so Finish, Save and
+  // Close wait for it. A counter, because the two sides can overlap.
+  const [repResolving, setRepResolving] = useStateA(0);
+  const repTyping = repResolving > 0;
   const showMembers = (side, list) => {
     membersShown.current[side] = list;
     (side === "a" ? setSquadA : setSquadB)(list);
@@ -1375,6 +1484,10 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     apply: () => {
       setDaihyosenHanteiArmed(daihyosenHanteiRecorded);
       setDaihyosenHantei(recordedDaihyosenSide);
+      // The verdict is the Ht mark on the representative bout's row and the winner the
+      // match gets from it, so adopting it is agreeing with both groups.
+      agreeRepBoutIfNotHeld();
+      claimChanged.agree(GROUP_RESULT);
     },
     keepLocalEdits: true,
     isDirty: daihyosenHantei !== recordedDaihyosenSide,
@@ -1399,6 +1512,13 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // and invisible on the wire. Hoisting the shared terms into this one const
   // makes that impossible: both callers see the same verdict-dirty answer by
   // construction.
+  //
+  // Only the VERDICT terms are shared. The two ROW halves differ on purpose:
+  // isDirty compares the whole board, so an unsaved representative pick is
+  // still unsaved work, while daihyosenTouched compares the row's score part
+  // through withoutRepPicks. A pick is its own change group (repPickA /
+  // repPickB, ordered by the server apart from the bout), so it must never
+  // un-silence the bout's scoreline.
   const daihyosenVerdictDirty =
     enchoPeriodCount !== initialEnchoPeriods ||
     daihyosenHantei !== recordedDaihyosenSide ||
@@ -1582,6 +1702,22 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   const giveSideAnotherTeam = (side) => {
     dropSideMembers(side);
     dropLineup(side);
+    newRepPick(side);
+    // The representative the side picked is a member of the team it no longer has, so the
+    // pick is dropped and the sheet stops sending that member's id. Only a pick the row
+    // holds is dropped, and it is dropped the server-following way (setSubs, not
+    // updateSub): no operator-edit stamp, no dirty mark, no autosave, and an armed Finish
+    // stays armed, since the operator changed nothing. A pick the server holds arrives
+    // cleared by the push that seats the new team, in the same update, so the board
+    // already agrees. A pick made HERE and not yet written is one the server never
+    // received and cannot clear, so this is the only place it goes. Either way the side's
+    // pick-part edit stamp goes with it: whatever was edited was about the old team, and
+    // the adopt takes the server's value for the side again.
+    lastRepPickEditRef.current[side] = undefined;
+    if (daihyosenIdx >= 0 && subs[daihyosenIdx]?.[`${side}MemberIdOverride`]) {
+      const memberKey = `${side}MemberIdOverride`;
+      setSubs(prev => reconcileRowsToPositions(prev, serverSubs).map((s, i) => i === daihyosenIdx ? { ...s, [memberKey]: "" } : s));
+    }
   };
   useEffectA(() => {
     const was = sideSeen.current;
@@ -1850,6 +1986,24 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     throw new Error(LINEUP_NOT_READ_NOTICE);
   };
 
+  // Posts a lineup notice under one bout row's key (lineupNoticeKey), unless the sheet
+  // has closed. Every pick path that reports into a row goes through it.
+  const lineupNotifier = (noticeKey) => (tone, text) => {
+    if (mountedRef.current) setLineupNotice({ key: noticeKey, tone, text });
+  };
+  // Asked where a pick waits on the server, as it began: true, with SIDE_TEAM_CHANGED_NOTICE
+  // posted under the row, once the side has been given another team since (watchLineupSide).
+  // Nothing is written for a team the side no longer carries.
+  const sideChangedGuard = (side, noticeKey) => {
+    const sideChanged = watchLineupSide(side);
+    const notify = lineupNotifier(noticeKey);
+    return () => {
+      if (!sideChanged()) return false;
+      notify("error", SIDE_TEAM_CHANGED_NOTICE);
+      return true;
+    };
+  };
+
   // Submit an inline position change: resolves/mints that position's member id
   // (see buildInlineLineupWrite), checks the lineup held for the side is not given
   // the member twice, then PUTs the one position it changes, named in `changed`
@@ -1860,10 +2014,11 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // undefined for a typed/"+ Add" name, and buildInlineLineupWrite writes
   // by id rather than resolving by name when it is present.
   const submitInlineLineup = async ({ side, noticeKey, posKey, value, member }) => {
-    const notify = (tone, text) => { if (mountedRef.current) setLineupNotice({ key: noticeKey, tone, text }); };
+    const notify = lineupNotifier(noticeKey);
     setLineupNotice(null);
     // The name is typed for the team that plays this side as the pick begins.
     const write = beginLineupWrite(side);
+    const sideChanged = sideChangedGuard(side, noticeKey);
     setInlineLineupSaving(true);
     try {
       // A typed name is resolved against the side's members, so they must have been
@@ -1882,11 +2037,6 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
       // another team's; again once it has been, which can take as long as the wait; and
       // again once the member writes are done. Those stay: they are what was typed for
       // the old team, and its own members.
-      const sideChanged = () => {
-        if (!write.sideChanged()) return false;
-        notify("error", SIDE_TEAM_CHANGED_NOTICE);
-        return true;
-      };
       if (sideChanged()) return;
       // The team as the sheet knows it now, not as it was when the pick began: a side
       // that carried only a name then can have been named by the roster meanwhile (the
@@ -1944,6 +2094,58 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     }
   };
 
+  // The representative typed on a daihyosen row (bc-dhrp). The name goes through the
+  // SAME resolver a numbered row's typed name goes through (resolveTypedMemberName,
+  // lineup_resolver.jsx: a name the team already has, else the blank member the pick
+  // holds, else a new member), under the guards submitInlineLineup keeps: the members
+  // are read first (membersWait), a side given another team is not written for, the
+  // members the resolver answers are shown, and a members list that could not be read
+  // is warned about in the row. No lineup is written: the REPRESENTATIVE_KEY slot is no
+  // lineup position. Only the resulting member id is stored on the row.
+  const resolveRepresentative = async ({ side, noticeKey, idx, value, priorId, seq }) => {
+    const notify = lineupNotifier(noticeKey);
+    const sideChanged = sideChangedGuard(side, noticeKey);
+    // A newer pick on this side (a list pick, a clear or another typed name) makes this one
+    // stale: it applies nothing and says nothing (the newer pick wins). The members the
+    // resolver wrote on the server are still merged, since they exist whatever pick follows.
+    const superseded = () => repPickSeq.current[side] !== seq;
+    let membersUnavailable = squadUnavailable;
+    const waiting = membersWait.current[side].pending();
+    if (waiting && !(await waiting)) membersUnavailable = true;
+    // An editor closed while the members were read (the court console moving on re-keys it)
+    // names no one: the resolver would POST a member nobody picked, and the pick lands nowhere.
+    if (!mountedRef.current || sideChanged() || superseded()) return;
+    const teamId = sideSeen.current[side].team;
+    const typed = await resolveTypedMemberName(m.compId, teamId, REPRESENTATIVE_KEY, value, membersShown.current[side], password, { [REPRESENTATIVE_KEY]: priorId });
+    if (!mountedRef.current || sideChanged()) return;
+    if (typed.resolverMissing) {
+      if (!superseded()) notify("error", `"${value}" could not be named: the team members are not loaded. Try again in a moment.`);
+      return;
+    }
+    wroteSideMembers(side, typed.squad);
+    if (superseded()) return;
+    if (!typed.memberId) {
+      const failure = typed.failures[0];
+      notify("error", `"${value}" was not picked as the representative. ${memberRefusalNote({ code: failure?.code, reason: failure?.reason }, "Pick one from the list instead.")}`);
+      return;
+    }
+    const member = typed.squad.find(mem => mem && mem.id === typed.memberId) || { id: typed.memberId };
+    pickDaihyosenRepresentative({ idx, side, updateSub }, member);
+    // No lineup is saved here, so the lineup's own warning ("Lineup saved, but...")
+    // would be false: say what an unread member list can actually have done.
+    if (membersUnavailable) notify("warn", `"${value}" was picked, but the team member list could not be read first, so they may have been added as a new team member. ${selfReport ? "Ask the tournament organizer to check the team." : "Check the team on the Lineups page."}`);
+  };
+  // A typed representative is named by resolveRepresentative, counted in repResolving for as
+  // long as it is out (Finish, Save and Close wait on it: see repResolving above).
+  const submitRepresentative = async (pick) => {
+    setRepResolving(n => n + 1);
+    try {
+      await resolveRepresentative(pick);
+    } finally {
+      if (mountedRef.current) setRepResolving(n => n - 1);
+    }
+  };
+
   // Shared factory (admin_scoring_shared.jsx): same handler as ScoreEditorModal.
   // Item 7: fusenpai routes through onAfterDecision (host-supplied) to advance
   // the court, same as ScoreEditorModal. Kiken follows the same rule now too
@@ -2013,6 +2215,13 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
         // persisted sub so re-opens keep the overtime marker. The daihyosen
         // row's encho is handled separately (daihyosenEnchoFields).
         encho: idx === daihyosenIdx ? 0 : (existing?.encho?.periodCount || 0),
+        // bc-dhrp: the representative bout's picks start from the stored row, so a
+        // saved pick is the editor's own value and round-trips. Numbered rows carry
+        // no such keys.
+        ...(idx === daihyosenIdx ? {
+          aMemberIdOverride: existing?.sideAMemberId || "",
+          bMemberIdOverride: existing?.sideBMemberId || "",
+        } : {}),
       };
   };
   // The LIVE baseline: what the SERVER currently holds for every visible
@@ -2032,6 +2241,18 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // RENDER-SYNCHRONOUS because this very render already indexes subs for the
   // new positions — an effect would run after the crash.
   const subs = reconcileRowsToPositions(subsRaw, serverSubs);
+  // The representative bout's row is one group (bout:-1) for the score, the overtime
+  // count and the Ht verdict. Taking the count or the verdict from the server agrees with
+  // that row, unless this board holds an unsaved edit of the row's score: the row follows
+  // the server per part (repRowTakes), and those adopts take no score. The per-row adopt
+  // below agrees with the row when it takes the score itself. Called from the adopts
+  // declared above, at effect time, when this render's boards are all declared.
+  const agreeRepBoutIfNotHeld = () => {
+    if (daihyosenIdx < 0) return;
+    const shown = subs[daihyosenIdx];
+    const served = serverSubs[daihyosenIdx];
+    if (shown && served && withoutRepPicks(shown) === withoutRepPicks(served)) claimChanged.agree(boutGroup(DAIHYOSEN_POSITION));
+  };
   // Two kinds of write reach `subs`, and one arming rule has to tell them
   // apart: the OPERATOR editing (which disarms Finish/End and closes an open
   // reason prompt, because what they were about to confirm has changed under
@@ -2047,6 +2268,10 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // the server's clock frame, server_clock.jsx), read by the per-row adopt
   // below.
   const lastRowEditRef = useRefA(new Map());
+  // The same, per SIDE, for the representative row's picks: a pick is an edit of that
+  // side's pick alone, so it stamps here and not on the row (updateSub's repPickSide).
+  // The row's own entry in lastRowEditRef is then the score part's.
+  const lastRepPickEditRef = useRefA({});
   // C1: updateSub is the single choke-point for all sub-bout state
   // mutations. Calling markScoringDirty() here captures every edit
   // (pts add/remove, fouls, fusensho, draw) without repetition.
@@ -2060,8 +2285,12 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // shows from the refused tap until the operator next edits any bout row, so
   // re-entering the points that caused the refusal does not bring it back
   // untapped. The server re-seed never comes through here (it uses setSubs).
-  const updateSub = (idx, fn) => {
-    lastRowEditRef.current.set(subs[idx]._pos, serverNowMs());
+  // `opts.repPickSide` ("a" / "b") says the edit is that side's representative pick on the
+  // representative row: it stamps the pick part, and every other edit of the row the score
+  // part, because the adopt follows the server for each part on its own.
+  const updateSub = (idx, fn, opts) => {
+    if (idx === daihyosenIdx && opts?.repPickSide) lastRepPickEditRef.current[opts.repPickSide] = serverNowMs();
+    else lastRowEditRef.current.set(subs[idx]._pos, serverNowMs());
     setSubsByOperator(prev => {
       const rows = reconcileRowsToPositions(prev, serverSubs);
       return rows.map((s, i) => i === idx ? fn(s) : s);
@@ -2219,7 +2448,18 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     match: m,
     enabled: !isKachinuki,
     held: pendingWrite,
-    onUndo: () => { setSubs(serverSubs); setFinishRefused(false); },
+    onUndo: () => {
+      setSubs(serverSubs);
+      setFinishRefused(false);
+      // The whole board is the server's again, so the editor agrees with every row
+      // and with both representative picks, which ride the board as their own
+      // groups: left unagreed, a pick built into an earlier write that has not
+      // echoed back would still be what the next build is compared against, and
+      // that build would name the group again under a newer stamp.
+      for (const ss of serverSubs) claimChanged.agree(boutGroup(ss._pos));
+      claimChanged.agree(GROUP_REP_PICK_A);
+      claimChanged.agree(GROUP_REP_PICK_B);
+    },
     onReset: () => setFinishRefused(false),
   });
   const withdrawalWinner = rulingShown ? ({ a: "b", b: "a" }[withdrawnKeyOf(m)] || null) : null;
@@ -2346,7 +2586,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // kachinukiCurrentBoutPlayed and kachinukiCurBoutPos below are pure
   // functions of it.
   const kachinukiCurBoutIdx = kachinukiBoutMode
-    ? (() => { const cur = visiblePositions.find(p => p !== "daihyosen"); return cur != null ? positions.indexOf(cur) : -1; })()
+    ? (() => { const cur = visiblePositions.find(p => p !== REPRESENTATIVE_KEY); return cur != null ? positions.indexOf(cur) : -1; })()
     : -1;
   // UX guard: Record bout with nothing entered for the current bout would
   // submit a silent no-op (known quirk Q4: the glossary term inside the
@@ -2683,6 +2923,10 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     const sideIdentity = (key) => {
       const name = override[`${key}Name`] || "";
       const pickedId = override[`${key}MemberIdOverride`] || "";
+      // bc-dhrp: the representative bout's identity is the operator's pick alone.
+      // Falling through would hand back the STORED id, or the team name, once the
+      // pick was cleared, and the row would show or write it again.
+      if (isDaihyoRow) return { name: "", memberId: pickedId };
       if (pickedId) return { name, memberId: pickedId };
       const lineup = key === "a" ? lineupA : lineupB;
       const existingName = key === "a" ? existing?.sideA : existing?.sideB;
@@ -2716,6 +2960,21 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     return member ? squadMemberLabel(teamNumber, member.index) : "";
   };
 
+  // The History disclosure's member resolver (match_history_view.jsx pickText): a
+  // representative pick is stored as a member id, and this sheet holds both teams'
+  // members, so the history can name the representative. The member's name, else its
+  // label (squadMemberLabel, as the rows show); null for an id the side's team does not
+  // hold now (a correction seated another team); undefined while the team's members have
+  // not been read, when the history says only that the side was picked. "a" is AKA,
+  // squadA, m.sideA.
+  const historyMemberLabel = (side, memberId) => {
+    const squad = side === "a" ? squadA : squadB;
+    if (!Array.isArray(squad) || squad.length === 0) return undefined;
+    const member = squad.find(mem => mem && mem.id === memberId);
+    if (!member) return null;
+    return member.name || squadLabelFor(side, memberId);
+  };
+
   // slotLabelFor: the fallback label for a NUMBERED fixed-order position
   // whose fighter has not resolved to a squad member yet (squadLabelFor
   // above returns "" in that case). bc-dnst (operator ruling 2026-09-15):
@@ -2942,11 +3201,17 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     // replay saving an unrelated bout) erased that verdict on its next save,
     // indistinguishable on the wire from an operator actually cancelling it.
     // A row is genuinely silent only when BOTH halves hold: the operator has
-    // not moved it away from what the SERVER holds (including the hantei
+    // not moved its SCORE part away from what the SERVER holds (the row
+    // without the two representative picks, `withoutRepPicks`, plus the hantei
     // arm/pick and the daihyosen encho counter) AND nothing about it is known
     // locally either (no recorded verdict, no scored points/fouls/draw, no
-    // overtime). An editor that mounted AFTER a verdict/score existed is not
-    // silent even if untouched - it is re-stating what it was shown, which is
+    // overtime). A representative pick is not part of that score part: it is
+    // its own change group (repPickA / repPickB, ordered by the server apart
+    // from the bout), so a pick on a bout nobody has scored must leave the
+    // scoreline unstated, or the write would stamp the bout and a device that
+    // had not yet seen a point struck elsewhere would erase it. An editor that
+    // mounted AFTER a verdict/score existed is not silent even if untouched -
+    // it is re-stating what it was shown, which is
     // the existing, correct behaviour (daihyosenEnchoFields below re-derives
     // and re-sends it). The first half compares against the live server
     // baseline, not a mount-time snapshot, so it now agrees with
@@ -2960,7 +3225,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
     // pre-gate explicit-[] behaviour (not a regression this change
     // introduces), not a gap this gate closes.
     const daihyosenTouched = hasDaihyosen && (
-      JSON.stringify(subs[daihyosenIdx]) !== JSON.stringify(serverSubs[daihyosenIdx]) ||
+      withoutRepPicks(subs[daihyosenIdx]) !== withoutRepPicks(serverSubs[daihyosenIdx]) ||
       daihyosenVerdictDirty
     );
     const daihyosenKnownLocally = hasDaihyosen && (
@@ -3005,22 +3270,14 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
       // apart. Consumed by state.SubBoutWinnerSide for IV. Empty when the
       // row's own id is unknown (a typed-name override, or a bout the server
       // has not paired yet), which leaves the server's name derivation to
-      // answer exactly as before. Kachinuki only: a fixed-format bout row
-      // names the TEAMS, which are unique by rule.
+      // answer exactly as before. Kachinuki and the representative bout only: a
+      // fixed-format bout row names the TEAMS, which are unique by rule.
       let winnerMemberId = "", sideAMemberId = "", sideBMemberId = "";
+      // playerNamesForBout is a pure lookup, read once for the two rows that carry
+      // fighters: a kachinuki bout's fighters, and the representative's own pick.
+      const fighters = isKachinuki || isDaihyo ? playerNamesForBout(idx) : null;
       if (isKachinuki && !isDaihyo) {
-        const { aName, bName, aMemberId, bMemberId } = playerNamesForBout(idx);
-        ({ sideA, sideB, winner } = resolveKachinukiBoutSides({ aName, bName, wKey, teamWinnerName }));
-        // The two SIDE ids travel with the winner's, because the winner id
-        // alone settles nothing: every consumer compares it against these two,
-        // so a row carrying one and not the others is read exactly like a row
-        // carrying none. The server stamps them when IT appends a pairing,
-        // but the first bout of an encounter is built here, and a browser run
-        // on a real same-name pairing is what showed that gap -- the unit
-        // fixtures had hand-written all three.
-        sideAMemberId = aMemberId || "";
-        sideBMemberId = bMemberId || "";
-        if (winner) winnerMemberId = (wKey === "a" ? aMemberId : wKey === "b" ? bMemberId : "") || "";
+        ({ sideA, sideB, winner } = resolveKachinukiBoutSides({ aName: fighters.aName, bName: fighters.bName, wKey, teamWinnerName }));
       } else {
         // A fixed-order (or daihyosen) bout settles at the MATCH level, so the
         // row records no per-fighter identity: the winner is the team, and the
@@ -3049,6 +3306,19 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
         sideB = isDaihyo ? sideBName : "";
         winner = teamWinnerName;
       }
+      // The two SIDE ids travel with the winner's, because the winner id
+      // alone settles nothing: every consumer compares it against these two,
+      // so a row carrying one and not the others is read exactly like a row
+      // carrying none. The server stamps them when IT appends a pairing,
+      // but the first bout of an encounter is built here, and a browser run
+      // on a real same-name pairing is what showed that gap -- the unit
+      // fixtures had hand-written all three. On the representative row they
+      // are the operator's picks (bc-dhrp), beside the team names above.
+      if (fighters) {
+        sideAMemberId = fighters.aMemberId || "";
+        sideBMemberId = fighters.bMemberId || "";
+        if (winner) winnerMemberId = (wKey === "a" ? fighters.aMemberId : wKey === "b" ? fighters.bMemberId : "") || "";
+      }
       const entry = {
         position: isDaihyo ? DAIHYOSEN_POSITION : idx + 1,
         sideA,
@@ -3060,11 +3330,17 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
         winner,
         decision,
       };
-      // Omitted, not stated empty: an absent key leaves the stored id and the
-      // server's own derivation untouched, which is what "this writer knows
-      // no id" has to mean. A typed-name override resolves to no id at all
-      // (playerNamesForBout short-circuits it), so a substitution never sends
-      // the replaced fighter's id under the new name.
+      // Omitted, not stated empty. On a numbered row an absent key leaves the
+      // stored id and the server's own derivation untouched, which is what "this
+      // writer knows no id" has to mean. On the representative row an absent id
+      // is how a CLEARED pick is sent, by naming that side's pick group: the write
+      // carries that row, so statedGroups adds repPickA and repPickB
+      // (match_groups.jsx) and groupKey reads an absent id as empty. The server
+      // copies the bout row WITHOUT the picks (CopyGroup keeps the destination's)
+      // and moves each side's pick as its own group, so an id left off the row
+      // clears the stored one only when that side's group is named. A typed-name
+      // override resolves to no id at all (playerNamesForBout short-circuits it), so
+      // a substitution never sends the replaced fighter's id under the new name.
       if (sideAMemberId) entry.sideAMemberId = sideAMemberId;
       if (sideBMemberId) entry.sideBMemberId = sideBMemberId;
       if (winnerMemberId) entry.winnerMemberId = winnerMemberId;
@@ -3349,6 +3625,12 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // bout log and stays open (operator decision 2026-09-27).
   const runRepBoutChange = async ({ preSave, send, refusals, notDone }) => {
     setEditorErr("");
+    // A typed representative still being named answers for the row this change moves: its
+    // answer must land nothing on whatever row is then the daihyosen. Both sides' picks are
+    // superseded here (the newer pick wins). Add and Remove are disabled while one is out
+    // (repTyping), so this is the backstop, not the usual path.
+    newRepPick("a");
+    newRepPick("b");
     setDaihyosenBusy(true);
     const settle = holdScoringWrite();
     try {
@@ -3404,7 +3686,10 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   // One serialisation, read three times (isDirty, the adopt signature, and the
   // per-row merge below). This editor re-renders on every SSE broadcast for the
   // competition, so serialising the same board once per consumer was pure
-  // repetition on the busiest path in the file.
+  // repetition on the busiest path in the file. isDirty compares the local board
+  // with the server board itself, so a representative pick the sheet dropped when its
+  // side was given another team (giveSideAnotherTeam) is no unsaved change once the
+  // server board no longer holds it.
   const serverSubsSig = JSON.stringify(serverSubs);
   const isDirty = JSON.stringify(subs) !== serverSubsSig || daihyosenVerdictDirty
     // A removed withdrawal is unsaved until Save correction sends it.
@@ -3455,30 +3740,50 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
       // untouched row would read as edited, keep its stale value, and be
       // written back over the server's by the next save.
       const priorByPos = new Map((prevServerSubsRef.current || []).map(s => [s._pos, s]));
+      // The representative row follows the server per PART (repRowTakes): the score
+      // and each side's pick are separate, so a pick made here does not hold another
+      // device's point on the bout, and a point struck here does not hold another
+      // device's pick. Decided HERE from the board this render showed, not inside the
+      // updater: whether a pick was taken is told to useChangedGroups below, and an
+      // updater may run a render later or twice. The kept parts are composed from the
+      // updater's own `prev` row, so a pick giveSideAnotherTeam dropped meanwhile is not
+      // put back.
+      const dhServed = daihyosenIdx >= 0 ? serverSubs[daihyosenIdx] : null;
+      const dhShown = daihyosenIdx >= 0 ? subs[daihyosenIdx] : null;
+      const repTakes = dhServed && dhShown
+        ? repRowTakes(dhShown, priorByPos.get(DAIHYOSEN_POSITION), {
+          score: lastRowEditRef.current.get(DAIHYOSEN_POSITION),
+          a: lastRepPickEditRef.current.a,
+          b: lastRepPickEditRef.current.b,
+        }, m.modifiedAt)
+        : null;
       setSubs(prev => {
         const localByPos = new Map(prev.map(s => [s._pos, s]));
         return serverSubs.map(ss => {
           const local = localByPos.get(ss._pos);
           if (!local) return ss;
-          // bc-kclr: a snapshot written BEFORE the operator's last edit to
-          // this row cannot know that edit, so the row stays theirs, whatever
-          // it now equals. Striking a point and taking it back returns the
-          // row to the value the server showed BEFORE the strike, so the
-          // untouched test below read it as untouched, and the court feed's
-          // lagging snapshot carrying the autosaved point was adopted over
-          // the clear (and written back). Once a snapshot written after the
-          // edit arrives (this editor's own save of it, or a later change on
-          // another device) the ordinary rule applies. Both stamps are in the
-          // server's clock frame (server_clock.jsx), so no time window.
-          const editedAt = lastRowEditRef.current.get(ss._pos);
-          if (editedAt !== undefined && (m.modifiedAt || 0) < editedAt) return local;
-          const prior = priorByPos.get(ss._pos);
-          // Untouched: the operator's row still equals what the server last
-          // said, so there is nothing of theirs to keep — take the new value.
-          if (prior && JSON.stringify(local) === JSON.stringify(prior)) return ss;
-          return local;
+          if (repTakes && ss._pos === DAIHYOSEN_POSITION) return composeRepRow(local, ss, repTakes);
+          // bc-kclr: a snapshot written BEFORE the operator's last edit to this row
+          // cannot know that edit, so the row stays theirs (rowTakenFromServer).
+          return rowTakenFromServer(local, priorByPos.get(ss._pos), lastRowEditRef.current.get(ss._pos), m.modifiedAt) ? ss : local;
         });
       });
+      // What this editor took from the server it now agrees with, so an edit that puts it
+      // back to what the editor mounted with (clearing a pick or a bout another device
+      // made) is still a change and is named, and an edit of something else does not name
+      // it again. What it kept is the operator's own edit and stays one, so each row, and
+      // each side's pick, is agreed on its own. The same rule as the updater above
+      // (rowTakenFromServer, repRowTakes), asked of THIS render's board here, for the same
+      // reason as repTakes: an updater may run a render later or twice.
+      const shownByPos = new Map(subs.map(s => [s._pos, s]));
+      for (const ss of serverSubs) {
+        const taken = repTakes && ss._pos === DAIHYOSEN_POSITION
+          ? repTakes.score
+          : rowTakenFromServer(shownByPos.get(ss._pos), priorByPos.get(ss._pos), lastRowEditRef.current.get(ss._pos), m.modifiedAt);
+        if (taken) claimChanged.agree(boutGroup(ss._pos));
+      }
+      if (repTakes && repTakes.a) claimChanged.agree(GROUP_REP_PICK_A);
+      if (repTakes && repTakes.b) claimChanged.agree(GROUP_REP_PICK_B);
       // Keep the correction baseline in step. It snapshots who won the bout
       // being corrected so renderCorrectionWarning can say "you changed who won
       // bout N"; left alone across a re-seed it would compare the SERVER's new
@@ -3508,7 +3813,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
   const leaveEditor = async (go) => {
     // Same contract as ScoreEditorModal: never close while a save,
     // decision, or daihyosen request is mid-flight.
-    if (submitting || decisionSubmitting || daihyosenBusy) return;
+    if (submitting || decisionSubmitting || daihyosenBusy || repTyping) return;
     // bc-dscn: on a RUNNING match every scoring edit is autosaved, and the
     // unmount writes one still inside the debounce window
     // (useDebouncedRunningWrite), so leaving discards nothing and asks
@@ -3632,7 +3937,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                 {isComplete ? "CORRECTION" : "PRE-MATCH"}
               </div>
             )}
-            {canClose && <button className="btn btn--ghost btn--sm" onClick={handleDismiss} disabled={submitting} style={{ padding: "2px 8px" }}>✕ Close</button>}
+            {canClose && <button className="btn btn--ghost btn--sm" onClick={handleDismiss} disabled={submitting || repTyping} style={{ padding: "2px 8px" }}>✕ Close</button>}
           </div>
         </div>
 
@@ -3916,12 +4221,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
               // A rename waits on the server, and the side can be given another team
               // meanwhile: the member it names is then the old team's, which is not put in
               // the new team's list nor reported in its row (submitInlineLineup's rule).
-              const sideChanged = watchLineupSide(side);
-              const sideChangedNotice = () => {
-                if (!sideChanged()) return false;
-                setLineupNotice({ key: noticeKey, tone: "error", text: SIDE_TEAM_CHANGED_NOTICE });
-                return true;
-              };
+              const sideChangedNotice = sideChangedGuard(side, noticeKey);
               return pickManualBoutName({
                 sub: s, idx, sideKey: `${side}Name`, memberIdKey: `${side}MemberIdOverride`, squad, teamId,
                 compId: m.compId, password, updateSub,
@@ -3974,7 +4274,41 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
             // never disagree on it.
             const manualPathB = isManualRow || kachinukiPastFirst || freeNameB;
             const manualPathA = isManualRow || kachinukiPastFirst || freeNameA;
+            // bc-dhrp: the representative bout's picker (submitRepresentative). It is
+            // offered whenever the row is open to this viewer: a participant's sheet
+            // (selfReport) offers it only while the match runs, and the judges'
+            // decision on the row locks it (repBoutDecidedForParticipant). Its roster
+            // is the team's whole squad: a representative is usually fielded at a
+            // numbered position already, so the placed-elsewhere filter does not apply.
+            const repPickable = isDaihyoRow && !repBoutDecidedForParticipant && (!selfReport || m.status === "running");
+            const repRosterFor = (side, lineup, squad) => (repPickable ? rosterForSide(side, lineup, squad) : []);
+            // A list pick is the member itself; a typed name is resolved (submitRepresentative);
+            // a box cleared empties the pick. Nothing here writes a lineup.
+            const pickRepresentative = (side, noticeKey, priorId) => (value, member) => {
+              setLineupNotice(null);
+              const seq = newRepPick(side);
+              if (member && member.id) { pickDaihyosenRepresentative({ idx, side, updateSub }, member); return; }
+              if (!value) { pickDaihyosenRepresentative({ idx, side, updateSub }, null); return; }
+              submitRepresentative({ side, noticeKey, idx, value, priorId, seq });
+            };
+
+            // One picker per side: the representative row's (bc-dhrp: the team's whole squad,
+            // and a pick writes the representative's id) or the bout row's (lineup, manual
+            // or free name). Its roster, box visibility and handler are derived together, so
+            // they cannot disagree on which path a side takes.
+            const pickerB = isDaihyoRow
+              ? { roster: repRosterFor(m.sideB, lineupB, squadB), forceInput: repPickable, onSelectName: pickRepresentative("b", noticeKeyB, s.bMemberIdOverride) }
+              : { roster: rosterB, forceInput: manualPathB, onSelectName: manualPathB ? pickManual("b", noticeKeyB, squadB, teamBId) : pickPlayer("b", noticeKeyB) };
+            const pickerA = isDaihyoRow
+              ? { roster: repRosterFor(m.sideA, lineupA, squadA), forceInput: repPickable, onSelectName: pickRepresentative("a", noticeKeyA, s.aMemberIdOverride) }
+              : { roster: rosterA, forceInput: manualPathA, onSelectName: manualPathA ? pickManual("a", noticeKeyA, squadA, teamAId) : pickPlayer("a", noticeKeyA) };
 
+            // The read-only representative row (no picker: repPickable is false, as a
+            // participant's sheet is once decided or not running) names an unpicked side by
+            // its team, as the read-only scoreboards do (resolveBoutSideName's daihyosen rule).
+            // A pickable box keeps its "Representative" placeholder, and a picked side shows
+            // its representative. Display only: buildPatch sends what it always has.
+            const repTeamWhenUnpicked = (memberId, teamName) => (isDaihyoRow && !repPickable && !memberId ? teamName : "");
             // Each row: [left side, center score, right side]: left=SHIRO, right=AKA
             // T096/FR-031: manual pts/fouls edits end the per-bout fusensho
             // (updateSubScore: the default-win circles go, struck points stay,
@@ -4006,8 +4340,8 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                 // The daihyosen is a representative bout, not a lineup position:
                 // "daihyosen" is not a valid lineup key (domain/team_lineup.go
                 // accepts only senpo/… or "1".."N"), so a name pick there would
-                // 4xx. Suppress the picker by passing an empty roster (the input
-                // only renders when roster.length > 0).
+                // 4xx, so the picker here writes the representative's member id
+                // instead (submitRepresentative).
                 // bc-dnst: playerName is the DISPLAYED name only -- a rename
                 // reaches a bout already fought via resolveBoutSideDisplayName
                 // (id-first against the current squad), while playerBName
@@ -4016,12 +4350,11 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                 // name untouched. This covers both the live LineupNameInput's
                 // `value` and the read-only static row, which both render
                 // from this same prop.
-                playerName: resolveBoutSideDisplayName({ squad: squadB, memberId: playerBMemberId, storedName: playerBName }),
+                playerName: resolveBoutSideDisplayName({ squad: squadB, memberId: playerBMemberId, storedName: playerBName }) || repTeamWhenUnpicked(playerBMemberId, sideBName),
                 memberId: playerBMemberId,
-                memberLabel: playerBLabel, roster: isDaihyoRow ? [] : rosterB, forceInput: manualPathB,
+                memberLabel: playerBLabel, ...pickerB,
                 noticeKey: noticeKeyB,
                 lineupSlot: !isDaihyoRow && idx + 1 <= teamSize,
-                onSelectName: manualPathB ? pickManual("b", noticeKeyB, squadB, teamBId) : pickPlayer("b", noticeKeyB),
               },
               {
                 key: "a", tapKey: `${idx}:a`, pts: s.aPts, fouls: s.aFouls,
@@ -4032,14 +4365,13 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                   return { ...prev, aFouls: r.fouls, bPts: r.opponentPts };
                 }),
                 color: "aka", label: "AKA",
-                // See SHIRO note above: no lineup picker on the daihyosen row.
+                // See SHIRO note above.
                 // bc-dnst: displayed name only, see the SHIRO note above.
-                playerName: resolveBoutSideDisplayName({ squad: squadA, memberId: playerAMemberId, storedName: playerAName }),
+                playerName: resolveBoutSideDisplayName({ squad: squadA, memberId: playerAMemberId, storedName: playerAName }) || repTeamWhenUnpicked(playerAMemberId, sideAName),
                 memberId: playerAMemberId,
-                memberLabel: playerALabel, roster: isDaihyoRow ? [] : rosterA, forceInput: manualPathA,
+                memberLabel: playerALabel, ...pickerA,
                 noticeKey: noticeKeyA,
                 lineupSlot: !isDaihyoRow && idx + 1 <= teamSize,
-                onSelectName: manualPathA ? pickManual("a", noticeKeyA, squadA, teamAId) : pickPlayer("a", noticeKeyA),
               },
             ];
 
@@ -4142,7 +4474,8 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                             metadata at all, so a fixed-order team registered
                             without members can still name its fighters bout by
                             bout; the static fallback remains only for the
-                            daihyosen row and for a row beyond teamSize that is
+                            daihyosen row a participant cannot pick on (see
+                            repPickable), and for a row beyond teamSize that is
                             not a kachinuki free/manual bout. No side chip here:
                             the header badge names the side once and the tinted
                             box carries it down the sheet. */}
@@ -4161,6 +4494,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                               // The Up Next panel passes this for exactly that
                               // case; only this host was missed (bc-dnst).
                               clearable={!!rs.memberId}
+                              placeholder={isDaihyoRow ? "Representative" : undefined}
                               ariaLabel={`${posLabel} ${rs.label} player`}
                               // A pick from the list closes it, and the list
                               // drops over this side's ippon buttons, so a double
@@ -4174,8 +4508,12 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                               onSelect={rs.onSelectName}
                             />
                           ) : (
-                            /* The read-only branch, which the DAIHYOSEN row
-                               always takes: it has no picker, so it never gets
+                            /* The read-only branch: a daihyosen row offers no
+                               picker on a participant's sheet once the judges
+                               decided it or while the match is not running
+                               (repPickable). It shows the picked representative,
+                               else the side's team name (repTeamWhenUnpicked), and
+                               "-" only where a row names no one. It never gets
                                LineupNameInput's `<position> <side> player`
                                aria-label. Removing the visible SHIRO/AKA chip
                                (operator ruling: the side is named once, by the
@@ -4388,7 +4726,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                     data-testid="team-daihyosen-remove"
                     title="Remove the representative bout"
                     onClick={onRemoveDaihyosen}
-                    disabled={daihyosenBusy || submitting || decisionSubmitting}
+                    disabled={daihyosenBusy || submitting || decisionSubmitting || repTyping}
                   >
                     Remove daihyosen
                   </button>
@@ -4478,7 +4816,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                     admin_scoring_shared.jsx). The term is taught in the
                     title/hint above instead. */}
                 {!removingWithdrawal && <div>
-                  <button data-testid="scoring-modal-daihyosen-button" type="button" className={`btn btn--sm ${teamTied ? "btn--primary" : "btn--ghost"}`} onClick={onDaihyosen} disabled={daihyosenBusy || submitting || decisionSubmitting}>
+                  <button data-testid="scoring-modal-daihyosen-button" type="button" className={`btn btn--sm ${teamTied ? "btn--primary" : "btn--ghost"}`} onClick={onDaihyosen} disabled={daihyosenBusy || submitting || decisionSubmitting || repTyping}>
                     {daihyosenBusy ? "Adding…" : "Add representative bout"}
                   </button>
                 </div>}
@@ -4707,7 +5045,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
           <KeptInHistoryNote note={keptInHistory.note} />
           {/* bc-mrgc: every write that reached this match, kept or applied.
               The organiser's view, so not on a self-run participant's sheet. */}
-          <MatchHistoryDisclosure match={m} password={password} hidden={!!selfReport} />
+          <MatchHistoryDisclosure match={m} password={password} hidden={!!selfReport} members={historyMemberLabel} />
           {/* bc-cse: a barred match cannot be started as scheduled -- the
               server would just refuse it -- so the ONE component that shows
               why and offers the default-win/reinstate resolution
@@ -4722,7 +5060,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
           )}
           <div className="score-nav">
             {prevMatch ? (
-              <button className="btn btn--sm score-nav__prev" onClick={goPrev} disabled={submitting}>← Prev</button>
+              <button className="btn btn--sm score-nav__prev" onClick={goPrev} disabled={submitting || repTyping}>← Prev</button>
             ) : <span />}
             <div className="score-nav__actions">
               {m.status === "scheduled" && !isBarredMatch(m) && (
@@ -4765,7 +5103,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                   {reopenCtl.busy ? "Reopening…" : reopenCtl.landed ? "Reopened" : "Reopen match"}
                 </button>
               )}
-              {canClose && <button className="btn" onClick={handleDismiss} disabled={submitting}>Cancel</button>}
+              {canClose && <button className="btn" onClick={handleDismiss} disabled={submitting || repTyping}>Cancel</button>}
               {kachinukiBoutMode ? (
                 // Kachinuki bout mode (mp-gmcg): TWO always-visible actions.
                 // [Record bout]: a RUNNING write flagged kachinukiBoutFinal;
@@ -4908,7 +5246,7 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                   if (isComplete && !correctionReason) { setReasonPromptKind("correction"); return; }
                   if (!isComplete && !confirmFinish(ev)) return;
                   doSubmit(() => (isComplete ? onSubmit : onSubmitAndNext)(buildPatch("completed")));
-                }} disabled={submitting || koTieBlocked}
+                }} disabled={submitting || koTieBlocked || repTyping}
                   title={koTieBlocked ? koTieTitle : undefined}>
                   {submitting ? "Saving…" : koTieBlocked ? "Needs a winner" : isComplete ? "Save correction" : finishArmed ? "Tap again to finish →" : "Finish + Start Next →"}
                 </button>
@@ -4918,14 +5256,14 @@ export function TeamScoreEditorModal({ match, teamSize, onClose, onSubmit, onSub
                   if (isComplete && !correctionReason) { setReasonPromptKind("correction"); return; }
                   if (!isComplete && !confirmFinish(ev)) return;
                   doSubmit(() => onSubmit(buildPatch("completed")));
-                }} disabled={submitting || koTieBlocked}
+                }} disabled={submitting || koTieBlocked || repTyping}
                   title={koTieBlocked ? koTieTitle : undefined}>
                   {submitting ? "Saving…" : koTieBlocked ? "Needs a winner" : isComplete ? "Save correction" : finishArmed ? "Tap again to finish" : "Finish"}
                 </button>
               )}
             </div>
             {nextMatch ? (
-              <button className="btn btn--sm score-nav__next" onClick={goNext} disabled={submitting}>Next →</button>
+              <button className="btn btn--sm score-nav__next" onClick={goNext} disabled={submitting || repTyping}>Next →</button>
             ) : <span />}
           </div>
           </>
diff --git a/web-mobile/js/admin_shiaijo.jsx b/web-mobile/js/admin_shiaijo.jsx
index 85e5a9c82..c04dea50f 100644
--- a/web-mobile/js/admin_shiaijo.jsx
+++ b/web-mobile/js/admin_shiaijo.jsx
@@ -14,8 +14,8 @@
 
 import { createTimerPool } from './timer_pool.jsx';
 import { applyPatch, keepNewerCompetitions } from './patch.jsx';
-import { SideCell } from './side_cell.jsx';
-import { useOpenedTapGuard } from './tap_guard.jsx';
+import { SideCell, WinnerTick } from './side_cell.jsx';
+import { useOpenedTapGuard, acceptTap } from './tap_guard.jsx';
 import { useDialogFocus } from './dialog_focus.jsx';
 // Imported DIRECTLY from the leaf rather than read off `window`. Two of the
 // call sites below sit inside a `try { } catch (_e) { }` that swallows, so a
@@ -25,10 +25,18 @@ import { useDialogFocus } from './dialog_focus.jsx';
 // api_client.jsx does not apply to it — the same move admin_scoring_shared.jsx
 // already makes.
 import {
-    writeDidNotLand, writeKeepsEditorOpen, writeWasSuperseded, writeWasRefusedForClock, CLOCK_SKEW_REASON_TEXT,
+    writeDidNotLand, writeKeepsEditorOpen, writeWasSuperseded, writeWasRefusedForClock,
     attemptScoreWrite, DOWNSTREAM_KNOCKOUT_PLAYED_CANCELLED, OVERRIDE_HELD_NOTICE,
-    startWhileCorrectingMessage, correctWhileRunningMessage,
+    startWhileCorrectingMessage, startWhileStartingMessage, startWasBlockedByStartMessage,
+    correctWhileRunningMessage, wasToasted,
 } from './write_result.jsx';
+// What a Start came back with (a clock_skew refusal, a thrown 409) is
+// start_match.jsx's to classify, shared with the Scores tab's own automatic
+// start (admin_schedule_score_editor.jsx). startPatch, the write itself, comes
+// from the same leaf, not from `window.startPatch`. The state wiring stays here:
+// startingRef/pickingRef carry the pick exemption (pickMatch), which that
+// leaf's guard has no word for.
+import { startPatch, classifyStartOutcome, startFailureMessage, startRefusalStands } from './start_match.jsx';
 // swissRoundLabel: single owner is pool_ids.jsx (mp-dej2); this file used to
 // carry its own copy. scoreRowMatchName names a match in the refusal notices.
 import { swissRoundLabel, scoreRowMatchName } from './pool_ids.jsx';
@@ -49,8 +57,16 @@ import { isBarredMatch, sideBarredByDecision, involvesCompetitor } from './ineli
 // stubs window.BracketTree before importing this file -- routing through
 // admin_scoring_shared.jsx pulled bracket.jsx's module body in ahead of that
 // stub taking effect and silently overwrote it. See barred_match_notice.jsx's
-// header.
+// header. The same rule is why winnerSideLR and teamMatchMarks come from the
+// side_marks.jsx leaf below, not from bracket.jsx.
 import { BarredMatchNotice } from './barred_match_notice.jsx';
+// The winner cue and a withdrawn team's mark, imported from their leaf (its one
+// import is competitor_identity.jsx), never read off `window`: a missing global
+// used to paint nothing, with no error to say why.
+import { winnerSideLR, teamMatchMarks } from './side_marks.jsx';
+// bc-tmwn: team match marks (Kiken, Fus.) are placed beside the withdrawn
+// side's name via teamNameMark.
+import { teamNameMark } from './match_scoreboard.jsx';
 
 const { useState: useStateSh, useMemo: useMemoSh, useEffect: useEffectSh, useRef: useRefSh, useCallback: useCallbackSh } = React;
 
@@ -309,7 +325,7 @@ export function shiaijoScoreCell(m) {
     const ipponsB = m.ipponsB || [];
     const s = window.formatIpponsScore
         ? window.formatIpponsScore(ipponsB, ipponsA, m.score, m.decision, m.encho, m.decidedByHantei,
-            window.winnerSideLR ? window.winnerSideLR(m) : null)
+            winnerSideLR(m))
         : "";
     return s ? { kind: "ippon", ippon: s } : { kind: "none" };
 }
@@ -618,14 +634,16 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
         const wname = _bracketSideName(w);
         if (wname) applyLocalBracketWin(match.compId, match.id, wname);
     }, [applyLocalBracketWin]);
-    // The last Start the server refused, as { key, compId, msg } for the match
-    // it was refused for (null = none). It is shown under Up next only while
-    // that match IS Up next, and it is dropped once it may no longer apply:
-    // whenever Up next changes to a different match, whichever match the
-    // refusal was for (the effect beside upNext below), and when any
-    // competitor's eligibility changes in that competition (the
-    // competitor_status_updated handler just below), which is what restoring
-    // a withdrawn competitor broadcasts. A refusal that
+    // The last Start the server refused, or the console refused for a start still
+    // out that has since landed, as { key, compId, msg } for the match it was
+    // refused for (null = none). It belongs to that match: it shows on that
+    // match's Up next card or queue row for as long as the match is still
+    // scheduled on this court, and goes when the match leaves scheduled or the
+    // court's (non-empty) list no longer holds it (the effect beside upNext
+    // below), when any competitor's eligibility changes in that competition (the
+    // competitor_status_updated handler just below), which is what restoring a
+    // withdrawn competitor broadcasts, or when the operator starts a match
+    // (startMatch). Up next changing by itself does not drop it. A refusal that
     // still applies comes straight back on the next tap. Before this it was a
     // bare string nothing cleared, so "kiken-voluntary at Pool A-2" outlived
     // the restore and then sat under the NEXT match (UAT, bc-tmfn). Declared
@@ -729,10 +747,30 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
 
     // Selected match for the inline scoring panel. `calledKey` marks the match
     // the operator has announced this session (local cue only); `callingKey`
-    // guards the in-flight announce request.
+    // guards the in-flight announce request. `callTapRef` guards against double
+    // taps on Call to court (bc-cdbl).
     const [calledKey, setCalledKey] = useStateSh(null);
     const [callingKey, setCallingKey] = useStateSh(null);
     const [startingKey, setStartingKey] = useStateSh(null);
+    // The start in flight, as { key, match } (null = none). The guards READ this
+    // ref, never startingKey: an advance awaits its finish write and then starts
+    // the next match from the render that began the await, so a closure's state
+    // is stale by then (a start begun meanwhile was not seen; one that has
+    // landed still was). The state above only drives the rendering.
+    const startingRef = useRefSh(null);
+    // The scheduled match a pick (pickMatch) is starting, from the moment its
+    // guards pass until the pick settles: { key, match } or null. It is a start in
+    // flight for the one-start guard, because the pick awaits the defer of the
+    // running bout before it reaches startMatch (and so before startingRef is
+    // set). startMatch is handed its own pick, which is exempt from the guard.
+    const pickingRef = useRefSh(null);
+    const callTapRef = useRefSh(null);
+    // The newest court call this console made per match, keyed by matchKey, as
+    // { id, msg }: the announcement id (a promise of it, null if the send failed)
+    // and the text sent, so the call can be withdrawn once its match leaves
+    // scheduled (bc-cdbl). A reload forgets them; the 5-minute expiry is the
+    // backstop.
+    const callIdsRef = useRefSh(new Map());
     const [contextOpen, setContextOpen] = useStateSh(true);
     // The whole queue column folds away so the scorer can take the full width;
     // the choice is per device, like the operator's other console preferences.
@@ -799,10 +837,16 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     // is reopened (see the effect beside correctingMatch below): a running
     // match is the live bout, not a correction. null = not correcting anything.
     const [correctingKey, setCorrectingKey] = useStateSh(null);
-    // The last tap the console refused because a match is live (a Correct) or
-    // a correction is open (a Start): { key, why: "running" | "correcting" }.
+    // The last tap the console refused because a match is live (a Correct), a
+    // correction is open (a Start) or another start is still out (a Start):
+    // { key, compId, why: "running" | "correcting" | "starting", against, label, start }
+    // (`against` is the blocker's key, `label` its name as the operator sees it, and
+    // `start` the in-flight start or pick record for "starting", null otherwise).
     // Only the tap is stored; the notice text is derived at render while the
-    // condition still holds (refusalNotice below), so it cannot go stale.
+    // condition still holds (refusalNotice below), so it cannot go stale. The one
+    // that outlives its condition is "starting": when the start it named lands,
+    // the effect beside startMatch turns it into a stored startError for the
+    // refused match, in the past tense.
     const [refusedTap, setRefusedTap] = useStateSh(null);
     // Pending court reassignment, awaiting operator confirmation. Moving a match
     // off this shiaijo is disruptive (it leaves the court and joins another's
@@ -1001,6 +1045,9 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     // running. ONE predicate for the editor's `started` prop and for liveBout
     // below, so the two cannot drift.
     const isStartedSnapshot = (m) => !!m && !!startedFrom && startedFrom.key === matchKey(m) && startedFrom.at === m.modifiedAt;
+    // The match whose start request is still in flight (startingKey), found on
+    // the court, for the render (liveBout below). The guards read startingRef.
+    const startingBlocker = startingKey ? sorted.find((x) => matchKey(x) === startingKey) || null : null;
     // The bout live on this court right now (bc-crpn): the pick when it is
     // running or is the start this console just made (the feed still reads
     // "scheduled" until the refetch; a queued offline start too), else
@@ -1008,24 +1055,35 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     // else the match whose start request is still in flight.
     const liveBout = (pickedMatch && (pickedMatch.status === "running" || isStartedSnapshot(pickedMatch)))
         ? pickedMatch
-        : running[0]
-            || (startingKey ? sorted.find((x) => matchKey(x) === startingKey) || null : null);
+        : running[0] || startingBlocker;
     // The correction the console holds open (completed), if any. A reopened
     // one is the live bout and is handed over by the effect above.
     const openCorrection = correctingMatch && correctingMatch.status === "completed" ? correctingMatch : null;
     // The "Another bout is running" list: the bouts beyond the one the panel
     // shows, plus the running one itself while a correction holds the panel.
     const alsoRunning = openCorrection ? running : running.slice(1);
-    // What refuses a tap right now, by kind: a live bout refuses a Correct,
-    // an open correction refuses a Start. ONE place builds each sentence, for
-    // the toast and the notice alike.
-    const refusalBlocker = (why) => (why === "running" ? liveBout : openCorrection);
+    // What refuses a tap right now, by kind: a live bout refuses a Correct, an
+    // open correction refuses a Start, and a start still out refuses a Start of
+    // another match. ONE place builds each sentence, for the toast and the
+    // notice alike.
+    // "starting" reads the refs, so a refusal made from an advance's async
+    // continuation names the start that is out NOW (the render's copy may be
+    // stale there), and a refusal made during a pick's defer names that pick. At
+    // render time the refs and the state agree.
+    const refusalBlocker = (why) => {
+        if (why === "running") return liveBout;
+        if (why === "starting") {
+            const s = startingRef.current || pickingRef.current;
+            return s ? s.match : null;
+        }
+        return openCorrection;
+    };
     const refusalText = (why) => {
         const blocker = refusalBlocker(why);
         if (!blocker) return null;
-        return why === "running"
-            ? correctWhileRunningMessage({ court, label: scoreRowMatchName(blocker) })
-            : startWhileCorrectingMessage({ label: scoreRowMatchName(blocker) });
+        if (why === "running") return correctWhileRunningMessage({ court, label: scoreRowMatchName(blocker) });
+        if (why === "starting") return startWhileStartingMessage({ label: scoreRowMatchName(blocker) });
+        return startWhileCorrectingMessage({ label: scoreRowMatchName(blocker) });
     };
     // The notice for a refused tap, derived: shown only while the match that
     // refused it still does, so it goes by itself when that match is finished,
@@ -1037,9 +1095,27 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     };
     // Refuse a tap: remember it against the match that blocks it, and toast.
     const refuseTap = (m, why) => {
-        setRefusedTap({ key: matchKey(m), why, against: matchKey(refusalBlocker(why)) });
+        const blocker = refusalBlocker(why);
+        setRefusedTap({
+            key: matchKey(m), compId: m.compId, why, against: matchKey(blocker), label: scoreRowMatchName(blocker),
+            // The start (or pick) record itself, which startMatch marks `landed` once the
+            // start went out: the effect beside startMatch asks it before writing the
+            // past-tense sentence.
+            start: why === "starting" ? (startingRef.current || pickingRef.current) : null,
+        });
         if (showToast) showToast(refusalText(why), "error");
     };
+    // The stored refusal is read against the refused match's LIVE row in the
+    // court's list (the same list the court-call withdrawal reads), never against
+    // a snapshot: the notice shows only while that row is still scheduled, so it
+    // cannot outlive the match for the render before the effect below drops it.
+    const startErrorKey = startError ? startError.key : null;
+    const startErrorRow = startErrorKey ? courtMatchesRaw.find((x) => matchKey(x) === startErrorKey) : null;
+    const startErrorStatus = startErrorRow ? startErrorRow.status : null;
+    // The Start notice a scheduled match's card or queue row shows: a refused
+    // tap's derived notice, else the stored Start refusal for that match.
+    const startNoticeFor = (key) => refusalNotice(key)
+        || (startError && startError.key === key && startErrorStatus === "scheduled" ? startError.msg : null);
 
     // For pool daihyosen/tiebreaker bouts, enrich the selected match with
     // rep-player roster data so ScoreEditorModal renders the rep-picker dropdowns
@@ -1122,11 +1198,8 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     // queue row (the default-win action, or Reinstate) rather than having it
     // offered as the next thing to start.
     const upNext = filteredScheduled.find((m) => !isBarredMatch(m)) || null;
-    // The Up next card's alert line: a refused tap's notice wins over a stored
-    // start refusal, being the newer tap.
-    const upNextNotice = upNext
-        ? refusalNotice(matchKey(upNext)) || (startError && startError.key === matchKey(upNext) ? startError.msg : null)
-        : null;
+    // The Up next card's alert line (startNoticeFor).
+    const upNextNotice = upNext ? startNoticeFor(matchKey(upNext)) : null;
     // Everything else in Upcoming: the whole scheduled list minus whichever
     // match became Up Next (by key, not index: Up Next may not be [0] when a
     // barred match sits ahead of it). Any barred match stays here, rendered
@@ -1134,20 +1207,29 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     const upcomingQueueMatches = upNext
         ? filteredScheduled.filter((m) => matchKey(m) !== matchKey(upNext))
         : filteredScheduled;
-    // A Start refusal describes ONE match at one moment. Whenever Up next
-    // changes to a different match (that one started, was moved, the operator
-    // switched competition, or the court moved on), any stored refusal is
-    // dropped, whichever match it was for. That includes a refusal for a match
-    // picked from further down the queue: when that match later reaches Up
-    // next, its cause (e.g. a competitor then fighting on another court) is
-    // usually gone, and nothing else would clear it (a finished match sends no
-    // competitor_status_updated). A refusal that still applies comes straight
-    // back on the next tap. Keyed on the key VALUE: a refetch that keeps the
-    // same Up next leaves a refusal for it where it is.
-    const upNextKey = upNext ? matchKey(upNext) : null;
+    // A stored Start refusal describes ONE match at one moment, so it is judged
+    // against that match's live row and nothing else (startErrorStatus above;
+    // start_match.jsx startRefusalStands owns the rule, and the Scores tab asks
+    // the same one, admin_schedule_score_editor.jsx). It is
+    // dropped when the match leaves scheduled (started here or elsewhere, closed
+    // by a decision), or when the court's list is non-empty and no longer holds
+    // it (the match moved). Up next changing by itself drops nothing: a refusal
+    // for a match picked from further down the queue stays on its row, and is
+    // there on the card if the match later reaches Up next. A refusal is about
+    // one match at one moment, so a stale one never revives when that match is
+    // later sent back to the queue: the next tap asks the server again. A start
+    // by the operator clears it too (startMatch), and so does an eligibility
+    // change in its competition (the competitor_status_updated handler).
+    //
+    // The list is EMPTY while it loads and across a transient empty refetch, and
+    // an empty list says nothing about the match, so the refusal is left where it
+    // is then (the court-call withdrawal below leaves an absent key alone for the
+    // same reason). Only a list that holds matches yet lacks this one counts.
+    const startErrorStands = startRefusalStands({ row: startErrorRow, listHoldsMatches: courtMatchesRaw.length > 0 });
     useEffectSh(() => {
-        setStartError(null);
-    }, [upNextKey]);
+        if (!startErrorKey) return;
+        if (!startErrorStands) setStartError(null);
+    }, [startErrorKey, startErrorStands]);
 
     // "Which pool is next" for the context panel: the first upcoming pool on
     // this court (within the selected comp) whose pool differs from the one
@@ -1223,50 +1305,125 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
         return { entries, alsoWaiting: selHasActive };
     }, [allMatches, effectiveCompId, running, filteredScheduled, courtKnown]);
 
-    // Delegate to the canonical start-patch factory (admin_schedule.jsx) rather
-    // than re-declaring its shape: a second copy could silently drift. Both
-    // modules ship in the same admin bundle, so the global is always present;
-    // fail loudly if that ever stops being true instead of forking behaviour.
-    const startPatch = () => {
-        if (typeof window.startPatch !== "function") {
-            throw new Error("startPatch factory unavailable: admin_schedule.jsx not loaded");
-        }
-        return window.startPatch();
+    // The one place the Starting… state follows the refs: the start in flight,
+    // else the pick still deferring the running bout (so a start settling inside
+    // a pick does not blank the button the pick is still holding).
+    const syncStartingKey = () => {
+        const s = startingRef.current || pickingRef.current;
+        if (mountedRef.current) setStartingKey(s ? s.key : null);
     };
-
-    // Returns true when the start write succeeded, false otherwise: pickMatch
-    // relies on this so it only pins pickedKey for a match that actually started
-    // (a blocked-by-eligibility start must not steal the panel).
-    const startMatch = async (m) => {
-        if (startingKey) return false;
+    // A refusal for a start that was still out ("starting") is derived while that
+    // start is out: "X is still being started". When it has landed (or failed),
+    // the sentence stops being true, but nothing else would say the match the
+    // operator asked for was never started (a 2.7s toast was the only sign,
+    // bc-aadv). So it becomes a STORED refusal for the refused match, in the past
+    // tense, bound to that match like every stored refusal (the effect beside
+    // upNext). The refused match is NOT started on its own: the court now has a
+    // running bout, so a second automatic start would draw court_busy or put two
+    // bouts on the court unasked, and one start at a time is the rule (fce5866c).
+    // The operator starts it, which clears the sentence. The effect re-runs when
+    // the start in flight changes (startingKey), and reads the refs for the truth.
+    //
+    // A start that did NOT land leaves the court free, so the past-tense sentence
+    // would be false, and that start's own refusal (a thrown 409, a clock_skew
+    // answer or a superseded one that held its result group) is what the
+    // operator needs. It is stored for the
+    // blocker before this runs (startMatch's refusal branch or its catch, ahead
+    // of its finally), and startMatch clears
+    // startError when a start passes the guard, so any value present when the
+    // blocker ends is the blocker's own: it is kept, and the waiting match shows
+    // nothing, as it did before the sentence existed.
+    //
+    // The sentence also needs a start that WENT OUT. The blocker can be a pick whose
+    // deferral of the running bout failed (the revert threw or was unavailable): it
+    // never started, nothing was written and the court is as it was, so "was being
+    // started" would be false. The start record the refusal holds says whether a start
+    // landed (`landed`, set by startMatch, also on the pick's record), not the court's
+    // list: the list is refreshed a moment after the write and may still show the match
+    // scheduled, and a start queued offline stays scheduled until the connection
+    // returns, yet both were sent. Otherwise the refused tap is dropped, with no sentence.
+    useEffectSh(() => {
+        if (!refusedTap || refusedTap.why !== "starting") return;
+        if (startingRef.current || pickingRef.current) return;
+        if (refusedTap.start && refusedTap.start.landed) {
+            const blocked = { key: refusedTap.key, compId: refusedTap.compId, msg: startWasBlockedByStartMessage({ label: refusedTap.label }) };
+            setStartError((prev) => prev ?? blocked);
+        }
+        setRefusedTap(null);
+    }, [refusedTap, startingKey]);
+    // Returns true when the start went out (landed, or was queued offline), false
+    // otherwise: pickMatch relies on this so it only pins pickedKey for a match that
+    // actually started (a blocked-by-eligibility start, a clock_skew refusal or a
+    // superseded answer that held the result group must not steal the panel; a
+    // superseded answer that held nothing is an echo of a start that landed and
+    // does pin it).
+    // `pick` is the pickingRef entry pickMatch made for THIS start, if it is one:
+    // that pick is the start itself, not a start in flight against it.
+    const startMatch = async (m, { pick = null } = {}) => {
+        const key = matchKey(m);
+        const refusalFor = (msg) => ({ key, compId: m.compId, msg });
+        const inFlight = startingRef.current || (pickingRef.current && pickingRef.current !== pick ? pickingRef.current : null);
+        if (inFlight) {
+            // One start at a time. An advance (Finish + Start Next, or the one
+            // after a decision) that asks for another match while a start is out
+            // is refused, and the refusal says so where the refused match is
+            // shown (refuseTap: its Up next card or its queue row) and toasts,
+            // rather than doing nothing (bc-aadv). A repeat for the match already
+            // being started is silent: it is on its way.
+            if (inFlight.key !== key && mountedRef.current) refuseTap(m, "starting");
+            return false;
+        }
         setStartError(null);
-        setStartingKey(matchKey(m));
-        const refusalFor = (msg) => ({ key: matchKey(m), compId: m.compId, msg });
+        const started = { key, match: m };
+        startingRef.current = started;
+        setStartingKey(key);
         try {
             // Starting makes the match running; the scoring panel shows
             // running[0], so it picks the match up on the next refetch.
             const res = await onEditScore(m.compId, m.id, startPatch(), m);
-            // A clock_skew refusal means the server stored NOTHING and, unlike
-            // a queued start, nothing will land later — so returning true here
-            // would pin the panel on a match that never started while the tap
-            // looked like it worked. Found in browser verification: this card
-            // button is a start path none of the review sweeps enumerated (it
-            // is not one of the editor call sites). The relearn the refusal
-            // triggers means a SECOND tap normally succeeds; the toast tells
-            // the operator that, instead of leaving a dead first tap.
-            if (writeWasRefusedForClock(res)) {
-                const msg = "Could not start: " + CLOCK_SKEW_REASON_TEXT + ". The clock has been resynced; try again.";
-                if (mountedRef.current) setStartError(refusalFor(msg));
-                if (showToast) showToast(msg, "error");
+            // A clock_skew answer, or a superseded one that held the result
+            // group, means the server stored NOTHING of the start and, unlike a
+            // queued start, nothing will land later, so returning true here would
+            // pin the panel on a match that never started while the tap looked
+            // like it worked. Found in browser verification: this card button is
+            // a start path none of the review sweeps enumerated (it is not one of
+            // the editor call sites). (A superseded answer that held NOTHING is an
+            // echo of a start that already landed: classifyStartOutcome answers
+            // ok for it and it takes the landed path below.)
+            // Both are a REFUSED start (start_match.jsx classifyStartOutcome): the
+            // sentence is stored on the refused match and toasted once, and
+            // `landed` stays unset, so a refusal that waited on this start is not
+            // worded as "was being started". The sentences differ in their advice
+            // (after a clock refusal a SECOND tap normally succeeds; after a
+            // held-group superseded one the operator checks the match first), which is why
+            // the toast and the card carry the sentence and not a bare failure.
+            //
+            // For a PICK the court is not "as it was": the running bout was
+            // already sent back to the queue (deferAndStart), and this refusal
+            // leaves the court idle with that bout waiting in the queue.
+            const outcome = classifyStartOutcome(res);
+            if (!outcome.ok) {
+                if (mountedRef.current) setStartError(refusalFor(outcome.msg));
+                if (showToast) showToast(outcome.msg, "error");
                 return false;
             }
+            // The start went out. A refusal that waited on it (or on the pick that
+            // made it) reads this, whichever record it holds.
+            started.landed = true;
+            if (pick) pick.landed = true;
             return true;
         } catch (e) {
-            if (mountedRef.current) setStartError(refusalFor((e && e.message) || "Could not start the match: check eligibility and try again."));
-            if (showToast) showToast((e && e.message) || "Could not start the match", "error");
+            const msg = startFailureMessage(e);
+            if (mountedRef.current) setStartError(refusalFor(msg));
+            // A thrown refusal onEditScore (editMatchScore, admin.jsx) already
+            // toasted is not toasted again: the toast is a single slot, so a
+            // second one only restarts its timer. The card or row says it either way.
+            if (showToast && !wasToasted(e)) showToast(msg, "error");
             return false;
         } finally {
-            if (mountedRef.current) setStartingKey(null);
+            // Only the start that holds the ref clears it; the state follows the refs.
+            if (startingRef.current && startingRef.current.key === key) startingRef.current = null;
+            syncStartingKey();
         }
     };
 
@@ -1283,13 +1440,42 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     //   • While a correction is open nothing starts (operator ruling
     //     2026-09-27, bc-crpn): the tap is refused with a notice, BEFORE the
     //     defer above, so a refused start sends nothing back to the queue.
+    //   • One start at a time (bc-aadv): while another match's start is still
+    //     out, a Start of a different scheduled match is refused with a notice
+    //     on its row, also BEFORE the defer, so the running bout is not sent
+    //     back for a start that never happens. A repeat for the match already
+    //     being started is silent: it is on its way.
     const pickMatch = async (m) => {
         if (!m || m.status === "completed") return;
         if (openCorrection) {
             refuseTap(m, "correcting");
             return;
         }
+        const inFlight = startingRef.current || pickingRef.current;
+        if (inFlight && m.status === "scheduled") {
+            if (inFlight.key !== matchKey(m)) refuseTap(m, "starting");
+            return;
+        }
         setRefusedTap(null);
+        // A scheduled pick is a start in flight from here, before the defer below
+        // awaits: a second Start tapped during that wait is refused, and does not
+        // send the running bout back a second time.
+        const pick = m.status === "scheduled" ? { key: matchKey(m), match: m } : null;
+        if (pick) {
+            pickingRef.current = pick;
+            syncStartingKey();
+        }
+        try {
+            await deferAndStart(m, pick);
+        } finally {
+            if (pick && pickingRef.current === pick) pickingRef.current = null;
+            syncStartingKey();
+        }
+    };
+
+    // The defer of the running bout and the start of the picked one, after
+    // pickMatch's guards and its pickingRef entry (see pickMatch).
+    const deferAndStart = async (m, pick) => {
         const cur = running[0] || null;
         const isSame = cur && matchKey(cur) === matchKey(m);
         if (cur && !isSame) {
@@ -1310,7 +1496,7 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
             if (!mountedRef.current) return;
         }
         if (m.status === "scheduled") {
-            const ok = await startMatch(m);
+            const ok = await startMatch(m, { pick });
             if (!ok || !mountedRef.current) return;
             // bc-strt: the editor treats this snapshot as running, so a point
             // struck before the refetch shows it running saves at once.
@@ -1355,14 +1541,45 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
     // competitors (and anyone watching the public app) are notified they're
     // being summoned to this shiaijo. It does NOT start the match; Start is
     // always available on its own.
-    const callToCourt = async (m) => {
+    const callToCourt = async (m, ev) => {
+        // bc-cdbl: double tap guard. acceptTap returns false for a bounce and
+        // true otherwise, stamping the tap as it goes.
+        if (!acceptTap(callTapRef, ev, matchKey(m))) return;
         if (!window.API || typeof window.API.sendAnnouncement !== "function") return;
         const a = (m.sideA && m.sideA.name) || "Aka";
         const b = (m.sideB && m.sideB.name) || "Shiro";
         const msg = `Now calling ${b} and ${a} to Shiaijo ${court}.`.slice(0, 200);
         setCallingKey(matchKey(m));
+        // The call already up for this match, if any: { id, msg }, where id is a
+        // promise of its announcement id. It comes down only once the new call is
+        // answered (below), so a send that fails leaves it up. The server replaces
+        // only an announcement with identical text, so a call whose text changed
+        // (a side's name resolved) would otherwise leave the earlier banner up
+        // until it expired (bc-cdbl).
+        const earlier = callIdsRef.current.get(matchKey(m)) || null;
         try {
-            await window.API.sendAnnouncement(msg, 5, password);
+            const sent = window.API.sendAnnouncement(msg, 5, password);
+            const key = matchKey(m);
+            // Keep the newest call per match, with its text, so starting the match
+            // can withdraw it (bc-cdbl). The id is kept as a promise: a start that
+            // lands before the answer must still withdraw the call once its id
+            // arrives. If the send fails, the earlier call stays up, and so does
+            // its entry.
+            const entry = { msg, id: sent.then((ann) => (ann && ann.id) || null, () => (earlier ? earlier.id : null)) };
+            callIdsRef.current.set(key, entry);
+            sent.catch(() => {
+                if (callIdsRef.current.get(key) !== entry) return;
+                if (earlier) callIdsRef.current.set(key, earlier);
+                else callIdsRef.current.delete(key);
+            });
+            // The earlier call comes down once this one is answered, but only when
+            // its text differs. An identical text already replaced it on the server
+            // (AnnouncementStore.Add), so a DELETE of it would 404; a failed send
+            // leaves it up (its id comes back unchanged, so nothing is taken down).
+            if (earlier && earlier.msg !== msg) {
+                takeDown(Promise.all([earlier.id, entry.id]).then(([oldId, newId]) => (oldId !== newId ? oldId : null)));
+            }
+            await sent;
             if (!mountedRef.current) return;
             setCalledKey(matchKey(m));
             if (showToast) showToast(`Called ${b} and ${a} to Shiaijo ${court}`);
@@ -1373,6 +1590,40 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
         }
     };
 
+    // withdrawCall: take this console's court call for the match keyed `key`
+    // back down once that match has left scheduled (bc-cdbl). Fire
+    // and forget: a failed delete is logged, never allowed to fail the start,
+    // and the 5-minute expiry still clears the banner.
+    const withdrawCall = (key) => {
+        const entry = callIdsRef.current.get(key);
+        if (!entry) return;
+        callIdsRef.current.delete(key);
+        takeDown(entry.id);
+    };
+    // takeDown: delete the announcement whose id `pending` resolves to (none
+    // when it resolves to null). Fire and forget, shared by withdrawCall and the
+    // earlier call callToCourt replaces.
+    const takeDown = (pending) => {
+        pending
+            .then((id) => {
+                if (!id || !window.API || typeof window.API.deleteAnnouncement !== "function") return;
+                return window.API.deleteAnnouncement(id, password);
+            })
+            .catch((e) => console.warn("Could not withdraw the court call", e));
+    };
+
+    // A court call comes down once its match has left scheduled, however that
+    // happened: started here, started from another device, or closed by a
+    // decision. A key the list does not hold is left alone, since the list is
+    // empty while it loads and a match moved off this court is not this
+    // console's to judge.
+    useEffectSh(() => {
+        for (const key of callIdsRef.current.keys()) {
+            const m = courtMatchesRaw.find((x) => matchKey(x) === key);
+            if (m && m.status !== "scheduled") withdrawCall(key);
+        }
+    }, [courtMatchesRaw]);
+
     // moveMatch: reorder by swapping scheduledAt with the adjacent row.
     // direction: "up" (earlier) or "down" (later). Only scheduled matches
     // can be reordered; running/completed are stable.
@@ -1460,7 +1711,13 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
         const { compId, matchId, to } = pendingMove;
         setMovingCourt(true);
         try {
-            await onMoveCourt(compId, matchId, to);
+            // The host answers true only when the move landed (the host reports
+            // its own failure and resolves false). A move that did not land
+            // leaves this console's call for the match up.
+            const landed = await onMoveCourt(compId, matchId, to);
+            // The call names the court the match is leaving, so it comes down
+            // once the move has landed (bc-cdbl).
+            if (landed === true) withdrawCall(matchKey({ compId, id: matchId }));
             if (mountedRef.current) setPendingMove(null);
         } finally {
             if (mountedRef.current) setMovingCourt(false);
@@ -1677,7 +1934,7 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
                                                 <button type="button"
                                                     className="btn btn--sm"
                                                     disabled={callingKey === matchKey(upNext)}
-                                                    onClick={() => callToCourt(upNext)}
+                                                    onClick={(ev) => callToCourt(upNext, ev)}
                                                     title="Announce this match to spectators and competitors"
                                                 >
                                                     {Icon && <Icon name="megaphone" />}{" "}
@@ -1707,7 +1964,7 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
                                     label="Upcoming" subGroup matches={upcomingQueueMatches}
                                     courts={courts} onMoveCourt={requestMoveCourt}
                                     onMove={moveMatch} onEnterLineup={(m) => setLineupKey(matchKey(m))}
-                                    onPick={pickMatch} noticeFor={(m) => refusalNotice(matchKey(m))}
+                                    onPick={pickMatch} noticeFor={(m) => startNoticeFor(matchKey(m))}
                                     onCall={callToCourt} callingKey={callingKey} calledKey={calledKey} startingKey={startingKey}
                                     scheduled={filteredScheduled}
                                     password={password}
@@ -1884,8 +2141,9 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
                                     }}
                                     onSubmitAndNext={async (patch) => {
                                         const next = nextActiveAfter(selectedMatch);
+                                        let res;
                                         try {
-                                            const res = await onEditScore(selectedMatch.compId, selectedMatch.id, patch, selectedMatch);
+                                            res = await onEditScore(selectedMatch.compId, selectedMatch.id, patch, selectedMatch);
                                             // See the onSubmit handler above: a superseded write must not
                                             // advance the local bracket on a winner the server discarded.
                                             if (!writeWasSuperseded(res)) maybeAdvanceLocal(selectedMatch, patch);
@@ -1898,9 +2156,13 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
                                             // Finish + start the next scheduled match, which then
                                             // becomes the running match the panel shows.
                                             if (next && next.status === "scheduled") {
-                                                try { await onEditScore(next.compId, next.id, startPatch(), next); } catch (_s) { /* gate */ }
+                                                await startMatch(next);
                                             }
                                         } catch (_e) { /* keep panel */ }
+                                        // The finish write's answer, as the editor needs it (a partial
+                                        // apply's note, a refused write's banner); undefined when the
+                                        // write threw.
+                                        return res;
                                     }}
                                     onAfterDecision={async (result) => {
                                         // A fusenpai/hantei decision already persisted the bout via
@@ -1917,7 +2179,7 @@ function AdminShiaijoPage({ tournament, court: routeCourt, onBack, onEditScore,
                                         // competitor a withdrawal or no-show has just barred.
                                         const next = nextActiveAfter(selectedMatch, sideBarredByDecision(result, selectedMatch));
                                         if (next && next.status === "scheduled") {
-                                            try { await onEditScore(next.compId, next.id, startPatch(), next); } catch (_s) { /* gate */ }
+                                            await startMatch(next);
                                         }
                                     }}
                                     password={password}
@@ -2170,6 +2432,10 @@ export function ShiaijoQueueRow({ m, scheduled, courts, onMoveCourt, onMove, onE
     const aName = slotName(m.sideA?.name || "", (m.feeders || [])[0]);
     const bName = slotName(m.sideB?.name || "", (m.feeders || [])[1]);
     const scoreCell = shiaijoScoreCell(m);
+    // bc-tmwn: for completed rows, determine which side won and get team marks.
+    const winnerSide = isComplete ? winnerSideLR(m) : null;
+    // teamMatchMarks itself returns no marks for a non-team row or one not completed.
+    const { shiro: teamShiroMark, aka: teamAkaMark } = teamMatchMarks(m, isTeamMatch(m));
     // Derive position in the full scheduled list to know when to disable ↑/↓.
     // `scheduled` is the court's complete scheduled array (including Up Next);
     // the row may be in the Upcoming slice but we disable based on absolute pos.
@@ -2225,12 +2491,18 @@ export function ShiaijoQueueRow({ m, scheduled, courts, onMoveCourt, onMove, onE
                     nothing. Removing the badge on top of it would have left the
                     side carried by colour alone on the one surface where reading
                     it wrong mis-scores a bout. */}
-                <SideCell side="shiro" className="shiaijo-qrow__side shiaijo-qrow__side--shiro">
-                    <span className="shiaijo-qrow__name"><NumberedName side="shiro" name={bName} number={m.sideB?.number} clip /></span>
+                <SideCell side="shiro" className={`shiaijo-qrow__side shiaijo-qrow__side--shiro ${winnerSide === "left" ? "shiaijo-qrow__side--win" : ""}`}>
+                    {winnerSide === "left" && <WinnerTick />}
+                    <span className={`shiaijo-qrow__name${teamShiroMark ? " msb-name--labelled" : ""}`}>
+                        {teamNameMark("shiro", teamShiroMark, <NumberedName side="shiro" name={bName} number={m.sideB?.number} clip />)}
+                    </span>
                 </SideCell>
                 <span className="shiaijo-qrow__vs">vs</span>
-                <SideCell side="aka" className="shiaijo-qrow__side shiaijo-qrow__side--aka">
-                    <span className="shiaijo-qrow__name"><NumberedName side="aka" name={aName} number={m.sideA?.number} clip /></span>
+                <SideCell side="aka" className={`shiaijo-qrow__side shiaijo-qrow__side--aka ${winnerSide === "right" ? "shiaijo-qrow__side--win" : ""}`}>
+                    {winnerSide === "right" && <WinnerTick />}
+                    <span className={`shiaijo-qrow__name${teamAkaMark ? " msb-name--labelled" : ""}`}>
+                        {teamNameMark("aka", teamAkaMark, <NumberedName side="aka" name={aName} number={m.sideA?.number} clip />)}
+                    </span>
                 </SideCell>
             </div>
             {/* bc-cse: a barred match cannot be started (the server refuses it),
@@ -2288,7 +2560,7 @@ export function ShiaijoQueueRow({ m, scheduled, courts, onMoveCourt, onMove, onE
                         call to the court for a match the server would refuse to
                         start. */}
                     {onCall && window.API && typeof window.API.sendAnnouncement === "function" && !barred && (
-                        <button type="button" className="btn btn--ghost btn--sm" disabled={callingKey === matchKey(m)} onClick={() => onCall(m)} title="Announce this match to spectators and competitors">
+                        <button type="button" className="btn btn--ghost btn--sm" disabled={callingKey === matchKey(m)} onClick={(ev) => onCall(m, ev)} title="Announce this match to spectators and competitors">
                             {callingKey === matchKey(m) ? "Calling…" : (calledKey === matchKey(m) ? "Call again" : "Call to court")}
                         </button>
                     )}
diff --git a/web-mobile/js/api_client.jsx b/web-mobile/js/api_client.jsx
index 44042b46e..d3674615f 100644
--- a/web-mobile/js/api_client.jsx
+++ b/web-mobile/js/api_client.jsx
@@ -41,7 +41,7 @@ import { bridge as _bridge } from './court_bridge.jsx';
 // The offset lives in a leaf so a score editor can read the same clock (server_clock.jsx).
 import { serverNowMs, serverClockOffsetMs, setServerClockOffsetMs } from './server_clock.jsx';
 import {
-    writeDidNotLand, writeWasSuperseded, writeWasRefusedForClock, writeNeedsWinner, writeDefaultWinStands, writeHeldDecision, writeDisplacedGroups, supersededBanner,
+    writeDidNotLand, writeWasSuperseded, writeWasRefusedForClock, writeNeedsWinner, writeDefaultWinStands, writeHeldDecision, writeDisplacedGroups, writeDisplacedForWinner, supersededBanner,
     decisionWord,
     SUPERSEDED_REASON, SUPERSEDED_ADVICE,
     CLOCK_SKEW_REASON_TEXT, CLOCK_SKEW_ADVICE, CLOCK_SKEW_UNHEALED_ADVICE,
@@ -719,8 +719,10 @@ function _isAllowedTerminalRequest(method, url) {
 //   'sent'          GOOD news (bc-offl): held finished results landed in one
 //                   flush; the one kind App renders as a success toast
 //   'displaced'     held finished results landed and moved a later change of
-//                   their match to its history (it would have left the
-//                   finished match without a winner); recorded, told once
+//                   their match to its history; recorded, told once.
+//                   `forWinner` of the `count` were moved because the change
+//                   would have left the finished match without a winner
+//                   (writeDisplacedForWinner); the rest carry no such reason
 // ---------------------------------------------------------------------------
 const _queueAlertListeners = new Set();
 const _pendingQueueAlerts = [];
@@ -1464,7 +1466,11 @@ async function _flushQueue() {
     };
     // Held finishes that landed and moved a LATER change of their match to
     // its history (writeDisplacedGroups): told once per pass, like 'sent'.
+    // displacedForWinnerThisPass counts those whose answer said the change
+    // would have left the finished match without a winner
+    // (writeDisplacedForWinner); the alert words the rest plainly.
     let displacedThisPass = 0;
+    let displacedForWinnerThisPass = 0;
     // bc-offl: HELD finished results that landed in this flush, counted the
     // same way and announced once at the end ('sent'), so the operator who saw
     // them held is told they arrived. A terminal write enters the queue only
@@ -1725,7 +1731,10 @@ async function _flushQueue() {
                             // applied:false answer, a clock-skew refusal included
                             // (which never reaches here: the arms above continue).
                             if (terminal && !writeWasSuperseded(body)) sentThisPass++;
-                            if (terminal && writeDisplacedGroups(body).length > 0) displacedThisPass++;
+                            if (terminal && writeDisplacedGroups(body).length > 0) {
+                                displacedThisPass++;
+                                if (writeDisplacedForWinner(body)) displacedForWinnerThisPass++;
+                            }
                             // A confirmed terminal score write needs no further rev
                             // tracking: drop its counter (mirrors recordScore's online
                             // completed path) so _matchRevCounters doesn't grow for the
@@ -1913,7 +1922,7 @@ async function _flushQueue() {
         // success, so a pass with both still ends on the error, and a pass with
         // no error shows the confirmation.
         if (sentThisPass > 0) _notifyQueueAlert({ kind: 'sent', count: sentThisPass, terminalCount: sentThisPass });
-        if (displacedThisPass > 0) _notifyQueueAlert({ kind: 'displaced', count: displacedThisPass, terminalCount: displacedThisPass });
+        if (displacedThisPass > 0) _notifyQueueAlert({ kind: 'displaced', count: displacedThisPass, terminalCount: displacedThisPass, forWinner: displacedForWinnerThisPass });
         _notifyScoreSupersededAlert(
             supersededThisPass,
             lastSupersededMatch ? lastSupersededMatch.compID : undefined,
@@ -4485,6 +4494,9 @@ const API = {
             method: 'DELETE',
             headers: { 'X-Tournament-Password': password }
         });
+        // 404: the announcement is already gone (expired, or another console
+        // withdrew it first), which is the outcome the caller asked for.
+        if (res.status === 404) return;
         if (!res.ok) {
             const err = await res.json().catch(() => ({}));
             throw new Error(err.error || `Failed to delete announcement (Status ${res.status})`);
diff --git a/web-mobile/js/app.jsx b/web-mobile/js/app.jsx
index 78dd6a8f8..93cd0dd16 100644
--- a/web-mobile/js/app.jsx
+++ b/web-mobile/js/app.jsx
@@ -390,10 +390,12 @@ export function queueAlertMessage(alert) {
     case "sent":
       return `${n} ${noun} sent.`;
     // Held finishes that landed and moved a later change of their match to
-    // its history (it would have left the finished match without a winner).
-    // Recorded, so not an error: the history has the change.
+    // its history. `forWinner` of them say the change would have left the
+    // finished match without a winner; the rest carry no such reason, and an
+    // alert without the count words none of them so. Recorded, so not an
+    // error: the history has the change.
     case "displaced":
-      return displacedAlertText(n, one);
+      return displacedAlertText(n, one, alert.forWinner || 0);
     default:
       return null;
   }
diff --git a/web-mobile/js/bracket.jsx b/web-mobile/js/bracket.jsx
index a6480dc12..8fb50d809 100644
--- a/web-mobile/js/bracket.jsx
+++ b/web-mobile/js/bracket.jsx
@@ -17,7 +17,14 @@ import { barredSides } from './ineligible_match.jsx';
 import { BarredChip } from './barred_chip.jsx';
 import { realIppons, enchoOn, defaultWinMaru } from './result_slot.jsx';
 import { sameCompetitor } from './competitor_identity.jsx';
+// The result-mark placement helpers live in the side_marks.jsx leaf, which the
+// court console imports without reaching this module (its render suite stubs
+// window.BracketTree, which this module's body reassigns). This file imports
+// them for its own use, keeps their `window.*` lines and re-exports the names,
+// so every importer of bracket.jsx and every window reader is unchanged.
+import { joinSp, placeMarks, sideMarks, winnerSideLR, teamMatchMarks } from './side_marks.jsx';
 import { NumberedName } from './numbered_name.jsx';
+import { WinnerTick } from './side_cell.jsx';
 import { creditedBoutSide, isTeamDefaultWinDecision } from './team_default_credit.jsx';
 import { matchShowsScore } from './match_shows_score.jsx';
 
@@ -33,7 +40,6 @@ function TermBC(props) {
 // Local hikiwake check: bracket.jsx is tested in isolation, so we don't rely
 // on window.isHikiwake here. See specs/openapi.yaml.
 function isHikiwakeBC(v) { return v === "hikiwake"; }
-function isKikenDecisionBC(v) { return v === "kiken" || v === "kiken-voluntary" || v === "kiken-injury"; }
 
 // roundLabelFromEnd: the ONE mapping from "rounds still to come after this one"
 // to a round NAME. 0 = Final, 1 = Semifinals, 2 = Quarterfinals, then the
@@ -206,26 +212,6 @@ function middleMark(decision, encho) {
   return enchoLabel(encho);
 }
 
-// joinSp: join a score fragment and a result mark with a space, skipping
-// empties ("M" + "Ht" → "M Ht", "" + "Kiken" → "Kiken"). The JS twin of
-// domain.JoinNonEmpty in internal/domain/result_marks.go.
-const joinSp = (a, b) => [a, b].filter(Boolean).join(" ");
-
-// placeMarks: resolve sideMarks onto the two display slots — the winner's
-// mark rides the winning side, the loser's the other. When neither slot is
-// known to have won, no marks are placed; each caller owns that fallback
-// (score strings trail the marks, match cards drop them). The JS analogue
-// of domain.SideMarksAB (internal/domain/result_marks.go), whose marks
-// export.SideMarksLR places White-left on the sheet.
-// Companion rule: on the two-slot GRID surfaces (the shared scoreboard and the
-// team score editor) which of a side's two cells the mark takes is answered by
-// resultSlot in result_slot.jsx — a separate leaf; the dependency reasoning is
-// stated ONCE, in that file's header. Flat score strings have no slots, so
-// they concatenate instead and never call it.
-function placeMarks(marks, firstWins, secondWins) {
-  return firstWins ? [marks.winner, marks.loser] : secondWins ? [marks.loser, marks.winner] : ["", ""];
-}
-
 // isDrawResult: a result is a draw when the recorded decision OR the
 // client-derived score.type says hikiwake (quick-score paths set only
 // score.type, so both sources count).
@@ -264,86 +250,6 @@ function matchMiddleMark(match) {
   return mid === "vs" ? "" : mid;
 }
 
-// sideMarks: the per-side RESULT marks. winner goes in the winning side's
-// score cell, loser in the losing side's — the mark names its competitor:
-//   hantei   → winner "Ht"    (FIK 7-5 / 29-6: judges picked the winner)
-//   kiken    → loser  "Kiken" (the competitor who withdrew)
-//   fusenpai → loser  "Fus."  (the no-show)
-//   fusensho → winner "Fus."  (the default WIN names the present side)
-// Mirrors domain.SideMarks (internal/domain/result_marks.go) exactly
-// (CLAUDE.md documents the pair as one mirrored rule). bc-tmfn removed the
-// earlier fusensho gap here: this surface used to omit the winner-side "Fus."
-// mark on the theory that "the viewer surfaces it via a separate bout badge",
-// but no such badge exists for a MATCH-LEVEL fusensho decision (only a
-// per-bout team row's ○○ fill, which is a different thing), so a match-level
-// default win used to render with no mark on this surface at all. There is no
-// divergence left to document: a fusensho match now reads identically here and
-// in the export.
-function sideMarks(decision, decidedByHantei) {
-  let winner = "", loser = "";
-  if (isKikenDecisionBC(decision)) loser = "Kiken";
-  else if (decision === "fusenpai") loser = "Fus.";
-  else if (decision === "fusensho") winner = "Fus.";
-  if (decidedByHantei) winner = joinSp(winner, "Ht");
-  return { winner, loser };
-}
-
-// teamMatchMarks: the match-level Kiken/Fus. mark for EACH side of a TEAM
-// match a default-win decision closed -- the same sideMarks + placeMarks
-// pattern MatchCard already applies to an individual match's score cell
-// (aWin/bWin via sameCompetitor, then placeMarks), generalized for a caller
-// that renders a side's NAME separately from its score cell (a list row, a
-// TV headline) rather than inline in a flat score string. THE one place this
-// composition lives (bc-tmfn): every consumer below calls this rather than
-// re-deriving its own copy.
-//
-// `isTeamRow` is the caller's OWN team-match signal (a subResults array, a
-// compKind check, whatever it already has) -- this function has no way to
-// tell an individual match's kiken from a team one, so it never guesses.
-// Without it, an ordinary INDIVIDUAL kiken/fusenpai match would get this
-// mark TWICE: once here, once already inline in its own matchScoreStr
-// (formatIpponsScore's sideMarks call), since teamIVPWScore is deliberately
-// free of marks and an individual score string is not.
-//
-// bc-cse: OPTIONAL. Four callers (admin_schedule_score_editor.jsx,
-// viewer_match.jsx, viewer_schedule.jsx, viewer_standings.jsx) computed the
-// exact same `Array.isArray(m.subResults) && m.subResults.length > 0` before
-// calling in, so that default now lives here instead and those four callers
-// pass nothing. A caller with a BETTER signal (viewer_match.jsx's own
-// compKind/teamSize check, display_scoreboard.jsx's competition-format
-// isTeamMatch prop) still passes it explicitly to override the default --
-// e.g. a genuine team match with an empty subResults array (nothing fought
-// yet) would otherwise read as non-team here.
-//
-// Returns {} for a non-team row, a not-yet-completed match, or a decision
-// sideMarks has nothing to say about (returns "" for both sides, same as
-// the individual case).
-function teamMatchMarks(match, isTeamRow) {
-  const teamRow = isTeamRow === undefined
-    ? Array.isArray(match?.subResults) && match.subResults.length > 0
-    : isTeamRow;
-  if (!teamRow || !match || match.status !== "completed") return { shiro: "", aka: "" };
-  const marks = sideMarks(match.decision, !!match.decidedByHantei);
-  const aWin = sameCompetitor(match.winner, match.sideA);
-  const bWin = sameCompetitor(match.winner, match.sideB);
-  const [aMark, bMark] = placeMarks(marks, aWin, bWin);
-  return { shiro: bMark, aka: aMark };
-}
-
-// winnerSideLR: which DISPLAY side won, under the SHIRO-left convention every
-// score string uses (sideB = Shiro = left, sideA = Aka = right). Returns
-// "left" | "right" | null (no winner recorded, drifted data, or a mixed
-// id/no-id pair that sameCompetitor refuses to guess on). Accepts both
-// object sides ({id, name}) and bare name strings (routed through
-// sameCompetitor, competitor_identity.jsx -- the one owner of the id/name
-// attribution rule).
-function winnerSideLR(m) {
-  if (!m || !m.winner) return null;
-  if (sameCompetitor(m.winner, m.sideB)) return "left";
-  if (sameCompetitor(m.winner, m.sideA)) return "right";
-  return null;
-}
-
 // Format ippons as a readable score string: ["M","K"] → "MK", [] → ""
 // Returns something like "MM vs K", "M (E) –", "M X K", "X", "BYE".
 //
@@ -518,7 +424,7 @@ const PlayerLine = React.memo(({ player, isWinner, side, showDojo, score, isTBD,
     <div className={`bc-side bc-side--${side} ${isWinner ? "bc-side--winner" : ""}`}>
       <div className="bc-name-wrap">
         <span className="bc-name">
-          {isWinner ? <span className="bc-winner-tick" aria-label="Winner" title="Winner">✓</span> : null}
+          {isWinner ? <WinnerTick /> : null}
           <NumberedName name={m1} number={player.number} />
         </span>
         {m2 ? <span className="bc-name">{m2}</span> : null}
@@ -1503,9 +1409,11 @@ window.sideLabel = sideLabel;
 // sideMarks/placeMarks: the same MatchCard pattern (which side gets which
 // result mark), exposed for the window-global consumers that place a
 // match-level Kiken/Fus. mark beside a withdrawn TEAM's name (bc-tmfn) --
-// VSchedItem/TWMatch/PoolNumberedMatchRow/the admin Scores row -- none of
-// which ES-import bracket.jsx (see those files' own window.matchScoreStr /
-// window.boutMiddle usage for the pre-existing pattern this follows).
+// VSchedItem/TWMatch/PoolNumberedMatchRow and the viewer/display bundles --
+// none of which ES-import bracket.jsx (see those files' own window.matchScoreStr
+// / window.boutMiddle usage for the pre-existing pattern this follows). The
+// court console and the admin Scores row import the same helpers from
+// side_marks.jsx instead, where they are defined.
 window.sideMarks = sideMarks;
 window.placeMarks = placeMarks;
 window.teamMatchMarks = teamMatchMarks;
diff --git a/web-mobile/js/lineup_resolver.jsx b/web-mobile/js/lineup_resolver.jsx
index 1c136bb93..c64c9880d 100644
--- a/web-mobile/js/lineup_resolver.jsx
+++ b/web-mobile/js/lineup_resolver.jsx
@@ -225,6 +225,42 @@ export function mergeLineupIdsForPosition(existingIds, posKey, resolvedId) {
   return updated;
 }
 
+// resolveTypedMemberName: the one step that resolves a name typed into a team
+// slot to its squad member, through resolveMemberIdsForPositions (admin_lineup.jsx,
+// reached via window.AdminLineupHelpers). `key` is the name's key in the
+// resolver's map: a lineup position's posKey, or the representative of a
+// daihyosen row (bc-dhrp). A lineup position's typed name (buildInlineLineupWrite)
+// and a representative's typed name (submitRepresentative) both resolve here, so
+// they resolve the same way. Answers { squad, memberId, failures, resolverMissing }. A resolver that is
+// missing or throws answers no member, with resolverMissing set when it was
+// missing, and the caller goes on without the member: the NAME is the
+// load-bearing half of a slot and the id an enhancement over it, so an
+// identity failure must never block the write (an operator swapping a
+// fighter mid-encounter keeps the swap). The caller reports the members-
+// unavailable warning, which memberIdentityWarning composes.
+export async function resolveTypedMemberName(compId, teamId, key, value, squad, password, currentIds) {
+  const answer = { squad: Array.isArray(squad) ? squad : [], memberId: null, failures: [], resolverMissing: false };
+  try {
+    const resolver = window.AdminLineupHelpers?.resolveMemberIdsForPositions;
+    if (typeof resolver !== "function") {
+      answer.resolverMissing = true;
+    } else {
+      // currentIds: a name typed into a slot PICKED by number (its member id
+      // already set on this key) renames that same member rather than falling
+      // back to the position's index default -- see resolveMemberIdsForPositions'
+      // own doc comment.
+      const resolved = await resolver(compId, teamId, { [key]: value }, squad, password, currentIds);
+      answer.squad = resolved.squad;
+      answer.memberId = resolved.memberIds[key] || null;
+      answer.failures = resolved.failures || [];
+    }
+  } catch (_e) {
+    // The helper's own per-position mint catch sits beneath this one, and the
+    // write still proceeds: see the note above.
+  }
+  return answer;
+}
+
 // buildInlineLineupWrite computes exactly what the inline lineup picker
 // (submitInlineLineup, inside TeamScoreEditorModal in admin_scoring_team.jsx)
 // writes with putMatchLineup: the one position it changes, `changed: [posKey]`
@@ -293,28 +329,12 @@ export async function buildInlineLineupWrite(compId, teamId, lineup, squad, posK
   let nextSquad = Array.isArray(squad) ? squad : [];
   let failures = [];
   if (!pickedMemberId && value) {
-    try {
-      const resolver = window.AdminLineupHelpers?.resolveMemberIdsForPositions;
-      if (typeof resolver === "function") {
-        // currentIds: a name typed into a slot PICKED by number (its
-        // memberId already set on this position) renames that same member
-        // rather than falling back to the position's index default -- see
-        // resolveMemberIdsForPositions' own doc comment.
-        const resolved = await resolver(compId, teamId, { [posKey]: value }, squad, password, lineup?.memberIds);
-        nextSquad = resolved.squad;
-        resolvedId = resolved.memberIds[posKey] || null;
-        failures = resolved.failures || [];
-      }
-    } catch (_e) {
-      // On top of the helper's own per-position mint catch, because this
-      // runs on the live scoring path: an operator swapping a fighter
-      // mid-encounter must not lose the swap because identity resolution
-      // failed. The NAME is the load-bearing half of a lineup slot and the
-      // id is an enhancement over it, so the write proceeds either way;
-      // mergeLineupIdsForPosition below clears this position's id, the same
-      // as any other unresolved name, and the load-time repair fills it in
-      // later from the squad.
-    }
+    // A failed resolve still writes the name: mergeLineupIdsForPosition below
+    // clears this position's id, and the load-time repair fills it in later.
+    const typed = await resolveTypedMemberName(compId, teamId, posKey, value, squad, password, lineup?.memberIds);
+    nextSquad = typed.squad;
+    resolvedId = typed.memberId;
+    failures = typed.failures;
   }
 
   const otherPosKey = memberPlacedElsewhere(lineup?.memberIds, posKey, resolvedId);
@@ -515,9 +535,9 @@ export function lineupPositionLabel(posKey) {
 // there so placeHt can put the hantei mark on the winner's side, and blanking
 // them drops the mark from the wire. Filtering them here blanked both of that
 // row's name cells, and the rep bout is the ONE row with no fallback label
-// (its lineup key is the literal "daihyosen", which no lineup carries, and it
-// offers no roster or typeable box), so the editor printed "-" against both
-// teams where the two names used to be.
+// (its lineup key is the literal "daihyosen", which no lineup carries; its
+// fighters are the member ids the operator picked on the row, bc-dhrp), so the
+// editor printed "-" against both teams where the two names used to be.
 export function resolveBoutSideName({ isKachinuki, isDaihyosen, existingName, lineupName, teamNameA, teamNameB }) {
   const namesATeam = existingName === teamNameA || existingName === teamNameB;
   const stored = namesATeam && !isDaihyosen ? "" : existingName;
@@ -529,7 +549,8 @@ export function resolveBoutSideName({ isKachinuki, isDaihyosen, existingName, li
 // bootstrap (index 0), the lineup position no longer identifies who fights
 // (winner-stays advancement determines the pairing), so display surfaces must
 // suppress the position-lineup name and fall back to the bout number. The
-// daihyosen (isDaihyosen) is an operator-chosen rep bout and stays lineup-first.
+// daihyosen (isDaihyosen) is an operator-chosen rep bout, not a lineup position,
+// and is never hidden.
 // Shared by the display surfaces (match_scoreboard, streaming_overlay) so the
 // bootstrap rule lives in one place.
 export function kachinukiHidesLineupPosition(isKachinuki, isDaihyosen, index) {
@@ -576,14 +597,18 @@ export function pickMemberIdFromLineup(lineup, index, teamSize) {
 // numbered bout's pairing is server-bout-log first, the SubMatchResult's own
 // sideAMemberId/sideBMemberId -- backfilled from team-members.yaml by the
 // legacy-upgrade repair -- so the lineup position's id must never outrank
-// it; fixed-format and the daihyosen row stay lineup-first). Callers pass
+// it; fixed-format rows stay lineup-first). The representative bout
+// (isDaihyosen) is the one row whose fighter is the operator's own pick,
+// recorded on that row (bc-dhrp), so it reads only that row's id and never a
+// lineup position. Callers pass
 // existingMemberId/lineupMemberId from the SAME existing/lineup objects
 // resolveBoutSideName was given for the SAME row, and must independently
 // block an operator's free-typed override (which has no valid lineup key to
 // resolve an id from at all) before ever reaching this function -- see
 // admin_scoring_team.jsx's playerNamesForBout for that guard.
 export function resolveBoutSideMemberId({ isKachinuki, isDaihyosen, existingMemberId, lineupMemberId }) {
-  if (isKachinuki && !isDaihyosen) return existingMemberId || lineupMemberId || "";
+  if (isDaihyosen) return existingMemberId || "";
+  if (isKachinuki) return existingMemberId || lineupMemberId || "";
   return lineupMemberId || existingMemberId || "";
 }
 
diff --git a/web-mobile/js/match_groups.jsx b/web-mobile/js/match_groups.jsx
index b58f83258..438e6c948 100644
--- a/web-mobile/js/match_groups.jsx
+++ b/web-mobile/js/match_groups.jsx
@@ -3,8 +3,8 @@
 // events must be ordered.").
 //
 // The server merges a score write group by group (internal/state/
-// match_groups.go): points, result, encho, flags, rep, and one group per bout
-// row, "bout:<position>". A write names the groups it changes in `changed`;
+// match_groups.go): points, result, encho, flags, rep, repPickA, repPickB, and one group
+// per bout row, "bout:<position>". A write names the groups it changes in `changed`;
 // each named group applies only when the write is not older than that group's
 // stored change, a group the write does not name is never overwritten, and a
 // change that is not applied is kept in the match's history. So a client write
@@ -27,7 +27,7 @@
 import { IPPON_PLACEHOLDER } from './result_slot.jsx';
 import {
     NEEDS_WINNER_NOTE, DEFAULT_WIN_STANDS_NOTE, writeNeedsWinner, writeDefaultWinStands, writeHeldDecision,
-    writePartlyHeld, writeHeldGroups, writeDisplacedGroups,
+    writePartlyHeld, writeHeldGroups, writeDisplacedGroups, writeDisplacedForWinner,
 } from './write_result.jsx';
 
 export const GROUP_POINTS = 'points';
@@ -35,9 +35,15 @@ export const GROUP_RESULT = 'result';
 export const GROUP_ENCHO = 'encho';
 export const GROUP_FLAGS = 'flags';
 export const GROUP_REP = 'rep';
+// The two representatives of the representative bout (the member ids on its -1
+// row), one group per side: each is a change of its own, dated apart from the
+// other side's and from "bout:-1", which keeps the bout's score and result. Not
+// to be confused with GROUP_REP, the pool daihyosen/tiebreaker players.
+export const GROUP_REP_PICK_A = 'repPickA';
+export const GROUP_REP_PICK_B = 'repPickB';
 
 // The scalar groups in the server's fixed order (state.ScalarGroups).
-export const SCALAR_GROUPS = [GROUP_POINTS, GROUP_RESULT, GROUP_ENCHO, GROUP_FLAGS, GROUP_REP];
+export const SCALAR_GROUPS = [GROUP_POINTS, GROUP_RESULT, GROUP_ENCHO, GROUP_FLAGS, GROUP_REP, GROUP_REP_PICK_A, GROUP_REP_PICK_B];
 
 const BOUT_PREFIX = 'bout:';
 
@@ -81,6 +87,8 @@ export function groupLabel(group) {
         case GROUP_ENCHO: return 'overtime';
         case GROUP_FLAGS: return 'flags';
         case GROUP_REP: return 'the representative players';
+        case GROUP_REP_PICK_A: return 'Aka\'s pick for the representative bout';
+        case GROUP_REP_PICK_B: return 'Shiro\'s pick for the representative bout';
         default: {
             const pos = parseBoutGroup(group);
             if (pos === null) return String(group || '');
@@ -110,26 +118,33 @@ export function heldGroupsNote(groups, needsWinner = false, defaultWinStands = f
 }
 
 // displacedGroupsNote: the note for a write that WAS recorded and moved a
-// later change of the match to its history, because that change would have
-// left the finished match without a winner (write_result.jsx
-// writeDisplacedGroups). null when nothing was moved.
-export function displacedGroupsNote(groups) {
+// later change of the match to its history (write_result.jsx
+// writeDisplacedGroups). `needsWinner` (writeDisplacedForWinner) when the
+// answer says why with heldReason "needs_winner": the change would have left
+// the finished match without a winner. A change moved for another reason (a representative's pick
+// stamped after the representative bout's removal, which leaves it nothing to
+// stand on) carries no such reason and is worded plainly, never with a winner
+// the match does not lack. null when nothing was moved.
+export function displacedGroupsNote(groups, needsWinner = false) {
     const words = groupsLabel(groups);
     if (!words) return null;
-    return `Saved. A later change to ${words} would have left the finished match without a winner, so it was moved to the match's history.`;
+    return needsWinner
+        ? `Saved. A later change to ${words} would have left the finished match without a winner, so it was moved to the match's history.`
+        : `Saved. A later change to ${words} was moved to the match's history.`;
 }
 
 // keptInHistoryNote: the ONE note a score editor (useKeptInHistoryNote) or
 // its closing host (admin.jsx's toast) shows for what a write's answer kept
 // in the match's history: this write's own groups held (applied in part, or
 // superseded because the finished match needs a winner), and/or later
-// changes it moved there. null when the answer kept nothing.
+// changes it moved there (worded by the reason the answer gives, if any).
+// null when the answer kept nothing.
 export function keptInHistoryNote(res) {
     const parts = [];
     if (writePartlyHeld(res) || writeNeedsWinner(res) || writeDefaultWinStands(res)) {
         parts.push(heldGroupsNote(writeHeldGroups(res), writeNeedsWinner(res), writeDefaultWinStands(res), writeHeldDecision(res)));
     }
-    parts.push(displacedGroupsNote(writeDisplacedGroups(res)));
+    parts.push(displacedGroupsNote(writeDisplacedGroups(res), writeDisplacedForWinner(res)));
     const text = parts.filter(Boolean).join(' ');
     return text || null;
 }
@@ -184,6 +199,10 @@ function statedGroups(next) {
     out.push(GROUP_ENCHO);
     if (has(next, 'flagsA') || has(next, 'flagsB')) out.push(GROUP_FLAGS);
     if (has(next, 'repPlayerA') || has(next, 'repPlayerB')) out.push(GROUP_REP);
+    // The representatives sit on the representative bout's row: a write that
+    // carries that row states both sides' picks (an id left off the row is that
+    // side's pick cleared).
+    if (rowAt(next, -1)) out.push(GROUP_REP_PICK_A, GROUP_REP_PICK_B);
     if (Array.isArray(next.subResults)) {
         for (const s of next.subResults) {
             const g = s ? boutGroup(num(s.position)) : null;
@@ -220,12 +239,43 @@ function groupKey(wire, group, next) {
                 has(next, 'repPlayerA') ? str(w.repPlayerA) : null,
                 has(next, 'repPlayerB') ? str(w.repPlayerB) : null,
             ]);
+        case GROUP_REP_PICK_A: {
+            // Each side's pick is a change of its own, so its value is that side's
+            // id alone. An absent id reads as empty: a pick cleared leaves its key
+            // out, and must still be named.
+            const row = rowAt(w, -1) || {};
+            return str(row.sideAMemberId);
+        }
+        case GROUP_REP_PICK_B: {
+            const row = rowAt(w, -1) || {};
+            return str(row.sideBMemberId);
+        }
         default: {
             const pos = parseBoutGroup(group);
             const own = rowAt(next, pos);
             const keys = new Set(Object.keys(own || {}).filter((k) => own[k] !== undefined));
             keys.add('encho');
             keys.add('position');
+            // On the representative bout the two picks are GROUP_REP_PICK_A's and
+            // GROUP_REP_PICK_B's (the server copies the bout without them), so a
+            // pick never reads as a change of the bout. The winner's member id is
+            // re-derived by the server from the bout's winner side and the stored
+            // picks (ReconcileWinnerMemberID), so a pick change moves it with no
+            // change to the bout: it is left out too, and the winner's name is what
+            // names the bout. The row's side names are the MATCH's sides: the server
+            // stamps the team names on the row at the add and keeps them equal to the
+            // match's on every re-seat, and the editor restates them so the hantei mark
+            // can be placed on the winner's side. They are never a change of the bout
+            // either, or a pick on a bout nobody has scored would name it and stamp its
+            // scoreline.
+            // Numbered rows keep the rule above.
+            if (pos < 0) {
+                keys.delete('sideAMemberId');
+                keys.delete('sideBMemberId');
+                keys.delete('winnerMemberId');
+                keys.delete('sideA');
+                keys.delete('sideB');
+            }
             // A row the baseline does not hold reads as an empty one, so an
             // untouched blank bout is not a change.
             return JSON.stringify(rowProjection(rowAt(w, pos) || { position: pos }, [...keys].sort()));
diff --git a/web-mobile/js/match_history_view.jsx b/web-mobile/js/match_history_view.jsx
index 94f66744c..d1e943a75 100644
--- a/web-mobile/js/match_history_view.jsx
+++ b/web-mobile/js/match_history_view.jsx
@@ -24,7 +24,7 @@ import { formatIpponsScore } from './bracket.jsx';
 import { hanteiDecided } from './result_slot.jsx';
 import { withdrawalLabel } from './admin_scoring_shared.jsx';
 import { sideWord } from './side_cell.jsx';
-import { groupLabel, parseBoutGroup, GROUP_POINTS, GROUP_RESULT, GROUP_ENCHO, GROUP_FLAGS, GROUP_REP } from './match_groups.jsx';
+import { groupLabel, parseBoutGroup, GROUP_POINTS, GROUP_RESULT, GROUP_ENCHO, GROUP_FLAGS, GROUP_REP, GROUP_REP_PICK_A, GROUP_REP_PICK_B } from './match_groups.jsx';
 
 const { useState: useStateH, useEffect: useEffectH, useRef: useRefH } = React;
 
@@ -45,10 +45,14 @@ const DOOR_WORDS = {
     'kachinuki-advance': 'Next kachinuki bout added',
     'kachinuki-remove-bout': 'Kachinuki bout removed',
     'downstream-reopen': 'Reopened by a correction to an earlier match',
-    // A change already recorded that an earlier-made finish, arriving later,
-    // moved out of the match because it would have left the finished match
-    // without a winner (the entry carries that change's own time).
+    // A change already recorded that a write arriving later moved out of the
+    // match: either an earlier-made finish whose later change would have left the
+    // finished match without a winner, or a representative pick made after its
+    // representative bout was removed (the entry carries that change's own time).
     'displaced': 'Later change moved to history',
+    // A match that was not reopened but had a side seated again by a correction to an
+    // earlier match (a feeder's winner changed), for a line of its own.
+    'reseat': 'Side given another team by a correction to an earlier match',
 };
 
 export function historyDoorWords(door) {
@@ -95,8 +99,20 @@ function resultText(v) {
     return 'finished with no winner';
 }
 
+// pickText: a representative pick is a member id, which says nothing to the operator by
+// itself. `resolve(side, memberId)` is the editor's (the team editor holds both teams'
+// members; the others pass none): a label for the member, null for an id the side's team
+// does not hold now (a correction seated another team), undefined when the editor has no
+// members to look in. Then the line says only that the side was picked.
+function pickText(memberId, side, resolve) {
+    if (!memberId) return 'not picked';
+    const who = typeof resolve === 'function' ? resolve(side, memberId) : undefined;
+    if (who === null) return 'picked (not on the team now)';
+    return who ? `picked ${who}` : 'picked';
+}
+
 // heldValueText: a short readable form of a change kept in the history.
-export function heldValueText(group, value) {
+export function heldValueText(group, value, resolve) {
     const v = value && typeof value === 'object' ? value : null;
     switch (group) {
         case GROUP_POINTS:
@@ -112,14 +128,20 @@ export function heldValueText(group, value) {
             return v ? `flags Shiro ${Number(v.flagsB) || 0}, Aka ${Number(v.flagsA) || 0}` : 'no flags';
         case GROUP_REP:
             return v ? `Shiro ${v.repPlayerB || 'not picked'}, Aka ${v.repPlayerA || 'not picked'}` : 'not picked';
+        case GROUP_REP_PICK_A:
+            // A = Aka = the match's side A; the id belongs to that side's team.
+            return pickText(v && v.sideAMemberId, 'a', resolve);
+        case GROUP_REP_PICK_B:
+            return pickText(v && v.sideBMemberId, 'b', resolve);
         default:
             if (parseBoutGroup(group) === null) return '';
             return v ? `${scorelineText(v)}${foulsText(v)}` : 'no bout';
     }
 }
 
-// historyEntryView: one history entry as the lines the disclosure shows.
-export function historyEntryView(entry) {
+// historyEntryView: one history entry as the lines the disclosure shows. `resolve` is
+// the editor's member resolver for a representative pick (pickText); optional.
+export function historyEntryView(entry, resolve) {
     const changed = (entry.changed || []).map(groupLabel).filter(Boolean);
     // A line per group the server recorded as HELD, and only those: an echo
     // it recorded as unchanged (the value already stored) never shows, even
@@ -131,7 +153,7 @@ export function historyEntryView(entry) {
     const keptWord = moved ? 'Moved to history' : 'Kept in history';
     const held = Object.keys(entry.held || {}).filter((g) => outcomes[g] === 'held').map((g) => ({
         group: g,
-        text: `${keptWord}: ${groupLabel(g)}, ${heldValueText(g, entry.held[g])}`,
+        text: `${keptWord}: ${groupLabel(g)}, ${heldValueText(g, entry.held[g], resolve)}`,
     }));
     const cleared = entry.clearedWithdrawal
         ? `Withdrawal cleared by later scoring: ${resultText(entry.clearedWithdrawal)}`
@@ -150,7 +172,10 @@ export function historyEntryView(entry) {
     };
 }
 
-export function MatchHistoryDisclosure({ match, password, hidden = false }) {
+// `members`, optional: the editor's resolver from (side, memberId) to the representative's
+// name (see pickText). Only the team editor holds the members, so the others pass none
+// and a pick reads as it always did.
+export function MatchHistoryDisclosure({ match, password, hidden = false, members }) {
     const [open, setOpen] = useStateH(false);
     const [state, setState] = useStateH({ key: '', loading: false, error: '', entries: null });
     const mountedRef = useRefH(true);
@@ -203,7 +228,7 @@ export function MatchHistoryDisclosure({ match, password, hidden = false }) {
                     {!error && entries && entries.length > 0 && (
                         <ol className="match-history__list">
                             {entries.map((e, i) => {
-                                const v = historyEntryView(e);
+                                const v = historyEntryView(e, members);
                                 // An entry has no id. The history is append-only and read
                                 // whole, oldest first, so its position is stable; the
                                 // rest only helps React tell a reload's entries apart.
diff --git a/web-mobile/js/side_cell.jsx b/web-mobile/js/side_cell.jsx
index d58fa6952..fc243574c 100644
--- a/web-mobile/js/side_cell.jsx
+++ b/web-mobile/js/side_cell.jsx
@@ -55,6 +55,21 @@ export function SideLabel({ side }) {
   return <span className="sr-only">{sideWord(side)}: </span>;
 }
 
+// The winner's tick beside the winning side's name. The glyph is decorative and
+// hidden from assistive technology; the sr-only word carries the fact, for the
+// same reason SideLabel is a span rather than an aria-label. The words follow
+// the tick's place in the row: "Winner: " before the name, ", winner" when the
+// tick sits after it (`trailing`, Aka on Recent results), so the row is spoken
+// "Aka: Tanaka, winner" and not "Aka: Tanaka Winner:".
+export function WinnerTick({ trailing = false }) {
+  return (
+    <span className="bc-winner-tick" title="Winner">
+      <span aria-hidden="true">✓</span>
+      <span className="sr-only">{trailing ? ", winner" : "Winner: "}</span>
+    </span>
+  );
+}
+
 // A tinted side cell.
 //
 //   side       "shiro" | "aka". The one place the surface states it.
diff --git a/web-mobile/js/side_marks.jsx b/web-mobile/js/side_marks.jsx
new file mode 100644
index 000000000..7fbf80208
--- /dev/null
+++ b/web-mobile/js/side_marks.jsx
@@ -0,0 +1,126 @@
+// side_marks.jsx: the RESULT-mark placement helpers (Kiken, Fus., Ht beside the
+// competitor they name) and the winner-side lookup they hang off. Leaf module:
+// its one import is competitor_identity.jsx, itself a leaf, so a surface that
+// must not reach bracket.jsx can still place a mark.
+//
+// WHY THIS IS NOT IN bracket.jsx. The court console (admin_shiaijo.jsx) places a
+// completed row's winner cue and a withdrawn team's mark, and it cannot import
+// bracket.jsx: its render suite stubs window.BracketTree before importing the
+// console, the console reads that global at module eval, and bracket.jsx
+// reassigns window.BracketTree in its own module body. An import's dependencies
+// evaluate FIRST, so a path from the console to bracket.jsx would overwrite the
+// stub (the console's header states the rule). The helpers used to be read off
+// `window` there, behind a guard that painted nothing when the global was
+// missing; they are imported from here instead. side_marks_leaf.test.jsx pins
+// the one-import rule.
+//
+// bracket.jsx imports these six, keeps every `window.X = X` line (the display
+// and viewer bundles read them) and re-exports the names, so every importer of
+// bracket.jsx keeps working.
+
+import { sameCompetitor } from './competitor_identity.jsx';
+
+// Local kiken check, so this leaf relies on no window global (the twin of
+// bracket.jsx's isHikiwakeBC). The kiken family is the wire's `kiken`,
+// `kiken-voluntary` and `kiken-injury`: see specs/openapi.yaml.
+export function isKikenDecisionBC(v) { return v === "kiken" || v === "kiken-voluntary" || v === "kiken-injury"; }
+
+// joinSp: join a score fragment and a result mark with a space, skipping
+// empties ("M" + "Ht" → "M Ht", "" + "Kiken" → "Kiken"). The JS twin of
+// domain.JoinNonEmpty in internal/domain/result_marks.go.
+export const joinSp = (a, b) => [a, b].filter(Boolean).join(" ");
+
+// placeMarks: resolve sideMarks onto the two display slots — the winner's
+// mark rides the winning side, the loser's the other. When neither slot is
+// known to have won, no marks are placed; each caller owns that fallback
+// (score strings trail the marks, match cards drop them). The JS analogue
+// of domain.SideMarksAB (internal/domain/result_marks.go), whose marks
+// export.SideMarksLR places White-left on the sheet.
+// Companion rule: on the two-slot GRID surfaces (the shared scoreboard and the
+// team score editor) which of a side's two cells the mark takes is answered by
+// resultSlot in result_slot.jsx — a separate leaf; the dependency reasoning is
+// stated ONCE, in that file's header. Flat score strings have no slots, so
+// they concatenate instead and never call it.
+export function placeMarks(marks, firstWins, secondWins) {
+  return firstWins ? [marks.winner, marks.loser] : secondWins ? [marks.loser, marks.winner] : ["", ""];
+}
+
+// sideMarks: the per-side RESULT marks. winner goes in the winning side's
+// score cell, loser in the losing side's — the mark names its competitor:
+//   hantei   → winner "Ht"    (FIK 7-5 / 29-6: judges picked the winner)
+//   kiken    → loser  "Kiken" (the competitor who withdrew)
+//   fusenpai → loser  "Fus."  (the no-show)
+//   fusensho → winner "Fus."  (the default WIN names the present side)
+// Mirrors domain.SideMarks (internal/domain/result_marks.go) exactly
+// (CLAUDE.md documents the pair as one mirrored rule). bc-tmfn removed the
+// earlier fusensho gap here: this surface used to omit the winner-side "Fus."
+// mark on the theory that "the viewer surfaces it via a separate bout badge",
+// but no such badge exists for a MATCH-LEVEL fusensho decision (only a
+// per-bout team row's ○○ fill, which is a different thing), so a match-level
+// default win used to render with no mark on this surface at all. There is no
+// divergence left to document: a fusensho match now reads identically here and
+// in the export.
+export function sideMarks(decision, decidedByHantei) {
+  let winner = "", loser = "";
+  if (isKikenDecisionBC(decision)) loser = "Kiken";
+  else if (decision === "fusenpai") loser = "Fus.";
+  else if (decision === "fusensho") winner = "Fus.";
+  if (decidedByHantei) winner = joinSp(winner, "Ht");
+  return { winner, loser };
+}
+
+// teamMatchMarks: the match-level Kiken/Fus. mark for EACH side of a TEAM
+// match a default-win decision closed -- the same sideMarks + placeMarks
+// pattern MatchCard already applies to an individual match's score cell
+// (aWin/bWin via sameCompetitor, then placeMarks), generalized for a caller
+// that renders a side's NAME separately from its score cell (a list row, a
+// TV headline) rather than inline in a flat score string. THE one place this
+// composition lives (bc-tmfn): every consumer below calls this rather than
+// re-deriving its own copy.
+//
+// `isTeamRow` is the caller's OWN team-match signal (a subResults array, a
+// compKind check, whatever it already has) -- this function has no way to
+// tell an individual match's kiken from a team one, so it never guesses.
+// Without it, an ordinary INDIVIDUAL kiken/fusenpai match would get this
+// mark TWICE: once here, once already inline in its own matchScoreStr
+// (formatIpponsScore's sideMarks call), since teamIVPWScore is deliberately
+// free of marks and an individual score string is not.
+//
+// bc-cse: OPTIONAL. Four callers (admin_schedule_score_editor.jsx,
+// viewer_match.jsx, viewer_schedule.jsx, viewer_standings.jsx) computed the
+// exact same `Array.isArray(m.subResults) && m.subResults.length > 0` before
+// calling in, so that default now lives here instead and those four callers
+// pass nothing. A caller with a BETTER signal (viewer_match.jsx's own
+// compKind/teamSize check, display_scoreboard.jsx's competition-format
+// isTeamMatch prop) still passes it explicitly to override the default --
+// e.g. a genuine team match with an empty subResults array (nothing fought
+// yet) would otherwise read as non-team here.
+//
+// Returns { shiro: "", aka: "" } for a non-team row, a not-yet-completed
+// match, or a decision sideMarks has nothing to say about (the same empty
+// marks as the individual case).
+export function teamMatchMarks(match, isTeamRow) {
+  const teamRow = isTeamRow === undefined
+    ? Array.isArray(match?.subResults) && match.subResults.length > 0
+    : isTeamRow;
+  if (!teamRow || !match || match.status !== "completed") return { shiro: "", aka: "" };
+  const marks = sideMarks(match.decision, !!match.decidedByHantei);
+  const aWin = sameCompetitor(match.winner, match.sideA);
+  const bWin = sameCompetitor(match.winner, match.sideB);
+  const [aMark, bMark] = placeMarks(marks, aWin, bWin);
+  return { shiro: bMark, aka: aMark };
+}
+
+// winnerSideLR: which DISPLAY side won, under the SHIRO-left convention every
+// score string uses (sideB = Shiro = left, sideA = Aka = right). Returns
+// "left" | "right" | null (no winner recorded, drifted data, or a mixed
+// id/no-id pair that sameCompetitor refuses to guess on). Accepts both
+// object sides ({id, name}) and bare name strings (routed through
+// sameCompetitor, competitor_identity.jsx -- the one owner of the id/name
+// attribution rule).
+export function winnerSideLR(m) {
+  if (!m || !m.winner) return null;
+  if (sameCompetitor(m.winner, m.sideB)) return "left";
+  if (sameCompetitor(m.winner, m.sideA)) return "right";
+  return null;
+}
diff --git a/web-mobile/js/start_match.jsx b/web-mobile/js/start_match.jsx
new file mode 100644
index 000000000..a1d5c3283
--- /dev/null
+++ b/web-mobile/js/start_match.jsx
@@ -0,0 +1,200 @@
+// start_match.jsx: the ONE owner of how a match START is written and of what
+// the answer to it means (bc-aadv, PR #463 round 13).
+//
+// Two hosts start a match on the operator's behalf: the court console
+// (admin_shiaijo.jsx startMatch: the Up next card, a queue row, Finish + Start
+// Next and the start after a decision) and the Scores tab
+// (admin_schedule_score_editor.jsx: the same two automatic advances). The
+// console read the answer and the Scores tab did not, so a start the server
+// refused with HTTP 200 {applied:false, reason:'clock_skew'} was taken for one
+// that landed there, a thrown 409 (eligibility, court_busy, already_ineligible)
+// was swallowed, and nothing stopped a second start while one was out. The
+// three rules below are therefore asked here, once, and neither host restates
+// them:
+//
+//   - startPatch(): the write itself.
+//   - classifyStartOutcome(res) / startFailureMessage(err): what an answer or a
+//     thrown error means, in the operator's words.
+//   - createStartGuard(): one start at a time.
+//
+// Each host keeps its own STATE (the console's startError/refusedTap and its
+// startingRef/pickingRef pair, whose pick exemption is the console's alone; the
+// Scores tab's startRefusal) and its own surface for the sentence. This leaf
+// holds no state of its own beyond the guard object a host creates.
+//
+// A leaf: write_result.jsx (the answer predicates and the clock-skew and
+// superseded words) and
+// match_groups.jsx (the group name startPatch writes, itself a near leaf over
+// write_result.jsx and result_slot.jsx). Neither host's module is imported
+// here, and both import this one directly.
+
+import {
+    writeWasRefusedForClock, writeWasSuperseded, writeHeldGroups, notSavedText,
+    CLOCK_SKEW_REASON_TEXT, SUPERSEDED_REASON, SUPERSEDED_ADVICE,
+} from './write_result.jsx';
+import { GROUP_RESULT } from './match_groups.jsx';
+
+// Minimal "start" patch (status -> running, empty score). Mirrors the editors'
+// own buildPatch("running") for an unscored match and works for both individual
+// and team matches (subResults is omitted, which the serializer treats as "no
+// bouts scored yet"). The server routes it through eng.StartMatchTx, so all
+// start-gating (eligibility 409, court_busy, the players check) still runs: a
+// 409 throws and the caller reports it.
+//
+// startOnly (bc-sbq): this write only starts the match, so the server keeps the
+// score the match already holds (a match sent back to the queue keeps one);
+// toBackendMatchResult leaves the empty scoreline below off the wire. The
+// editors' own Start sends their board unflagged, so an operator who cleared
+// every mark still clears it.
+//
+// bc-mrgc: a start changes the status and nothing else, so it names the result
+// group alone (match_groups.jsx): the server keeps every other group of the
+// match as stored, the score a send-back kept included.
+//
+// The court console and the Scores tab both import it from here; it is not
+// published on `window`.
+export function startPatch() {
+    return {
+        startOnly: true,
+        changed: [GROUP_RESULT],
+        status: "running", winner: null, ipponsA: [], ipponsB: [], hansokuA: 0, hansokuB: 0,
+        score: { type: "ippon", winnerPts: 0, loserPts: 0, ippons: [], fouls: { a: 0, b: 0 }, live: true, corrected: false },
+    };
+}
+
+// The sentence for a start the server refused for the device's clock. A
+// clock_skew refusal means the server stored NOTHING and, unlike a queued
+// start, nothing will land later; the relearn it triggers means a second tap
+// normally succeeds, so the sentence says that instead of leaving a dead first
+// tap.
+export const START_CLOCK_SKEW_MESSAGE = "Could not start: " + CLOCK_SKEW_REASON_TEXT + ". The clock has been resynced; try again.";
+
+// The sentence for a start the server held as superseded WITH a held group (HTTP
+// 200 applied:false, reason superseded, heldGroups ['result']): a different
+// result is already stored (a send-back, a correction), so nothing of the start
+// was written and the match is not running. Unlike the clock sentence above it
+// never says "try again": the opposite is true, the operator must look at the
+// match first, since starting it again blind is exactly what that newer change
+// may have made wrong. Its words are write_result.jsx's (SUPERSEDED_REASON and
+// SUPERSEDED_ADVICE, composed by notSavedText as for every superseded write),
+// under this file's own "Not started" lead; they read, via notSavedText:
+// "Not started: a newer change to the same thing was recorded first, so this one
+// was kept in the match's history and nothing is lost. Check the match and its
+// history before entering anything again: entering it again would replace the
+// newer change." A superseded start with NO held group is not this sentence at
+// all: see classifyStartOutcome.
+export const START_SUPERSEDED_MESSAGE = notSavedText({ lead: 'Not started', reason: SUPERSEDED_REASON, advice: SUPERSEDED_ADVICE });
+
+// The sentence for a thrown start that carries none of its own.
+export const START_FAILED_MESSAGE = "Could not start the match: check eligibility and try again.";
+
+// classifyStartOutcome: what did a start write come back with?
+//   { ok: true }          the start landed, or was QUEUED (a queued start lands
+//                         on reconnect, so the host treats it as started), or
+//                         came back without a body, or was held as an ECHO of a
+//                         start that already landed (below).
+//   { ok: false, msg }    the start was REFUSED and nothing will land later: a
+//                         host that called it started would pin a panel on a
+//                         match that never started while the tap looked like it
+//                         worked. Two answers are refusals, each in its own
+//                         words:
+//                           - clock_skew: the device's clock was out of step;
+//                             the relearn it triggers means a second tap
+//                             normally succeeds (START_CLOCK_SKEW_MESSAGE).
+//                           - superseded WITH a held group: a newer change to
+//                             the match's result is already stored, so nothing
+//                             of the start was written (START_SUPERSEDED_MESSAGE).
+//                             The sentence never invites a retry, since the
+//                             operator must look at the match first.
+// Both hosts take a refusal the same way (store it on the refused match, toast
+// it once, return not-started), so a superseded start needs no branch of its own.
+// A start that THROWS (a 409) is not an answer at all; startFailureMessage
+// words it.
+//
+// Why a superseded answer is two cases (PR #463 round 19). A start names the
+// `result` group alone (startOnly, startPatch's `changed`), and the server lists
+// a held group in `heldGroups` only when its incoming value DIFFERS from the
+// stored one: an equal one is a HeldEcho, neither listed nor kept (reportHeld,
+// match_merge.go), and respondSuperseded omits `heldGroups` when it would be
+// empty. A start does carry rev/revSession like every running payload
+// (api_client.jsx stamps them), and the rev guard (holdOlderRevision ->
+// holdWriteTx, holdAll) holds through reportHeld too, so an echo is an echo-hold
+// there as well. So:
+//   - NO heldGroups: the stored result already equals the start. Another
+//     device's start of this same match landed first with a later stamp, i.e. the
+//     match IS running. The start went out, as far as this device is concerned:
+//     a refusal would say "Not started" about a live match, a pick would not pin
+//     the panel on it, and the Scores tab would clear a waiting refusal ("was
+//     being started") that was accurate.
+//   - heldGroups ['result']: a different result is stored, so the match is not
+//     running and the start is refused.
+// Residual, not fixed: the `result` group's projection also holds
+// CorrectionReason and ResultSource, so a start over a match that is running under
+// a different source or reason answers heldGroups ['result'] and shows the refused
+// sentence while the match is running. The stored notice drops once the live data
+// shows it running (startRefusalStands); only the toast is left, and it is
+// wrong for that one case.
+export function classifyStartOutcome(res) {
+    if (writeWasRefusedForClock(res)) return { ok: false, msg: START_CLOCK_SKEW_MESSAGE };
+    if (writeWasSuperseded(res) && writeHeldGroups(res).length > 0) return { ok: false, msg: START_SUPERSEDED_MESSAGE };
+    return { ok: true };
+}
+
+// startFailureMessage: the sentence for a start that threw. The server's own
+// words when it sent any ("Alice withdrew in Pool A · Match 1 and cannot
+// fight again. ..."), else one fallback.
+export function startFailureMessage(err) {
+    return (err && err.message) || START_FAILED_MESSAGE;
+}
+
+// startRefusalStands: does a stored Start refusal still hold? A refusal is about
+// one match at one moment, so it falls when its row has left `scheduled`, or
+// when a list that holds matches no longer holds it (the match moved), and a
+// stale one never revives when that match is later sent back to the queue. An
+// EMPTY list says nothing about the match (it is empty while a feed loads and
+// across a transient empty refetch), so the refusal stands then. `row` is the
+// refused match's live row in the host's list, or null when the list lacks it;
+// `listHoldsMatches` is whether that list holds any match at all. The court
+// console and the Scores tab both ask this, so they cannot disagree on how long
+// the notice lives.
+export function startRefusalStands({ row, listHoldsMatches }) {
+    if (row) return row.status === "scheduled";
+    return !listHoldsMatches;
+}
+
+// createStartGuard: ONE start at a time. A host creates one and brackets every
+// start it makes with begin/end.
+//
+//   begin(key, match)  { started: true }                        the start may go ahead
+//                      { started: false, repeat: true, blocker } the SAME match is already being
+//                                                                 started: it is on its way, the
+//                                                                 repeat is dropped silently
+//                      { started: false, repeat: false, blocker } ANOTHER match is being started:
+//                                                                 the host refuses this one and
+//                                                                 says so (startWhileStartingMessage,
+//                                                                 write_result.jsx) naming
+//                                                                 blocker.match
+//   end(key)           frees the guard, but only for the start that holds it.
+//   inFlight()         the { key, match } being started, or null.
+//
+// The console keeps its own startingRef/pickingRef pair instead: a pick
+// (pickMatch) is exempt from its own guard and defers the running bout before
+// its start, which this guard has no word for. The Scores tab has no pick.
+export function createStartGuard() {
+    let current = null;
+    return {
+        begin(key, match) {
+            if (current) {
+                return { started: false, repeat: current.key === key, blocker: current };
+            }
+            current = { key, match };
+            return { started: true };
+        },
+        end(key) {
+            if (current && current.key === key) current = null;
+        },
+        inFlight() {
+            return current;
+        },
+    };
+}
diff --git a/web-mobile/js/viewer_competition.jsx b/web-mobile/js/viewer_competition.jsx
index bd7f565f7..86fbad720 100644
--- a/web-mobile/js/viewer_competition.jsx
+++ b/web-mobile/js/viewer_competition.jsx
@@ -151,8 +151,11 @@ export function ViewerCompetition({ tournament, competition, pools, poolMatches,
     // answers the same question from the same rule (mp-jnvl). An unstamped
     // bout still falls back to scheduled time, so a competition whose results
     // predate the stamp reads exactly as it did.
+    // A completed bout with no winner is a hikiwake (drawn match), which is a
+    // result. The membership rule matches the operator's Completed list (status
+    // alone), and the order comes from result_recency.jsx.
     const recent = allMatches
-      .filter((m) => m.status === "completed" && m.winner && hasBothSides(m) && matchInvolvesWatched(m))
+      .filter((m) => m.status === "completed" && hasBothSides(m) && matchInvolvesWatched(m))
       .sort(resultRecencyDesc)
       .slice(0, hasActiveFilter ? 20 : 5);
     return { runningMatches: running, upcomingMatches: upcoming, recentMatches: recent };
@@ -726,7 +729,7 @@ export function ViewerOverview({ c, myPlayer, myUpcoming, currentMatch, runningM
           <div className="vsched">
             {recentMatches.map((m) => (
               <React.Fragment key={m.id}>
-                <VSchedItem m={m} tweaks={tweaks} onClick={() => handleMatchClick(m)} highlight={isPlayerWatched(m.sideA, highlightPlayers) || isPlayerWatched(m.sideB, highlightPlayers)} />
+                <VSchedItem m={m} tweaks={tweaks} onClick={() => handleMatchClick(m)} highlight={isPlayerWatched(m.sideA, highlightPlayers) || isPlayerWatched(m.sideB, highlightPlayers)} winnerTick={true} />
                 {!isSelfRun && expandedMatchId === m.id && <MatchDetailCard match={m} onClose={() => setExpandedMatchId(null)} />}
               </React.Fragment>
             ))}
diff --git a/web-mobile/js/viewer_match.jsx b/web-mobile/js/viewer_match.jsx
index eb12474e6..59f7421ed 100644
--- a/web-mobile/js/viewer_match.jsx
+++ b/web-mobile/js/viewer_match.jsx
@@ -13,7 +13,7 @@
 // unchanged.
 
 import { writeKeepsEditorOpen } from './write_result.jsx';
-import { SideLabel } from './side_cell.jsx';
+import { SideLabel, WinnerTick } from './side_cell.jsx';
 import { useTeamLineups, TeamScoreboard, IndividualScore, numberedParts, teamNameMark } from './match_scoreboard.jsx';
 import { NumberedName } from './numbered_name.jsx';
 import { TermV, poolLabel } from './viewer_utils.jsx';
@@ -195,7 +195,7 @@ export function MatchDetailCard({ match, onClose, escapeToClose = true, slotLabe
 // VSchedItem
 // ---------------------------------------------------------------------------
 
-export const VSchedItem = React.memo(({ m, tweaks, showCompetition, onClick, highlight }) => {
+export const VSchedItem = React.memo(({ m, tweaks, showCompetition, onClick, highlight, winnerTick }) => {
   // bc-pnum: sameCompetitor, never a bare `winner.id === side.id` (see
   // bracket.jsx's MatchCard for why the naked equality lights both sides
   // once both are id-less). No presence guard: sameCompetitor(null, x) is
@@ -291,7 +291,10 @@ export const VSchedItem = React.memo(({ m, tweaks, showCompetition, onClick, hig
               above, so without it a long name clipped that mark away (or, on
               Aka, pushed its leading mark past the visible width) exactly as
               the bare number once did. */}
-          <span className="n msb-name--labelled">{barredNameMark(m, "shiro", teamNameMark("shiro", teamShiroMark, <NumberedName side="shiro" clip {...numberedParts(m.sideB, undefined)} />))}</span>
+          {/* The winner tick (Recent results only) rides INSIDE the `.n` flex
+              row, at the side's outer edge: first on Shiro, last on Aka. As a
+              sibling of `.n` it took a line of its own above the name. */}
+          <span className="n msb-name--labelled">{winnerTick && bWin && <WinnerTick />}{barredNameMark(m, "shiro", teamNameMark("shiro", teamShiroMark, <NumberedName side="shiro" clip {...numberedParts(m.sideB, undefined)} />))}</span>
           {tweaks.showDojo && m.sideB?.dojo ? <span className="d">{m.sideB.dojo}</span> : null}
         </div>
         {/* No score string (pending, or completed with no recorded cells) →
@@ -319,7 +322,7 @@ export const VSchedItem = React.memo(({ m, tweaks, showCompetition, onClick, hig
         )}
         <div className={`vsched-item__side vsched-item__side--aka ${aWin ? "vsched-item__side--w" : ""}`}>
           <SideLabel side="aka" />
-          <span className="n msb-name--labelled">{barredNameMark(m, "aka", teamNameMark("aka", teamAkaMark, <NumberedName side="aka" clip {...numberedParts(m.sideA, undefined)} />))}</span>
+          <span className="n msb-name--labelled">{barredNameMark(m, "aka", teamNameMark("aka", teamAkaMark, <NumberedName side="aka" clip {...numberedParts(m.sideA, undefined)} />))}{winnerTick && aWin && <WinnerTick trailing />}</span>
           {tweaks.showDojo && m.sideA?.dojo ? <span className="d">{m.sideA.dojo}</span> : null}
         </div>
       </div>
diff --git a/web-mobile/js/write_result.jsx b/web-mobile/js/write_result.jsx
index 9f53d6951..3a7214608 100644
--- a/web-mobile/js/write_result.jsx
+++ b/web-mobile/js/write_result.jsx
@@ -120,15 +120,22 @@ export function supersededAlertText(n, one, needsWinner = false, defaultWinStand
 // one choice of banner for a superseded write, asked by notLandedBanner and by
 // api_client.jsx's not-applied broadcast.
 //
-// The same reason rides on a second, APPLIED answer (writeDisplacedGroups): a
-// finish that arrived after a newer scoring change which, applied after it,
+// The same reason can ride on a second, APPLIED answer (writeDisplacedGroups):
+// a finish that arrived after a newer scoring change which, applied after it,
 // would have left the match without a winner. The finish is recorded and that
 // later change is MOVED to the history (`displacedGroups`, no heldGroups).
 // writeNeedsWinner is therefore true only for a write whose OWN change was
-// held for the reason; a displaced answer is not one, and says "Saved". An
-// answer that both held groups and moved a later change carries the one
-// reason for both, and the client reads it as the move's: telling the
-// operator to correct a result that IS recorded would be the worse error.
+// held for the reason; a displaced answer is not one, and says "Saved".
+//
+// A change can also be moved for another reason and then carries NO
+// heldReason: a representative's pick stamped after the representative bout's
+// removal has nothing left to stand on. writeDisplacedForWinner is the one
+// question "was the move for a winner": true for heldReason needs_winner only,
+// never for "a reason is present", because the reason is per ANSWER and a
+// decision that stands (default_win_stands) can ride beside displacedGroups
+// too. An answer that both held groups and moved a later change carries the
+// one reason and is worded by it, which is the move's: telling the operator to
+// correct a result that IS recorded would be the worse error.
 export const HELD_REASON_NEEDS_WINNER = 'needs_winner';
 export function writeDisplacedGroups(res) {
     return res && Array.isArray(res.displacedGroups) ? res.displacedGroups.filter((g) => typeof g === 'string') : [];
@@ -138,12 +145,27 @@ export function writeNeedsWinner(res) {
         && writeDisplacedGroups(res).length === 0
         && (writeWasSuperseded(res) || writeHeldGroups(res).length > 0);
 }
+export function writeDisplacedForWinner(res) {
+    return !!res && res.heldReason === HELD_REASON_NEEDS_WINNER && writeDisplacedGroups(res).length > 0;
+}
 // displacedAlertText: the queue alert for queued finishes that landed and
 // moved a later change of the same match to its history (writeDisplacedGroups).
-export function displacedAlertText(n, one) {
-    return one
-        ? "A held result was saved. A later change to that match would have left it without a winner, so the change was moved to the match's history."
-        : `${n} held results were saved. Later changes to those matches would have left them without a winner, so the changes were moved to each match's history.`;
+// `forWinner` is how many of the n answers moved their change for a winner
+// (writeDisplacedForWinner): all of them keeps the winner sentence, none says
+// plainly that the change was moved, and a mix says both. An alert that
+// carries no such count reads as none.
+export function displacedAlertText(n, one, forWinner = 0) {
+    const f = Number(forWinner) || 0;
+    if (one) {
+        return f > 0
+            ? "A held result was saved. A later change to that match would have left it without a winner, so the change was moved to the match's history."
+            : "A held result was saved. A later change to that match was moved to the match's history.";
+    }
+    if (f >= n) {
+        return `${n} held results were saved. Later changes to those matches would have left them without a winner, so the changes were moved to each match's history.`;
+    }
+    const moved = `${n} held results were saved. Later changes to those matches were moved to each match's history.`;
+    return f > 0 ? `${moved} ${f} of those changes would have left a match without a winner.` : moved;
 }
 export const NEEDS_WINNER_REASON = "this change would leave the finished match without a winner, and it needs one, so it was kept in the match's history and nothing is lost";
 export const NEEDS_WINNER_ADVICE = 'Correct the result with a winner.';
@@ -839,6 +861,23 @@ export function startWhileCorrectingMessage({ label }) {
     return `Save the correction of ${label}, or leave it with Back to court, then start this match.`;
 }
 
+// A second Start while another match's start is still out (bc-aadv, one start at a time).
+export function startWhileStartingMessage({ label }) {
+    return `${label} is still being started on this court. Start this match once it has.`;
+}
+
+// The same refusal once the start it named has LANDED (bc-aadv, item 4). While
+// that start was out the sentence above was true and was derived from it. When it
+// lands the court has a running bout, the refused match is NOT started on its own
+// (one start at a time; a second automatic start would draw court_busy or put two
+// bouts on the court unasked), and nothing else would say that the match was asked
+// for and never started. So the refusal is kept, in the past tense, on the refused
+// match until that match leaves scheduled or the operator starts one. The court
+// console and the Scores tab both word it from here.
+export function startWasBlockedByStartMessage({ label }) {
+    return `Not started: ${label} was being started when this match was asked for. Start it when the court is free.`;
+}
+
 export function correctWhileRunningMessage({ court, label }) {
     return `${courtBusyMessage({ court, label })} Then correct this match.`;
 }
@@ -982,3 +1021,26 @@ export async function attemptScoreWrite({ recordScore, confirmDialog, compId, ma
         throw e;
     }
 }
+
+// A thrown refusal is toasted ONCE. editMatchScore (admin.jsx), the chokepoint
+// every score write goes through, toasts the error it is about to throw; a host
+// that catches that same error to show it on a card or a row (the court console's
+// startMatch, the Scores tab's startNext) used to toast the same sentence again,
+// which replaced the single-slot toast and restarted its timer. editMatchScore
+// marks every error it toasted (markToasted) and a host asks before it toasts
+// (wasToasted); the card or row notice is set either way. A refusal only the host
+// sees (a clock_skew answer is a RETURN, not a throw; a local "still being
+// started" refusal never reaches onEditScore) carries no mark and is toasted
+// there, once.
+//
+// The mark rides on the error object, the way downstreamKnockoutPlayedCancelled
+// does, so nothing is threaded through a signature. `toasted` is the field name
+// (check-write-result.mjs polices `.applied`/`.persisted`, never this).
+export function markToasted(err) {
+    if (err && typeof err === 'object') err.toasted = true;
+    return err;
+}
+
+export function wasToasted(err) {
+    return !!err && typeof err === 'object' && err.toasted === true;
+}