fix(bc-rfsw,bc-offl,bc-rboq,bc-flst,bc-kheb,bc-mrgc,bc-hlck): merge match writes by change, held results visible, correction refusals, kachinuki encho by gitrgoliveira · Pull Request #453 · gitrgoliveira/bracket-creator

gitrgoliveira · 2026-10-02T22:17:50Z

Summary

Seven beads, plus operator requests made during review.

Merge changes, never drop (bc-mrgc). Operator ruling 2026-10-03: "Nothing should be dropped. All events must be ordered." A match write now applies only the groups it changes (points, result, overtime, engi flags, representative players, each bout row), each ordered by when the change was made, never by when it arrived. Whatever does not apply is kept in a per-match history, written in the same transaction as the match and shown in every score editor under History. The rules, each an operator ruling:
- Points scored after a withdrawal of that match mean the withdrawal was a mistake: it is cleared and kept in the history.
- A late point on a finished match applies, the match stays finished, and the winner is worked out again.
- A change that would leave a finished knockout match without a winner, or an engi match without a valid flag count, is held, and the operator is told to correct the result with a winner. In a pool or league the match becomes a draw.
- A match closed by a kiken, fusenpai or fusensho keeps that result against a court still scoring it, and the notice names the decision.
- For engi, the newest valid count decides, whichever write arrives first.
- The final state does not depend on the order in which writes arrive.
The offline queue keeps every write: one entry per write, each sent on its own, nothing dropped for its age. A write that keeps failing holds back no other, and a write the server keeps refusing can be discarded on its own.
No write stamped before the match it was made against (bc-hlck). A device stamps a write no earlier than the match it saw, so a correction made just after a write from a device whose clock runs ahead is applied rather than kept in the history.
Correction refused while a later match is being fought (bc-rfsw). A knockout correction that would change a side of a running later match is refused with a 409 naming that match and its shiaijo, instead of re-seating a bout in progress.
Held results are visible (bc-offl, bc-rboq). The top bar reads "Offline: N result(s) not sent", the sync pill "Reconnecting…", and a toast confirms "1 finished result sent." Every queued notice reads "Not sent yet: saved on this device, and sent when the connection returns." The top-bar count opens a list of everything held on the device, with Discard for a write the server keeps refusing. Kachinuki Record bout returns its result, so a bout held offline shows "Not sent yet".
Fighter list (bc-flst). The list commits on click, swallows a bounced second tap, and reopens when its name box takes focus.
Kachinuki overtime on the bout (bc-kheb). A kachinuki encounter carries no match-level (E): the mark lives on the bout row. Writes strip it, and stored marks are repaired once on load.
Remove kiken, fusenpai or fusensho. Operator ruling 2026-10-03: "an operator can fix a mistake, but the fix must leave the match resolved". A decision recorded by mistake on a match fought to a result is removed in one save: Remove takes it off the board, the operator enters the real result, and Save correction sends it. The match stays finished, never needs the court, and the barred competitor can fight again. Clear and reopen stays beside it for a match with fighting left. Kachinuki is not offered Remove: a finished encounter has no Save correction.
The decision is named. Operator ruling 2026-10-04: every finished match has a result, a scoreline or a registered decision. Every label, notice, message and docs page names the recorded decision ("Record fusensho for ", "Remove kiken", "Not applied: this match was closed with a fusensho"). Three prose gates keep the old term out of Go strings, web-mobile strings and the docs.
Shared courts (operator request 2026-10-03). The court-move confirm names both competitors. A court whose competition still has matches names another competition's waiting matches in a quiet line ("1 Individual match also waiting on this court."), and the console switches only on a tap.
Gaps closed (operator request 2026-10-04): a court console back online refetches its queue; each pool bout has one number on every surface, its place in the playing order; a write the disk refused after its transaction log committed is retried by the device and logged as a disk error; the server refuses to start on a data folder it cannot write, naming each folder; the pdfcpu 0.16.0 bump on main (every call takes a context) is fixed.
Two defects found while closing the review's gaps. Release archives and packages embedded no Preact, so the app's UI rendered blank: the published v2.1.0 answers 404 for all four of its vendor scripts. The release hooks now fetch them, and the package smoke test starts the app and fetches its UI assets, so a missing one fails the release. And the armed state of a two-tap button had no text colour of its own, so kachinuki's armed End match read dark on navy; it is white now.

Why

