Repository navigation
fix(dashboard): let a mirrored session unlink; name a paused mirror - #14117
Conversation
GPT 5.6 Review — ✅ human override acceptedHuman judgment by @pepmach overrides the GPT 5.6 finding for [GPT-OVERRIDE] 7d54b67 This comment is updated in place on each push. The model was not re-run because an authorized human decision supersedes it. False positive or not applicable? A repository writer can comment: |
Design Review (Fable 5) — ✅ PASSDesign-level review of Design-Verdict: PASS Confirm a maintainer sanctions partially reversing #3006's recorded pause-only decision (its vocabulary pins are rewritten here on #14068's evidence). [DESIGN-REVIEWED] 7d54b67 |
First Principles Review (Fable 5) — 🟡 CONCERNSPremise-level review of First-Principles-Verdict: CONCERNS
Not justified as shipped
What this change shipsInventory (10 items) — 9 justifiedIntent: FIX — give a dashboard user a way to remove (not just pause) a channel binding, ending the session-control lock-out and the UI describing a severed-looking link that survived. More than 10 differences; the 10 most noticeable kept.
[FIRST-PRINCIPLES-REVIEWED] 7d54b67 |
UX Review (Fable 5) — 🟡 CONCERNSUX-level review of UX-Verdict: CONCERNS Primary verbs were all read correctly but only as guesses, and the born-in note reads as a global "cannot be removed" claim beside menus offering removal. Watch
[UX-REVIEWED] 7d54b67 |
Opus 5 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
7bd7565 to
038c7d5
Compare
|
|
|
|
|
|
|
|
|
038c7d5 to
c489b17
Compare
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Description gains the |
A dashboard session mirrored to a Discord DM can be paused from the session menu (Disconnect) but not severed: #3006 removed the sever actions when it made Disconnect mean "output stops, the binding stays", and the mirror-unlink endpoint kept working with nothing calling it. The retained binding keeps routing the DM's messages into the session and keeps session control refusing it ("sessions mirrored to a channel cannot control other sessions") with no exit anywhere on the dashboard. The paused state also reads exactly like the connected one on the header chip, and like a never-connected channel in the menu. This reverses that part of #3006 on the evidence of #14068. The session menu gains an Unlink item beside Disconnect for every explicitly bound channel (mirror-unlink; slack-unlink for a Slack thread), a paused row says "Disconnected but still linked", and the chip names the paused state ("Driven from X · output paused"). Disconnect keeps the pause semantics #3006 recorded. _has_channel_mirror keeps refusing on a paused mirror -- fail-closed, because a paused binding resumes with one click -- and that is pinned with a test and stated in the spec. The Discord /unlink value sweep is pinned, on the real store and through the dispatcher, for the observed row shape (dashboard key, DM location with a null thread, paused, inbound-accepting); the two inferred causes for the row surviving are refuted by those tests. Fixes #14068
|
AI-review override not recorded: keep the reason to 500 characters or fewer. |
|
|
AI-review override not recorded: keep the reason to 500 characters or fewer. |
|
/ai-review override gpt 7d54b67: I accept this residual: no in-repo writer sends a channel-less unlink object (the guarded caller sends channel_type+binding from a rendered row, LinkedSurfacesSection.tsx:368 / client.ts:4696; the projection never mints an empty-channel row, state.py:8060-8061; the unguarded caller sends no body, client.ts:4676), so {} reaches only the documented no-row clear, SEL-audited (chat_mirror.py:938-944), announced (link.py:304) and re-linkable. The channel_type-in-body tightening lands via #14377. |
Human judgment recorded@pepmach marked the gpt AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
|
Problem / Motivation
Goal: A dashboard session mirrored to a Discord DM can be un-mirrored from the dashboard — the binding removed, not only paused — so session control stops refusing the session and the screen no longer describes a surviving binding as disconnected.
A dashboard session mirrored to a Discord DM cannot be un-mirrored from the dashboard. The session menu's Discord row offers Disconnect, and Disconnect only pauses: the binding stays in the session store. That retained binding still routes the DM's messages into the session, and session control still refuses the session —
session_create/session_send/session_read_messageanswer "sessions mirrored to a channel cannot control other sessions" — across Disconnect and a gateway restart. Nothing on screen says the binding survived: the header chip reads "Driven from Discord DM" exactly as it did before Disconnect, and the menu row reads "Connect to Discord" exactly like a channel that was never connected.Why it matters
The operator's own dashboard session becomes unable to dispatch or read workers with no user-facing exit, and the UI tells them it is disconnected while the store says it is bound. The one working exit is a command typed in Discord, which a dashboard user has no reason to know about.
Not a goal
mirror-pause/slack-pausetake no stale-row guard — a pause is reversible with one click on the same row and destroys nothing, so a stale pause is corrected by the next slots push, and the guard is for the destructive verb only.owner_dm_refusaljudges channel-born slots only, and a dashboard-born mirrored caller stays refused here (session control: should a dashboard session mirrored to the owner's own DM be admitted, as #13522 admits the DM session itself? #14084).What changed (motivation → approach → change)
Unlink from Xmenu item (LinkedSurfacesSection)mirror-unlink; a body naming the Slack thread is handed to the Slack teardown server-side (the routing row below). Offered beside Disconnect on every explicitly bound channel, never on a channel the session was born in — the explicit row there is the dispatcher's own self-mirror, and popping it would strand dashboard-taken turns until the next inbound message rebinds it. The two items define each other under their labels, so neither is read as the other: every connected row's toggle readsPause replies to X— the Disconnect action labelled for what it does, the symmetric twin ofResume replies to X(the UX lane's rename, verbatim: "disconnect" everywhere else in life means sever, and the reader read the row right only through its sub-line while "the wording pulled in different directions"; a label change only, #3006's pause semantics stand) — and carries "The connection stays." beneath it (trimmed from "Pauses replies — the connection stays": under a verb that already says the replies pause, the first clause was the verb repeated, and the sub-line's job is what STAYS; ended as a sentence, like the paused line, because the unpunctuated form read as "cut off, like a sentence missing its ending" — every locale, each with its own terminal mark; the failure line follows the verb too, "Could not pause replies to X: …") — a born-in channel's row too, where it is equally true (the conversation stays bound, a reply there resumes it) and where a bare pause verb otherwise reads as possibly "the harsher thing" to a reader who has learned the line elsewhere — and Unlink carries "Removes the connection — X stops driving this session. Reconnect anytime from the session menu." for a two-way binding, "Removes the connection — replies stop going to X. Reconnect anytime from the session menu." for a one-way mirror. Reconnecting is real, and the line says where it lives: right after an unlink the session menu offers the same destination as a freshConnect torow. The way back is its own sentence: as a third dash-clause ("… until you reconnect — from the session menu.") the place attached to the nearest verb and parsed first as "removes the link from the session menu". The line no longer names the kind of link — "two-way link" made a reader pause on the one control that ends the lock-out ("I'd pause first because I don't fully understand 'two-way link'"), and the tail already carries the direction. The place is named as "the session menu", not "this same menu": the same rows also open under the paused header chip, and an unlink from there removes the chip and its menu, so "this menu" pointed at a menu that had just vanished ("which menu?"). A reader who understood the verb still would not click it without knowing how easy the way back is ("I'm not sure how easy reconnecting is"), so the outcome line names the place. "Forgets this connection" on Unlink alone was tried and read as hard to undo, with nothing under Disconnect to compare it against. Which pair a row gets is the row's owndrives_session— the slots projection's statement that messages sent there land in this session — never an inference from the wire'sdirectionor the channel name: a Slack thread row is projectedout(its inbound routing is Slack's own thread index, never the mirror's inbound marker), yet a reply in a linked thread resumes this session while the link stands and the Slack teardown evicts that index, so the projection marks itdrives_session: trueand the row takes the two-way pair; inferred client-side from direction and channel, the paused Slack row claimed a one-way link and its Unlink understated what the sever destroys. While a row's STALE refusal notice shows ("The X connection changed while this menu was open. Nothing was unlinked; the row was refreshed."), that channel's Unlink item is not rendered at all: the refetch the refusal triggers may redraw the very same row (a binding re-linked on the same channel), and an Unlink directly under that notice — live or dimmed — contradicted it (a reader "cannot reconcile those and would not click anything"; a dimmed one still read as "odd"). The item follows the notice and returns with its dismissal (or the row's next click); an ordinary failure keeps it live for a retry. The "Ask the agent" hand-off stays under the stale notice as under every other failure: inside Radix menu content it is the notice's only keyboard-reachable escalation and renders in the notice's own conditional branch witharia-describedbythe notice's id —errors-use-error-notice's third sanctioned state; a notice with neitheraskAgentnor that sibling is a dead end (the Opus lane's block on the previous head, which had suppressed the item for the stale case). It earns its place there once the notice says what happened rather than "no longer linked": the notice is worded after what the refusal knows — the connection the row was drawn from was replaced, nothing was unlinked, the row was refreshed — never as "X is no longer linked", because a nonce-only mismatch (a Slack thread replaced in the same channel, a rebind after an unlink from a second tab) means the channel IS linked, to a new target, and the refetch redraws the row as connected right beside the text; and "the connection changed while this menu was open" is a question the agent can answer — which the item now says under its label, in the menu's own sub-line grammar: "Ask what this channel is linked to now." (new keyask_agent_stale_outcome, every locale;ErrorNoticeMenuItemgains an optionaloutcomesub-line for a host whose every other item self-describes). A bare sparkle item in such a menu was the one control a blind reader could not identify ("no idea what it does or why it's in this menu"). Only the stale refusal carries the line; an ordinary failure keeps the bare item, as the hand-off reads everywhere else in the dashboard. Every sub-line says "the connection", never "the link": "Copy link" a few items up means a web address, and one word for two things in one menu read as a collision.Resume replies to X— the verb names the state its sub-line describes. Under a line saying the link still stands,Connect to Xread as a second link rather than a resume ("the title says 'Connect' but the small text describes the current paused state… I would not be confident which one I was about to do"), and every paused-mirror repair passes through this row. Every paused BOUND row reads it — a paused born-in conversation too, because that row carries the direction tag and a bareConnectunder a tag asserting the connection stands is the same contradiction (the paused born-in row is now shown, below); only a never-connected offer, which asserts no connection, keepsConnect to X. The line is ONE sentence on every paused bound row, "Replies paused — the connection stays.", the born-in row included — with only the verbResume repliessaying it, a reader found "the menu itself doesn't say 'paused' anywhere" — rendered ABOVE the born-in note, so that row reads state first, then why it has no Unlink; so a paused row is not mistaken for "never connected", does not say "linked" beside the "Copy link" item, and leads with what is paused rather than with "Disconnected" under a row that readsConnect. It carries no direction: as a pair ("…messages there still reach this session" / "…don't reach this session") it flipped between two visually identical rows with nothing marking why, and the reader who met both stopped trusting either ("I cannot tell which is true … I no longer trust the captions") — the same reader who, a round earlier, read the kind-names ("the two-way link stays" / "the one-way link stays") as jargon. The direction lives on the row's label instead (next row). While the row's stale refusal notice shows, this line (and the connected row's "The connection stays") is withheld and the verb falls back to the plainConnect to X— beside a notice that says the connection changed while the menu was open and nothing was unlinked, a line or tag asserting the connection stays, or a verb that resumes it, made the row disagree with itself.LinkedSurfacesSection)drives_session(the projection's statement of inbound routing per row, judged over the channel's rows: a born-in channel drives by its origin row) — never inferred fromdirectionor the channel name. It is what makes the Unlink pair legible: the Unlink line keeps its two tails ("X stops driving this session" / "replies stop going to X"), because what a sever STOPS genuinely differs, and the label directly above it names which kind of link the row is, so the two tails read as two kinds of link rather than as one caption that contradicts itself. Every locale; the arrows are literal characters in the catalogs.LinkedSurfacesSection)InboundLinkChip)Resume replies to XandUnlink from Xwith "Resume or unlink X." as itstitle, for the live chipPause replies to XandUnlink from Xwith "Pause or unlink X." as itstitle(new keydriven_from_hint, every locale). No other channel's rows and no offers (LinkedSurfacesSectiontakes achannelscope; a chip that reads "Driven from Discord DM" must not open a menu offering Slack or Telegram; a scoped section does not even fetch the target list). The paused chip is the one a reader clicks hoping to resume, and a hover-only hint (delayed, absent on touch, unread by a screen reader) did not cure the dead click; the live chip is the same trigger because a button beside a plain span that looked identical gave one chip two behaviours a reader could not tell apart before clicking (the UX lane on the previous head), and the menu already carries the live row's actions, so opening it from the chip adds no control — the chip itself still owns none (the old Release button stays gone). Not a second control: the rows are the one component that connects, pauses and unlinks.LinkedSurfacesSection)labelas the slots projection spells it (_link_label: "Discord DM", "Slack", …), the header chip reads the same row's label, and an offer reads the target'slabelfromchannel-targets— the same channel form with the destination on it ("Discord DM · 118273645"), the one thing an offer must add, since several destinations on one channel can be offered at once. The menu kept a brand table of its own for bound rows (channelBrandLabel: "Discord"), so one destination carried three names across the journey — the chip's "Discord DM", the rows' "Discord", the offer's target label — and a reader "cannot tell why one is more specific than the other, or whether they do different things". The brand table is now only the fallback for a wire row that carries no label; a row's own name never changes between its connected and paused states (both read the same link row). On the OFFER row that target label is split at its·: the verb line keeps the channel form (Connect to Discord DM— the name the bound row and the chip use) and the discriminator is the row's muted 11px sub-line — a human tail as the transport sent it ("#eng", "Direct Message", "yourself"), and a tail that is nothing but the id of auser:target named for what it is, "Direct message · 118273645" (new keydirect_message_id, every locale) — because the tail on the verb line read as "a raw number on a button … I don't know whose number that is", and the reconnect path the Unlink line promises lands on exactly that row (the UX lane's smallest fix, taken as worded); an unavailable offer keeps its discriminator above its reason, so two unavailable destinations on one channel stay told apart. A failed Slack connect is reported under the offer label it was clicked as, exactly as a failed mirror connect already was. Server strings, so no catalog change. The frames' fixture had been inventing the offer label ("Discord · Direct Message"); it now carries the form the Discord transport really sends (Discord DM · <user id>), and every AFTER menu frame below is re-shot with it (the BEFORE frames, main's build, still show the earlier fixture label on the offer).SessionMap.clear_mirror_linktakes both spellings (src/kiro_crew/session_map.py)dashboard:row it superseded. The read (_mirror_key) falls back to the older row the moment the canonical one is gone, so clearing the winner alone did not unlink the session:mirror-unlinkansweredwas_linked: true, the menu dropped the row, and the next slots frame redrew it pointing at the OLD target — a mirror the user had just removed, reported as removed, still delivering. Onemirror-unlinkrequest now clears both rows in one save (each popped before the save, so no reader observes the fallback in between); the endpoint is unchanged apart from its docstring, which had claimed a single spelling.dropSlotLinksreducer (website/src/store/dashboardSlice.ts)bindingthe completed request named — never the whole channel — and clears the slot'sslack_*fields in the same write only when the Slack thread row matched. Between the click and the response another tab can unlink A and link B on the same channel with B's slots push landing first; the server deleted exactly A, so exactly A's rows go and B stays.bindingon every slots link row (src/kiro_crew/dashboard/state.py,website/src/types)targetstays display-only. The nonce (src/kiro_crew/session_map.py:mirror_noncebesidemirror,slack_link_noncebeside the Slack fields; read throughSessionManager.mirror_link_nonce/slack_link_nonce) is minted whenever a binding is created or its target changes, kept across an identical rewrite (the inbound paths re-write the same coordinates on every turn, and the dispatcher rebinds a channel-born session's own conversation each inbound message), and dropped with the binding — so unlink → reconnect the SAME target yields a token the old row never carried. Without it the token was a pure function of the coordinates, and a delayed unlink from a tab still holding the old row (another tab having unlinked and reconnected the same DM meanwhile) matched the recreated binding and deleted it. Random (secrets.token_hex(8), stdlib) rather than a counter so a deleted-and-recreated entry cannot restart the sequence; it never leaves the server except inside the digest. A binding written before nonces existed has none and its token digests the coordinates alone — the binding that replaces it carries a nonce, which is all the guard needs.drives_sessionon every slots link row, andmirror-unlinkrouting a Slack binding (src/kiro_crew/dashboard/state.py,chat_mirror.py;website/src/types,LinkedSurfacesSection.tsx)channel === 'slack'. (1) Whether messages sent in a row's conversation land in this session: the projection says so per row —truefor abothmirror (its inbound marker),falsefor a one-wayoutmirror,truefor a Slack thread although its direction readsout(Slack routes replies through its own thread index),truefor the conversation a session was born in. The menu'sdrivenreads that field and infers nothing; the inference is what rendered a paused Slack row as a one-way link. (2) Which store a binding lives in:mirror-unlinktakes every row's Unlink and hands a body naming aslackbinding toslack-unlink's handler (both key spellings, the slot's own fields, the thread's reverse index, the courtesy note — the aiohttp body is served to the delegate from the cache the first read filled), beside the code that makes the assumption true:mirror-linkrefuses Slack on channel type, so no slack-typed mirror is creatable, andSessionMap.get_mirror_linkalready reads the thread as the session's mirror. The menu posts one request shape to one endpoint. Adrives_sessionbit alone cannot pick the endpoint — a two-way mirror and a Slack thread both drive this session and live in different stores — which is why the routing moved server-side rather than onto the field.SessionMap.clear_mirror_link_if/clear_slack_link_ifinsrc/kiro_crew/session_map.py, delegated bySessionManager; the token insrc/kiro_crew/messaging/link.py; callerschat_mirror.py,chat_slack.py; client half inwebsite/src/api/client.ts){channel_type, binding}. The map — not the route — recomputes the row token (messaging.link.binding_token, the projection mints it from the same function) from the binding it holds and that binding's nonce, and clears only on equality, in one@_guardedstep under the map's own lock. A mismatch — another tab rebound the slot, a Slack re-link landed a fresh thread in the same channel, or another tab unlinked and reconnected the very same target — is False, and the route answers 409mirror_changedwith nothing touched; the menu reports in place that the connection changed while the menu was open and nothing was unlinked, withholds that channel's Unlink item, the row's consequence line and its direction tag while the notice shows (the agent hand-off stays, described by the notice), and refetches. A body naming the channel with no token is refused the same way. Only an EMPTY body keeps the unconditional clear (clear_mirror_link; the Slack handler's bodiless twin-key clear): a body that is present but not valid JSON, or not a JSON object, is 400invalid_bodyand clears nothing — reading it as "no body" would have handed a caller that garbled the row it meant to name the one answer the guard exists to withhold (the Design lane's suggestion on the previous head;_expected_bindingnow reads the raw text and distinguishes empty from garbled). No unlink route holds a compare of its own any more: a route that read the binding, compared it and then cleared it performed two steps, and a rebind landing between them — another thread's!sessionspick, a rival claim, the dispatcher re-asserting an origin mirror — was cleared by the stale unlink that had matched the binding before it. That was the FOURTH member of one family on this PR (the thread id dropped from the compare,chat_slack.py:490; the client completion keyed on the channel,LinkedSurfacesSection.tsx:249; the token as a pure function of the coordinates,state.py:762; the compare and the clear as two route-level steps,chat_mirror.py:902), so the family is closed structurally rather than patched a fourth time:test_channel_connect_row.py::TestCompareAndClearIsOneStepenumerates the unlink routes (exactly the two registered under an-unlinkpath) and asserts, over each handler's AST, that it calls its primitive and reads nothing of the binding itself. The mirror twin clears exactly asclear_mirror_linkdoes (both spellings, one save, the unbind audit); the Slack twin clears both key spellings of a dashboard session. The_binding_identity/_binding_matchesroute-side helpers are gone.chat_mirror.py,chat_slack.py)mirror-link,mirror-pause,mirror-unlink,slack-link,slack-pause,slack-unlink—await state.sessions.aflush()between the map write and the first thing that reports it done: the slots push, the note or transcript backfill in the channel, the{ok, …}answer. The map's writer is debounced (50 ms), so without it a gateway exit before the deferred write reloaded an unlinked binding on restart (the channel kept driving a session the user had been told it no longer does — the GPT lane's persist-before-you-publish block two heads back), silently lifted a pause the user had set (a muted channel started delivering again), or lost a link whose thread already carried the transcript. The unlink routes got the await first; the First Principles lane's point that the pause and link siblings published the same lie is taken, and all six now share one contract, stated insession.md. Awaited in the routes rather than made the map's default because the writers that are not answering a user (inbound turns, the dispatcher's origin rebind) tolerate the debounce.mirror-link's claim runs off the loop, where a batch writes the file inline on the way out, so its await normally finds nothing owed — it is there so the contract does not hinge on which thread the claim ran on. A failed flush propagates rather than answeringok— and onslack-unlinkthe slot's own fields and the thread's reverse-index entry are torn down in afinallyaround the flush, so they follow the in-memory map in failure too: with the teardown after the await and nofinally, a write failure (a full or read-only data home) left the map clear in memory while the slot still asserted the thread — the row kept rendering from the fields, a reply in the thread still resolved to the slot, and a retried Unlink was 409mirror_changedwith nothing left to compare (the Opus lane's finding on the previous head, taken). Only what the user is TOLD waits for durability; the fields follow the map — LITERALLY: the teardown is conditional on what the map holds once the await returns. The write is a real thread hop, and a second same-slotslack-linkcan run its whole handler inside it (the existing-thread branch reacheslink_slackwith no network await), so the map may hold a NEW binding by then; an unconditional teardown stripped that link's fields and reverse index while the map kept asserting it, and a re-link then short-circuited onalready_linkedwith no in-process recovery (the GPT lane's block on the previous head). Now a link the map holds after the flush is that newer write (the route cleared the old one), whatever its thread — its fields and index stand, the thread gets no "unlinked" note and no struck OPTIONS control, and the answer carriesrelinked: true; an empty map means the old binding's fields and index are torn down, in success and in failure alike. The structural test's rule became positional: a binding read is forbidden BEFORE the compare-and-clear (that is the compare-then-clear shape) and only the plain link read is allowed after it._has_channel_mirroron a paused mirror/unlinkvalue sweepThe lock-out has one cause: the only user-facing action on a mirror was a pause, because #3006 removed the sever actions (the chip's
Releasebutton and the menu'sStop mirroringitems) when it made Disconnect mean "output stops, the binding stays" — and themirror-unlinkendpoint kept working with nothing calling it. This PR reverses that part of #3006 on the evidence of #14068: a binding nobody can sever locks the operator's own session out of session control. Disconnect keeps the pause semantics #3006 recorded (its header comment is the record;docs/decisions/holds no decision on it), and Unlink is a second item rather than a change to Disconnect, because the two verbs mean different things — and each item says what it does under its label, because stacked together the two verbs read as near-synonyms.The guard compares an opaque identity rather than the row's redacted tail because the tail is lossy in exactly the case the guard exists for: a Slack link's only discriminator is its thread id, a re-link after an unlink (or a Slack-side resume) lands in the same owner DM channel on a fresh thread, and two such rows read alike on
target. The token is minted by the slots projection and recomputed by the map from one function (messaging.link.binding_token, below the map so the map can compare it), so the menu and the compare cannot disagree; the routes' one piece of the guard is the body reader (_expected_bindinginsrc/kiro_crew/dashboard/state.py), and the compare-and-clear is the map's (clear_mirror_link_if/clear_slack_link_if). The menu posts every row's Unlink tomirror-unlink, which hands aslackbinding to the Slack teardown on the fact the server itself enforces (mirror-linkrefuses Slack on channel type, so no slack-typed mirror binding is creatable); the client carries no channel-to-endpoint switch, and no inbound inference either — whether a row drives the session is the projection'sdrives_session.Why the Slack unlink's durability await is not followed by an epoch stamp on the slot's Slack fields (the GPT lane's F1 on the previous head,
chat_slack.py:538: a relink that starts and completes inside theaflushinstalls new slot fields, and the resumed unlink blanks them). The interleave needs a second same-slot link request to begin and finish its whole handler inside one worker-thread map write, in the only body shape that makes zero Slack round trips (an explicitthread_tsand a non-DM channel) — any link that began before the adjacent clear returnsalready_linked, and any real Slack round trip lands after the unlink resumes, which is the correct outcome. Both racers are browser-driven: two user actions on the same slot colliding inside one local file write. The residue is bounded, visible and self-healing: the persisted link says linked while the slot's fields say not, so outbound mirroring pauses and the row already renders unlinked; inbound does not misroute, becauseslot_registry.py:138-140prunes the stale reverse-index row and returnsNone; and the fields are rebuilt from the persisted link whenever the slot is next constructed (state.py:6933-6938) — a restart heals it, and an in-process unlink-then-link is the exit. Reordering the field teardown ahead of the await would publish "unlinked" (the slot projection reads those fields) before it is durable, which is the lie the await exists to prevent; a generation stamp compared after every await is new state plus a new ordering contract between link and unlink, carried by every future reader, against a residue that puts no credential, ceiling or user data at stake. So the await stays where it is, and the race is recorded here rather than guarded.The paused-mirror refusal is kept, deliberately. Pause mutes outbound delivery only; inbound routing never reads
mirror_paused, and one click on the same row resumes delivery, so a paused binding is a latent audience that returns without further authorization, and the gate fails closed on it. The way back into session control is Unlink.docs/system-specs/modules/session-control.mdstates this beside the mirror refusal,docs/system-specs/modules/session.mddescribes the Unlink item, the binding token and the three chip states, anddocs/system-specs/modules/messaging.mdrecords that the/unlinksweep reaches a paused, dashboard-keyed row.Frontend strings go through the catalog (
website/src/i18n/locales, all twelve locales plus the regenerated pseudolocale). The capture script behind the frames below is NOT part of this diff (it was, two heads back; the Design lane noted it re-asserts strings the component tests already pin and rots on every wording change, so it was removed from the commit — the frames stay attached, generated from a local run of the same script against this head's build);website/src/test/dashboardSlice.test.ts,website/src/test/ChatHeaderMenu.slack.test.tsxand the component tests underwebsite/src/componentscover the new paths; the backend pins live intest/.Backwards compatibility
Compatible:
mirror-unlinkandslack-unlinkalready exist and gain a caller plus an OPTIONAL body — a bodiless call behaves exactly as before;mirror-unlinkadditionally accepts a body naming the Slack thread and serves it through the Slack teardown (a body the menu never sent there before — it routed Slack rows toslack-unlinkitself). Slots link rows gain two fields (binding,drives_session); a client from before them sends nothing and is unaffected, a client holding a cached row withoutbindingis refused as stale and refetches, and one withoutdrives_sessionreads the row as not driving until the next slots push. The session map gains two OPTIONAL per-entry fields (mirror_nonce,slack_link_nonce), written only when a binding is created or rebound and dropped with it; an entry from before them reads as "no nonce" and its token stays the coordinates-only digest it always was, so nothing is migrated and an older gateway reading the file ignores the fields.dropSlotLinksis a new reducer,dashboardSlicekeeps every existing action. New catalog keys only.Tests
test/test_session_map_mirror.py::TestLegacyDashboardSpelling::test_clear_removes_the_superseded_legacy_row_tooandtest/test_channel_connect_row.py::TestEndpoints::test_one_unlink_clears_the_superseded_legacy_row_too— a realSessionMapholding both the canonical binding and the pre-unificationdashboard:row it superseded; oneclear_mirror_link(the second test drives it through onemirror-unlinkPOST on a channel-keyed slot with the row's own token) leavesget_mirror_linkempty, the nonce empty, the legacy row'smirrorpopped, and the slots projection with no mirror row. Red-first on the previous head: both fail withassert ChannelLink(channel_type='telegram', channel_id='old'…) is None— the clear had answered200 {was_linked: true}and the OLD target was the live binding again.test/test_chat_mirror.py::TestMirrorUnlink::test_a_row_from_before_an_unlink_cannot_unlink_the_same_target_relinkedandtest/test_chat_slack.py::TestSlackUnlink::test_a_row_from_before_an_unlink_cannot_unlink_the_same_thread_relinked— the ABA the coordinates cannot see: bind, take the row's token, unlink, reconnect the SAME target (mirror) / re-link the SAME thread (Slack); the old token is 409mirror_changedwith the recreated binding untouched, the new token unlinks. Red-first on the previous head, run as a scratch probe against its sources: the old token answered200 {ok, was_linked: true}and deleted the recreated binding.test/test_session_map_mirror.py::TestBindingNonce— a nonce is minted on create, kept across an identical rewrite (also across anaccepts_inboundflip on the same target), re-minted on a target change and after clear + recreate, dropped byclear_mirror_link,clear_mirror_links_atandclear_slack_linkand by the Slack clear sentinel; the legacy Slack-synthesized mirror reads the Slack link's nonce; a binding planted before nonces reads"".test/test_chat_slack.py::TestSlackUnlink::test_a_stale_row_cannot_unlink_a_relinked_thread— the case the lanes named: old thread and replacement thread in the SAME channel; the old row's token is 409mirror_changedwith nothing cleared, the current row's token unlinks. A channel-plus-redacted-tail compare answers 200 to the old row.test/test_chat_mirror.py::TestMirrorUnlink— a Discord row cannot unlink a Telegram replacement, and a Telegram row cannot unlink a same-channel replacement whose id shares its redacted tail; a namespaced Discord id still matches its bare row; the right channel with no token, the right token under the wrong channel, and a row naming a binding that is already gone are all refused; no body keeps the unconditional clear.test/test_chat_mirror.py::TestMirrorUnlink::test_a_garbled_body_is_refused_and_clears_nothingandtest/test_chat_slack.py::TestSlackUnlink::test_a_garbled_body_is_refused_on_the_slack_route_too— a body that is present but not valid JSON ({"channel_type": "telegram",), or valid JSON that is not an object ([],"telegram",42), is 400invalid_bodyon both unlink routes with the binding still held and nothing pushed; the empty body still clears unconditionally. Red-first on the previous head:assert 200 == 400— the garbled body was read as "no body" and cleared the binding.test/test_channel_connect_row.py::TestTheWireReportsIt::test_every_row_carries_the_binding_the_unlink_compares— the projected row'sbindingequals_binding_identityof the stored link WITH its nonce, differs from the coordinates-only digest, hides both the raw id and the nonce, stays the same across an identical rewrite, changes across unlink + reconnect to the same target, and differs between two threads in one Slack channel (the Slack row digesting the Slack link's own nonce).test/test_slack_thread_sync.py— the exact row shape pins carry the token anddrives_session(trueon the origin row,falseon the one-way mirror); thebothmirror readstrue, the degraded-accessor mirrorfalse, the Slack threadtruebeside itsoutdirection.test/test_channel_connect_row.py::TestTheWireReportsIt::test_every_row_says_whether_it_drives_this_session— on the real map: a one-way mirror row is("out", False), the same binding rebound withaccepts_inboundis("both", True), a Slack thread row is("out", True), and the field is a bool on every row. Red-first on the previous head:KeyError: 'drives_session'.test/test_channel_connect_row.py::TestEndpoints::test_a_slack_row_unlinked_here_gets_the_slack_teardown— one slot holding a Discord mirror AND a Slack thread on the real map; a stale Slack token posted tomirror-unlinkis 409mirror_changedwith the thread intact, the current Slack token is200 {ok, was_linked: true}and the Slack teardown ran (both map spellings gone, the slot's_slack_*fields reset, the thread's reverse index dropped,slack_linkedfalse in the projection) while the Discord mirror beside it still stands — so the request went to the Slack teardown, not the mirror clear. Red-first on the previous head:assert 409 == 200.test/test_channel_connect_row.py::TestCompareAndClearIsOneStep::test_a_rebind_cannot_land_between_the_compare_and_the_clearand::test_a_slack_relink_cannot_land_between_the_compare_and_the_clear— the race GPT named, made deterministic: the nonce read the compare depends on is wrapped so a REBINDING THREAD is released inside it and given half a second to land. Under the map lock it cannot: the unlink answers200 {ok, was_linked: true}for exactly the binding it named,landed_insidereads False, and the rival binding (a Telegram mirror / a fresh Slack thread) stands afterwards. Red-first on the previous head, run as a scratch probe against its routes:status=200 landed_inside=True after=None— the rebind landed in the window between the route's compare and its clear and the stale unlink deleted the binding it never named (Slack:after=(None, None)).::test_a_rebind_that_lands_first_is_refusedpins the other ordering the lock allows: the rival is already there, the stale token is a mismatch (False), the rival's own token clears the rival, and a row whose binding is gone is refused.test/test_channel_connect_row.py::TestCompareAndClearIsOneStep::test_a_rebinder_the_compare_never_released_exits_without_a_writeand::test_an_early_failure_inside_the_block_still_joins_the_rebinder_without_a_write— the race helper cannot outlive its test: it is a context manager whose exit cancels and joins the rebinding thread (bounded join), and the rebinder writes only when the compare released it — a wait that times out, or the release cleanup sends, exits without a write. Proven with the shape GPT named: an assertion injected inside the block before any compare runs propagates, the thread is joined on the failing exit, and the real map's binding is unchanged (nothing can recreatetmp_pathafter the fixture removed it). Red on the previous head with a scratch probe: the old rebinder wrote after its 5 s wait timed out (1 call(s)).test/test_channel_connect_row.py::TestPersistBeforePublish— on the real map with the debounce held at 60 s (so only an explicit flush can write the file), one pin per route:mirror-unlinkwith a row token,mirror-unlinkwith no body, and the Slack thread throughmirror-unlinkeach leavesession_map.jsonwithout the binding by the time the slots push goes out (captured insidepush_slots_update) and by the time the response is read;slack-pauseandmirror-pausehave theslack_paused/mirror_pausedmarker on disk at both moments;slack-linkhas the thread on disk when the response is read and when the route's own slots push goes out (state.link_slackredraws the slot row from inside the map write, so the FIRST push may still read the old file — a redraw the next push corrects, not a report the user acts on);mirror-linkhas the binding on disk at both moments (its claim writes inline off the loop, so this one is a contract pin, green on the previous head too). Red on the previous head for the two pause routes and the Slack link:the answer was published while the pause was not yet on disk/… while the thread was not yet on disk; two heads back for the unlink routes:… while the binding was still on disk._with_real_storageandtest_slack_mirror_unlink.pybind the real map'saflushso the routes' durability point writes the file the pins read.test/test_chat_slack.py::TestSlackUnlink::test_a_failed_flush_still_tears_down_the_slot_and_the_reverse_index— a REALSessionMapwith the debounce held off and_write_payloadmade to raiseENOSPC:slack-unlinkanswers 500 with nothing published, the map reads no link, and the slot's_slack_*fields and the thread's reverse-index entry are torn down anyway, while the file still holds the thread (the write failed — a restart reloads the link, and the user was told nothing to the contrary). Red on the previous head:assert slot._slack_linked is Falsefailed — the raise skipped the teardown and the fields still said linked.test/test_chat_slack.py::TestSlackUnlink::test_a_relink_that_lands_inside_the_flush_window_survives_the_unlink(another thread; the same thread) and::test_a_plain_unlink_still_tears_down_the_slot_and_the_reverse_index— a realSessionMap; the route'saflushis wrapped so a concurrentlink_slack(fields, map and reverse index, the real path) lands inside the write window: the answer is{ok, was_linked: true, relinked: true}, the newer link's fields and index stand, no courtesy note and no struck control go to the relinked thread, the slots push still goes out; without a relink the answer isrelinked: falseand the old binding's fields and index are gone. Red on the previous head:the unlink stripped the relinked slot's fields(assert False is True) in both relink cases. The r9 Slack race pin (test_a_slack_relink_cannot_land_between_the_compare_and_the_clear) now readsrelinked: true— the re-link that lands after the clear is reported, not silently torn down after — andtest_every_unlink_route_clears_only_through_the_primitiveenforces the positional rule (forbidden before the primitive, the plain link read alone allowed after).test/test_chat_mirror.py::TestMirrorUnlink::test_an_undecodable_body_is_refused_like_a_garbled_oneandtest/test_chat_slack.py::TestSlackUnlink::test_an_undecodable_body_is_refused_on_the_slack_route_too— invalid UTF-8 bytes, or an unknowncharset=, are the garbled body:_expected_bindingcatchesUnicodeDecodeError/LookupErroraroundrequest.text()and answers the same 400invalid_bodywith nothing touched (a fenced GPT finding on an earlier read of the previous head: the decode raised before any read or mutation, so only the status code was wrong — a 500 where the guard has a 400). Red on the previous head:assert 500 == 400.test/test_channel_connect_row.py::TestCompareAndClearIsOneStep::test_every_unlink_route_clears_only_through_the_primitive— structural: the routes registered under an-unlinkpath (read fromroutes/*.py) are exactlyapi_chat_slot_mirror_unlinkandapi_chat_slot_slack_unlink; over each handler's AST, the primitive is called and none ofget_mirror_link,get_slack_link, the nonce accessors,binding_tokenor the former route-side compare helpers appears — no route reads the binding for a compare of its own.test/test_session_map_mirror.py::TestCompareAndClear— the primitives on the real map: a match clears exactly like the plain clear (nonce, inbound marker and pause flag gone; the superseded legacydashboard:row too), a wrong channel, a wrong token, an empty token and a binding already gone are all False with nothing touched; a binding from before nonces matches its coordinates-only token; the Slack twin clears both key spellings of a dashboard session (the bare-key copy planted, since a live claim on the same thread would evict the prefixed owner) and only the one key of a channel session.website/src/components/LinkedSurfacesSection.cov80.test.tsx— Unlink sends{channel_type, binding}(neverpauseMirror); every connected row carries the Disconnect sub-line and Unlink its outcome sub-line; a paused explicit row readsResume replies to Xand neverConnect to X(red on the previous head), a paused born-in row readsResume replies to Xunder its two-way tag, then the ONE paused line, then the born-in note in that order (compareDocumentPosition), and never the Disconnect sub-line (red on the previous head: no paused line at all; two heads back it readConnect to X); every bound row carries its direction label ("Two-way · X ↔ this session" / "One-way · this session → X") and every paused bound row the ONE paused line, with no Disconnect sub-line; a one-way row is labelled one-way and its Unlink names what a one-way mirror stops (replies); an offer carries no label; a section scoped to onechannelrenders that channel alone, no offers, and never fetches the target list; a PAUSED SLACK THREAD (wiredirection: 'out',drives_session: true) is labelled two-way and takes the two-way Unlink line, never the one-way one; the label and the Unlink line follow the wire'sdrives_sessionand nothing else — a paused Slack thread and a pausedbothmirror whose rows LACK the field (a cached pre-field payload) are both labelled one-way with the one-way Unlink line and share the single paused caption (red on the head that inferred two-way from the channel name and the direction); the stale notice withholds the direction label along with the consequence line, and both return when it is dismissed; a cached row without a token sends''; a born-in channel beside its own self-mirror row, once paused, carries the paused line too and still no Unlink; an origin-only row and a channel the session was born in have no Unlink but do carry the Disconnect sub-line and the born-in note (red on the previous head), while a mirrored row carries no note; a Slack row posts its Unlink tounlinkMirrorlike every other row —unlinkSlackis never called from the menu (red on the previous head) — and the slot's Slack fields clear on success; a failed unlink reports in place and keeps the row; a 409 is reported asunlink_staleand the slots refetched, replacing the stale Discord row with the server's Telegram row; when the refetch redraws the SAME row, there is no Unlink item under the stale notice but the "Ask the agent" hand-off item IS there,aria-describedbythe notice'sid, the notice carries theunlink_staletext, the hand-off item carries "Ask what this channel is linked to now." under its label (red on the previous head: the bare label), the row's consequence line and direction tag are withheld, and dismissing the notice removes the hand-off with it and restores the item, the line and the tag, and the next click unlinks (red on the previous head, which dropped the hand-off for the stale case); an ordinary failure keeps the Unlink item live and the hand-off reachable, as the bare item (no outcome line — that line is the stale refusal's); a PAUSED stale row falls back to the plainConnect to Xverb under its notice and readsResume replies to Xagain once the notice is dismissed; an ordinaryunlink_failedleaves the item live; an in-flight click is swallowed. Labels: a bound row reads the label the wire sent on its link row (zzq-wire-label) and never the client brand table ("iMessage", "Feishu") — red on the previous head, which rendered the brand — while a wire row with an empty label still falls back to the brand table and an unrecognised channel to the link label; every row/label pin in the file names the fixture's wire label (zzq-guild,zzq-slack,zzq-tg), which a brand-labelled row cannot satisfy; a failed Slack connect is reported under the offer label it was clicked as (zzq-slack-dm, red on the previous head: it reported the brand "Slack").website/src/components/InboundLinkChip.cov80.test.tsx— the three chip states; BOTH the live and the paused chip are a button (the same menu trigger) carrying their own hint astitle("Pause or unlink X." / "Resume or unlink X."); the live chip's menu carriesPause replies to Xwith "The connection stays." andUnlink from Xand no resume row (red on the previous head, whose live chip was a span with no button and no menu); the paused chip's menu is theLinkedSurfacesSectionrows for ITS channel alone (with a Telegram row on the slot and a Slack offer configured, the menu lists the Discord rows only and the target list is never fetched), (Resume replies to Xwith the paused consequence line, Unlink), and clicking the resume row there callspauseMirror(slot, false, false), after which the chip reads live and stays the trigger, its menu now carrying the pause row.website/src/components/LinkedSurfacesSection.cov80.test.tsxalso pins the completion race red-first: Unlink A, a slots push replaces the row with B (a differentbinding) before A's response, and B's row survives the completion with its Disconnect/Unlink still offered; the same on the Slack path keeps theslack_*fields. On the previous head both fail with B erased (expected [] to deeply equal [ 'b-2' ]).website/src/components/LinkedSurfacesSection.cov80.test.tsx(offers) — a target labelledDiscord DM · 118273645underuser:118273645renders the verbConnect to Discord DMwith the sub-line "Direct message · 118273645" and never the whole label on the verb;Slack · #engrendersConnect to Slackover "#eng",WhatsApp · yourselfover "yourself" (a human tail is shown as sent, never renamed); the click still links the exacttarget_id; an unavailable offer keeps its discriminator above its reason. Red-first on the previous head (the whole label sat on the verb line).ChatHeaderMenu.slack.test.tsx's offer pins read the split the same way (the two-offers test now proves distinguishability through the sub-lines, with the verb lines both channel names).website/src/test/ChatHeaderMenu.slack.test.tsx— the feat(channels): one connect/disconnect row per channel #3006 vocabulary pins updated to the reinstated Unlink item and to the pause verb (Pause replies to Slack/Pause replies to Discord DM, with "The connection stays." beneath): Unlink is present with its outcome (the two-way line — the fixture's Slack row carriesdrives_session: true, as the projection emits it), the rest of the removed vocabulary stays gone, a paused Slack row readsResume replies to Slackand neverConnect to Slack, and a held channel still gets no second offer. Its Discord literal pins read the wire label the fixture carries (Disconnect from Discord DM,Unlink from Discord DM), where they read the brandDiscordbefore. The chip test'sbothrows carry the field the same way, and its menu pins name the fixture's wire label (zzq-chan).website/src/test/dashboardSlice.test.ts—dropSlotLinksdrops the rows carrying the named binding and keeps the origin row; a same-channel row with a different binding is left alone and nothing is stamped; the Slack fields clear only with the Slack thread row the binding matched; no-op on a channel with no rows and on an unknown slot.test/test_session_control_boundaries.py::test_a_paused_mirror_still_refuses,test/test_session_map_mirror.py::TestReleaseConversationLocation::test_a_paused_dashboard_mirror_into_this_dm_is_swept,test/test_discord.py::test_unlink_frees_a_paused_two_way_dashboard_mirror— pins on the paused-mirror refusal and the/unlinksweep.Round 17: the Slack unlink's in-process teardown is conditional on what the map holds after the flush, so a relink that lands inside the write window survives and the answer names the race (GPT). Round 16: the unlink teardown completes even when the SessionMap flush fails (Opus). Rebased onto main
a83d2258a2immediately before this push (chore(prepare-pr): hold the skill under its 68000-byte ceiling #14404, fix(members): accept free-form display names #11121, docs: credit zerovulnlabs for a private security report #14408, docs(ci): point CODEOWNERS at the kirocrew-pr-review team #14393, fix(ci): unbreak the two base-side gates red on every open PR #14398, fix: owner-gate remaining MCP/config mutations #14300, fix(dashboard): owner-gate gateway restart and update-policy routes #14341 and the one commit after them since the previous base — none in this PR's files;git merge-treeclean, the rebased tree identical to the merge tree). fix(ci): unbreak the two base-side gates red on every open PR #14398 heals the two base-side gates that were red on every open PR, so this head inherits no expected red. Before that, rebased onto main55580af241,e4e6ed7c60,962247d7a5and4d683462c2in turn.Rebased onto main
e4e6ed7c60immediately before this push (the eleven commits since the previous base — ci(readiness): settle events that cannot change the verdict #14154, feat: show a per-type glyph on the attachment card #12916, ci(platform-tests): run the macOS shards on two xdist workers #14162, ci(review): budget the slot lookup that licenses a notice comment #13657, fix(history): keep incognito and temporary transcripts, learn nothing #13760, fix(acp): reclaim per-run work dirs and report refused alias unlinks #13974, fix(subagent): leave startup on the first stream event, not at stream open #14020, feat(desktop): re-land the bundled kiro-cli, widen signing wait #13207, ci(readiness): drop the fork lanes whose payload can never name a PR #14164, ci(watchdog): fix the blind evidence reserve and make the partial hold exact #13977, ci(macos): give the 40-minute cap headroom back with four file-shards #14173 — touch CI workflows, their tests, the attachment card and unrelated modules;git merge-treeclean, the rebased tree identical to the merge tree). Before that, rebased onto main962247d7a5after the 22:50 merges, and before that onto main4d683462c2after fix(ci): stop platformdirs' pytest11 plugin killing Windows pytest lanes #14268 merged. That merge-ref carries the Windows heal, so theBackend Tests (Windows),E2E Gateway Boot (windows-latest)andWindows Fail-Closed Sandbox Contractreds the previous heads inherited (upstream platformdirs 4.12.0'spytest11plugin, ci(windows): platformdirs 4.12.0 declares a pytest11 entry point at platformdirs.pytest_plugin that will not import, so every Windows pytest lane dies before collection #14249) clear here; earlier heads sat on7b2da39c53(the fix(settings): regenerate the settings registry for the moved double-click route #14138 heal for Chat rail registry: chat.double-click-to-edit-your-messages has no page tag, failing Frontend Tests and Coverage Gate on main #14150) and before that on the green-of-record694f61983e. Nothing is cited as an expected red on this head. Should something recur that is not this PR's:Backend Tests (Windows) (1)once failed intest/test_history_index_worker.py::test_a_contended_write_waits_instead_of_failing("the write did not actually contend") — a Windows timing test in a file this PR does not touch, a flake to rerun;Build Windows Installer (x64)is ci(windows): installer smoke test exceeded the 120-second install ceiling on an unchanged tree #12888 (the 120 s ceiling). The two CI frontend shards were run in full on the7b2da39c53head with the exactci.ymlinvocation (I18N_BASE_REF=origin/main npx vitest run --shard=N/4: 9617 + 9454 passed) and not again since — the later heads change catalog keys and the component tests under them, all covered by the i18n suite and the named files below.Gates run locally on this head, on the rebased tree: black ratchet (
chat_slack.py,chat_mirror.pyandtest_channel_connect_row.pyare baselined — untouched by black, only this round's hunks re-applied; the ratcheted files pass), isort, flake8, mypy onchat_slack.pyandstate.py; named backend tests with-n0, one file at a time:test_chat_slack.py(26),test_session_map_mirror.py(115),test_channel_connect_row.py(38),test_chat_mirror.py(88),test_slack_mirror_unlink.py(2). No frontend file changes since the head whose frames are attached (i18n 707/707 against origin/main, 77/77 across the four component/menu files, tsc, eslint,i18n:check, build all ran there; every frame is that head's render and nothing it shows has moved). Docs lint, comment-history and feature-map (enforced against the base) on this head; disclosure grep over the added lines: 0. No local review lane ran on this head; the server round is its first read. Conflict watch:git merge-tree --write-tree HEAD refs/pull/13524/head(feat(messaging): queue or steer into a busy bound session on every channel #13524 also toucheschat_slack.py) merges clean; the head sits on maina83d2258a2, the latest main at push time, sopush_guard.py --require-single-on-basereads SAFE.Manual verification
The frames below were taken from the real built SPA — this branch's build for AFTER,
main's build for BEFORE — with the slot state mocked at the API boundary (the repo's transcript harness answers/api/**from fixtures; themirror-unlinkPOST is intercepted and answered{ok, was_linked: true}, or 409mirror_changedfor the stale frame). The render is real; the Discord binding is not, because a pod has no Discord to bind. The local capture run asserts the request body carries{channel_type, binding}and that no sub-line is visually truncated. Each frame was opened and checked by eye.Screenshots / video
BEFORE (main): a paused mirror reads exactly like a live one on the chip, and like "never connected" in the menu — no way to sever it.
AFTER: the three states each read differently, the connected row's verb says what it does (
Pause replies to X, the twin ofResume replies to X), Pause and Unlink each name their outcome under the label so the pair defines itself (and the Unlink line says, in its own sentence, where reconnecting lives), every surface names the destination by the one label the server sends, and a stale Unlink is refused in place — the item withheld under a notice that says what happened, the agent hand-off beside it.The two shapes the DM-mirror frames cannot show. A session BORN in the DM has no Unlink (the conversation is the session), and its Disconnect carries the same pause line:
A one-way
!linkmirror (replies go there, nothing comes back) carries the one-way consequence lines, connected and paused; neither state shows a "Driven from" chip, because nothing drives the session from there:The chips'
titlehints ("Pause or unlink Discord DM." / "Resume or unlink Discord DM.") are native tooltips, which the browser draws outside the page — no screenshot can show them, and they are not the affordance: the click is. The local capture run reads the attribute from the DOM and asserts each chip carries its own hint, that both chips are buttons, and that the live chip's menu carries the Pause replies and Unlink rows while the paused chip's carries Resume replies and Unlink.More frames
Related Issues
Fixes #14068
Pattern harvest
Not generalizable: the missing action was a recorded product decision (#3006) that a later lock-out (#14068) overturned, not a dropped call site — a grep for uncalled API-client methods would have flagged an intentional removal.
Checklist
feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)