Skip to content

feat(dashboard): open an existing peer session locally - #10288

Merged
iamwhatever merged 1 commit into
mainfrom
feat/teleport-to-local
Sep 13, 2026
Merged

iamwhatever merged 1 commit into
mainfrom
feat/teleport-to-local

Conversation

@cixuuz

@cixuuz cixuuz commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

You cannot see or open a session that lives on another crew. Your Sessions list shows only what this machine owns, so a conversation running elsewhere is reachable only by switching the whole app to that crew's dashboard pane.

This PR builds both halves of that: the Sessions list learns to show a connected crew's sessions, and clicking one opens it here.

Why it matters

The Sessions list promises one thing: these are your conversations, click one to open it. For a multi-machine user it silently omits most of them, and the only way in navigates away from everything else.

What changed (motivation → approach → change)

Two things ship together, because neither is useful alone. A connected crew's live sessions now merge into this machine's Sessions list, ordered with local rows by recency and badged with the owning crew (useInstanceSessions.ts, GET /api/instances/{id}/chat-slots). And clicking one opens that session here: the hub binds a fresh local slot to the peer session, copies the peer's transcript into it, and you land in a real local conversation whose turns keep running on the crew that owns it. The whole surface is behind Settings → Developer → Feature Previews → Remote instance sessions, default off.

The row you clicked becomes that session. It does not get replaced by a new row beside it. That is the whole reason row_identity exists on the wire: the server is its only author. /api/instances/{id}/chat-slots stamps <instance_id>:<peer_key> on every peer row it shapes, and the projection resolves the same string for a remote-bound slot — minted on a crew through create_peer_slot, or opened from a peer row — so the identity the peer row carried survives the binding. The browser reads that value and never composes the format itself, because two spellings of one contract is how the equality that makes this work goes unchecked. The sidebar keys rows on it, so one element re-renders where a fresh key would mount a second one. identity is deliberately not the local slot key and never becomes it; read key for the local slot, because splitting the identity yields the peer's key, which is routable only back through that instance. The list drops a peer row whose identity a local slot already claims, because the client's cached peer listing can be older than the binding.

The Older Sessions pane keys its own rows by owning crew for the same reason, against a different field: a federated search row names the peer that answered in instance_id, and two crews can return the same deterministic key, so without that the pair would reconcile as one React child and a row would vanish from the drawer.

