Repository navigation
feat(slack): code-channel bar actions, canvas comments, view tabs - #22370
Conversation
UX Review (Opus 5.5) — ⏭️ skippedRevision |
Sensitive Change ReviewSensitive files changed:
|
Design Review (Opus 5.5) — ✅ PASSDesign-level review of Design-Verdict: PASS Nothing blocks. Every new inbound path (bar clicks, canvas comments) goes through the existing allow-list, origin, channel-policy and Stop gates, and dropping the separate CI item is declared in Backwards compatibility. Notes
[DESIGN-REVIEWED] 9dfb3e0 Description read[DESCRIPTION-READ] 50d8f66acd2dd2444ea8215485a553a99176bbaa3035819b8674dcc14a3488de That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
First Principles Review (Opus 5.5) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Nothing blocks. The base RFC ( Notes
What this change shipsInventory (9 items) — 8 justifiedIntent: let people in a Slack code channel act from its context bar and give feedback on the plan that reaches the agent, and stop tab and refusal failures from going unnoticed. This is an ADDITION.
[FIRST-PRINCIPLES-REVIEWED] 9dfb3e0 Description read[DESCRIPTION-READ] 63a1002c6a4949fca53a3970896b793e150fd058ffc86310ae37b910bdc218dd That sha256 names the PR description this verdict read. Recompute it with |
Opus 5.5 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
GPT 6.1 Review — ✅ no blocking findingsGPT 6.1 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: |
f25d025 to
d2a4c58
Compare
beab93b to
0d23e0a
Compare
d2a4c58 to
f3e263f
Compare
0d23e0a to
cc01bfb
Compare
cc01bfb to
a4dfdbe
Compare
f3e263f to
a277a54
Compare
5da454b to
8291cb0
Compare
GPT 6.1 and Opus 5.5 (both upheld at 2ea3dfe): the "Stopped by" note read the worker slot's turn generation after awaiting the stop and the Slack reply, so a queued follow-up turn that started meanwhile was shown as stopped and lost its Stop button. Fixed as a class, each with a test that fails without it: - the final gate reads the stopped turn's generation before the stop awaits; stops.note takes it and keeps nothing for a turn the slot has moved past, and never erases a later turn's note; - the repeat mark is per turn, so a Stop on the next queued turn is a new stop; a stop that raises (cancellation included) leaves no repeat mark; - stops.reconcile drops a stale "Stopped by" line right before the board and the Workers tab render, and before the one-time edit-gap skip is taken; a stale stop's skip is dropped with it. The board's scope rule from #22370 (a channel that turned shared, or whose slot was relinked, is not shown the conductor ledger's content), now asked again across every await of this PR's own surfaces, each with a test that fails without it: - every Workers-tab and PR-tab write and removal (tabs._may_write, asked right before each send and each removal); - the board message, after the Workers tab's awaits and again right before each send and before each needs-you mention (publisher.publish in_scope); - the wrap-up: built and, again, right before each post (the retry without tab links included), without the workers' outcomes and their PR tabs (the channel's own PR tab stays); - the Workers-tab Stop: its final gate refuses a channel out of scope, and a stop whose channel left the scope while it ran names no worker and notes no "Stopped by" line. GPT 6.1 (upheld at 55817e1): with worker hand-off off (the default) the scope check refused the channel's OWN PR tab too. The own PR (the channel's workspace record, not the ledger) now takes the channel fences only; worker PR tabs keep the scope check right before each write, and a sync that starts out of scope uses only the own PR. Tests fail without it.
8291cb0 to
f777357
Compare
7dd25c1 to
c9c10de
Compare
GPT 6.1 and Opus 5.5 (both upheld at 2ea3dfe): the "Stopped by" note read the worker slot's turn generation after awaiting the stop and the Slack reply, so a queued follow-up turn that started meanwhile was shown as stopped and lost its Stop button. Fixed as a class, each with a test that fails without it: - the final gate reads the stopped turn's generation before the stop awaits; stops.note takes it and keeps nothing for a turn the slot has moved past, and never erases a later turn's note; - the repeat mark is per turn, so a Stop on the next queued turn is a new stop; a stop that raises (cancellation included) leaves no repeat mark; - stops.reconcile drops a stale "Stopped by" line right before the board and the Workers tab render, and before the one-time edit-gap skip is taken; a stale stop's skip is dropped with it. The board's scope rule from #22370 (a channel that turned shared, or whose slot was relinked, is not shown the conductor ledger's content), now asked again across every await of this PR's own surfaces, each with a test that fails without it: - every Workers-tab and PR-tab write and removal (tabs._may_write, asked right before each send and each removal); - the board message, after the Workers tab's awaits (the publisher's own per-send and per-mention re-check is #22370's ``admits``, passed through); - the wrap-up: built and, again, right before each post (the retry without tab links included), without the workers' outcomes and their PR tabs (the channel's own PR tab stays); - the Workers-tab Stop: its final gate refuses a channel out of scope, and a stop whose channel left the scope while it ran names no worker and notes no "Stopped by" line. GPT 6.1 (upheld at 55817e1): with worker hand-off off (the default) the scope check refused the channel's OWN PR tab too. The own PR (the channel's workspace record, not the ledger) now takes the channel fences only; worker PR tabs keep the scope check right before each write, and a sync that starts out of scope uses only the own PR. Tests fail without it.
c9c10de to
5c0d705
Compare
GPT 6.1 and Opus 5.5 (both upheld at 2ea3dfe): the "Stopped by" note read the worker slot's turn generation after awaiting the stop and the Slack reply, so a queued follow-up turn that started meanwhile was shown as stopped and lost its Stop button. Fixed as a class, each with a test that fails without it: - the final gate reads the stopped turn's generation before the stop awaits; stops.note takes it and keeps nothing for a turn the slot has moved past, and never erases a later turn's note; - the repeat mark is per turn, so a Stop on the next queued turn is a new stop; a stop that raises (cancellation included) leaves no repeat mark; - stops.reconcile drops a stale "Stopped by" line right before the board and the Workers tab render, and before the one-time edit-gap skip is taken; a stale stop's skip is dropped with it. The board's scope rule from #22370 (a channel that turned shared, or whose slot was relinked, is not shown the conductor ledger's content), now asked again across every await of this PR's own surfaces, each with a test that fails without it: - every Workers-tab and PR-tab write and removal (tabs._may_write, asked right before each send and each removal); - the board message, after the Workers tab's awaits (the publisher's own per-send and per-mention re-check is #22370's ``admits``, passed through); - the wrap-up: built and, again, right before each post (the retry without tab links included), without the workers' outcomes and their PR tabs (the channel's own PR tab stays); - the Workers-tab Stop: its final gate refuses a channel out of scope, and a stop whose channel left the scope while it ran names no worker and notes no "Stopped by" line. GPT 6.1 (upheld at 55817e1): with worker hand-off off (the default) the scope check refused the channel's OWN PR tab too. The own PR (the channel's workspace record, not the ledger) now takes the channel fences only; worker PR tabs keep the scope check right before each write, and a sync that starts out of scope uses only the own PR. Tests fail without it.
5c0d705 to
7355586
Compare
f777357 to
64cc0b6
Compare
…tabs
Closes the Slack Code API gaps on top of the conductor work board.
- Context bar, budgeted to Slack's five items (a longer list is kept to its
first five with only a warning): a Workers item with the board's tally
("2 working · 1 needs you") linked to the pinned board's permalink
(chat.getPermalink, cached per board message), repo, branch, Stop while
the channel's own turn runs (decided at send time, so a refresh racing a
turn start never drops it), and ONE PR slot: the channel's own PR with
its CI, else Create PR when the branch has commits past the Code tab's
base. Each worker's PR is on the board. The Workers item rides only a bar
sent with the channel's binding and is scope-checked right before that
send; a refresh sends the bar again once its board is known. Open in
dashboard takes a free slot only; an unchanged bar is not resent.
Create PR and Stop are action items (code_channel_action, now
subscribed): Create PR runs commands.run_command for /create-pr, Stop is
Slack's own Stop handler, so both run routing._stop_bound and its stop
fence. Bars outside Slack's schema are refused before sending; the agent
cannot take a channel-action key.
- Plan-canvas comments are read with agents.conversations.getCanvas at a
normal turn end and by an idle-channel poll (Slack sends no comment
event), and reach the session as the commenter's message: authorized
like a typed message, redacted, framed as feedback, de-duplicated
against Slack's own listing across restarts, bounded. Only a ROUTED
delivery is marked seen.
- View tabs: every tab we open is recorded; at Slack's five-view cap the
stalest of OURS by recorded id (never the Plan tab or the diff, never
another agent's) is removed and the write sent once more.
- agent_resource follows the channel's PR (renames, merge, close); the work
board is the live summary_message until a wrap-up replaces it.
- Docs conformance: suspended while a tool approval waits (by request id);
one dashboard notice when Slack answers not_agent_channel /
not_authorized; plain tool errors for too_many_sections /
content_too_large; html sized after redaction; an ambiguous click is
refused.
- The stop-fence commit-point guard now also scans views, comments,
actions, notices and workspace/publishing.
slack/code_channels/comments.py redacts canvas comments as they are read from Slack (agents.conversations.getCanvas), before they reach the session, like slack/thread_replies.py does for thread replies. It owns no output of its own, so it joins NON_EGRESS_REDACTION_MODULES.
Sensitive change review
|
bolichen97
left a comment
There was a problem hiding this comment.
Reviewed head 9dfb3e0. CI is green (80 pass, 18 skipped), the branch merges cleanly into current main (46 behind), and the changed backend suites plus test_security_posture.py and test_slack_code_channel_stop_helpers.py pass locally (1033 passed). Design, First Principles, Opus and GPT lanes all pass on this head.
What I checked by hand:
- Both bar actions reuse existing paths. Stop builds the same
agent_session_stoppedevent and goes throughsession_events.admits+handle_stopped, so it gets Slack's Stop checks and nothing more. Create PR goes throughcommands.run_commandafter the feature gate, de-dup, the workspace-origin gate,channel_inbound_permitted+channel_refusal, a bound-channel check and a liveact_refusal.parse(src/kiro_crew/slack/code_channels/actions.py:83) treats two different user ids as nobody, which fails closed. - Canvas comments go through
is_allowed_user, the channel redactor androuting._route_to_slotwith anadmitgate at the route's commit point. Our own comments are skipped, so a turn-end read cannot loop on the agent's own output. - In
route_linked_thread,note_channel_sendernow runs after the newadmitcheck and right before the append, with no await between (src/kiro_crew/slack/handler_runtime/inbound.py). The recursive re-route still records the sender, so the owner-only dispatch exemption is not widened. - Views are removed only by the view id this gateway recorded, never the Plan or Code tab, and the retry is one write under the same fence.
- The dashboard link comes from
board.links.link_builder, https only, with no click token.
Non-blocking:
- File size. test/test_slack_code_channel_board_diff.py goes from 1,580 to 1,603 lines, past the 1,600-line target that AGENTS.md says a change should split in the same PR. The new test/test_slack_code_channel_api_gaps.py starts at 1,901. src/kiro_crew/slack/code_channels/workspace/service.py (1,934), routing.py (1,912) and src/kiro_crew/slack/events.py (1,965) grow further toward the 2,000 cap. check_file_line_cap.py only reports these, but a follow-up split would keep the next code-channel PR from hitting the cap.
- Revertability, as Design Review notes.
code_channel_action's body is still undocumented, and actions.py plus its manifest subscription share the large first commit with the four other features. Moving them into their own commit, or a follow-up that can be reverted alone, would make a production shape mismatch cheap to back out. - src/kiro_crew/slack/code_channels/comments.py:80-81:
_locksand_last_readare keyed by channel id and never pruned when a channel is unbound or archived. This is small in practice, butpoll_once(line 431) stamps every due channel each pass, so the dicts only grow over a gateway's lifetime.
Approving.
AI-assisted, sent by Bolin Review bot
Problem / Motivation
Goal: A Slack code channel uses the Slack Code API the way Slack documents it: buttons on its context bar, plan-canvas comments that reach the agent, tabs that never fail at Slack's cap, the PR as the channel's resource, a live summary, and a clear notice when Slack refuses.
Kyle's brief for this PR (10-20, then "do the smaller things too, get this REALLY polished"): close three Slack Code API gaps (context-bar action buttons, canvas comment read-back, view-tab cleanup), then agent_resource, a live summary_message, a decision on
message.sessionandslash_command_url, and a docs-conformance pass over everything sent to Slack Code.On main today every context-bar item is a link (nothing handles
code_channel_action), comments people leave on the comment-only Plan canvas are never read,listViewsis used only by the scope probe andremoveViewhas no caller, so a sixth tab fails withtoo_many_views.Why it matters
People in a code channel can't act from the bar (open the PR, stop the turn, jump to the session), their plan feedback goes nowhere, and a busy channel silently stops getting new tabs. Smaller mismatches with Slack's docs (the status during a tool approval, silent refusals) make the channel read wrong.
Not a goal
/kirocrew trust.slash_command_url): Kiro Crew runs Socket Mode only.agent_resource(only the channel's PR is tracked; there is no issue binding to read).Backwards compatibility
Compatible: every new surface and workspace record field has a default, so stored records load unchanged, and a record written by a build that filed workers still reads; an install whose Slack app does not yet subscribe
code_channel_actiongets no clicks (the bar still renders), and the Settings update panel lists the new event like any manifest change. The separate CI item is folded into the PR item's label (five slots cannot hold repo, branch, PR, CI and the actions).Premise (for the maintainer override)
First Principles blocks the context-bar action items because Slack documents
code_channel_action's trigger but not its body, and RFC open question 2 said Phase 3 ships link items only. Kyle's ruling (10-23): ship Create PR and Stop on the documented trigger, and keep the bar's Stop next to Slack's own.Action items: RFC open question 2 records the decision and exactly how
actions.parsereads a click (channel, person, key, workspace, de-dup id). A click it can't read is refused and audited, never guessed; two different users in one body make it nobody's. Each key runs an existing path with that path's own checks and audit (/create-pr; Slack's own Stop handler, owner or allowed user), so no action adds a way in. The first click's field names (never values) are logged so the live shape can be pinned.The bar's Stop: shown only while the channel's own turn runs. It builds the same
agent_session_stoppedSlack's button sends and goes throughsession_events.handle_stopped, so it is the same Stop:routing._stop_boundmarks main's stop fence first, thenstop_helpers.stop_channelstops the channel's session, its helper agents and their sub-agents and says in the channel how many it stopped, and an idle channel's status is set back toactive, exactly as for Slack's button and!stop. The click's own private reply "Nothing is running." goes out only when nothing it stops was running: not the channel's session, its helper agents, or a live or queued sub-agent of either. It is the same Stop as Slack's button: it is asked exactly the checks Slack's own Stop event is, none in front of them and none left out, so withslack.code_channelsswitched off mid-turn it still stops the running session.slack.code_channelsonsession_events._feature_on)session_events.admitsevent_id)event_ts_may_use_botrefuses none)session_events.admits)channelsinbound ceiling, per-channel ceilingstop_from_channel; otherwise not ours)act_refusal)channel_and_origin_permit)Known limits (wording only; the Stop itself is unchanged): a Stop that stops only sub-agents waiting in the task store, or continuation runs, still tells the presser "Nothing is running." beside the channel's "Stopped" reply; and on an idle channel where only other board sessions run, the presser is told "Nothing is running." while the channel's reply names those sessions as still running.
What changed
1. Context-bar actions (
workspace/context_bar.py, newactions.py,events.py, manifest). Budgeted to Slack's five items:setPropertieskeeps only the first five of a longer list (with atoo_many_context_bar_itemswarning), so the bar is built in priority order instead of losing whatever came sixth:board.model.bar_label: "2 working · 1 needs you", "3 of 3 done"), linked to the pinned board message (chat.getPermalink, read once per board message and cached on the surface record).own_pass()), no git read./create-pr's capability holds and the branch has commits past the Code tab's base.The agent's own items, then Open in dashboard (a deep link, never a sign-in token; https only), take only a slot left free. Stop and Open in dashboard follow the channel's live session: the workspace record takes the binding's session on every turn start, whatever the worktree (a non-git project included). The Workers item rides only a bar sent with the channel's binding and is scope-checked right before that send; main's refresh order is kept (the channel's own bar and diff, then the board) and the bar is sent again once the pass's board is known (a digest match sends nothing). A bar matching the last send that landed is never resent. Action items never carry a
url, andset_context_barrefuses a list outside Slack's schema before sending. A click arrives ascode_channel_action(now subscribed). Stop goes first and is asked exactly what Slack's own Stop event is (session_events.admits, thensession_events.handle_stopped); every other key gets the feature gate, de-dup by event id, the per-workspace origin gate and thechannelsinbound ceiling, and Create PR runscommands.run_commandfor/create-pr(same gates, audit row withvia=action).2. Plan-canvas comments (new
comments.py). Slack sends no canvas-comment event, soagents.conversations.getCanvas(open threads) is read at each normal turn end of the bound session and by a 60 s poll over idle channels with a plan canvas (25 a pass, every skipped channel stamped). New comments and replies (never our own) become one message per commenter, routed throughrouting._route_to_slotlike a typed message, framed as feedback and redacted with the channel's redactor. Only a delivery the route answersROUTEDis marked seen, and so is one it answered with a refusal in the channel (REFUSED), so that refusal is never posted again; an unrouted one is read again next time. A comment delivered once is never delivered again, whatever a listing shows: Slack lists only the newest 100 threads and 100 replies of each, and no resolved thread, so nothing is forgotten because a listing left it out; the record is bounded at 10,200 instead, dropping the oldest by Slack ts behind a floor that only rises, so nothing dropped reads as new. Commenters who may not use Kiro Crew are skipped and audited. A stopped turn's unwinding reads nothing (main's stop fence); once the slot is idle the poll reads as a pass of its own (own_pass()plusadmit()), so a comment left after a Stop arrives, and only a Stop during that read holds it back. The route itself runs outside that pass, so a turn it starts is fenced by its own start only.3. View tabs (new
views.py). Every tab this gateway opens is recorded with its view id. Ontoo_many_viewsthe live list is read, entries Slack no longer lists are dropped, and the least recently written view whose recorded id is listed is removed (never the Plan tab or the Code tab, never another agent's), then the write is sent once more under the same write fence.4. agent_resource follows the channel's PR (
{url, resource_type: "pull_request", title: "Fix the flaky login test (#42[, merged|closed|draft])", provider: "github"}), redacted, resent only when it changes; the PR shown is only this checkout's (main'spr_foridentity).5. Live summary_message: the work board message is recorded as
code_channel.summary_messageonce per message; a current wrap-up for the same session is never displaced.6.
message.session: not added (message.channels/message.groupsalready deliver code-channel messages). 7.slash_command_url: omitted (Socket Mode).8. Docs conformance (each with a test):
suspendedwhile a tool approval waits on the bound session, by request id; one dashboard notice per channel when Slack answersnot_agent_channel/not_authorized; plain tool errors fortoo_many_sections/content_too_large; html sized after redaction; an ambiguous click refused.9. The client's commit point carries each site's fence.
SurfaceClient._callawaits the outbound policy before every send. Each write this PR adds hands its own synchronous fence (activation, a rebind, the board's scope) to that commit point (surface.send_fence), so an Off, a Review or a scope change during that await sends nothing: view writes, removals and resends, the bar, the Code tab and the resource, the live summary, the command set, the canvas read, and every send a tool makes (run_tool).10. The route's own commit point carries the caller's gate.
route_linked_threadawaits after its caller's gate (the agent read, the window load, the image copy). It now takes an optionaladmit, asked last, right before the row is appended or the turn starts; a refusal answersLinkedRoute.HELD, silent in the router, and its caller speaks. A typed channel message passes none, as on main. Every path this PR adds that appends to or starts a session:/summarize,/wrap-up,/create-pr, the bar's Create PRadmitted)/wrap-upis disarmedOn main's changes since the last round: main's stop fence and its Stop of helper agents and sub-agents (
stop_helpers.py, #38243) decide every Stop (Slack's button,!stop, the bar's Stop) and this PR adds no Stop mechanism of its own; main'srefresh/_refresh(underown_pass()/admit()), itspr_foridentity and its board are used as they are;publishing.pyis re-derived from them. The stop-fence commit-point guard (test_slack_code_channel_commit_point.py) now also scansviews.py,comments.py,actions.py,notices.pyandworkspace/publishing.py, with a reason recorded for each write it allows.Sensitive change
src/kiro_crew/security_posture.pyis the one Sensitive Change Review path: 3 added lines inNON_EGRESS_REDACTION_MODULES(commitfix(security): classify plan-canvas comment read-back as capture-side). The hunk is byte-identical to the one on the previous head5c6a3159a5(same 3 lines afterslack/thread_replies.py). Filled reasoning for the owner to post (a worker never posts it):Tests
test/test_slack_code_channel_api_gaps.py: bar order, Create PR only without a PR and with capability, actions never link, every bar within Slack's schema, the dashboard link with no token; clicks (Create PR runs/create-pr's path, Stop runs Slack's Stop handler, strangers refused privately, redelivery once, every inbound gate, unknown keys, two-user bodies); comments (attributed and framed delivery, once across a restart, retry after a failed delivery, strangers and our own bot skipped, redaction, the per-read bound, 720 comments each delivered exactly once, the legacy baseline, a stopped turn delivers nothing); views (stalest of ours removed, never Plan or Code, never another agent's); agent_resource; the live summary;suspendedduring an approval; refusal notices once; plain tool errors.test/test_slack_code_channel_bar_budget.py: Slack's first-five truncation against the builder's worst case, the client refusing six, the priority order, the PR slot (the channel's own PR only, no worker item ever, Create PR needing commits from the Code tab's base), the Workers label table, every icon and label within Slack's limits, the permalink read once per board message, onesetPropertiesper real change, Stop at turn start with no git read and across a racing refresh, and Stop taken off when a stopped turn ends.test/test_slack_code_channel_board_scope.pyandtest/test_slack_code_channel_fences.py: the Workers item and every bar, diff, resend and summary write re-check their scope or activation right before sending; a Stop during a refresh or a bar build sends nothing; an Off or scope change inside the client's own policy read sends nothing at each commit-point site; after a Stop, an idle channel's poll delivers (and the turn it starts carries no poll admission) and a Create PR click corrects the command set; a refused comment is answered once; a comment,/summarize,/wrap-upor a Create PR click refused at the route's own commit point is held (through the realroute_linked_threadwith the Off inside its agent read, and each pinned re-entry asking the gate once); the bar's Stop still stops a running session with the feature switched off, and it and Slack's own Stop agree in all 144 cases of feature, the code channel's toggle, presser, origin, workspace and running or idle; on an idle conductor channel with a running helper agent, a click stops that helper and its sub-agent throughsession_events.handle_stoppedwith the same channel reply as Slack's Stop, and is not told "Nothing is running." (fails when the click is routed aroundhandle_stopped); a click that stops only an idle session's sub-agent is not told so either.test_slack_code_channels_routing.py(the bar's Stop settles like Slack's);test_slack_code_channel_stop_fence.py(the turn-end hook's stub carries the bar's turn set).This head is rebased onto main
f05269b1bb, after #38243 (a code channel's Stop also stops its helper agents and their sub-agents) merged. Two hunks were resolved by hand: the spec's Stop row (main's sentence plus the bar's Stop) andtest_slack_code_channel_board.py(main's removal of the idle-Stop reply tests, this PR's bar-label test kept); everything else is unchanged ingit range-diffexcept the bar's Stop reply fix (actions._anything_running), its two tests and two doc lines. Before that, after #38181 (per-row PR and CI, the combined Code tab) merged: the hand-merged files keep both sides (the Code tab is main'sCodeTab, sent with this PR's activation fence and view-cap room;PullRequesthas main'schecksand this PR'stitle; the client asks this PR's send fence, then main's send gate).routing.pyis 1,912 lines:_route_to_slotmoved whole intoroute_gate.py, re-exported fromrouting.Run on head
9dfb3e0d2f5ecb4311181e1b02c9ef5024979152(on mainf05269b1bb):test_slack*/ code-channel test file importing a module main changed since the last full run (50 files, 2,049 tests): pass.GITHUB_BASE_REF=main(224 files, 453 tests): pass.website/file changes, so the frontend steps have nothing to run.test_security_posture.py: 57 pass.On
3a597c9fa5, the same two commits two main commits earlier (identical ingit range-diff):test/test_slack*.pyplus every other test file that drivesroute_linked_threadorLinkedRoute(198 files, 7,606 tests): pass.test_slack_code_channel_api_gaps.py, the one test file the sub-agent reply fix changes, collected twice and run in 3 shuffled orders: 180 of 180 every time.5c6a3159a5(the conflict resolution, the edits after it, and this PR's Stop paths read against main'sstop_helpers.py), rerun after the sub-agent reply fix: no findings. GPT's review prompt on that fix alone (9056399af9..3a597c9fa5, read againststop_helpersand the sub-agent manager's reads): no findings.On
9056399af9, the head before the sub-agent reply fix:5c6a3159a5: no findings. Opus's found that the click's private reply ignored sub-agents (a Stop that stopped only an idle session's sub-agent was also told "Nothing is running."), now fixed with a test that fails without it.On
a4b3179d7b(before #38243; three test fixtures differ since):b6dfe1f188,e86c4173bbanda3b518cb0ehas a test that fails without its fix.Manual verification
Still required on a live Slack Code workspace (not reachable from this host):
code_channel_actionunderbot_eventswhen the updated manifest is saved, and a click arrives with the fieldsactions.parsereads (the gateway logs the first body's field names).Screenshots / video
Scripted capture from the real builders (
build_items,pr_resource,comments.feedback_text, the refusal and notice strings), rendered in a Slack-like page because Slack itself is not reachable from this host.The context bar: the bar for a conductor channel with three helper agents and a running turn, the same channel idle with its own PR, all helper agents done, and Create PR; then

agent_resourceafter the PR merged.Replies and notices: the private replies to a bar click, three agent tool errors, and a Plan-canvas comment as the session receives it (the ⛔ shows as a box: the capture host has no emoji font).
Related Issues
Builds on #21993 (the conductor work board, merged). Follow-ups: PR B (per-row PR and CI on the board, the combined diff, the wrap-up's worker outcomes) and the tabs PR (PR tabs, tab links, the Workers tab). Slack docs: Code channel properties, Lifecycle, setProperties, getCanvas, listViews, removeView, setView, setStatus.
Checklist
Contribution License Agreement
Contributions are accepted under the project's Apache-2.0 license.