bc-mrgc: a write older than the stored result was dropped whole and kept nowhere, even when it changed something else. A running write could replace a queued Finish, queued writes expired after 12 hours, and two read-modify-write windows could lose an entry.
bc-hlck: two devices' estimates of server time differ by up to the 5 s the server accepts, so a correction could be stamped older than the write it corrected.
bc-rfsw: the guard judged only later matches already played, so a correction reaching a running match got through.
bc-offl, bc-rboq: a queued write and a landed write looked the same to the operator.
bc-flst: the list closed on blur before the click registered, and a bounce picked the wrong fighter.
bc-kheb: one bout fought on in encho put the whole encounter in overtime.
Remove: undoing a mistaken withdrawal needed a reopen, which takes the court and leaves the match unresolved.
Gaps: a reconnected console kept a stale queue, because the stream reopening raises no error and its reconnect refetch never ran; a stuck autosave, lineup or hand-set winner had no way out but signing out.
Release: web-mobile/vendor is gitignored and only the Makefile's vendor-frontend target fetches it; goreleaser never ran that target, and its smoke test only ran bracket-creator version. Docker images and the Homebrew formula build through other paths and were not affected.
Armed button: .btn--confirm set a navy fill and relied on .btn--primary for white text; End match is a plain .btn.

Upgrade and rollback

Upgrading in the middle of a tournament needs no action:

pool-matches.csv gains a GroupStamps column, appended last, and bracket.json a groupStamps field. A match without them reads every group as stamped at its ModifiedAt, which is how the previous release ordered writes.
Each competition gains a history/ folder, created when a match is first written.
A kachinuki competition's stored encounter overtime is repaired once, on first load, and config.md records it (kachinuki_encounter_encho_cleared).
Writes a browser queued under the previous release load and replay unchanged.
Pool bout ids follow the playing order in draws made from now on; an existing draw keeps its ids.
One behaviour change at startup: the server refuses to start if it cannot write to the data folder or any competition folder, and names each one. A deployment that ran with such a folder before now stops at startup.

Rolling back to the previous release: it reads these files, ignoring the extra column, the extra field and history/. Its next save of a match file drops the stamps, so those matches fall back to one stamp per match. Its writes are not added to the history, and its Discard draw leaves history/ in place, so a draw discarded and regenerated under it shows the earlier draw's history for the reused match ids after upgrading again.

Checked in a browser against v2.1.0 on the same data: a finish this build's page held offline was sent to v2.1.0 and saved; after a reload as the v2.1.0 client, a finish this build had queued (the new entry format, with changed) was read, sent and saved, and the queue emptied. v2.1.0 rewrote pool-matches.csv without the stamps column and added no history line. The published v2.1.0 binary serves no UI (the release defect above), so the old client was v2.1.0 built from its tag.

Files changed