flowchart LR
  subgraph Before
    A1[click peer row]:::ctx --> B1[switch to crew's pane]:::removed
  end
  subgraph After
    A2[click peer row]:::ctx --> B2[bind local slot<br/>+ backfill transcript]:::added --> C2[same row, now local]:::changed
  end
  classDef added fill:#DCFCE7,stroke:#16A34A,color:#14532D,stroke-width:2px
  classDef changed fill:#FEF3C7,stroke:#D97706,color:#78350F,stroke-width:2px
  classDef removed fill:#FEE2E2,stroke:#DC2626,color:#7F1D1D,stroke-dasharray:4 3
  classDef ctx fill:#E0F2FE,stroke:#0284C7,color:#0C4A6E
  linkStyle 0 stroke:#DC2626,stroke-dasharray:4 3
  linkStyle 1,2 stroke:#16A34A,stroke-width:2px
Loading

🟩 added · 🟨 changed · 🟥 removed · 🟦 unchanged

Clicking a crew's session opens it on this machine, in the row you clicked, instead of navigating away.

The peer decides what the adopted session is, not the request. The peer's agent, title and memory_mode are authoritative, and a peer row that reports no memory_mode is refused with adopt_peer_mode_unknown rather than resolved to this machine's default. memory_mode is the user's privacy boundary: guessing it would turn an incognito session on the crew into a persistent one here, writing memory the user never agreed to. A crew whose rows predate the field reaches that case on version skew alone, so the refusal is the only answer that cannot leak. Before agent or title is persisted, hidden Unicode is stripped and credential redaction runs, matching the peer-list sink so a zero-width character cannot split a secret around the redactor.

An adopted session assumes exclusive hub-side driving from the bind onward. The backfill is a one-time copy: turns started here are mirrored per-turn and opt-in (remote_mirror.py, ?relay=1), so a reply that finishes on the crew after the copy, and anything a peer-side user sends later, is not pulled in. Every adopted transcript therefore starts with the boundary in plain words: new turns started on the named machine after opening this chat do not appear here; continue the session here. That makes an absent peer-side turn visible rather than letting a stale local transcript claim to be complete. A bounded re-read before the first local turn remains a possible mitigation; merging independently appended transcripts after local turns begin is a separate design problem.

Two adopts racing for the same peer session resolve to one slot: the create path re-checks for an existing binding immediately before get_or_create_slot, with nothing awaited in between, so on asyncio the check and the create are atomic. The loser of that race gets the winner's slot, not a 404 — already-linked and forged-key are different answers. A peer slot that closes after the list check but before its transcript read is different again: a transcript 404/410 aborts before a local binding exists. The peer-side sibling guard requires every ?relay=1 send to target an existing slot, so a still-later close fails with slot_not_found rather than recreating an empty peer session under the vanished key. A transcript that is still streaming on the peer is dropped rather than persisted as a finished reply, with a notice in its place, because a half-written turn copied as complete would read as the model's final word. The full-history read retries with a bounded 500-row tail only when its reply crosses the byte ceiling. HTTP, transport, parse, and shape failures use the visible copy-failed notice instead, because they do not prove any older message was dropped.

Two smaller surfaces come with the listing. The board view shows no peer rows at all — it says how many were left out instead, because a board column is a drag target and a row that lives on another machine cannot be dragged into a local folder. And while the crews are being read the list says checking remote instances, with one banner for the whole read when it fails rather than an error per crew, so a hub with several unreachable crews shows one line instead of a stack of them.

A crew's own name marks the rows that belong to it, and the row says what clicking will do. Every shared crew chip reads On , not a bare name, so a running row still says where it lives when the more useful live state occupies the one status line. One pill marks every session whose turns run on another machine, because a session opened here and a session not opened here yet are the same kind of thing — the same executor / instance_id / remote_slot triple, the same relayed turns, the same actions that have to happen on the crew. What differs is a lifecycle stage: an unopened peer row's status reads On — click to open here, and the line goes away the moment the row becomes local. Any live state the crew reported — a turn running, an approval owed — outranks that line. Each pill's tooltip names its own outcome, which differs by row: a live peer row opens the session here, a search result switches to the crew that owns it.

Change accounting

Changed area What it owns here
docs/feature-map/README.md Preview feature map entry and limits.
src/kiro_crew/dashboard Owner-only listing, link validation/backfill, identity projection, relay guards, and route wiring.
src/kiro_crew/docs Generated Settings registry documentation.
src/kiro_crew/instances Bounded peer-list and transcript reply limits.
src/kiro_crew/security_posture.py Owner-only posture for the peer-session listing.
website/src/api Peer-session list and link request client calls.
website/src/components Generated Settings registry and shared remote-location chip.
website/src/i18n Localized preview, row, tooltip, and notice copy plus plural metadata.
website/src/pages Sessions merge, row lifecycle/status, board omission, hover hold, and Feature Preview UI.
website/src/store Guarded slot activation during asynchronous linking.
website/src/types Wire type for server-resolved row_identity.
website/src/utils Default-off preview flag registration.

Tests

test/test_remote_crew_adopt.py covers the link handler: peer-owned agent / title / memory_mode, hidden-Unicode credential splitting in inherited metadata, an empty peer title staying pinned, refusal when the peer reports no valid mode, concurrent links resolving to one slot, a transcript 404/410 aborting without a local binding, other copy failures remaining visible and non-fatal, in-flight and truncated history notices, the always-present exclusive-driving boundary, and persistence of copied rows. test/test_remote_crew_execution.py requires a relayed send to target an existing peer slot, returning slot_not_found without invoking slot creation when that target vanished. Both vanished-slot tests are mutation-checked.

Two tests pin the equivalence the sidebar's shared marker depends on: a session opened from a peer row carries the same executor / instance_id / remote_slot triple a minted one does, and it is refused the same crew-only actions with the same remote_action_unsupported 409. Opening a session from a peer row respects the switched-away guard: switch to another session while the peer call is open and the view stays where you put it. A failed transcript copy has to name which chat is the session, not only where the turns run.

test/test_remote_crew_peer_slots.py covers the listing route, including that a peer reply this hub cannot parse answers 502 — a dict instead of a list, and a deeply nested document whose parse exhausts the interpreter stack — rather than surfacing as a 500 from the gateway.

website/src/test/ChatSidebar.instanceSessionsMerge.test.tsx covers the row: a peer row links instead of switching panes, switches to the returned local slot, respects a user switching away during the link, keeps one row when a local slot and stale peer row share an identity, and renders one status line while linking. It pins both visible states: an idle peer row says On — click to open here, while a running row keeps its live state and the chip itself still says On . website/src/test/useInstanceSessions.test.tsx covers the listing hook. test/test_chat_slot_facade_contract.py pins row_identity's projected position, and test/test_remote_crew_peer_slots.py pins the listing identity byte-equal to the bound-slot projection.

Manual verification

The feature is behind Settings → Developer → Feature Previews → Remote instance sessions (default off). With it on and a crew connected, a peer session's row is clickable, opens locally with its history, and stays a single row across the bind.

Screenshots / video

Screenshot 2026-09-12 at 13 45 40 Screenshot 2026-09-12 at 13 46 00 Screenshot 2026-09-12 at 13 46 52

Related Issues

no linked issue: reported in conversation as a UX complaint about the Sessions list, not filed as a tracked issue.

Pattern harvest

The reusable idea is that row identity is a server concern when two channels feed one list. Local slots arrive on the authoritative push and peer rows on a per-crew poll, so only the server sees both sides of a binding at once. Resolving identity there — and keeping the pre-binding identity across the bind — is what lets the client render a transition instead of a replacement, without the client having to reconcile two freshness domains.

Checklist

  • Tests added/updated for the behaviour changed
  • tsc -b, flake8, mypy, isort, black and the comment-history gate run locally
  • Feature is behind a default-off preview flag
  • Feature map row updated

@cixuuz
cixuuz requested review from a team and smeyffret September 12, 2026 04:15
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Sep 12, 2026
@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

Intent: Make a remote crew's session row in the Sessions list open that session locally — bind a fresh local slot to the peer session that already exists and backfill its transcript — instead of switching the app to that crew's dashboard pane.
Not a goal: Changing how sessions BORN on a peer work (#7693's mint path), touching the federated Older-Sessions row's pane switch, deprecating #6211's chat-proxy route, or adding any second endpoint for adopt.

@github-actions

github-actions Bot commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — ✅ PASS

Design-level review of 0de826a3e3e56998c01e5a33ffe837ef71f58718 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: PASS

Real gap, sound shape: server-authored row identity, peer-owned metadata with refuse-over-guess on memory_mode, bounded reads, race-checked idempotent adopt, default-off preview flag.

The one accepted gap — peer-side turns after adoption never arrive, disclosed only by a birth-time notice — is explicitly stated, tested, deferred with a named mitigation (bounded re-read before the first local turn), and gated behind the preview flag whose purpose is exactly this feedback; it is a conscious decision, not an oversight, so it does not rise to a blocking or watch-level finding.

[DESIGN-REVIEWED] 0de826a

@github-actions

github-actions Bot commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Fable 5) — 🟡 CONCERNS

UX-level review of 0de826a3e3e56998c01e5a33ffe837ef71f58718 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

All evidence is in. Reconciling: the blind reader understood the primary interaction (peer row → click opens the chat; shot-03's "Opening this session here…" spinner read correctly), but the screenshots show a superseded build — the chip reads bare "chick"/"astro" where HEAD renders "On chick", and the transcript notice the reader quoted ("The conversation continues there, and the crew still answers with it") no longer exists at HEAD; remote_adopt.py rewrote it precisely because of a blind read. So the shipped strings were never cold-read, and several new states appear in no screenshot. No block predicates are met: the row keeps one identity/key/layoutId across the adopt (continuity mechanism is in the diff), notices assert rather than hedge, and the reader dared to click the primary control.

UX-Verdict: CONCERNS

The shipped copy postdates the screenshots: every string the blind read choked on was rewritten, and the rewritten surface has never been shown or cold-read.

Watch

  • One machine, two nouns: this PR's own strings say "Remote instance sessions" / "Checking remote instances…" while opens_on_crew_switches_there ("switches to that crew") and the backend adopt error ("Could not reach that crew…") say "crew" — the noun remote_adopt.py's own comment rejects because Crews is a separate agent feature, and the blind reader had "no idea what 'the crew' is". Every feature user meets both terms, every time. Pick "instance" (or the crew's name alone) across the new strings.
  • The blind reader could not identify the ownership pill ("no idea what they name — machines, helpers, people"); the "On {{name}}" label plus tooltip is the author's fix, but it is exactly the part no screenshot shows — verify with a fresh read before relying on it.

Evidence gaps

  • All three screenshots show a superseded build (bare-name chip, old transcript notice); fresh screenshots of the current copy would close this.
  • The idle peer row's "On {{name}} — click to open here" state — the feature's front door — appears in no screenshot.
  • Settings → Feature Previews "Remote instance sessions" toggle, the board-view omission count, "Checking remote instances…", and both failure banners (instance-sessions-error, session-peer-adopt-error) appear in no screenshot.
  • The in-place peer→local row transformation (including the pill moving from the agent-name slot to the badge strip) has no recording; the recordings list is empty.

Suggestions

  • remote_sessions_not_shown_in_board_view: the count offers no next step — pair it with the list-view toggle ("Switch to list view to see them") so the surfaced number is actionable.

[UX-REVIEWED] 0de826a

@github-actions

github-actions Bot commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

⚠️ Stale verdict notice (2026-09-13 11:22 UTC): a later GPT 5.6 run did not produce a completed verdict for 0de826a3e3e56998c01e5a33ffe837ef71f58718; the verdict below is from an earlier completed run. Inspect the GPT 5.6 Review job logs and re-run the workflow, or have a repository writer comment /ai-review override gpt 0de826a3e3e56998c01e5a33ffe837ef71f58718: <one-sentence reason>.

GPT 5.6 Review — ✅ no blocking findings

GPT 5.6 completed its review of 0de826a3e3e56998c01e5a33ffe837ef71f58718 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 0de826a

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 0de826a3e3e56998c01e5a33ffe837ef71f58718: <one-sentence reason>

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 12, 2026
@github-actions

github-actions Bot commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — 🟡 CONCERNS

Premise-level review of 0de826a3e3e56998c01e5a33ffe837ef71f58718 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

Two new inline bounded-read loops re-implement an existing helper, and two pre-existing crew chips get relabelled with no named person who was misreading them.

Not justified as shipped

  • Item 9 — unjustified move/relabel: the s.executor === 'remote' chip and the federated-history chip change from a bare crew name to "On " for users of other previews; the only support is making them match the new peer-row pill ("the same marker would mean two different clicks"), which is the symmetry form — with this preview off, no peer rows exist and the ambiguity being cured does not occur.

What this change ships

Inventory (10 items) — 9 justified

Intent: let a multi-machine user see and open sessions living on a connected peer crew from this machine's Sessions list — an ADDITION.

  1. A connected crew's live sessions merge into the Sessions list, badged, behind a new default-off Feature Preview — justified
  2. Clicking a peer row opens that session locally, in the same row, with the peer's transcript copied in — justified
  3. New owner-only, GET-only GET /api/instances/{id}/chat-slots with allowlist, redaction, byte+row caps — justified
  4. New adopt_remote_slot create parameter; refuses when the peer reports no memory_mode; idempotent under races — justified
  5. Adopted transcripts open with staleness / truncation / in-flight / copy-failed notices — justified
  6. row_identity projected on every slot payload; sidebar and history rows re-keyed by origin-qualified identity — justified
  7. A ?relay=1 send to a vanished peer slot now 404s instead of recreating it empty — justified
  8. Board view omits peer rows and reports the count; one "checking" line and one merged error banner — justified
  9. Pre-existing remote-execution and history-row crew chips relabelled "On " with new tooltips — unjustified move/relabel (symmetry-form provenance, no named failing user)
  10. New PEER_SLOTS_REPLY_MAX_BYTES constant plus feature-map, settings-registry and i18n entries — justified

Watch

  • The accumulate-to-EOF capped read is hand-rolled twice more (read_peer_slots in handlers_instances.py, _read_peer_transcript in remote_adopt.py) while a named helper already does it: read_capped_response, src/kiro_crew/dashboard/handlers/_shared.py:206. Counted: the helper has 3 consumers (updates.py:997, feedback.py:183, source_providers.py:4448); the inline pattern grows from 2 pre-existing copies (ssh_tunnel_manager.py:2721, :2851) to 4 with this PR (grep: iter_chunked).
    Clears when: the two new loops call read_capped_response with the len(raw) > cap sentinel (the interrupted-body try/except wraps the await unchanged), or a stated reason the helper cannot serve these reads.
  • Item 9's relabel.
    Clears when: a report or observed confusion over the bare-name chip is named, or the relabel is confined to the new peer-row pill.

Subtractions

  • Replace the two new inline read loops with read_capped_response (dashboard/handlers/_shared.py:206); each collapses ~12 lines to one call plus the existing over-cap sentinel.
  • Drop the label= argument at the two pre-existing RemoteCrewChip call sites (executor-remote row, history row in ChatSidebar.tsx), keeping the bare name; the new peer-row site remains the label prop's one consumer.

[FIRST-PRINCIPLES-REVIEWED] 0de826a

@github-actions

github-actions Bot commented Sep 12, 2026 •

Copy link
Copy Markdown
Contributor

Opus 4.8 Review — ✅ no blocking findings

Reviewed 534b58eb9fb8c4a7b616c94ca597840588376db6 — this comment is updated in place on each push.

Review details

No findings.

The sole candidate reads the PR's intended fix as a regression. The new relay=1 guard 404s when the peer slot is absent from state._slots; previously such a request fell through to get_or_create_slot, which minted a fresh empty ordinary slot under the peer key and ran a context-free turn on the peer — exactly the "resurrect an empty session and return a plausible reply with none of the inherited transcript" bug the comment describes. Relay traffic always targets a peer slot created via create_peer_slot (slot: slot.remote_slot); persistent peer slots are restored into state._slots on restart, so a live binding hits the lookup. When the peer session is genuinely gone (e.g. a non-persisted incognito slot after a peer restart), the 404 surfaces to the owner as an honest RemoteTurnError ("The crew refused the turn (HTTP 404)… reconnect and try again") in _peer_turn_chunks, which is a correct outcome, not a wrong one. There is no observable wrong outcome (c) — the replaced behavior was the defect. Candidate dropped under falsification.

[OPUS-REVIEWED] 534b58e

Verdict parsed from the review's SHA-scoped output markers for commit 534b58eb9fb8c4a7b616c94ca597840588376db6.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 534b58eb9fb8c4a7b616c94ca597840588376db6: <one-sentence reason>

@cixuuz
cixuuz force-pushed the feat/teleport-to-local branch from ebbd257 to f09fd4f Compare September 12, 2026 04:38
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 12, 2026
@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added — a doc line this PR itself introduced was corrected.

  • Feature map contradicts peer-session activation (span=2f6082500a24) — fixed in f09fd4f49.

Legitimate and fixed. The line was written by this PR's own earlier state, when the peer row DID switch panes, and the adopt path made it false without updating it. docs/feature-map/README.md:67 now reads that clicking a peer row binds a fresh local slot and backfills the peer's transcript, names the adopted-row dedupe, and adds chat_handlers.py + remote_adopt.py to Handler and POST /api/chat/slots (adopt_remote_slot) to Endpoints.
Class-level ruling for feature-map-correctness on this PR: the Peer-owned live session row is the ONLY feature-map entry this change touches, and its description, Handler and Endpoints cells are now all derived from the adopt path rather than from the pane switch. A finding that the feature map still describes pane-switch behaviour anywhere in this diff is covered by this ruling.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: adopt pending/error state now resolved inside the existing ordered rowState chain rather than as its own JSX branch.

  • Adoption feedback adds a second status line (span=c3bc99e7b8e9) — fixed in f09fd4f49.

Legitimate and fixed. The adopt pending and error lines rendered BESIDE the ordered rowState resolver, so a peer row reporting an active remote turn rendered its running line and the adopting line together — two status lines on a row that session-row-fixed-height allows exactly one. Both are now entries in that same resolver (peer_adopt_error, then peer_adopt_pending, at the top because they describe the user's own in-flight action rather than the session's state), so the mutual exclusion is structural instead of a condition someone has to remember.
Class-level ruling for session-row-fixed-height on this PR: every secondary line this change adds to a session row goes through the rowState resolver, which renders exactly one entry. A finding that this PR renders a second status line on a row is covered by this ruling unless it names a line rendered OUTSIDE that resolver.
Pinned by test: renders ONE status line on a running peer row that is also adopting counts spinners inside the row, and it was mutation-checked — reintroducing a second line beside the resolver turns it red with "length of 1 but got 2", so it is not passing vacuously.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: a second idempotency check (adopted_slot_for) placed after every await on the adopt path, immediately before slot creation.

  • Concurrent adopts create duplicate local bindings (span=78d6e248f252) — fixed in f09fd4f49.

Legitimate, reachable, and fixed — and it is a corruption bug, not merely a duplicate row. The already check was synchronous but the path to creation crosses await resolve_adopt_target and await fetch_adopted_backfill, so two identical POSTs cleared it as a pair and each minted a local slot bound to one peer session. Each then accumulates its own turns, so the two transcripts diverge, and read_peer_slots filters the peer's own row on whichever binding it happens to see, making the session the user lands in arbitrary.
The fix re-asks the question immediately before get_or_create_slot, after every await, and nothing between the two suspends — asyncio runs one task at a time, so check-and-create is atomic there without taking a lock. The loser returns the winner's slot, which also keeps the frontend's switchSlot(resp.key) correct for whichever request lost. The pre-peer check is kept for what it is good at: answering a retry without a tunnel round-trip or a second transcript copy.
Not rebutted on rarity, and the adjudication was right to refuse a rarity argument: the trigger is a double click, which the code's own comment named as expected. Verified rather than asserted — the regression test forces the interleaving with a barrier on the backfill (a plain gather does NOT reproduce it, because the fake peer manager never yields, and the test passed with the fix reverted until that barrier was added). With the recheck removed it now fails assert 2 == 1.

@cixuuz
cixuuz force-pushed the feat/teleport-to-local branch from f09fd4f to 50ec517 Compare September 12, 2026 04:54
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 12, 2026
@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: REMOVED the streaming-to-assistant mapping; added _BACKFILL_IN_FLIGHT_NOTICE to the existing leading notice row.

  • Adopting a running session persists an incomplete response (span=638eb7c4b367) — fixed in 50ec517f5.

Legitimate, and the loss is worse than the finding's title suggests: the frozen snapshot is re-serialized into the local transcript file, where nothing distinguishes it from a reply that really ended there. This hub never mirrors a turn it did not start, so the suffix never arrives — the user keeps a truncated answer presented as a complete one, permanently, with no way to tell.
Fixed by SUBTRACTION rather than by hardening. The streaming row is now DROPPED instead of mapped to assistant, and the drop is reported in the transcript's leading notice row. That keeps the same text missing but says so, which is the difference between an absence and a falsehood. My earlier comment argued the mapping avoided "silently losing" the in-flight text; it was the mapping that made the loss silent, because absence is visible and a truncated reply is not.
Neither of the fixes suggested in the finding was taken, and the reason is the intent rather than cost. Refusing the adopt when a streaming row is present breaks a normal supported case — adopting a session the crew is actively answering in is exactly what the merged list invites — and re-reading after the turn settles waits an unbounded time on someone else's machine. Both trade a working feature for the bug.
Class-level ruling: no peer row role is mapped onto a different local role anywhere in this change. Roles are copied as-is, skipped with a documented reason (chunk, done, permission, streaming), or dropped as unknown. A finding that this PR renders one kind of peer row as another is covered by this ruling.
Pinned by two tests: test_an_in_flight_streaming_row_is_dropped_and_reported on the pure mapper, and test_adopting_a_session_the_crew_is_answering_in_says_so end-to-end, which asserts the partial text appears under NO role and that the notice does.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added — the sanctioned {/* No hand-off: … */} JSX marker was added beside the existing notice.

  • Adopt error lacks the required hand-off decision marker (span=c3bc99e7b8e9) — fixed in 50ec517f5.

Legitimate and mechanical. errors-use-error-notice requires the askAgent-off case beside an unsaved draft to carry a {/* No hand-off: … */} JSX comment naming the draft, and the adjudication is right that what was there did not satisfy it: folding this notice into the rowState resolver turned the surrounding explanation into a // comment inside an object literal, which is not the sanctioned marker even though it said the same thing. The marker is now a JSX comment immediately before the notice, naming the composer draft as the reason the hand-off is off.
The decision itself is unchanged and still deliberate: askAgent navigates away, and this row sits beside a composer that may hold an unsaved draft.
Note this span is a REPEAT — it was the second-status-line finding on ebbd257be, and the fix for that one is what moved the notice into the resolver and dropped the marker's JSX context. Recorded so the next round can see the two are the same site rather than two unrelated hits: the mechanism is right, the marker was collateral from relocating it.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added — two conditional assignments became unconditional, and the test asserting the old direction was inverted.

  • if not agent and body.get("title") let adopt requests override validated peer metadata (span=27afc892be32) — fixed in 50ec517f5.

Legitimate, and it contradicted this module's own stated contract rather than just the PR body: remote_adopt.py's docstring says "nothing the caller sends decides what the adopted session claims to be", while agent fell back to the peer only when absent and a caller title won outright. memory_mode was already peer-authoritative, so the three fields disagreed with each other.
Both are now unconditional for an adopt: the peer's agent and title win ahead of anything the caller sends. This is a subtraction, not a new guard — the adopt path has no picker for either field and sends neither, so the override could only ever have produced a session opened under a different agent than the one answering in it, or renamed the row the user just clicked.
Class-level ruling: on the adopt path every field describing WHAT the session is (agent, title, memory_mode) comes from the validated peer row and nothing else. A finding that a caller-supplied value can decide any of those is covered by this ruling.
The test that asserted the old direction (a caller supplied title still wins) was inverted rather than deleted, and a sibling added for agent, so the contract is pinned in both directions.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added — the existing driven snapshot moved from before the peer read to immediately before the filter that consumes it.

  • Snapshotting driven before the peer await misses a binding created during that read (span=301b1fe59b93) — fixed in 50ec517f5.

Legitimate and fixed by moving the read, not by adding anything. The set is now built immediately before the filter that consumes it, so an adopt landing while a listing is in flight is seen and its peer row is dropped.
Worth recording that the code's own comment argued the opposite — that reading after the await "would race a binding created or torn down while the tunnel call was in flight and let its duplicate through" — and that reasoning does not hold. _slots is mutated on the event loop, so a synchronous read is consistent by construction wherever it happens; taken before the tunnel call it is simply staler. Reading after the await is correct in both directions: a binding created during the call is filtered, and one torn down during it correctly reappears as an adoptable peer row.
This is the "never listed twice" guarantee the feature-map entry and the PR body both claim, so leaving the window open would have made those claims false in exactly the case a user is most likely to hit — the moment just after they click.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: a second idempotency check (adopted_slot_for) after every await on the adopt path, immediately before slot creation.

  • The already idempotency check runs before two peer round-trips, and is_new_slot is always True for an adopt (span=d085816e0bea) — fixed in 50ec517f5.

Legitimate, and the second half of the observation is the sharper one: because an adopt always passes an empty name, is_new_slot is unconditionally True, so nothing downstream of the awaits was ever going to catch the duplicate. The check that existed could not close the window it was guarding.
Fixed by re-asking the question immediately before get_or_create_slot, after resolve_adopt_target and fetch_adopted_backfill have both completed. Nothing between the recheck and the create suspends, and asyncio runs one task at a time, so check-and-create is atomic there without a lock. The loser returns the winner's slot, so the frontend's switchSlot(resp.key) stays correct for whichever request lost.
Verified by forcing the interleaving rather than hoping for it: the fake peer manager never yields, so a plain gather of two posts runs them sequentially and the test passed even with the fix reverted. Gating the backfill until both requests arrive reproduces it, and with the recheck removed the test fails assert 2 == 1.

@cixuuz

cixuuz commented Sep 12, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added — the existing asyncio.to_thread offload was extended to cover the decode as well as the redaction.

  • json.loads parses up to 16 MiB of peer transcript on the event loop while the cheaper redaction pass is offloaded (span=b3970590b0ed) — fixed in 50ec517f5.

Legitimate, and the inconsistency was the tell: the code already judged this work loop-blocking enough to offload prepare_backfill_rows, then did the bigger of the two costs inline. A long adopted history is an explicitly supported case with its own 16 MiB cap, not an abuse, so the stall was reachable on normal input — and it blocks every other client's slot updates and unrelated sessions' turns for the whole parse, not just the adopting request.
json.loads now runs through asyncio.to_thread alongside the shaping pass. No new mechanism: the offload already existed a few lines below, and this is the same call moved onto it.

@github-actions github-actions Bot removed the readiness: checking Automated validation is still running label Sep 12, 2026
@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: added — fatal transcript 404/410 plus an existing-slot guard for every relay=1 send.

  • A vanished peer slot is adopted as a valid session — span=638eb7c4b367 — fixed in 7d74e19f9.

Legitimate security/data-integrity class despite the fenced adjudication: memory mode stayed correct and the old notice was loud, but the binding still pointed at nothing. The first relayed turn could then fall through get_or_create_slot on the peer and recreate an EMPTY ordinary slot under the vanished key, producing plausible replies without the inherited transcript.
Both TOCTOU branches are closed. A transcript endpoint 404/410 now raises AdoptTargetUnknown through the backfill layer and the create returns adopt_target_unknown before any local slot exists. Every relay=1 send independently requires its target in state._slots, returning slot_not_found without invoking creation if the peer closes one instruction later.
Other history failures remain non-fatal and visible: a timeout/500 does not prove the peer slot vanished, so the working-session contract is preserved.
Two regression tests, both mutation-checked: disabling either guard fails its test.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: added — _post_link_staleness_notice(peer) on every successful or nonfatal-copy adoption.

  • Post-adopt peer-originated turns diverge silently — span=ca6d825604f4 — fixed in 7d74e19f9.

Legitimate: backfill is a birth-time snapshot, this hub mirrors only turns it starts, and after linking the local row wins identity dedupe so the peer listing no longer exposes later peer-side activity. The transcript otherwise looked complete while missing turns.
Every adopted transcript now starts with the operating boundary: “New turns started on after opening this chat do not appear here. Continue this session here.” Copy-failed, truncated and in-flight notices join ahead of it when applicable; even an empty session carries only this truthful future-facing boundary.
The notice and persistence are tested, and disabling the unconditional notice fails the regression test.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: no

  • Re-read and append peer rows newer than the last backfilled timestamp — span=dfd4ea8a5105 — rebutted.

The narrow “before the first local turn” form is technically possible, but it is no longer needed to make the shipped contract honest: span=ca6d825604f4 is fixed by surfacing the exclusive-driving boundary in every adopted transcript.
Re-running on every slot activation is not a cheap reuse. After this hub starts local turns, the peer and hub hold independently appended histories; timestamp-only append cannot establish causality, deduplicate mirrored turns safely, or choose an order under skew. It turns one bounded copy into a transcript-merge protocol.
Keeping the one-time snapshot plus explicit exclusive-driving notice is the smaller complete solution for this preview; it preserves round-0 intent without introducing a partial synchronizer that can silently duplicate or reorder conversation history.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: added — localized on_instance visible label on every RemoteCrewChip consumer.

  • A running peer row leaves only an unexplained bare crew name — span=96486cb9e80a — fixed in 7d74e19f9.

Legitimate: live state correctly outranks the click-outcome line because one fixed-height row gets one status line, but that made the bare chip the only persistent location cue and pushed its meaning into hover.
The shared chip now visibly reads “On ” in every state and consumer; tooltips continue to name the different click outcomes. This keeps “Running” visible without a second status line and makes the ownership/location claim pointer-independent.
on_instance is translated across every locale catalog, the pseudolocale and parity gates pass, and a running-row test pins “On astro.” Rendering the bare name again fails it.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes

  • New copy splits one machine across “remote instance” and “crew” — span=2000b004b14b — accepted-and-deferred.

Legitimate and the same class already tracked from spans e6ad23723e5f, 437c52aec6fc, and 25dc1fc3e562. The complete fix chooses one noun across Settings, rows, tooltips, banners and errors; it is not another isolated string edit.
Tracked in issue #10481, labelled deferred-finding, assigned to cixuuz, with Due: 2026-10-12. Its body requires changing the canonical en.json source, regenerating both settings-registry artifacts, translating every catalog, running locale/frontend gates, and recapturing affected surfaces.
This head adds only noun-free visible location copy (“On ”); the binding, relay and identity contracts do not depend on which noun #10481 selects.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes

  • Peer rows carry a raw key and mask local-key lookups one site at a time — span=2e6c60876f06 — rebutted.

The raw key is intentional routing data, not presentation identity. onAdoptPeerSession(peerId, s.key, rowIdentity) sends s.key to the owning peer; row_identity is the server-qualified DOM/merge identity. Keeping those concepts separate enforces the invariant that an identity is never parsed or substituted for a routable slot key.
Replacing key with the qualified identity does not remove the two-key shape; it creates a new peer_slot_key, then makes generic key mean a routing key on local rows and a render identity on peer rows. A forgotten generic caller would route <instance>:<peer-key> back to a peer that only knows <peer-key>.
The local lookup guards are origin boundaries as well as collision masks: a peer row must never inherit this hub’s folder, pin, active-slot or mutation state, even when values happen to coincide. The explicit masks keep that policy at each local-state sink rather than relying on today’s key grammar for isolation.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes

  • Move collision prevention into peer-row key and remove origin masks — span=7e4e3e90b180 — rebutted with a recorded design decision.

Decision: peer rows keep the owner-routable raw key; row_identity alone carries the non-colliding merged-collection identity. The distinction is pinned end-to-end: /chat-slots is the sole identity author, useInstanceSessions forwards it, the sidebar keys the row on it, and the adopt call separately sends raw s.key to the peer.
This preserves one stable rule across lifecycle stages: key addresses the slot in the store that owns it; row_identity addresses the rendered conversation across stores. Qualifying key would make it presentation-only before linking and local-routing after linking, exactly the semantic branch the proposed dedicated raw-key field merely moves.
The remaining origin guards are accepted cost because they enforce “peer rows never consume local metadata or mutation affordances,” not only “colliding keys do not.” Subtracting them makes isolation depend implicitly on colon qualification instead of explicit at each sink.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: oversized-only transcript-tail retry signal

  • fixed — generic transcript failures no longer trigger a tail retry (span=b3970590b0ed)

Fixed in 0de826a3e3e56998c01e5a33ffe837ef71f58718.
_read_peer_transcript raises _PeerTranscriptTooLarge only when the full reply crosses the byte ceiling, and fetch_adopted_backfill catches only that signal for the bounded-tail retry.
HTTP, transport, parse, and shape RemoteTurnErrors now go straight to the visible copy-failed notice, so they cannot produce a false older-messages-dropped claim.
The regression assertion pins one unbounded transcript request for a generic HTTP 500. Restoring the broad catch made it fail with an unexpected limit=500 second request; the oversized-tail test still passes.

Clicking a remote crew's session row in the Sessions list now opens that
session HERE — in the local pane, with its transcript — instead of handing
the whole app over to that crew's dashboard pane.

Two halves, both in this commit:

1. DISCOVERY (carried forward from the closed #7444). The merged Sessions
   list reads each connected crew's slots and interleaves peer-owned rows
   with local ones by recency, keeping the two key spaces distinct so a
   colliding key cannot leak local pin/folder/unread/running state onto a
   peer row.

2. ADOPT (new). Clicking such a row binds a FRESH local slot to the peer
   session that already exists, and backfills its transcript.

WHY THIS SHAPE

instance_id + remote_slot forwards its turns to a slot on the peer. Its
only create path mints a NEW peer session ("New chat on crew"), so there
was no way to reach a session the peer's own user had already started —
which is exactly the set this list shows. #7444 shipped those rows with a
pane switch as the click, and the review objected: the row should open
where it is listed.

That objection was right, and this commit retracts the claim in #7444 that
adopting an existing session was structurally impossible. It is not. The
bind is a POST-CREATE STAMP in api_chat_slot_create, and the 409
remote_already_bound guard only fires when a create resolves to an
EXISTING LOCAL slot. Adopt makes a fresh local slot, so the guard is not
in the way: adopt simply feeds a caller-supplied peer key where
create_peer_slot's minted one went. Everything downstream is unchanged.

WIRE

POST /api/chat/slots gains one optional field, adopt_remote_slot — the
peer session's own key, as listed by GET /api/instances/{id}/chat-slots.
No second endpoint: the local slot is created the same way either way and
only what it binds to changes. Requires instance_id (the owning crew).

  400 adopt_needs_instance   adopt without a crew
  404 adopt_target_unknown   not a currently-listed peer session, or a
                             hub-driven execution slot (not adoptable)
  502 remote_bind_failed     peer unreachable during validate/backfill

VALIDATION AND OWNERSHIP

The supplied key is validated against the peer's LIVE listing, through the
same read the listing route uses (extracted here as read_peer_slots rather
than duplicated). That rejects forged keys and excludes hub-driven slots
for free. agent, title and memory_mode are inherited from the validated
peer row, not from the request: memory_mode is the privacy boundary and
the session it belongs to already chose it, so an adopt resolves NO local
default — sending this machine's default risked turning an incognito peer
session into a persistent local transcript. The peer wins on agent and
title too, ahead of anything the caller sends rather than as a fallback:
the adopt path offers no picker for either, so a caller-supplied value
could only disagree with the session being adopted — opening the peer's
conversation under a different agent than the one answering in it, or
renaming the row the user just clicked.

Adopt is idempotent, and that holds for concurrent requests as well as
sequential ones. A repeat (instance_id, adopt_remote_slot) returns the
same local slot instead of creating a second, and reads neither the list
nor the transcript again. Two requests arriving together are decided by a
recheck placed immediately before slot creation, after every await on the
path: nothing between it and get_or_create_slot suspends, so on asyncio's
single thread check-and-create is atomic without a lock. Two local slots
bound to one peer session would not merely duplicate a row -- each
accumulates its own turns, so the transcripts diverge and read_peer_slots
filters the peer's row on whichever binding it happens to see.

BACKFILL

The peer's full history is read from its own slot path and appended before
the first frame, redacted through the existing peer-text sink, capped by
rows and reply bytes with a bounded-tail fallback and a visible notice
when truncated. A failed or malformed read is a notice, not a 500 — the
session still opens. The backfill is placed after the app-ownership and
member-assignment checks so a create that is about to be refused never
copies a transcript.

An adopted session stops appearing as a peer row, so the list does not
show it twice.

TESTS

38 new backend tests cover bind-not-mint, the untripped guard, forged and
hub-driven keys, unreachable/refusing/version-skewed peers, authorization
(app tokens and non-owner identities refused), idempotency including a
half-written binding, inherited metadata and redaction, backfill caps and
failure modes, and row mapping.

Frontend: the peer-row click is asserted to adopt (instance_id +
adopt_remote_slot) and NOT to reach the pane switch, and to switch to the
new LOCAL key the response names rather than the peer's key. The
pane-switch assertions in the base spec are inverted accordingly; the
federated Older-Sessions row keeps its selectInstance, which is a
different row class and unchanged here.

KNOWN GAPS

- Relayed-turn pending approval is a pre-existing relay_remote_turn gap,
  not introduced here.
- The visible session-peer-destination marker is removed: it existed to
  warn that the click did something the row did not promise, and adopt
  removes that surprise. Where the turns run is now carried in the row's
  title/aria hint. Worth a UX opinion in review.
- UX screenshots are not captured in this commit.
@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • accepted-and-deferred — unify crew/instance vocabulary across generated surfaces (span=94a669ff1250)

The wording drift is legitimate, but the runtime locales, generated Settings registry, generated docs, and feature map form one vocabulary chain; changing only this peer-session copy would preserve the same split elsewhere.
The complete task is tracked by issue #10481. Its body names the vocabulary-unification work, it carries deferred-finding, is assigned to cixuuz, and says Due: 2026-10-12.
This default-off preview keeps the current established terms until that cross-surface change is made together; the deferral is tracked rather than silent.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted — do not fabricate an unavailable connected-peer state (span=76ee7fa07500)

A truthful current capture of On <crew> and the peer-to-local transition requires a live connected crew; this worktree has no launchable pod, and its detached backend reload was already verified to fail while the old process stayed live.
The three permanent attachments remain verbatim and the Screenshot Evidence gate passed. Exact idle and running On <crew> states, the one-line precedence, and the transition are pinned by frontend regression tests.
A mocked screenshot would not verify the cross-machine flow the concern asks about, so adding one would create weaker evidence rather than close the gap honestly.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted — the existing board/list control already provides the next step (span=8efb3b31eaac)

When a board is active, the same sidebar menu renders the explicit switch_to_list_view action; the omission banner separately reports the exact number of peer rows withheld from non-routable board columns.
Repeating that control label inside the standing 11px banner would duplicate an existing action and consume constrained board width without making a new path reachable.
The count stays informational while the established control owns the action, which is the smaller complete surface.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted — On <crew> has concrete prior UX provenance (span=4cbce7d15909)

Current-PR UX span 96486cb9e80a found that a bare crew-name pill failed to state location, especially when a running state occupies the row's only status line; that finding introduced the visible On <name> label across production consumers.
The shared text states the same relationship for one remote-bound equivalence class. Each consumer's tooltip separately states its click outcome, so the label does not claim the controls perform the same action.
The maintainer explicitly accepted that visual distinction and required the shared marker to remain one class; reverting only older consumers would reopen the evidenced bare-pill defect.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted — a bare name reopens the running-row location ambiguity (span=52f846267396)

On a running remote-bound row, live state outranks the lifecycle status line; the chip is then the persistent location cue, and a machine name alone does not state the relationship.
Prior UX span 96486cb9e80a identified this exact production consequence and was fixed with visible On <name> wording, not merely symmetry with the new peer row.
Keeping the label preserves that fix while per-consumer tooltips continue to distinguish open-here from switch-there actions.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted — the proposed chip subtraction breaks the explicit equivalence-class contract (span=56e46758b822)

Minting and linking both produce the same executor / instance_id / remote_slot binding and downstream behavior, so their shared RemoteCrewChip must state one permanent location relationship.
Dropping label= at two consumers would make that same marker alternate between a bare name and On <name> by lifecycle, while reopening prior UX span 96486cb9e80a on running rows.
The controls remain visually distinct and their tooltips state different actions; the maintainer explicitly ruled that distinction sufficient.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: shared capped-response drain with caller-specific outcomes

  • fixed — both new response drains use read_capped_response (span=81f450770366)

Fixed in 534b58eb9fb8c4a7b616c94ca597840588376db6.
read_peer_slots and _read_peer_transcript now delegate accumulation to the existing helper while retaining their caller-specific len(raw) > cap outcomes.
Exact-cap acceptance, multi-chunk EOF reads, cap-plus-one oversized signalling, transcript tail fallback, and interrupted peer-list 502 mapping all remain pinned by the existing helper and route tests.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: removed duplicate peer-response drain loops

  • fixed — duplicate capped-read loops were subtracted without removing their guards (span=1eb5ebe3e56c)

Fixed in 534b58eb9fb8c4a7b616c94ca597840588376db6.
The two inline iter_chunked accumulators are gone. Each caller now makes one read_capped_response call and keeps only the domain conversion the shared helper cannot own.
Transcript overflow still raises _PeerTranscriptTooLarge for the bounded-tail retry; interrupted peer-list bodies still become peer_slots_interrupted / 502 rather than an HTTP 500.

@cixuuz

cixuuz commented Sep 13, 2026

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: sanitize inherited peer metadata before credential redaction

  • fixed — hidden Unicode can no longer split credentials in adopted metadata (span=b3970590b0ed)

Fixed in 534b58eb9fb8c4a7b616c94ca597840588376db6.
peer_row_metadata now applies sanitize_string before redact_peer_text and the length cap for both agent and title, matching the sibling peer-list sink before either field is persisted.
A regression test covers a credential split by U+200B in both fields. Removing sanitization made that test fail with the split secret still present; the restored fix and all 300 affected tests pass.

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ✅ no blocking findings

GPT 5.6 completed its review of 534b58eb9fb8c4a7b616c94ca597840588376db6 and found no blocking issues.

This comment is updated in place on each push.

Review details

FINDING -- src/kiro_crew/dashboard/chat_handlers.py:2905 -- An untitled peer makes "if title:" preserve and pin the generated local key as its title -> Fix: explicitly clear slot.title for an untitled adopt.
[GPT-REVIEWED] 534b58e

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 534b58eb9fb8c4a7b616c94ca597840588376db6: <one-sentence reason>

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants