Repository navigation
fix(chat): re-read kept rows a link or reply change outdated - #15029
billygerhard wants to merge 1 commit into
Conversation
UX Review (Opus 5.5, fork) — 🟡 CONCERNSUX-level review of UX-Verdict: CONCERNS The failure notice never says what the risk is: a link you blocked may still be clickable. Nobody has done a first-time read of these screenshots. Watch
Suggestions
[UX-REVIEWED] 53acb31 Description read[DESCRIPTION-READ] cff0052a34498e645fc303b48b3511a3e285640d35093411e96c2414c0ad780e That sha256 names everything this verdict read: the PR description, plus the 13 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
GPT 6.1 Review (fork) — 🔴 changes requested (blocking)Reviewed 2 of 2 blocking finding(s) are security-class and were withheld from adjudication, so the blocking verdict stands. BLOCKING -- website/src/store/chatSlice.ts:987 -- Variant frames overwrite an unrelated earlier reply
BLOCKING -- website/src/store/chat/slotRefresh.ts:109 -- Live-tail preservation discards recovered stream text
[BLOCK-MERGE] 53acb31 Adjudication (Opus 5.5) — is blocking on each finding proportionate?F1 — F2 — |
First Principles Review (Opus 5.5, fork) — 🔴 BLOCKPremise-level review of First-Principles-Verdict: BLOCK The frozen Goal (stop whole-transcript downloads) is already met on main, by the PR's own account. Everything still shipped adds new whole-transcript reads. Not justified as shipped
What this change shipsInventory (10 items) — 3 justifiedIntent: keep long chats from re-downloading their whole transcript. Framed as a FIX; the diff ships staleness ADDITIONS.
Blockers
[FIRST-PRINCIPLES-REVIEWED] 53acb31 Description read[DESCRIPTION-READ] 57e1345ef8515ab0d510792bc0b956abf730f844690e543b327e029cceba7d94 That sha256 names the PR description this verdict read. Recompute it with |
Design Review (Opus 5.5, fork) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS The staleness guard adds back whole-transcript reads, the very thing the Goal line says to remove: a restart, allow/revoke or missed variant switch makes a >500-row view download its whole transcript. Watch
Suggestions
[DESIGN-REVIEWED] 53acb31 Description read[DESCRIPTION-READ] 4c1c9c3921f91ec9603b7e341b88c5dca7e803c7878ac0fc344cde234389bb57 That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
Opus 5.5 Review (fork) — 🔴 changes requested (blocking)Reviewed BLOCKING: BLOCKING — website/src/store/chatSlice.ts:985 for (let i = rows.length - 1; i >= 0; i--) { const m = rows[i]; if (m.role === 'assistant' && Array.isArray(m.variants) && m.variants.length) { target = m; break } }Trigger: an earlier reply in the chat has already been regenerated (its row holds 3 variants). The user then regenerates a newer reply, and the new reply writes text before a tool call or permission prompt. That flushes a broadcast segment through |
89176ab to
d3b0801
Compare
f589b5a to
b0d8d85
Compare
91d0381 to
e2e427d
Compare
e2e427d to
6d9e7ab
Compare
4ad9325 to
2b0505a
Compare
2b0505a to
3fb26b8
Compare
3fb26b8 to
c00e8b7
Compare
c00e8b7 to
37141aa
Compare
7c3997d to
4bbabd2
Compare
|
Thanks @billygerhard. Your diagnosis and measurements here are what showed that the background warm ( Since #13236 has merged, which bounds That covers the warm-bounding part of this PR. The heal-failed banner and Retry flow are separate and still yours to drive here. If you rebase onto main, the overlapping |
Rebased onto kirodotdev#13236 and kirodotdev#16005, which bound refreshSlot, switchSlot and warmSlotCache with a clamp plus an older-walking window. This keeps that walk on all three and adds only what a kept head needs on top of it: a marked view or cache (a serving change) reads whole instead of walking, since the walk keeps rows above its anchor verbatim, a walked or overlapping head still offering a sign-in link reads whole, and a background warm that anchors nothing in a cache with a raw retained count reads whole once so a remote clear is still read as a shrink. The refreshSlotBound over-ceiling test is
|
Closing. The goal of this PR, stopping long chats from downloading their whole transcript (#12907), is now met on main by #13236, #16005 and #16017. What remained here healed stale rows kept above the newest page by re-reading the whole transcript, which reintroduces the unbounded read. The stale-row problem is tracked in #17023 with a bounded approach. |
Problem / Motivation
Goal: A long chat you have scrolled back through no longer downloads its whole transcript into the open tab every time it reconnects, finishes a turn, or is switched back into.
#13203 bounded the background pane warm (
warmSlotCache) to the rows the pane already holds, floorPANE_HYDRATE_LIMIT, ceilingSLOT_DETAIL_MAX_LIMIT(500). The open pane's refresh (refreshSlot) shares the same bound. ButcountMatchedFetchLimitanswersundefinedwhen the count is over the ceiling, and both callers treatundefinedas "no limit". So a pane or view holding more than 500 rows (any long chat paged back through "load earlier") still asks the server for the entire transcript: the warm on every background turn end, the refresh on every reconnect and turn end of the open chat.Measured against
origin/mainwith a stubbed server, first request the warm makes:limit=100/499/500refreshSlotbehaves the same above its ceiling (REFRESH_LIMIT_CEILING, also 500); an existing test pinned that unbounded read on purpose.#13236 and #16005 (merged since) gave
refreshSlot,switchSlotand the background warm (warmSlotCache) their own bound: a window that misses the view or cache walks older one page at a time (walkWindowBackTo) instead of reading unbounded. This PR is rebased onto both and keeps that walk on all three paths; what it still adds is the staleness guard below, which the walk needs as much as any kept head: a walked window keeps the rows above its anchor verbatim, so a marked view or cache reads whole instead of walking, and a walked head still offering a sign-in link reads whole.Why it matters
The chat most likely to hold more than 500 rows is exactly a long-running session: an always-on babysit or monitor loop that a user scrolls back through. For a 52 MB / 5,894-row session that is 52 MB fetched, redacted server-side and parsed into whatever tab is open, on every one of that session's turn ends, which is the renderer-kill described in #12907. It also puts the whole-corpus read and redaction back on the gateway's worker thread, which the comment above the warm names as the reason the bound exists.
Not a goal
totalin collapsed units. The client now records which units a retained count is in instead (below); changing the server's count would move every othertotalconsumer too.What changed (motivation → approach → change)
Symptom (on the base this PR was opened against; #13236 and #16005 have since fixed it on
mainwith the walk): a refresh or warm of a transcript over the ceiling is unbounded. Root cause: "no count-matched bound because the span exceeds the ceiling" and "no bound can be proven safe" share oneundefined, and both callers give both the unbounded read.Approach: the bound itself is now #13236's and #16005's clamp and walk, on all three readers. This PR adds only the guards that keep a stale or sign-in head from surviving them, and the units rule a wide chat's first bounded read needs:
refreshSlot,switchSlotandwarmSlotCacheall walk older on a coverage miss, as onmain.totalascomparableTotal.Keeping a head is only sound while the server still serves those rows the way the view or cache holds them. Two changes break that: a redaction host allowed or revoked (workspace-wide, so every loaded session, in every tab), and a reply's variant switched (any loaded row of that session). A new
markLoadedRowsChangedaction marks the affected slots inslotHeadUnverified, valued by aloadedRowsEpochcounter: every loaded slot, the open one included, or only the named ones. While a slot is marked, its refresh accepts a count-matched page only where it spans the view and otherwise takes the whole read, its switch and warm read whole on a coverage miss instead of walking, so its next read re-serves every loaded row. That read clears the mark only if it saw the same epoch at dispatch, so a change landing mid-read keeps its mark. The open slot is marked rather than trusted to its re-read: switching away drops that re-read's answer and caches the view it would have replaced, and the mark then makes the switch back re-serve it. The mark is evicted with the slot's other per-slot state.The slot switch had the same width-only case.
slotSwitchFetchLimitclamps a cache over 500 rows to a 500-row window, and the coverage check then measured the WHOLE cache against it, so the shortfall was certain and every switch back into a long chat retried unbounded. The switch reducer already keeps every cached row above the window's first row as a head (the sharedolderHeadAbovePagecut), so coverage is now measured only over the cached rows from that cut on, the rows the window actually replaces. No cut (the window moved past the whole cache, an ambiguous anchor) measures the whole cache as before.The mark is driven by the server, not only by the tab that clicked. The
dashboardstatus frame, sent on every connect and every 5 seconds, now carriesredaction_hosts_gen: a value that moves with every input that conditions how rows are served (dashboard/serving_gen.py: one registry,SERVING_INPUTS, holding the allow list, the companion's exempt hosts and the operator'soauth_endpoints.json; an HMAC of them under a domain-separated use of the dashboard's persisted signing secret, aschat_tag_grantsdoes, computed off the event loop (it stats the OAuth file) by the status funnel and the allow/revoke routes: keyed because the status frame reaches every socket, app tokens included, while the allow list is owner-only, so a plain hash would let a socket confirm guessed hosts; with a per-process boot value folded in, because the write counts below live in memory and restart at zero, so a list revoked back to its boot state after a restart would otherwise hash to the value a tab took before it; the cost is one re-read of what is on screen per gateway restart: the open chat and each pane showing (a split view tops out at a handful), never the background caches, which keep their mark and heal on their next read. A view holding more than one page ceiling of rows (older pages loaded by scrolling up) re-reads its whole transcript, since no bounded page re-serves every row it holds. A value from content alone would avoid this, but it reaches tabs on a polled frame, so a list written and written back between two polls would answer the value a tab already holds while that tab kept rows read in between. A gateway restarts rarely and each restart already drops every socket, so this rides a reconnect that re-reads the open chat anyway. It never returns to an earlier value within a process: the allow list's part counts writes and the OAuth file's carries its stat (mtime, the kernel-kept change time, size, device and inode, so even a backup restored with its old mtime moves it), so a list or file changed and changed back still reads as changed, and a render spanning both changes cannot vouch for its rows). Allow and revoke also answer with the value their write left.noteRedactionHostsGenis the one decision both feed: a status frame's first value is a baseline, a value that moved means mark every loaded slot and re-read the open one, and this tab's own write adopts its value, so the status frame carrying the same change afterwards is not handled a second time (and a write that changed nothing, such as re-allowing a host, moves nothing). So every tab heals, including one whose socket was down through the change and one where the change was made from Settings. A variant switch marks its own slot, which also covers a switch in a background session whose refresh cannot run. An older page (loadOlderMessages) read before such a change is dropped like a cancellation rather than prepended above rows the change's own re-read healed; the next climb reads it again. A tab that sees achat_variant_switchframe applies it in place to the row the server rewrote (the newest assistant row carrying variants) where it holds that row, logged like any row patch (noteVariantSwitch), so a regenerate in a long chat keeps its re-read bounded; only a slot whose rewritten row it cannot find is marked. A tab whose socket was down through achat_variant_switchframe learns of the switch from the slot list: each slot carriesvariant_seq, a revision of its switches (and of regenerated replies finalized as new variants): minted bymint_tags_revision(as each slot's tag revision is) when the slot is created and on every switch or variant attach, including a regenerate's terminal flush that sends no switch frame, so a gateway restart never hands back a value a tab already holds; it is patched on every change and sent in full on reconnect, so a switched row 500 rows back cannot survive a reconnect. A moved count marks that slot alone and re-reads it if it is open; so does a first count for a slot already holding rows (a resume, or a read that raced the first list), since nothing vouches those rows predate no switch; the live frame carries the same count, so the tab that saw the switch does not re-read it twice. The workspace-wide served value does not move for a switch, and it is read before any row of a transcript read, so a switch landing during a read can only make the value older than the rows. The owner's credential-redaction switch is reachable from the render but is not an input: it acts only insideowner_view(), which only the file viewer enters, and a test pins that no chat render can reach it.The baseline is the value the tab's rows were served under, not whatever status frame arrives first. Every transcript read now reports
redaction_gen, read before its rows are prepared (so a change landing mid-render leaves the rows newer than the value, never older), and the tab's first applied read seeds the baseline; a status frame only seeds it when no read has, and only for a document holding no rows yet: rows installed by a path that reports no value (a history resume) make the first status value a change, so a revoke landing before it cannot become the baseline. So a revoke landing between a tab's first read and its first status frame is still a change there. An unloaded list serves as empty (allowed_hosts_foranswers nothing until the background load lands), so its value is the empty list's: rows served just after a gateway start compare unequal to the loaded list and heal as soon as the list loads.list_fingerprintlives in thekiro_crew.securitypackage, whose measured line budget intest/test_security_gate_liveness.pyis re-pinned for it and forexfil.oauth_extension_changes(34 lines together), with the reason written beside it. The invariant this rests on is pinned where rows are served (_prepare_messagesinchat_utils.py): any new input that changes what already-served rows look like must move that value or mark loaded rows, or long chats keep stale rows above their newest page.Handling a change re-reads the open chat; a background pane on screen (a split view, a member's panes) re-reads itself as soon as its slot is marked, and a cache no longer on screen keeps its mark and heals on its next read, so one click never fans out whole-transcript reads to every session opened this visit. If that re-read fails while the slot is still marked (
slotHealFailed), the open chat or the pane shows its load error with a Retry, so a revoked link is never left clickable silently. A change this tab made from a redaction card in a background pane marks that pane (which re-reads itself) and still refreshes the open chat, whose rows the change outdates just as much (the status frame will not report it, since the write already adopted the value). A background pane's first read (its hydrate) that comes back served under an outdated value re-reads before installing. Every re-read, in warm, switch and hydrate alike (a refresh needs none: the mark drops it), goes through one helper (renewUntilCurrent): a re-read is checked again only when the value moved while it was in flight, so a revoke landing mid re-read re-reads again, while a re-read that disagrees with an unchanged value is the server's current answer and is kept (no loop right after a gateway restart). A refresh, warm or switch dispatched before a change that has since marked its slot (a variant switch, an allow or revoke) is dropped when it lands (slotRowsChangedAt+markedSince; a switch, which must finish, re-reads the whole transcript instead): reads carry no ordering, so a late one would otherwise reinstall the rows the change outdated after the change's own read had cleared the mark. It is capped at three re-reads, and a page still outdated once the cap is spent is refused (ObsoleteReadError), never installed: installs carry no ordering, so a late one could overwrite the fresh rows the newest change's own read already put on screen, and that read is what heals the view. A switch refused this way keeps the rows on screen rather than clearing them, and reports nothing. If a pane's hydrate re-read fails, the pane shows its usual load error with Retry (which re-runs the check) instead of a blank pane; the outdated rows are never installed. A marked switch also takes the whole read when its cache holds a persisted row with no readable timestamp (a row streamed this session): the coverage measure cannot place that row, so it cannot prove the window re-served it. A read that was already in flight when the change landed answers with rows the change outdated; the refresh, warm and switch each compare the read'sredaction_genwith the document's current value and re-read instead of writing outdated rows over the fresh read the change asked for. A marked view also no longer counts a page as covering it when id-less durable rows (history read off disk without amid) sit above the page's anchor: those rows would be kept verbatim, so the view takes the whole read.One consequence needed its own fix. The unbounded handler branch counts raw rows (every per-turn
donerow) where a bounded read counts after collapsing them, and a wide chat's retained baseline came from unbounded reads until now. Its first bounded warm then read the smaller collapsed count as a server shrink and dropped the pane's live identity-less tail (the in-flight streaming row).retainServerTotalnow records when a count came from a read that says it was unbounded (slotServerTotalRaw, cleared with the other per-slot maps on eviction); the settled background hydrate now says which read it was too, while a running hydrate's count stays refused as before. Against a raw baseline the warm reducer compares the payload's own rawtotalwhenever it has one (an unbounded read, or the coverage retry), so a genuine truncation such as another client clearing the slot is still detected. Only a bounded page with no raw count declines the shrink and same-count checks: the same "no comparable count, keep the rescue" answer an absent baseline gets. The collapsed count then becomes the baseline.A sign-in (
mcp_oauth) row still offering its Authorize link is never kept above a bounded page: the server withdraws a dead child's link only as it serves the row, so a refresh, warm or switch whose kept head holds an open one reads the whole transcript instead (hasOpenOAuthRow, pinned per path inchatSlice.overCeilingRead). A settled link (completed, failed, superseded or expired) keeps the bounded read.A whole read on the open chat takes as long as the transcript is big, so on a streaming slot a live chunk landing inside it is near-certain. Its rows predate that chunk and the fulfilled reducer rebuilds the view from them, so when the live-frame counter moved since dispatch,
refreshSlotinstalls every read past its first page (the marked whole read, its unbounded retry, and the sign-in whole read) with the live tail carried over (withLiveTail): the view's rows after the newest row the read also holds, which the read lacks, and the view's streaming row in place of the read's older copy of it. Discarding the read instead would leave a revoked link clickable until the turn ends, which is what the read exists to stop. A patch to a row already on screen or cached (chat_message_update: a sign-in banner settling or retired, a tool row's result) moves no live-frame count, so every such patch, for any slot, is numbered into a capped log (rowPatchLog,store/chat/rowPatch.ts,withReplayedPatches) and the ones past dispatch are replayed onto every page a refresh installs (bounded pages included), and onto what a switch or a background warm installs, so a settled or retired Authorize link is not put back; a read that outlived the log's cap is refused as a failure, so a marked chat or background pane shows its "Couldn't refresh" notice with Retry rather than silently keeping the revoked link.Costs this takes on knowingly, all bounded to what is on screen: any change to a serving input (an allow or revoke, a write to
oauth_endpoints.json, including an editor save or a scheduled touch that only moves its stat, and the first status frame after any gateway restart) re-reads the open chat, and each pane on screen, whole once; more than three changes landing inside one switch refuse that switch's read, and the newest change's own refresh fills the chat instead. On Windowsst_ctimeis the creation time, so a restore can reproduce the file's whole stat; the value therefore also folds inexfil.oauth_extension_changes(), a count of changes to the endpoint set the loader has returned in this process, so rows rendered under a set since restored never share a value with the restored state on any host.One trade a maintainer should decide:
TestServingInputsArePinned's reach walk andPINNED_READSfail when code reachable from the render reads a module-level name the pin does not list, in one of the seven serving-state modules, or when a new module enters that chain; a read or module that drops out passes, so only a genuinely new read costs a judged re-pin (the regeneration command is in the test file). A constant those modules add but the render never reads passes too. Reviewers split on it: one asks to drop the walk and keep only the signature pins and theSERVING_INPUTSbehaviour tests, another to extend it to method calls, which it does not follow today.Today the only server-side changes to already-loaded rows' content are the registered serving inputs and a variant switch (which marks its slot); nothing else re-serves rows differently.
Backwards compatibility
Compatible: no persisted-state change; one additive status field (
redaction_hosts_gen) and one additive response field (gen). (slotServerTotalRaw,slotHeadUnverifiedandloadedRowsEpochare in-memory store state). The allow and revoke responses gain agenfield; a client that does not read it handles its own write exactly as before. A view or pane at or under the ceiling takes the identical request path as before (pinned by tests).Tests
New
website/src/test/chatSlice.overCeilingRead.test.ts(29 tests):limit=500read, and views of those sizes refresh with exactly onelimit=500read; afterwards each holds every original row plus the new ones, in order;limit=500read and ends with every row; a window that moved past the whole cache, or is missing a cached row below the cut, still retries unbounded;markLoadedRowsChangedmarks every loaded slot including the open one, or only the named slots; a marked 600-row cache's next switch and next warm each re-serve a changed older row and clear the mark; a second change landing while a read is in flight keeps its mark; a switch away that drops the open view's re-read leaves the view marked, and the switch back re-serves it.ChatPageFollowupalso pins that the "Allow for this host" reload marks another loaded session's cache.chatSlice.overCeilingReadpinsnoteRedactionHostsGen: a status frame's first value is a baseline and a moved one is handled once; this tab's write is handled once whichever of it and the status frame lands first; an empty value is unknown, but a write without one is still handled.UseWebSocketCoveragepins that a status frame whoseredaction_hosts_genmoved marks a background cache and re-reads a 600-row open chat whole, while the first value and an empty one change nothing, and that a variant switch marks a background slot. Backend:test_redaction_handlers.pypins that allow and revoke answer with the value their write left, unmoved by a write that changed nothing;test_redaction_allow.pypins that the fingerprint of an unloaded list equals the empty list's, moves with every change, returns to its value when the list does, and shows none of the list;test_dashboard_status_snapshot.pypins that the status snapshot carries it.test_slot_detail_full_history.pypins the counting contract the units marker rests on, where the counting lives: the same transcript with per-turndonerows reports its raw count unbounded and its collapsed count on a bounded read.chatSlice.overCeilingReadalso pins the read seeding: a first read's value makes a differing first status frame a change, a later read never moves a baseline, and a pane hydrate and a warm seed it too;test_slot_detail_full_history.pypins that both read branches report the value.chatSlice.overCeilingReadalso pins that a change re-reads a mounted background pane, that a refresh, a warm and a switch whose read was served under an outdated list each re-read, and that a marked view with an id-less row above its oldest identified row takes the whole read.ChatPane.hydrateBoundpins that a pane hydrate served under an outdated value re-reads instead of installing, and that a re-read answering the same value installs rather than looping;chatSlice.overCeilingReadpins that this tab's write from a background pane warms that pane and refreshes the open chat, pins that a marked switch holding a timestamp-less row takes the whole read, and pinsrenewUntilCurrent(re-reads when the value moves mid re-read, keeps an answer under an unchanged value, refuses a still-outdated page at the cap) and that a refused switch does not wipe the chat, and that a refresh or warm predating a variant switch is dropped;chatSlice.overCeilingRead,ChatPane.hydrateBoundandChatPageFollowuppin that a failed re-read of a marked slot shows the load error with a Retry that re-reads it (and that an unmarked slot's failure, or an outdated read refused, does not);TestServingInputsArePinnedalso pins that the published value is keyed by the persisted secret, not a plain digest;ChatPane.hydrateBoundalso pins a revoke landing during the hydrate's re-read.test_slot_detail_full_history.py::TestServingInputsArePinnedfails when_prepare_messagesor_prepare_messages_scopedgains a parameter or consults a new module helper, or when the set of project functions reachable from_prepare_messagesat any depth changes (followed by name and through modules,mod.helper(), whether imported at module level or inside a function; methods are not followed and are left to review); the reached modules are pinned by name, and in the seven that hold or read serving state (dashboard.chat_utils,dashboard.state,security.redaction_allow,security.redaction_switch,security.exfil,config.loader,platform.context) the module-level state their reached code reads is pinned by name too (PINNED_READS, a readable list per module, not per-function hashes), so a helper that starts reading a new setting fails it, while renaming, splitting or adding a helper that reads nothing new passes untouched (both pins are printed for a judged re-pin by running the test file directly) (walked in a fresh interpreter, so test fixtures cannot skew it); it also pins that the served value moves with each registered input, so a new serving input cannot land without deciding how it invalidates kept heads. The same invariant is stated at the slot-detail handler's render and at the client'sfilterMessages, the two other places a serving change could be made.ChatPane.hydrateBoundalso pins that a failed re-read shows the load error and that Retry recovers.UseWebSocketCoveragepins that a variant switch on a 600-row view takes one unbounded read, andChatPageFollowuppins the same for the "Allow for this host" reload.chatSlice.refreshSlotBound's "above the handler ceiling" test now pins the bounded request and that the view is not shrunk, instead of the unbounded read. That test pinned the unbounded read to guard one harm, a bounded page shrinking the view and dropping scrollback; the kept head keeps the rows above the page, so the intent stands and only the mechanism it pins changed.Mutation checks, each reverting one piece: the refresh change (4 fail), the warm's marked whole read, its raw-baseline whole read and its sign-in head whole read (one test each fails, after the #16005 rebase), the units gate (the raw-baseline test fails), declining every raw-baseline comparison instead of using the retry's raw count (the remote-clear test fails), the coverage condition (the hole test fails), the raw-marker write and the hydrate's flag (their marker tests fail), the marked refresh's ceiling skip and its overlap refusal (one test each fails), the switch's coverage cut (3 fail), the unverified-head gate on the switch, on the warm, and on the page's mark dispatch (one test each fails), clearing a mark regardless of its epoch (the mid-read test fails), leaving the open slot unmarked (7 fail, including the switch-away race), the refresh's mark clear, the variant switch's mark, the status-token wiring, a missing baseline, and reading an empty token as a change (each fails its test), dropping the status value's dedup, its baseline, a value-less write, the status wiring, or the page reporting its write as a status (each fails its test), and a constant fingerprint or an empty status field (one test each fails).
Local gates on the rebased head:
tsc -p tsconfig.app.json,npm run lint, jscpd,lint:i18nandi18n:checkwithI18N_BASE_REF=origin/main, theme-colors, phantom-classes, restyle-ratchet, the bundle-size gate, and the feature-map and decision-ledger gates all pass. All 83 store and chat-pane suites (src/store,src/test/chatSlice*,refreshSlot*,ChatPane*,switchSlot*) pass, includingchatSlice.warmSlotCacheBound,chatSlice.boundedRefetchShrinkandChatPane.hydrateBound.Manual verification
N/A: unit coverage drives the real store and reducers against a stubbed server at the request boundary, which is where the behavior lives. Nothing in the rendered UI changes.
Screenshots / video
The one new visible state: when the open chat's re-read after an allow or revoke fails, the chat says so with a Retry (
heal-error) instead of leaving rows the change outdated on screen silently. Captured from the built SPA bywebsite/scripts/capture-heal-failed-notice.mjs(the redaction card's ownmc:redaction-hosts-changedevent, with the transcript endpoint failing, then Retry with it healthy):aria-disabledandaria-busy, meanwhile: still focusable, so a keyboard user keeps their place, and the re-mounted open-chat Retry takes focus back) and clears only once a re-read lands; in split view only the grid pane shows it, not a second banner above the grid; a Retry that fails again re-mounts the notice, so itsrole="alert"is announced again rather than the click reading as ignored.capture-heal-failed-notice.mjskeeps the endpoint failing through one Retry).scripts/capture-heal-failed-pane.mjs), where the copy wraps beside its Retry; the harness asserts the notice sits inside the second pane. The whole second pane renders dimmed because it is the unfocused pane of the split; its Retry is enabled.A background pane shows the same copy in its existing load-error slot (
chat-pane-hydrate-error); its Retry re-runs that pane's warm (pinned byChatPane.hydrateBound). Everything else changes how many rows a fetch requests; the panes render the same rows before and after.Related Issues
Refs #12907. Follows #13203.
Pattern harvest
Rule candidate: review-prompt
Pattern: an
undefinedmeaning "no safe bound" consumed as "no limit", where one of the declines (over a ceiling) has a safe bounded answer the caller never asks for.Checklist
feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)Contribution License Agreement