Repository navigation
Conversation
UX Review (Fable 5) — 🔴 BLOCKUX-level review of UX-Verdict: BLOCK Cannot evaluate: missing stills of the shipped build — every screenshot shows a pre-fix run ("SESSION" badge, unreadable "F…" sender stubs, raw pinned-band prefix). Evidence gaps
Watch
[UX-REVIEWED] 9a03781 |
Design Review (Fable 5) — ✅ PASSDesign-level review of Design-Verdict: PASS Confirm the owner's no-anti-loop acceptance on #10527 covers shipping zero prompt guidance — SEL rows plus a watching operator are the only ping-pong brake. [DESIGN-REVIEWED] 9a03781 |
GPT 5.6 Review — ✅ no blocking findingsGPT 5.6 completed its review of This comment is updated in place on each push. Review detailsNo findings. False positive or not applicable? A repository writer can comment: |
First Principles Review (Fable 5) — 🔴 BLOCKPremise-level review of First-Principles-Verdict: BLOCK Members messaging members and worker reports running as the creator's own prompt ship default-on, with the deciding record an issue closing comment, not an RFC. Not justified as shipped
What this change shipsInventory (10 items) — 6 justifiedIntent: let crew members hand each other work and let workers report back into the thread that dispatched them, without the owner relaying by hand — an ADDITION (the description's own word is "Experiment").
Blockersproduct-shape change without accepted RFC (items 1–3, one decision). The description records the decision as "#10527, closing comment": "the owner's decision is to fix it inside the session model instead" — a proposal, not a record. Grepped [FIRST-PRINCIPLES-REVIEWED] 9a03781 |
Opus 4.8 Review — ✅ no blocking findingsReviewed Review detailsNo blocking issues — one advisory finding: the peer-message roster badge double-counts a steer that is requeued and later drained. FINDING — website/src/hooks/useWebSocket.ts:1629 — a peer [OPUS-REVIEWED] 9a03781 Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
9bdf351 to
dc7f7c2
Compare
|
|
|
|
|
|
dc7f7c2 to
225b39a
Compare
|
|
|
|
|
225b39a to
6618a88
Compare
a74815e to
edd1a3b
Compare
|
Round 25 — GPT 5.6 — fenced F1, a peer's MIRRORED frames can carry forged provenance: upheld, fixedReal, and the third door after the client body (round 10) and the stored peer rows (round 24): the live frames a peer mirrors (
First Principles — BLOCK: unchanged, owner ruling pending. |
Two send-only allows in front of the not_creator fence: a crew member may session_send to another member's DM thread, and a session may send to the session that created it. A busy member takes the message through the steer path the Members page already uses instead of the queue. Every delivered row carries meta.sent_by (session_key, title, agent, via, member_slug) while the [sent by session X via session_send] text prefix stays as it is. send_message(session="origin") from a non-cron caller now resolves to the session that created the caller and lands there as such a row; only a caller with no creator falls back to the bell. The Members thread draws sent_by rows as a collapsible "From <name>" row with a kind badge (member / worker / session), peer rows open, worker rows folded, the prefix line hidden from display only; the roster shows a count of such rows that landed while the thread was not open. Deliberately not added: hop cap, per-pair rate limit, inbox store.
edd1a3b to
9a03781
Compare
|
Rebase only (no code change) —
|
|
🤖 Kiro Crew [operator: dwu96#8c08bee0]: This PR has been inactive since 2026-09-15 with failing CI. I reviewed the blockers but they require your input:
For the record on what is not blocking: Design Review PASS and Opus 4.8 reports no blocking findings at this head. The GPT 5.6 lane is stale and carries no verdict — its comment is stamped When you've addressed these, the pipeline will re-assess on its next cycle. If you'd prefer no automation touched this PR at all, add the |
bolichen97
left a comment
There was a problem hiding this comment.
Request changes: turning off agent.session_control no longer closes the new origin door, and the tool, prompt and Settings text still describe the old contract
The First Principles review already covers the product-shape question and the RFC conflict. This review is about two gaps it does not mention. Both were checked at head 9a03781e8c.
1. deliver_to_creator skips the operator switch
src/kiro_crew/dashboard/session_control.py:2384 calls authorize_target(..., operation="send", skip_enabled_check=True). That skips the only switch check in authorize_target (:1544):
if not skip_enabled_check and not session_control_enabled() and not _member_bypass(caller_key):agent.member_dispatch is skipped as well, because _member_bypass sits in the same expression.
Failure scenario:
- An operator sets
agent.session_control: false, and optionallyagent.member_dispatch: false, to stop agents from driving each other's sessions. - A child session that already exists calls
send_message(session="origin"). Its_created_bysurvives a restart. - Its text still starts a user-role turn in its creator, either the user's own chat or a member thread.
send_messageis in@kirocrew-core, which the shippedconfig/defaults.jsonauto-approves, so no approval prompt stops the call.
This contradicts two texts:
- the Settings text at
src/kiro_crew/config/sections.py:1292: "Turn this off to withdraw the capability from every agent at once"; - this PR's own spec at
docs/system-specs/modules/session-control.md:195: "Ordinary (non-member) callers are untouched: they still require the switch."
The skip_enabled_check docstring (session_control.py:1490-1497) limits the flag to a synchronous re-check made after the feature "was already confirmed enabled". No test runs with the switch off: the autouse fixture at test/test_member_thread_projection.py:49-51 forces session_control_enabled to True.
Fix direction: gate this door on the switch instead of skipping it, and also on member_dispatch when the creator is a member thread. When the capability is withdrawn, the send should fall back to the bell. Add a test with the switch off.
2. Contract text left stale at the head
src/kiro_crew/mcp_tools/messaging.py:113-114and:232, plussrc/kiro_crew/config/prompt.md:82, still tell the model thatoriginmeans the session that spawned the cron. A worker reading them cannot learn that its text now runs as its creator's next turn.src/kiro_crew/config/sections.py:1295("a crew member … reaches only sessions it created itself") and:1310("a member's reach is still bounded to sessions it created itself") are both false once_peer_member_sendallows member-to-member sends.src/kiro_crew/agent.py:6498-6500still sayssend_messageaddresses "a person rather than a session's turn queue".
If the owner picks option (c) from the author's disposition, finding 1 goes away along with deliver_to_creator. The two sections.py strings still need updating either way, because the member-to-member allow stays.
From a full open-PR audit against origin/main c66f95b (2026-09-25); findings were checked by independent reviewers reading the code. Reply here if this is wrong.
|
Open-PR triage (against origin/main Status. The PR's merge base Existing blockers still stand at head
New finding: Overlap: #5819 (open, Recommendation: rebase and continue development once the RFC decision is made. Keep the PR open; do not close it. Automated open-PR audit. Every claim above was checked against the PR diff and origin/main. Reply here if any of it is wrong. |
iamwhatever
left a comment
There was a problem hiding this comment.
Thanks @CrysisDeu for the member-thread projection work. One rebase issue before this can land.
#17642 deleted remote_adopt.py and #17662 deleted the relay path (remote_relay.py, remote_mirror, relay_remote_turn) on main. Old executor="remote" slots now answer 409 relay_archive_read_only, and the peer owns its session through the crew window (#16757). These hunks touch code that no longer exists, so they are no longer needed:
src/kiro_crew/dashboard/remote_adopt.py(deleted on main): R41-57 and R442-450 (prepare_backfill_rows).src/kiro_crew/dashboard/remote_relay.py(deleted on main): R65-71, R313-406 (_replay_mirrored_frame), R430-438 (_apply_row).src/kiro_crew/dashboard/session_control.py: the newif slot.executor == "remote":branch at R2389, and theremote_relay.peer_row_metareference at R2016.src/kiro_crew/dashboard/state.py: theremote_relay.peer_row_metacomment at R2427.docs/system-specs/modules/session-control.md: R281-282 (remote_relay._apply_row,remote_adopt.prepare_backfill_rows,peer_row_meta).test/test_member_thread_projection.py: the relay/adopt tests at R1460-1540 (imports ofpeer_row_meta,remote_adopt,_strip_peer_frame_provenance,_replay_mirrored_frame).
Could you drop those hunks and rebase on main? Please keep the rest of the PR as it is. Thank you.
|
@iamwhatever thanks for the review. Before dropping the relay/adopt hunks we tried the port onto current main, and most of what this PR adds now exists on main in a different shape:
Keeping "the rest as is" would add a second delivery path beside main's, so we need a call:
We lean toward closing it, unless the |
|
Closing this PR. Main took a different path for worker reporting in #23010: a worker's report now comes back to its conductor as a On the open change requests:
#10527 stays open. If member-to-member messaging is still wanted, it needs an RFC first. The branch is kept, and this PR can be reopened. |
Problem / Motivation
Two crew members cannot talk to each other. A member's DM thread is fenced to the sessions it created, so
session_sendfrom the conductor to the autofix member is refusednot_creator, and the owner copies the task between the two threads by hand (#10527).When a worker a member dispatched calls
send_message(session="origin"), the message goes to the bell. The origin resolver knows only cron jobs, so a worker's report never reaches the thread that asked for the work.When a message from another session does land in a member thread today, it is drawn as the person's own bubble with
[sent by session X via session_send]in bracket text. Nothing on the row says a colleague spoke.Why it matters
Members that cannot hand each other work need a person in the middle. Workers that cannot report back need the member to poll. Rows that all look like the owner's own words make the thread unreadable once two agents are in it. The inbox-model RFC tried to fix all of this with a subsystem; the owner's decision is to fix it inside the session model instead.
What changed (motivation → approach → change)
Goal. Let members message each other and let workers report back, on the plain member session transcript, driven by row metadata. No inbox store, no scheduler, no wake slots.
Approach. Keep every existing containment check. Add exactly two
send-only exemptions to the ownership fence, stamp who spoke on the row the gateway appends, and let the Members thread draw that row differently. Reuse the steer path the Members page composer already uses for a busy member.Change, backend (
session_control.py,state.py,chat_delivery.py,handlers/messaging.py,mcp_tools/messaging.py).authorize_target: two allows in front ofnot_creator, both for operationsendonly._peer_member_send: a caller whose RESOLVED slot is a member (member-key ANDmode == "member") may send to a target that is one by the same test (a squatter or a mode-less restore on a member key is a member at neither end, andsent_by_metanames a sender as a member by the same test)._report_to_creator: a session may send to the session named in its own_created_by.create/stop/close/readstay refused; a member still cannot reach the person's own sessions.send_to_targetstampsmeta.sent_by = {session_key, title, agent, via: "session_send", member_slug?, child?}on the delivered user row. The record is built by the gateway from the caller's resolved slot, never from the body;child: trueis present only when the caller is a session the TARGET created, so the transcript names the relationship (a worker reporting back) rather than the tool the report came through. The text prefix the model reads is unchanged. Asent_byrow spends no stateless question card:_ChatSlot.appendretires unanswered stateless questions on a liveuserrow because that row is "the user's next message", and a peer's message is not (authored_by_another_session; the frontend'sdropStaleStatelessQuestionmirrors it), so the card and its answer channel survive a peer's send the way they survive a nudge. The steer path also re-validates containment in the steer's own tick:deliver_sent_bytakes the admission snapshot the caller captured right afterauthorize_targetand compares it with a fresh one with noawaitbeforesteer_into_running_turn(which does not suspend beforeclient.steer; the ACP transport writes before its firstawait), so a link or mirror that lands between authorization and the steer refuses the message (notice on the target, SEL denied row,containment_changed409 to the caller, bell for an origin report) instead of steering under a stale authorization -- the same re-validation the queue's drain performs. The check runs again when a steer comes back unavailable (the RPC suspended and landed nothing) before the message falls through to the queue, and the queue entry carries the ORIGINAL admission rather than a fresh stamp, so the drain re-validates against whatauthorize_targetsaw. A peer steer the turn's end never confirmed is requeued with that same admission (_steer_admission, registered beside the author while the steer is pending), not a teardown-time snapshot. A peer's queue entry is not the user's to edit:queue_edit_by_idrefuses an entry carryingsent_by(the rewritten text would be attributed to the peer), the edit endpoint answerspeer_authored409, and the queue card (live fromdeliver_sent_byor from the requeue of an unconsumed peer steer, or hydrated -- all carrysent_by) offers no edit and hides the provenance line; cancel stays available. A peer's message queued behind a busy target broadcasts itsqueue_pushcard (enqueue_or_run_prompt(on_queued=...), display-safe body with the provenance line stripped), because the client rebuilds the drained row from that card onqueue_popand no composer drew one. The steer path has the same rule at its own retirement point: the consumed echo that settles a steer retires the card only when a settled steer was the user's own (_settle_consumed_steersreads_steer_sent_by, which for that reason lives as long as the steer is pending instead of being dropped when the accepted steer stamps its row). An untitled caller yields an emptytitle(the sidebar placeholder is not a name), so the row reads with the localized "another session" fallback.sent_byis a gateway-only key (state.GATEWAY_STAMPED_META_KEYS):POST /api/chatdrops it from client-suppliedmetaat its one ingress (strip_reserved_client_meta, ahead of every reader of that dict), a connected peer crew's relayed or adopted rows drop it beside the peer'smid(remote_relay.peer_row_meta, used by_apply_rowandprepare_backfill_rows), and the live frames a peer mirrors losesent_by/sentBy/meta.sent_bybefore the local broadcast (_strip_peer_frame_provenance), because a forged or peer-stamped record would otherwise persist and draw as "From ".deliver_sent_by: a BUSY member is steered into its running turn (steer_into_running_turn, the same primitivebusyMode="steer-only"uses; the owner's scope asks for exactly this -- a peer's message reaches the member while it is still working on what prompted it, instead of after the turn); a member whose turn has no steer-capable client, and every non-member target, keeps the queue. Busy means a live turn OR a multi-stage plan between stages (_in_stage_execution, the composer's own predicate), so a delivery never starts a turn that overwrites a plan. This is a change toenqueue_or_run_promptitself and therefore reaches its other callers too — the Slack heartbeat prompt, the issue-radar wake and the workflow-finished auto-turn (server.py, the "user is waiting" prompt) now queue behind a mid-plan slot instead of starting a turn over it. Intended for all three: the invariant is the slot's, not the caller's — a turn started between plan stages overwrites the plan whoever asked for it, and the queued prompt runs when the plan ends. Thesession_sendMCP tool now readssteeredand tells the sender its message was injected into the running turn, instead of the false "runs when the current turn ends". A peer-authored queue entry drains ALONE (carries_sent_by, besidecarries_attachments): the drain's merge unions entry meta last-writer-wins, and a merged row would attribute every line to one author. The immediate path broadcasts the user row (broadcast_user=True) because no composer rendered it.steer_into_running_turngainedsent_by: stamped on the row, echoed on thesteer_pushframe assentBy, and kept in a_steer_sent_bymap in lockstep with_steer_send_ids, so a steer the turn's end never confirmed is requeued WITH its author and WITHOUT the human-composer exemption (directive_user_origin=False): the drained row still reads "From ", and a channel link the target gains before the drain drops it like any other cross-session prompt.enqueue_or_run_promptgainedmeta/broadcast_user, and the queued path unions the meta into the entry the drain already copies onto the row.send_message(session="origin"), non-cron caller: the MCP tool forwards a STRICTLY resolved session key (same bar as a channel send) and, when it cannot resolve one, sends NO key at all -- never the lenient ancestor walk, under which an unidentified sub-agent resolves to its parent and would report into the parent's creator; that send takes the bell fallback. The gateway honours that header only on a request that proved theX-Internal-Secret(internal_auth), so an app-token caller naming a worker's key keeps the bell. The gateway callsdeliver_to_creator, which reads_created_byoff the caller's slot, admits the creator throughauthorize_target(so workspace / channel-link / mirror / ephemeral / app refusals still apply), and lands the text throughdeliver_sent_bywithvia: "send_message_origin"and a[sent by session X via send_message]prefix. Only a caller with no creator, or a refused or vanished creator, falls back to the bell.Change, frontend (
SentByCard.tsx,transcriptRenderers.tsx,ChatPane.tsx,MembersPage.tsx,dashboardSlice.ts,useWebSocket.ts,utils/pinnedPrompt.ts,utils/sentBy.ts).meta.sent_byrenders asSentByCard: chevron · kind badge (Member / Worker / Other session, lucide icon, tooltip naming the sender) · "From " · one-line preview when folded · time. The kind is keyed on the RELATIONSHIP the gateway stamped (member_slug→ Member,child→ Worker, else Session), never on the tool the message came through. A member is named by its slug, anything else by its title, and a title-less session by the localized "another session" rather than a raw slot key; the name carries the sender's agent as a tooltip (sent_by.agent). Peer-member rows open by default, worker and other-session rows start folded. The body renders through the samerenderUserContentpath a user bubble uses, minus the provenance prefix line, which is stripped from DISPLAY only. Expand state usesuseRowDisclosure, so it survives the virtualized transcript.createTranscriptRenderersserves (ChatPane in the Members thread and the session grid, SideChat, the chat page): the row is the same row wherever the thread is viewed, and a pane that drew it as the person's own bubble would claim they said something they did not. A row without the record falls through to the SDK user bubble unchanged.dashboardSlice.sentByUnread, bumped from thechat_messageandsteer_pushframes) and shown as a numbered badge where the unread dot sits; an unread that is only the member's own reply keeps the dot. The count is window-local, clears whenever the unread badge clears, and is dropped only with a slot's live teardown (never on a stale slots reply). After a reload the plain dot stands in for it — the shared boolean unread stays the read/unread record. The pinned-prompt band (the last typed prompt that scrolled behind the header) skips rows carryingsent_by(utils/pinnedPromptisPrompt, beside its steer and subagent-completion exclusions): a peer's message is user-role but not what this user typed, and the band quoted it raw, prefix and all, as the person's own prompt while hiding the From-row behind itself (run 2, frames 4/5 at 1280). One predicate,utils/sentBy.isSentByMeta, serves the card, the roster count and the band. The sender name in the From-row is clamped (45% of the row) with the full name and agent in its tooltip; the folded preview gives way first (shrink-[8]), and below 28rem of card width a container query (index.css, keyed off the card like the topbar ladder) drops the preview and lifts the name's 45% cap, so the name — then the only flexible child — takes the space the preview gave up (run 3 measured 83/175 px with the cap still on; without it the full title fits in the 294 px pane) — run 2 measured the name at 18–24 px with the preview drawn in a 294 px pane.pages.chat.sentByCard.*andpages.membersPage.sent_by_unread_countin all 13 catalogs (plural forms per locale), pseudolocale regenerated.session-control.md(the two allows, the record, the steer),messaging.md(the origin resolver order), and the Crew Members / Session control / Agent chat egress rows of the feature map.flowchart LR subgraph Before A1[member A session_send]:::ctx --> F1[not_creator fence]:::ctx --> X1[refused]:::removed W1[worker send_message origin]:::ctx --> B1[bell]:::removed end subgraph After A2[member A session_send]:::ctx --> F2[peer-member allow]:::added --> S2{member B busy?}:::added S2 -->|yes| T2[steer into turn]:::added S2 -->|no| U2[start or queue]:::ctx T2 --> R2[user row + meta.sent_by]:::added U2 --> R2 W2[worker send_message origin]:::ctx --> C2[creator allow]:::added --> R2 R2 --> V2["From name row · roster count"]:::added 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🟩 added · 🟨 changed · 🟥 removed · 🟦 unchanged
A member's send now reaches a peer, a worker's report now reaches its creator, and both land as a row that says who spoke.
Deliberately not added (owner decision, recorded in the closing comment on #10527: #10527 (comment) -- "Considered, not adopted (owner: trust the agents)"):
session_sendrow) and stopping a member. The RFC's hop-propagation notes stay on the issue for the day a runtime bound is wanted.metais the only new state.Also true, stated so nobody has to find it: the child→creator allow admits ANY session-control
session_sendfrom a created session to its creator, not only thesend_messageorigin door — the two share one exemption on purpose. Everysession_sendrow, member or not, now carriesmeta.sent_by, reaches an open recipient tab live, and draws as the From-row on every transcript surface.Tests
Backend,
test/test_member_thread_projection.py(new) andtest/test_session_control.py(one result-shape update):sendallowed;stop/close/readon a peer stillnot_creator; an agent-created ordinary session cannot send to a member; a squatter on a member key (mode != "member") is not a member target; a member still cannot reach the person's own session; child→creatorsendallowed,stop/close/readrefused, child→stranger refused._ChatSlots: idle member starts a turn, prompt keeps the exact prefix, row carries the fullsent_byshape; busy member is steered (steerawaited once, nothing queued, row hassteer+sent_by); busy member without a steerable client queues with the meta on the entry; busy NON-member target still queues and never touches the steer client;steer_pushframe carriessentBy; a plain steer withoutsent_byis byte-for-byte unchanged. A peer steer the turn never confirmed is requeued withsent_byon the entry and_directive_user_originoff, a human steer's requeue is unchanged, and an accepted steer leaves the author map empty.sent_by_meta:childis present for a worker sending to its creator through either door and absent toward a stranger.queue_popframe carriessent_by(so the live-rebuilt row draws as the From-row and counts toward the badge); a plain entry's frame shape is unchanged. Thesession_sendtool reports a steered delivery as steered; started / queued wording unchanged. Peer entries never merge: two peers pop separately, a peer entry ends a human merge run without being folded in, plain human messages still merge.session="origin"forwards the strict key andcaller_sessionwhen resolved; with no strict key it posts with an EMPTY session key (no header) and reports the bell; a cron origin send never consults the strict resolver.sent_by_metashape for a member caller, an ordinary caller (nomember_slug), and an unknown caller.queue_pushthe requeue broadcasts carriessent_byand the prefix-free body; a human steer's requeue frame carries neither.peer_authoredwith noqueue_editframe; slot-detail queue items carrysent_by. FrontendQueueStack.test.tsx: peer card has no edit button and hides the provenance line, cancel stays; a malformed record leaves the card the user's own.send_to_targetsurfacescontainment_changed409 (snapshot sequence patched soauthorize_targetsees the unlinked target); an unchanged target still steers; source pin that noawaitseparates the check from the steer and none precedesclient.steer. Queued peer row:queue_pushcarries the entry id and the message without the provenance line; an idle target broadcasts no card.sent_byuser row keeps an unanswered stateless card and announces no retirement; the user's own row still retires it; the predicate is the queue drain's (carries_sent_by). Steers: a settled peer steer keeps the card and releases its author; the user's own settled steer retires it; a peer steer the echo did not account for keeps its author for the requeue; source pin that the accepted-steer tail does not drop_steer_sent_by. An untitled caller's record carries no title; a titled one does.not_creatorby the allow;sent_by_metagives it nomember_slug(nor to a member key with no live slot).queue_push/steer_push/chat_messageshapes lose their provenance carrier before the local broadcast; a mirroredqueue_pushre-broadcasts under the local key withoutsent_by.peer_row_metadropssent_byandmid, keeps tool correlation; an adopted backfill row with a peer-stampedsent_bylands with no meta; the client-ingress list and the peer-ingress list are the same set.strip_reserved_client_metadropssent_byand keeps the rest, a body that is only the forgery becomes no meta, an honest body passes through by identity; a source pin holds the strip ahead of everyuser_metareader inapi_chat.deliver_to_creator: worker report lands in the creator's thread withvia: send_message_origin; busy member creator is steered; orphan caller, unknown caller, vanished creator (rehydrate returns None), and a creator in another workspace all returnNonewith nothing appended./api/send-messageroute: internal-secret caller with a creator →delivered_to: "session", no bell; without a creator → bell; an app-token request naming a worker's key → no creator lookup, bell; a cron caller never takes the creator lookup; noX-Session-Keyheader → no lookup.Frontend (vitest):
SentByCard.test.tsx(record parsing incl. malformed records and a non-truechild, kind keyed on relationship not door, name rules incl. the generic fallback, prefix stripping leaves other bracket lines alone, peer row expanded with badge + name + body, worker row folded with preview and expands on click, plain session row never shows a raw key);pinnedPrompt.steer.test.ts(asent_byrow is skipped and the last typed prompt pins; the same text without the record still pins, as the control);chatRolesParity.contract.test.tsdocumentssent_byas a shared-dashboard entry;transcriptRenderers.test.tsx(thesent_byentry resolves on every surface, wins over the steer-only user override, a row without the record or with a malformed one falls through touser, the card renders);chatSlice.questionCard.test.ts(asent_byuser frame keeps the stateless card on the active and pane paths; a malformed record does not qualify);dashboardSlice.test.ts(count per slot, clears on local read, survives a non-covering relayed read and clears on a covering one, ignores empty / unsafe keys);MembersPage.test.tsx(count badge replaces the dot with accessible name "2 new messages from other sessions", clears on opening the thread; own-reply unread keeps the dot).CI runs the suites. Nothing was run locally beyond the static gates (black / isort / flake8 / mypy on touched files, comment-history, sync-io-in-async, agent-sdk-boundary, loop-bound-locks, feature-map, docs-lint, brand-name;
tsc -b, eslint on touched files, i18n string / key / untranslated / parity scripts, theme-colors, phantom-classes).Manual verification
Real-gateway run, two plain crew members, real model, no fixtures. recorded from
9bdf351f3b45e69aab83d5be2ff2b6fbcb6ec886· origin/feat/member-thread-projection · crew memberskirocrew-conductor(A) andkirocrew-autofix(B) on the default agent template plus akirocrew-workercrew forsession_create;agent.session_control/agent.member_dispatchat their defaults · hand-started pod (pod up cannot reach the systemd user bus from the capture shell; gateway started with the pod harness's environment shape: isolated throwaway home and data home,--no-crons --no-tunnel --no-open --approval yolo, the worktree's venv, the SPA built from the worktree) + real model (kasACP backend), no fixtures. Dark theme, 1280×820. Every row cited is the gateway's own slot history; tool results are read off the caller's transcript and cross-checked against the SEL audit rows.Head note. The branch was amended twice while the gateway ran. Modules imported at boot and the SPA on screen are
9bdf351f3;session_control.pywas first imported lazily after the second amend and is the later content (visible as"child": trueon the worker rows). The frontend changes since9bdf351f3(kind keyed onchild, "another session" fallback, agent tooltip, nopeerRows, roster preview strip) are not in the frames; the later fixes below (queue_popcarriessent_by; the tool reportssteered) are not either — the run is what found gap 2.session_sendtomember-kirocrew-autofixwhile B's thread was not open → tool result "Delivered … it started a turn", SEL{"started": true, "steered": false}. B's row:meta.sent_by = {session_key: member-kirocrew-conductor, via: session_send, member_slug: kirocrew-conductor, …}. Roster before opening B: numbered badge 1 on B's row. B opened: onesent-by-card, badge MEMBER, "From kirocrew-conductor",aria-expanded="true", body without the[sent by session …]line. B replied, confirming receipt.session_created akirocrew-worker(created_by: member-kirocrew-conductor) and sent it an instruction ending insend_message(session="origin", …). The worker's tool result: "Message injected into target session." Gateway log:send_message session=origin delivered to creator member-kirocrew-conductor started=True steered=False. A's row:sent_by = {…, via: send_message_origin, child: true, title: worker-report-test, agent: kirocrew-worker}. Roster with A not open: badge 1 on A's row. A opened: the card is folded (aria-expanded="false", badge WORKER, "From worker-report-test", one-line preview), expands on click. An earlier attempt with A busy took the steer path: log… started=False steered=True, same success string.sleep 8between; A'ssession_send"STEER-CHECK from A" while B wasrunning: true→ SEL{"started": false, "steered": true}. B's row landed between the 1–5 and 6–10 steps withmeta = {steer: true, steerState: consumed, sent_by: {…}}; B acknowledged it in the next line and finished the count. The recording shows the task sent, the first step, the From-row landing inside the running turn (~17 s), the acknowledgement (~24 s) and the count resuming.session_sending to B, which it did not create:403 not_creator— the fence the two allows are carved out of still holds. An ORDINARY chat session sending to B was allowed (started: true): a person's own session is not ownership-fenced andagent.session_controldefaults to on, so this is pre-existing behaviour, not a change here; its row draws as a folded SESSION-kind card.Gaps the run found (all recorded honestly; two fixed on later heads):
session_sendtool told A "Queued … runs when the current turn ends" for a send the server reportedsteered: true— fixed in6618a8849(the tool readssteered).[sent by session …]prefix — fixed on this head (stripSentByPrefixon the roster line).send_message; the harness seeded a warm-up turn first. Backend behaviour, not this PR's, but it bounds the worker-reports-back flow.--approval yolodid not cover a member thread's shell tool in this harness (per-chat Trust was used for C). Harness note.authorize_targetenforces with the switch on — see D above.Run 2 — current SPA, same harness. recorded from
373d481fe2d0fcba0265ce8aed75a626dba9e28e· origin/feat/member-thread-projection · plain crew memberskirocrew-conductor(A) andkirocrew-autofix(B) on the defaultkirocrewtemplate plus akirocrew-workercrew forsession_create; nomembersblock,agent.session_control/agent.member_dispatchat defaults · hand-started pod + real model (claude-fable-5.1on thekasACP backend), no fixtures · dark, 1280×820 unless stated.HEADwas373d481feat build, boot and every capture (each frame's DOM sidecar carries the head). The two later amends (8835d7bba: server-side preview strip + mid-plan pin test;e26c25a20: header width rule below) were not built or captured — what they change is called out per item.session_sendsPEER-HELLO-3 …to B while B's thread is closed; SEL{"started": true, "steered": false}; B's rowmeta.sent_by = {session_key: member-kirocrew-conductor, via: session_send, member_slug: kirocrew-conductor, title, agent}. Roster row for B: badge 1 (aria-label"1 new message from another session") and the preview starts withPEER-HELLO-3, not[sent by session— the SPA'sstripSentByPrefix. The API's ownlast_messagestill carried the 61-char prefix and capped the text after it, so the preview's tail is cut (run-2 gap 1) —8835d7bbastrips server-side before the cap; not pictured.data-kind="member", expanded, badge MEMBER ("Sent by another crew member"),From kirocrew-conductorwith tooltipkirocrew-conductor · Agent: kirocrew-conductor, body without the prefix line anywhere in the thread.session_createsworker-report-test(kirocrew-worker,created_by: member-kirocrew-conductor); the worker callssend_message(session="origin", …)→ tool resultMessage injected into target session.; logsend_message session=origin delivered to creator member-kirocrew-conductor started=True steered=False; SEL{…, "via": "send_message_origin"}. A's rowsent_by = {…, child: true, title: worker-report-test, agent: kirocrew-worker}. Roster (B open): badge 1 on A. A opened: card folded, badge WORKER with the tooltipA session this member started to do a task for it (listed under “Sessions it's driving” in the Crew summary); its report lands here,From worker-report-test(bare), one-line preview; expands on click, prefix hidden.Fix the flaky retry testposts to/api/session-control/sendwith its own key →200 {started: true};sent_by = {…, title, agent: default}(nomember_slug, nochild). Row:data-kind="session", folded, badge SESSION,From “Fix the flaky retry test”(quoted), tooltipFix the flaky retry test · Agent: default. Measured clamp (DOM rects): pane 294 px at 1280 with the Crew summary open → name 22/175 px; 346 px at 900 → 37/175; 586 px at 1600 → 108/175. Time never pushed off the row, but at 1280 the name readsFr…(run-2 gap 2) — addressed one26c25a20: the preview takesshrink-[8]so it gives way before the name, and a container query on the card hides the preview below 28rem (448 px) so the name gets the row (≈91 px at 294); not pictured.792794944). In both, the chat-3 SESSION row had scrolled behind the header, so the pinned-prompt band quoted it — raw[sent by session chat-3-…] SESSION-ROW check …text drawn as B's own prompt — while the From-row itself sat hidden under the band (its DOM sidecar entry has empty text). The band now skipssent_byrows; not pictured.373d481fea dashboard slot with no title haddisplay_title = "New Session…"copied into the record, so the row readFrom “New Session…”. Changed on4ff366799(UX suggestion): the placeholder is not a name, so the record carries no title and the row reads the localizedFrom another session; not pictured.1badge on B (peer row unread) and the plain unread dot on A (ordinary reply unread), never both on one row.Run-2 notes that are not this PR's: native
titletooltips do not paint in headless captures (recorded in the DOM sidecars); the roster query refetches on remount / 30 s stale window and the transcript tail it previews flushes ~1–1.5 s after the live push (two earlier takes of frame 1 showed the previous reply); a brand-new session's first turn still has no MCP tools (run-1 gap 3, unchanged).Run 3 — current head, the four states the UX lane asked for. recorded from
bf4f71848cf86a69968cb3ac358dd24d4a5d09a6· origin/feat/member-thread-projection · same harness as run 2 (plain memberskirocrew-conductorA /kirocrew-autofixB,kirocrew-workercrew, defaults, real model on thekasACP backend, no fixtures, dark 1280×820 unless stated).HEADwasbf4f71848at build, boot and every capture; the one later amend (edc716aa7) is the run's own finding (item 4 gap) plus a test-only fix, both called out below.From “Fix the flaky retry test”in a 294 px card:.sent-by-previewis rendered butdisplay: none, the name shows 83/175 px (From “Fix the flaky retr…; run 2 on the pre-fix head: 22 px). At 1600 the preview is visible again and the name gets 164/175 px. Onbf4f71848the name was still clamped by its own 45% cap (83/175 px);b69d1d90flifts the cap inside the same narrow rung, not re-pictured.pinned-promptreads the human'sPIN-TEST human prompt: …, no[sent by sessiontext anywhere on the page; wheeling the newest peer row to just above the header, the band still quotes the human prompt and the From-row scrolls out cleanly instead of being covered.title: ""and the row readsFrom another session(tooltipanother session · Agent: default). Run 2's gap 3 is closed.chat-4-…, held on a pending shell approval) receives A'ssession_send→200 {started: false, steered: false}(queued). Live card (4b):1 · PEER-QUEUE from conductor: …with no prefix, buttonsSend nowandCancel queued message, no edit;PATCH …/queue/<id>→409 {"code": "peer_authored"}. After the turn (drain SELqueue_drain_revalidation allowed) the row draws as an expanded MEMBERFrom kirocrew-conductorrow (4c, 4d).edc716aa7(frame 4b2, not re-pictured): after a page reload the HYDRATED card showed the[sent by session …]prefix and anEdit queued messagebutton —api_chat_slot_detailsnapshots the queue before rendering and the snapshot carried id and content only, sosent_bynever reachedGET /api/chat/slots/<key>. The snapshot keepsmetanow; test added (test_slot_detail_hydration_carries_the_record). The server refused the edit either way.Run-3 harness notes:
--approval yolodid not auto-approve the worker's sandboxed shell tool, so the pending approval is what kept the target busy (the drained From-row therefore lands ~10 min after the send); native tooltips are in the DOM sidecars.Screenshots / video
Dark theme, 1280×820, real gateway, provenance as above.
A — peer row. Roster badge on B before its thread is opened; then B's thread with the expanded MEMBER row (no prefix line):
B — worker report. Roster badge on A; the folded WORKER row with its preview; the same row expanded:
C — steer into a running turn (recording, 60 s, real time; the row lands at ~17 s, the acknowledgement at ~24 s):
c-steer-recording.mp4
D — an ordinary session's row (SESSION kind, folded)
Run 2 — current SPA,
373d481fe(dark, 1280×820 unless stated; frames named as in the run-2 list above).Frame 1 — roster: badge 1 on kirocrew-autofix and the preview starting at
PEER-HELLO-3, prefix stripped:Frame 2 — B's thread on the current SPA: MEMBER,
From kirocrew-conductor, expanded, no prefix line:Frame 3 — roster badge on kirocrew-conductor after the worker's report; the folded WORKER row; the same row expanded:
Frame 4 — SESSION row with a quoted title at 1280 (name clamped to
Fr…, the width gap fixed one26c25a20), at 900, and at 1600:Frame 5 — title-less sender renders From “New Session…”; Frame 6 — badge and dot together (740 wide)
Run 3 —
bf4f71848, the four UX-lane states (dark, 1280×820 unless stated).Frame 1 — folded SESSION row at 1280 with the Crew summary open: preview dropped, name readable; the same row at 1600 with the preview back:
Frame 2 — peer rows scrolled behind the header; the pinned band quotes the human's prompt, not the peer's:
Frame 3 — an untitled sender's row reads From another session:
Frame 4 — peer message queued behind a busy session: the live card without the prefix and without an edit button; the drained row as a MEMBER From-row:
Related Issues
Part of #10527 (the minimal scope recorded in its closing comment). Supersedes the closed RFC #10528 and PRs #10535 / #10543 / #10559.
no linked issue: #10527 stays open until the owner decides the scope is complete; this PR is the first of it.