File	What
`.github/workflows/release.yaml`	the package smoke test also starts the app and fetches `/dist/app.js`, `/dist/glossary_data.js` and the four `/vendor/*.js` files
`.goreleaser.yaml`	the release hooks run `make vendor-frontend`, so archives and packages embed Preact
`CLAUDE.md`	the rules this PR settles: match groups, stamps and history, the held-write answers, the offline queue, Remove , the decision named, the startup write check, pool bout numbers
`docs/architecture/data-model.md`	group stamps, the per-match history file and every reason it records, write ordering, pool bout ids in playing order
`docs/architecture/infrastructure-architecture.md`	the startup write check
`docs/architecture/network-architecture.md`	how writes are queued on the device, sent and ordered; held and moved changes; a match closed by a decision keeps it
`docs/check_prose.py`	a rule refusing the term this PR removes from the docs
`docs/screenshots/kachinuki-reopen.png`, `kachinuki-correct-bout.png`, `kachinuki-knockout-tie-encho.png`, `kachinuki-scoring-buttons.png`, `mobile-encho-overtime.png`, `mobile-score-editor.png`	recaptured: the History line under the board (`kachinuki-reopen` also no longer clips its footer)
`docs/screenshots/mobile-draw-preview.png`, `mobile-pool-standings.png`	recaptured: the standings legend names the decisions
`docs/videos/kachinuki-demo.webm`	recaptured: the armed End match is readable (chapter marks unchanged)
`docs/user-guide/court-operators/recording-decisions.md`	buttons named by the recorded decision; Remove beside Clear and reopen
`docs/user-guide/court-operators/scoring-a-match.md`	match history; results held offline; changes kept rather than applied, with the notices quoted as the editor shows them; correction refused while a later match is fought; the shared-court line
`docs/user-guide/install/install.md`	the startup write check
`docs/user-guide/organisers/team-tournaments.md`	the decision named
`running_a_kendo_tournament.md`, `specs/003-tournament-gap-closure/inputs/gaps_spec_brief.md`, `gaps_tournament_spec.md`, `gaps_webui.md`	the decision named
`specs/openapi.yaml`	`changed`, `heldGroups`, `displacedGroups`, `heldReason`, `heldDecision`, `clearWithdrawal`; the history route and every reason it records; the new 409 shapes, with the `runningMatches` body on every door that returns it
`internal/domain/decision.go`	`DecisionWord`: the one Go owner of a decision's word
`internal/domain/glossary.go`, `web-mobile/js/glossary_data.js` (generated)	the kiken and fusenpai tooltips say the match is awarded to the opponent
`internal/engine/bracket_result.go`	projects group stamps so a rollback restores them; `bracketMatchCourtAndSchedule` for a replayed decision's answer
`internal/engine/competition.go`	discarding a draw deletes its match history
`internal/engine/daihyosen.go`	pool daihyosen injection reads, decides and saves in one transaction
`internal/engine/eligibility.go`	`lookupExistingResultIn`: one read answers the prior and which file holds it
`internal/engine/engi.go`	the engi finish ordered by stamp, never a draw, the newest valid count deciding; the override guard runs the running-match check even when forced
`internal/engine/engine.go`	test-only read seam for the lost-update tests
`internal/engine/errors.go`	the running-downstream refusal; `sentenceList` lists "A, B and C" as the SPA does
`internal/engine/kachinuki.go`	`runningDownstreamRefusal`; encounter overtime stripped; the advance re-checked under the lock, re-read on a stale check, stamped no older than the match, and written with its history entry in one transaction (`KachinukiAdvance` hands back its stamps)
`internal/engine/league_tiebreak.go`	league tie-break injection in one transaction
`internal/engine/match_history.go`	new: history entries for every write door
`internal/engine/match_merge.go`	new: the merge owner (groups, stamps, R2 to R4, moved changes, the finish kept with its scoreline, the decision hold)
`internal/engine/pools.go`	`numberPoolMatchesInPlayingOrder`: a pool's ids follow the playing order
`internal/engine/scoring.go`	the shared correction guards; `KeepsWithdrawalRuling` does not keep a ruling the write clears; both write branches merge; the hand-set winner and the requeue write and append history in one transaction
`internal/engine/scoring_tx.go`	the decision pre-check (stale replay, the score door's rules); history points; held writes; exact decision replay with the bracket match's court; kachinuki overtime stripped in `recordDecisionTx`
`internal/engine/swiss.go`, `tiebreaker.go`	the next Swiss round and tie-break injection each in one transaction
`internal/engine/testdata/downstream_running_messages.json`	new: the refusal sentences, read by the Go and JS tests
`internal/mobileapp/deps.go`	the history store interface; `MaybeAdvanceKachinuki` returns `*engine.KachinukiAdvance`
`internal/mobileapp/errors.go`	the running refusal as a 409 with `reasonHuman`; a committed but unapplied write logged as a disk error
`internal/mobileapp/handlers_branding.go`, `handlers_sponsors.go`	folder names from `state`
`internal/mobileapp/handlers_competition.go`	a new kachinuki competition starts with the repair marker
`internal/mobileapp/handlers_daihyosen.go`	changed and held groups on the representative-bout routes
`internal/mobileapp/handlers_decision.go`	the handler-side clear removed (the engine owns it)
`internal/mobileapp/handlers_match.go`	`/score` reads `changed` and `clearWithdrawal`; `withHeldGroups`, the one owner of the held answer keys; the running revision guard holds; `messageForHeldReason`; the Record-bout answer carries the advance's stamps
`internal/mobileapp/handlers_match_history.go`	new: `GET .../matches/:mid/history`
`internal/mobileapp/middleware.go`, `server.go`	the history route, main-gated in self-run
`internal/mobileapp/testdata/default_win_cases.json`	new: the case table the Go and JS prose gates both read
`internal/pdf/generate.go`, `pagenum.go`, `pdfops.go`	pdfcpu 0.16.0: every call takes the generator's context
`internal/state/bracket.go`	`groupStamps` on bracket matches; `MatchByID`
`internal/state/legacy_upgrade.go`	the one-time encounter overtime repair; a read failure leaves the marker unset
`internal/state/match_groups.go`	new: the group owner, stamps and merge report
`internal/state/match_history.go`	new: the per-match history file, staged in the write's transaction; a damaged line, or one the scanner cannot read past, is logged with the match
`internal/state/models.go`	`GroupStamps`; the request-only fields; `ClearKachinukiEncounterEncho` and its marker
`internal/state/pools.go`	the `GroupStamps` CSV column; request-only fields never cached
`internal/state/store.go`, `writable.go`	the startup write check (`checkDataWritable`, `ErrDataNotWritable`), run before the transaction log replay
`internal/state/testdata/match_groups.json`	new: the group names, read by `TestMatchGroups_SharedTable` and `match_groups_table.test.jsx`
`internal/state/transactions.go`	history methods on `StoreTx`
`internal/*/_test.go` (55 files)	new and updated Go tests: the merge rules, history and its crash atomicity (`match_history_crash_test.go`), lost-update windows, the refusals, the repair, the prose gates
`web-mobile/check-helpers.mjs`, `check-imports.mjs`, `check-write-result.mjs`	the prose gate reads the comment-stripped whole file; `admin_shell.jsx` may import from `write_result.jsx`
`web-mobile/css/styles.css`	the top-bar offline chip, the fighter list, the quiet "also waiting" line; `.btn--confirm` owns its text colour
`web-mobile/js/__tests__/**` (44 files)	new and updated unit and render tests
`web-mobile/js/admin.jsx`	the closing toast for a held or moved change
`web-mobile/js/admin_schedule_score_editor.jsx`	a start names only the result group
`web-mobile/js/admin_scoring_autosave.jsx`	the changed-groups hook; the kept-in-history note; each tap records the shown match's stamp
`web-mobile/js/admin_scoring_engi.jsx`, `admin_scoring_individual.jsx`	the shared not-sent notice; Remove unlocks the board and sends `clearWithdrawal`; a discarded held write disarms Finish and the engi save (`dropHeldWrite`)
`web-mobile/js/admin_scoring_shared.jsx`	the fighter list; `RecordedWithdrawal` with Remove and Undo; `useWithdrawalRemoval`; the held-write hooks and notice; a decision carries the stamp it was recorded against; comments on `RecordedWithdrawal` and the fighter list's focus brought up to date
`web-mobile/js/admin_scoring_team.jsx`	Record bout returns its result and adopts the answer's stamp; the fighter list; Remove on a team match; a discarded held write disarms Finish and End match (`dropHeldWrite`)
`web-mobile/js/admin_shell.jsx`	the top-bar held count, a button opening the held-writes list
`web-mobile/js/admin_shiaijo.jsx`	the move confirm names the match; the "also waiting" line; refetch on reconnect and on returning to the foreground
`web-mobile/js/api_client.jsx`	one queued entry per write, sent on its own, never dropped; the held-writes list and Discard; `_stampAfterSeen` on every stamped write
`web-mobile/js/api_serializers.jsx`	forwards `clearWithdrawal`
`web-mobile/js/app.jsx`	the "Reconnecting…" pill; the queue alert names the decision
`web-mobile/js/barred_match_notice.jsx`, `ineligible_match.jsx`	"Record fusensho for "; the shared queued notice
`web-mobile/js/match_groups.jsx`	new: the client group owner, pinned to the server's by the shared table
`web-mobile/js/match_history_view.jsx`	new: the History disclosure (held overtime reads "overtime, started" or "not started")
`web-mobile/js/match_scoreboard.jsx`, `viewer_standings.jsx`	the circle's tooltip and the standings legend name the decisions
`web-mobile/js/viewer_utils.jsx`	"Match N of M" reads the bout's number from its id
`web-mobile/js/write_result.jsx`	the queued, refused, held, needs-a-winner, moved-to-history and decision-hold copy; `decisionWord`

Screenshots

bc-rfsw: correction refused, running final named

bc-offl: finished offline, the top bar shows the held result

bc-offl: the reconnecting pill while a write is held

bc-offl: the sent toast, once the held result lands and the court moves on

bc-rboq: a kachinuki bout held offline shows Not sent yet

bc-flst: the fighter list, and the list reopened by a focused name box

bc-flst: a typed name committed by tapping an ippon button scores it (bout 1); a double tap on a list option picks once (bout 2, Fusensho untouched)

bc-kheb: a tied bout fought on in encho and decided: (E) on the bout row, none on the encounter

The armed End match is readable (it was dark text on navy)

Remove: the recorded kiken offers both fixes, Clear kiken and reopen and Remove kiken (Aoki withdrew; court A is scoring Mori vs Sato meanwhile)

Removed: the circles gone, the real result entered (Sato K, Aoki M K), a reason asked as for any correction

Saved: the match reads K vs MK, Aoki's next match can start, Mori vs Sato was never interrupted

While the removal is pending, the name carries no Kiken mark (Undo brings it back)

Team match: removed, bouts 2 and 3 become rows to fill (Save refuses until they have a result)

Team match saved: Kyoto wins 2-1 on bouts and can compete again

Buttons name the recorded decision

Shared court: the move confirm names the match

Shared court: court B, open in another tab, names the moved match about 0.3 s after the move, with no reload, and stays on Teams

Shared court: one tap switches court B to Individual, the moved match is Up next

Merge: a kiken made offline before a point recorded on another device. The point stands, the match keeps running, the kiken is kept in the history and nobody is barred

Merge: a late point that would leave a finished knockout tied. The match keeps its finish, the point is kept in the history, and the operator is told it needs a winner (the Scores tab's editor, which stays open; on the court console the editor closes when the match finishes and the same message comes as an alert)

Merge: a court offline ticked overtime after another device recorded a kiken. Back online, the overtime is held and the court is told which decision closed the match and where to change it; the history records "a kiken closed this match" (the Scores tab's editor, as above)

Kachinuki Record bout, then the next tap: the winner stays on against Red's next fighter, and the first point on the new bout saves cleanly ("Synced", no held note)

Gaps: a court console back online moved on by itself (Match 1 had been started on another device)

Gaps: the held-writes list from the top bar, with Discard for a write the server keeps refusing

Gaps: the editor's banner once the server keeps refusing a held result

Gaps: the first bout to be played is Match 1 on the court console and in the scores list

Gaps: a result finished while the browser's storage is full

Review history

Every finding was checked against the code before anything changed. Each fix comes with a test that fails without it, except where noted.

Code review 1. A stale queued decision is answered superseded, before any of its refusals. A typed fighter name committed by tapping an ippon button keeps that tap. Go lists three or more matches "A, B and C", as the SPA does. The encho repair retries after a read failure, and a new kachinuki competition starts with its marker. (The docs sweep has no test.)
Code review 2, Remove and shared courts. The court console no longer switches competition by itself. Every competition waiting on a court is named. Undo of a removal disarms a hantei armed during it. A tied knockout team match after Remove points to Clear and reopen. A correction held offline offers no Undo.
Code review 3, the merge work and the owner's threads. R4 revised: a change that would leave a finished knockout without a winner is held, never sent back to running. Both arrival orders end in one state (displacedGroups). A write that does not name the result keeps a hantei mark. The queue holds nothing behind a failing write. Request-only fields never reach the cached copy. CodeQL's allocation alert fixed.
Code review 4, the gaps and the owner's threads. A second failing held write is published when it crosses the threshold. An editor's banner goes once nothing is held for its match. A hand-set winner resent after a clock refusal keeps its floor. A team match decided by its representative bout alone no longer reads tied.
Code review 5. The kachinuki advance hands back the stamps it left and reads the match again rather than standing down. A verdict sent again records no new status, so a reinstatement stands. Points clear only a withdrawal of the match itself; a fusensho stands. A damaged history line is logged.
Code review 6. An engi finish echoing the stored count applies. An echo keeps its stored stamp. A finish is kept together with the scoreline it stood on. The decision hold has its own answer and notice. A replayed decision keeps its court. The advance, the hand-set winner and the requeue append history in the same transaction as their write (their tests pin the entry; crash atomicity of the shared transaction path is pinned by the crash test added for the docs review's gaps). A line the history scanner cannot read past is logged.
Review loop, rounds 1 to 4. A group the writer names takes the write's stamp. No stamper lowers a stamp, and the engi recorder writes the stamps the merge decided. Overtime from a court still scoring a match a decision closed is held with its points. The held notice names no button the kachinuki editor lacks. The engi ruling (the newest count decides). The three prose gates and their shared case table. The loop stopped at the owner's direction once only gate wording and docs truth remained.
Docs review. The history reasons listed in full in the data model and the OpenAPI spec; the held notices quoted as the editor shows them; the runningMatches body on every 409 that returns it; a table cross-reference by name; this body rebuilt with the upgrade and rollback notes and every changed file. (Docs only, no test.)
The docs review's open gaps. A crash test for the history append (match_history_crash_test.go): a real transaction whose file apply fails on the match file or on the history file, a crash before the apply and one between the two files, each replayed on restart with both landing, and an abort that leaves neither; it fails when AppendMatchHistory bypasses the transaction log. The OpenAPI reopen text said a force-reopened match loses its bouts and that a bye is refused (it keeps its points and the bye is unwound). Two stale code comments. The four untested items below were checked in a browser. Found on the way: the release packaging defect and the armed-button colour (the colour has a CSS test that fails without the fix; the release fix was checked with a goreleaser snapshot build, whose binary served all six UI assets, against the v2.1.0 release, where the new smoke step stops at Preact's 404). All PR screenshots were recaptured on this build.
Owner decisions, 2026-10-05. A discarded held result disarms the two-tap commit (Finish, Finish + Start Next, End match, the engi save), whichever door discarded it: each editor's one dropHeldWrite serves its own Discard held result and the edge a discard from the top bar produces. A render test covers both doors in all three editors and fails without the disarm; in the browser, after the server refused a finish 11 times and the operator discarded it, the button read "Finish + Start Next →" and the queue was empty. The held overtime line reads "Kept in history: overtime, started" rather than "overtime, overtime".

Dismissed with evidence: "re-parses the same files" (config, pool and bracket loads are served by the version and mtime cache); "the kept-in-history note can leak across matches" (every host keys the editor on its match).

Notes for review

Accepted residuals, each recorded in CLAUDE.md: a lineup save made while one is queued reads {queued: true} until the flush sends it; a finish that carries none of its own scoreline cannot be replayed under a newer tying change and is held; the history file is rewritten whole on each write to its match; two writes floored by the same seen stamp share it; a correction held whole when a court still scoring moved the result stamp first; a write the disk refused after its log committed is answered 500 and retried, and a Discard does not stop it applying at restart.
An echoed engi count's history outcome reads "applied" rather than "unchanged". The History view lists held groups only, so no operator sees the difference.
The four items earlier listed as untested are now covered: crash atomicity of the history append by match_history_crash_test.go; queued writes across a rollback in a browser (refer to Upgrade and rollback); the lineup panel's Save lineup with the fighter list in a browser (a click commits, a double tap places one fighter, a focused box reopens the list, and the saved lineup carries each member's id); and the Record-bout floor with the page's server time set 2.5 s behind, where the next tap's own estimate was older than the appended bout and it went out at the bout's stamp plus 1 ms and applied.
A finish that did not land (queued) still leaves the two-tap button armed while the write is held, by design: a second tap re-sends into the same queued entry, and the banner offers Retry now. A discard disarms it (owner decision above).
bc-kheb: the repair writes config.md once per kachinuki competition on first startup. On a tied level bout X outranks (E), so only "Undo encho" shows the overtime until a point lands.
bc-rfsw: runningDownstreamRefusal may go if bc-dlck removes the T103 block. bc-offl's e2e fixme flip lives on PR test(bc-e2eh, mp-yqxn.2): e2e harness and a clumsy-operator review of knockout and mixed #442.
Seven commits name the term this PR removes: five from before the 2026-10-04 ruling (76ffb044, 37d4187e, 0ec2e3ea, 47d739da, 8b90315c) and two that quote it to say it was removed (aa81d5c7, 53f54164). Rewording them needs a force-push; a squash merge leaves none of them.

Test plan

Closes bc-rfsw
Closes bc-offl
Closes bc-rboq
Closes bc-flst
Closes bc-kheb
Closes bc-mrgc
Closes bc-hlck

🤖 Generated with Claude Code

…ued bout shows "Not sent yet" Co-Authored-By: Claude Code <noreply@anthropic.com>

… the bounce Co-Authored-By: Claude Code <noreply@anthropic.com>

…they land Co-Authored-By: Claude Code <noreply@anthropic.com>

Co-Authored-By: Claude Code <noreply@anthropic.com>

…er match Co-Authored-By: Claude Code <noreply@anthropic.com>

…ir stored legacy marks on load Co-Authored-By: Claude Code <noreply@anthropic.com>

Co-Authored-By: Claude Code <noreply@anthropic.com>

…i encho inside recordDecisionTx Co-Authored-By: Claude Code <noreply@anthropic.com>

Copilot