Skip to content

feat(session-control): broadcast to a fleet, and a roster that remembers a lost worker - #14185

Merged
buluoray merged 2 commits into
mainfrom
feat/session-broadcast-and-status
Sep 28, 2026
Merged

buluoray merged 2 commits into
mainfrom
feat/session-broadcast-and-status

Conversation

@chenmingwei23

@chenmingwei23 chenmingwei23 commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A session that dispatches workers can address all of them in one call, and can see which of them are still alive.

A session that dispatches workers can say one thing to one worker, and cannot find out which workers are still alive.

session_send takes one target. A conductor holding eight workers that must tell all of them "the base moved" writes eight calls and tracks by hand which ones landed. There is no way to say "interrupt all of them", so the urgent case costs the same eight round trips as the patient one.

There is also no roster. list_sessions reads the durable catalog, so it does list a closed session -- but it reports neither who CREATED one nor whether it is still running, so a conductor cannot tell a worker still working from one that died with its process, and cannot pick its own workers out of every session in the workspace.

Why it matters

Both gaps fail silently.

A hand-written loop of session_send calls that dies partway leaves no record. The conductor's own reasoning is the only place that knows targets four through eight never got the message, and a compaction takes that with it. A worker that missed "the base moved" pushes against a base that moved.

The missing roster is worse, because the absence reads as success. A patrol sees seven live workers, decides the eighth finished, and never re-dispatches it. The work item is dropped and nothing reports a failure.

Not a goal

  • Telling a FINISHED worker apart from a LOST one. Both read gone, which conflates them; the roster's job here is that neither disappears. Deferred to issue session_status: a gone row cannot tell a finished worker from a lost one #14213.
  • Making steer_into_running_turn cancellation-safe. Its maps are left populated on cancel and the teardown requeue is what saves the message, so unwinding them would DISCARD text instead of delivering it late. That affects every steer caller, not just broadcast, and belongs in its own change.
  • Changing when the fenced crew log writes lineage. A session that dies before its first turn is reported from transcript metadata instead, at the created_by the ownership fence already trusts.
  • Any new delivery mode. queue and steer are the two the backend already has; broadcast fans them out and adds none.

What changed (motivation → approach → change)

Part What it does
session_broadcast one message to many sessions; queue or steer
session_status the caller's own sessions, and what each is doing
gone a session the crew log has and the dashboard does not
tree how complete the roster read was
MAX_BROADCAST_TARGETS 32; over that is refused, not cut
BROADCAST_TARGET_ALLOWANCE_SECS one name; per delivery and per request
delivery_timeout this side stopped waiting; outcome unknown

Two new tools on the kirocrew-dashboard session-control server: schemas in src/kiro_crew/validation.py, tools in src/kiro_crew/mcp_dashboard.py, verbs in src/kiro_crew/dashboard/session_control.py, routes in src/kiro_crew/dashboard/handlers/session_control.py and src/kiro_crew/dashboard/server.py, docs in src/kiro_crew/docs/session-control.md and docs/system-specs/modules/session-control.md.

session_broadcast calls the existing send_to_target once per target, so every bound already there holds per delivery and it reaches nothing a session_send could not. Its default audience reads the same _created_by field the ownership fence reads, so it is a subset of what the fence admits; an explicit target is bound instead by that same fence running per delivery.

mode is required with no default: queue and steer are different instructions, and defaulting either way substitutes one for the other across a whole fleet.

Deliveries run one at a time, each under its own bound, and a refusal is a ROW rather than an abort. The bound is what makes sequential delivery safe: one session that never answers would otherwise starve every session behind it, and the steer it suspends on has no ceiling -- so the urgent "stop, that is already fixed" would reach two of eight workers. On expiry the delivery is cancelled, reported as delivery_timeout, and the loop moves on. That row does NOT claim the target missed the message, because the cancel can land after the target consumed it; the honest answer is that this side stopped waiting and the outcome is unknown, which is why it is a separate code from a crash.

Partial delivery is normal: the caller is told which targets got the message. An explicitly empty targets is refused, never read as "everything". Duplicates go by RESOLVED session, not spelling, since a key and a title can name one worker. One name bounds the cap and one bounds the delivery allowance, each read by both the schema or client and the verb.

session_status needs three sources because none answers alone. The live slots know what is running but forget a session the moment it is gone -- exactly the worker a patrol must not lose -- so the roster also comes from the crew log's durable session tree. That tree's edge is written at a session's first turn, so a worker that died earlier is in neither: transcript metadata supplies those, at the created_by the fence already trusts. Every row names its source, and a history row is unknown rather than gone: metadata proves a birth, not whether it finished. Both durable reads can be partial, so tree and history each carry their own quality and an incomplete count is a floor. The fence applies to the rows too, since a row carries another session's title.

Supporting work. The caller-side half of authorize_target's gate moves into two shared helpers -- two and not one, because the gate runs them on opposite sides of its target resolution. Both tools join the channel-agent block list in src/kiro_crew/channel.py. In src/kiro_crew/agent.py, session_status is granted to the conductors and session_broadcast only to a crew member. The Session control row in docs/feature-map/README.md gains both verbs, both endpoints and the app-caller refusal.

Backwards compatibility

Compatible: two new tools, two new routes and two new grants. No existing argument, response field, refusal code or grant changes, and the gate's extracted helpers keep every check, code, message and call order they had inline.

Tests

97 new tests in three files.

test/test_session_broadcast.py covers the audience (default set, the caller excluded, sessions it did not create excluded, stable order, dedup, a blank list refused, the cap refused rather than cut), both modes and the missing-mode refusal, partial delivery (a refusal collected while siblings still receive, an unexpected failure given its own code, sequential execution proved by an overlap counter), the caller gate, the route, and an end-to-end class that stubs no layer: the tool call through the real handler into two real slots.

test/test_session_status.py covers all four statuses including a plan's between-stages gap, the gone row and its absent title, all three tree qualities including a raising projection, the fence on rows, the workspace boundary, and that the targets are unchanged afterwards.

Four of those pin the repairs this PR's own review found, each proved failing before the fix: an empty targets reaching nobody, two spellings of one session delivering once, the request timeout derived from the cap, and one name bounding both caps.

test/test_mcp_dashboard_session_broadcast.py covers the prose the model reads: every row outcome including a steer that fell back to a queue, the missed-target warning present only when something was missed, and each tree caveat.

Two source-shape pins are taught the new shape rather than loosened. test/test_queue_drain_revalidation.py parses the gate's refusals from source; the gate is now three functions, so it parses all three and names one refusal from each, which catches a whole function going missing instead of reporting eight refusals as deleted. test/test_pending_boundary_consumer_semantics.py enumerates every reader of a slot's running state, so the roster verb is declared there as one.

Ratchets updated where they pin the tool set by count or membership: test/test_session_control_doc.py, test/test_mcp_dashboard_registration.py, test/test_mcp_dashboard_folders.py, and the grant pins in test/test_conductor_agent.py, test/test_pipeline_conductor_agent.py, test/test_security_conductor_agent.py and test/test_member_dispatch_mount.py.

Manual verification

N/A -- the end-to-end class drives the real MCP tool through the real HTTP handler into real slots, which is what a manual run would do.

Four mutations were checked to prove the tests discriminate, each caught, with the file restored byte-identically (sha256 verified): dropping the broadcast provenance, forcing every delivery to the queue, aborting on the first refusal, and widening the default audience to every slot.

Related Issues

no linked issue: a new feature carries its context in the PR.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@chenmingwei23
chenmingwei23 requested review from a team and smeyffret September 26, 2026 09:05
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Sep 26, 2026
@github-actions

github-actions Bot commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — ✅ PASS

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

Design-Verdict: PASS

Description table says MAX_BROADCAST_TARGETS is 32; code and shipped docs say 50 — fix the stale table row before merge.

[DESIGN-REVIEWED] 20adedc

@github-actions

github-actions Bot commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — ✅ PASS

Premise-level review of 20adedccb431b2fabe7826b8c9f6312d52355d43 — 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: PASS

Verify the one unattended widening: session_broadcast auto-approved for crew-member DM sessions — one prompt-free call now writes into up to 50 worker sessions.

The grant's argument is the fence's own (default audience read from the same _created_by the ownership fence reads, re-gated per delivery), and the cap relation is pinned (MAX_BROADCAST_TARGETS >= MAX_SLOTS_PER_CREATOR, MAX_SLOTS_PER_CREATOR = 50 at src/kiro_crew/dashboard/state.py:345) — but it is the highest-consequence line in the diff and a human should own it. Minor: the description's "What changed" table still says the cap is 32; the shipped constant is 50.

No existing mechanism duplicates either verb: every broadcast hit in src/kiro_crew/ is websocket-frame fan-out, not session delivery, and list_sessions (src/kiro_crew/mcp_tools/sessions.py:398) reads the durable catalog with neither creator nor liveness, confirming the described gap. The two edited pins (test_session_control_doc.py tool count, test_queue_drain_revalidation.py source parse) are extended to the new shape, not reversed. The steer-cancellation shield exists because this PR introduces the first canceller of that path, and the deeper fix is explicitly deferred in ## Not a goal.

What this change ships

Inventory (10 items) — 10 justified

Intent: let a session that dispatched workers message all of them in one call and see which are still alive — an ADDITION.

  1. New session_broadcast tool and route: one message to many sessions, queue or steer, per-target outcome rows — justified
  2. New session_status tool and route: roster of the caller's own sessions with liveness, including gone and unknown rows — justified
  3. session_broadcast auto-approved for crew-member DM sessions (no prompt per worker) — justified
  4. session_status auto-approved for the goal, pipeline and security conductors — justified
  5. Both new tools blocked for channel agents — justified
  6. A broadcast delivery is cancelled after 5s and reported delivery_timeout; the shielded steer may still land and is never double-claimed — justified
  7. The provenance envelope now names the sending verb, so a worker can tell a broadcast from a direct send — justified
  8. Audience capped at 50; an over-cap request is refused, never truncated — justified
  9. session_status reply bounded (256 rows, 500-char titles) with per-source quality fields and exact omission counts — justified
  10. authorize_target's caller-side checks extracted into shared helpers with identical codes and order, reused by the targetless verbs — justified

[FIRST-PRINCIPLES-REVIEWED] 20adedc

@github-actions

github-actions Bot commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ✅ no blocking findings

GPT 5.6 completed its review of 20adedccb431b2fabe7826b8c9f6312d52355d43 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 20adedc

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 20adedccb431b2fabe7826b8c9f6312d52355d43: <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 26, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Intent: Let one session address the fleet of workers it dispatched, and find out which of them are still alive -- a broadcast with an explicit queue-vs-steer mode, and a roster whose durable half reports a worker that was closed or lost as gone instead of silently absent.
Not a goal: widening what a session may reach (every delivery re-runs the existing per-target gate), per-worker progress in the roster, retrying a refused delivery, or a stop-the-fleet mode.

@chenmingwei23
chenmingwei23 force-pushed the feat/session-broadcast-and-status branch from e667d02 to 3d66457 Compare September 26, 2026 11:26
@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 26, 2026
@github-actions

github-actions Bot commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5 Review — ✅ no blocking findings

Reviewed 20adedccb431b2fabe7826b8c9f6312d52355d43 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 20adedc

Verdict parsed from the review's SHA-scoped output markers for commit 20adedccb431b2fabe7826b8c9f6312d52355d43.

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

@chenmingwei23

chenmingwei23 commented Sep 26, 2026 •

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none added; the envelope's own docstring and spec bullet now match it

  • span=29914e6a98b5 module docstring and spec still declare one writing verb — fixed.

Legitimate, and self-added by this PR: the delivery now formats via <verb> so a
worker can tell a fleet-wide instruction from one aimed at it alone, but the
module docstring still said "One verb" and quoted the fixed literal, and the
spec's Provenance bullet repeated it. A comment asserting something the code
stopped doing is the defect, not a style point.
Fixed as advised: the docstring names both verbs and the parameterised form, and
the spec bullet does the same, with one line on why the verb is part of the
message's meaning rather than decoration.
Second finding of this class on this PR -- the local round fixed a comment
contradicting the audience_empty branch -- so the sweep now covers docstrings and
spec sentences about changed behaviour, not only comments next to the edit.
Docs lint and the session-control suites pass.

@chenmingwei23
chenmingwei23 force-pushed the feat/session-broadcast-and-status branch from 3d66457 to 3ded9ae Compare September 26, 2026 11:55
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: gone row and its crew_log source

Legitimate, and the sharper half of the finding is the second one: the prescribed
action needs exactly the memory this verb exists to replace, so a compacted
conductor sees N indistinguishable rows and cannot learn any of their outcomes.
Deferred because the distinction needs durable state that is not recorded today.
The session tree holds session/opened plus adoption and release edges; a CLOSE
writes no edge, so nothing in the log says whether a session ended deliberately.
Adding one changes the crew log's entry vocabulary and its projection, which is a
different change from adding two MCP verbs.
Not hidden in the meantime: the tool's own text says gone means "closed,
archived, or lost", so a reader is told the row is ambiguous rather than being
given false precision.
#14213 carries the deferred-finding label, an assignee and a Due date, and names
both closing conditions -- a close edge in the tree, or an in-band way to read a
gone worker's outcome so the distinction stops mattering.

@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 26, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none; the current-edge choice is the existing documented behaviour

  • span=603a4f56682a gone-row ownership follows the current parent, not the opening one — rebutted.

The behaviour is real and it is the decided one, stated in _created_tree_roster's
own docstring before this finding: the roster follows the CURRENT parent edge, so
an adopted session is listed under whoever holds it now rather than whoever opened
it. That is what session_adopt MEANS — a takeover moves answerability, and the
verb reports the sessions a caller is answerable for.
So the described consequence is the feature. A conductor that handed a worker to
another conductor should not keep it on its own patrol list; the adopter's roster
shows it, and the adopter is the session that can act on it.
Deriving ownership from the immutable opening parent instead would invert that: a
conductor would keep seeing workers it gave away and could not reach, while the
session that actually holds them would not list them. That is a worse answer for
both, not a safer one.
The narrow case the finding gestures at -- creator A, adopter B, both B and the
worker gone -- is real but is the gone-ambiguity problem already deferred to
#14213, not a second defect: a terminal marker in the tree is what lets any of
those rows be read at all.
No code change. The edge choice is load-bearing and documented where a reader
meets it.

@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 26, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: none; the grant's second mechanism was already in place, now stated explicitly

  • Verify the crew-member auto-grant of session_broadcast holds for explicit targets too — rebutted, and the ask was the right one.

It holds, but NOT by the sentence the verdict quotes -- and the reviewer is right
that the quoted one covers only half the surface. Two different mechanisms:
DEFAULT audience: broadcast_audience reads the same _created_by field
_created_by_other reads, so the audience is a subset of what the fence admits
BY CONSTRUCTION. This is the fence-subset claim, and it is only about this path.
EXPLICIT targets: the subset argument does NOT apply -- a caller may name any
string. What binds this path is that every retained target is delivered through
send_to_target, which calls authorize_target(operation="send") before it
writes anything, with the member's carried fence verdict. An out-of-fence name
therefore comes back as a not_creator refusal ROW, and the message is never
written into that session. Dedup resolution does not authorize: it computes an
identity key only, and what enters the audience is the caller's raw name.
So the no-prompt grant rests on per-delivery authorization, with the subset
property as a second, narrower guarantee on the default path. The grant comment in
agent.py already says both ("the verb's DEFAULT audience is read from the same
created_by field ... and every delivery re-runs that fence per target"); this
records which clause does the work for which path.
No code change: nothing was missing, and a broadcast reaches nothing a sequence of
session_send calls could not.

@chenmingwei23
chenmingwei23 force-pushed the feat/session-broadcast-and-status branch from 3ded9ae to 401f1d8 Compare September 26, 2026 12:25
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: per-delivery asyncio.wait_for + delivery_timeout row + one shared allowance constant

  • span=a9d0071ef0b3 a hanging target starves every target behind it — fixed in 401f1d8.

The sharpest finding on this PR, and it was drawn from two sentences I had written
myself without putting them together: the steer RPC has no wait_for, and
deliveries are sequential. So the mode that exists for "stop, that is already
fixed" reached two of eight workers and the caller got no report at all.
Reproduced before fixing, with a target awaiting a never-set event: pre-fix the
outer 30s bound expired, chat-4 was never called and the report came back None;
post-fix it finished in 5.01s with all three targets called and
requested=3 delivered=2.
Each delivery now runs under BROADCAST_TARGET_ALLOWANCE_SECS and yields a
delivery_timeout row on expiry, then the loop continues. The bound wraps the
WHOLE call, not just the steer RPC, so the queue arm is covered too -- it also
suspends before it delivers.
The row deliberately does not claim non-delivery: wait_for cancels at the
suspended await, which for a steer is the RPC, so the bytes may already be
consumed. A separate code from delivery_failed for exactly that reason -- a
crash did not deliver, a timeout might have -- and the message says only that this
side stopped waiting and the outcome is unknown.
Two consequences recorded in the code: the pre-RPC audience fence is left unpopped
so the turn's cross-surface legs stay withheld (fail-closed), and no per-send audit
row exists for a cancelled delivery, so the broadcast's own entry is the trail.
6 new tests, 0 passed / 6 failed before the fix; 107 passed after. One name in
validation.py now bounds both the enforced per-delivery ceiling and the client's
request budget, so the two cannot drift apart.

@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 26, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/session-broadcast-and-status branch from 401f1d8 to eababb9 Compare September 26, 2026 12:38
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: BROADCAST_RESPONSE_MARGIN_SECS, one shared name, asserted as a strict inequality

  • span=74c260d15da4 the client budget has no room left for the response — fixed in eababb9.

Legitimate, and confirmed by arithmetic before any edit: the client sized its one
request at MAX_BROADCAST_TARGETS * BROADCAST_TARGET_ALLOWANCE_SECS = 160.0s, and
the backend's worst path is 32 sequential deliveries each bounded at 5.0s = the
same 160.0s, before the per-target gate, two audit writes and the HTTP response.
Margin 0.0s on paper, negative in practice.
Sharper than the numbers: the per-delivery bound added last round exists so a
fleet of unresponsive targets still yields a per-target report. In exactly that
case the client expired first and discarded it, so the mechanism defeated itself
at its own worst case.
This is the third round on this arithmetic, so removal was weighed before repair.
Dropping the per-delivery bound reopens the starvation defect; dropping the scaled
request reopens the 30s mid-fleet expiry. Neither removal survives, so the margin
is the smaller complete fix.
BROADCAST_RESPONSE_MARGIN_SECS = 10.0 in validation.py, beside the cap and the
allowance both layers already read, and named as an ALLOWANCE rather than a
measured value. The per-delivery bound is unchanged -- shrinking it to buy margin
would have traded a correctness property for arithmetic convenience.
Pinned as a STRICT inequality computed from the three named constants, never a
copied 160 or 170: a test carrying its own number is the drift this PR already
fixed twice. 517 tests pass; black, isort and flake8 clean.

@chenmingwei23

chenmingwei23 commented Sep 27, 2026 •

Copy link
Copy Markdown
Contributor Author
  • span=f2-comment-overclaims-nondisclosure my own comment claimed more than the code does — fixed in cefe0dd.

Upheld, and this is the FIFTH time on this PR that a comment of mine claimed more than
its code. The claim "cannot disclose the hidden slot that happened to carry it" is
false: the unresolved name still reaches authorize_target, whose UNRESTRICTED
resolution matches the hidden title and returns its containment class
(not_creator, mirrored_target, ephemeral_target) rather than target_not_found.
I narrowed the comment instead of collapsing the row to target_not_found, because the
containment class is the caller's only signal for WHY a target it named is unreachable,
and flattening it to "no such session" would trade a real diagnostic for a weaker
disclosure property. The reduced claim is still worth making: the slot KEY never
appears, which is what the enumeration fence exists to prevent.
Existence disclosure through the containment class is pre-existing authorize_target
behaviour on every verb that calls it, not something broadcast introduces.


Marker removed: this comment named a span id I wrote by hand rather than one from pr_findings.py, so it claimed no real finding identity. The rationale stands; the findings it answers are fixed and no longer listed on the head.

@chenmingwei23

chenmingwei23 commented Sep 27, 2026 •

Copy link
Copy Markdown
Contributor Author
  • span=f3-unknown-renders-as-idle a session of unknown fate rendered as the one that needs a decision — fixed in cefe0dd.

Correct. The description enumerated working/queued/idle/gone while the verb also
emits unknown, and the renderer mapped it to idle's sleep glyph -- so a patrol read
"unknown fate" as "open and doing nothing, the one that needs a decision". The two
places disagreed, and the glyph made the disagreement invisible.
unknown is now named in the description and carries its own mark, with a test that an
unknown row does not render as idle.


Marker removed: this comment named a span id I wrote by hand rather than one from pr_findings.py, so it claimed no real finding identity. The rationale stands; the findings it answers are fixed and no longer listed on the head.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

PR Hygiene was failing on main's template, not on the diff: ## Not a goal and a **Goal:** line under ## Problem / Motivation became required. Both added to the description, no push needed. The exclusions listed are the real ones this PR defers -- the gone conflation (issue #14213), steer_into_running_turn's cancellation safety, the fenced crew log's lineage timing, and any new delivery mode.

Rebased c203fac29 -> a41323c65 with no file overlap; the suites were re-run anyway: 557 passed.

@chenmingwei23

chenmingwei23 commented Sep 27, 2026 •

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: both cap mentions in the package-shipped page now read 50, and test_the_documented_limits_match_their_constants pins each to MAX_BROADCAST_TARGETS

  • span=0d67cfb96c8c the package-shipped agent reference still said 32 after the cap rose to 50 — fixed in 25e5dc8.

Upheld, and it is the exact drift I claimed to have handled one round earlier. Raising
MAX_BROADCAST_TARGETS to 50 updated docs/system-specs/modules/session-control.md and
missed src/kiro_crew/docs/session-control.md — the page SHIPPED IN THE PACKAGE, which
is the one an agent actually reads before calling the tool. It understated the cap in
two places, so an agent would split a fleet of 40 into subsets it never needed to.
The literal was the defect, so a literal is not the fix. This page already had
test_the_documented_limits_match_their_constants, pinning the rate-limit windows and
slot ceilings against their constants, and the broadcast cap was simply not in it. Both
mentions are now asserted against MAX_BROADCAST_TARGETS.
Mutation-checked: setting the prose back to 32 fails that test, and the file was
restored byte-identically (sha256 verified).
This is the third time a copied number drifted on this PR — first test literals, then
the schema, now the shipped page. The pin is what makes a fourth impossible.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: handover_returned deleted — declaration, write and read — and the AST test now asserts the classifier reads exactly one progress flag

  • span=ba815f5dc4a9 handover_returned had zero consumers — fixed in 25e5dc8.

Upheld, verified against the code rather than taken on faith: steer_await_entered is
set BEFORE the await and handover_returned immediately after it returns, so the second
can only be true when the first already is — and _timeout_delivery_observation
answered _TIMEOUT_UNKNOWN on both. Cancel during the await or after it, the reported
outcome is identical. The field could not change any answer.
It is my own dead weight from the round that fixed the 5-second timeout's blind spot.
Taking the deletion rather than showing a path where it matters, because no such path
exists: a field the classifier cannot act on is not a fact worth keeping, and a reader
who finds it has to reconstruct that argument before concluding it means nothing.
The two tests that pinned it moved with it. The AST test previously asserted both flags
were read; it now asserts the read set is EXACTLY {"steer_await_entered"}, so a second
progress flag cannot be reintroduced without a test saying why it changes an outcome.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: the caller-surface gate is re-called after the history scan, plus a workspace equality check, both refusing through the same audited path

  • span=36bec42fc986 the roster published private session titles past a gate whose verdict did not survive the suspension — fixed in 9f5fdd7.

Upheld. Verified against the code before fixing, and the defect is sharper than
"missing re-check": the comment I wrote above that await BRAGS that the suspension is
"deliberately AFTER the complete synchronous caller gate". The gate did run. Its
VERDICT is what does not survive the hop, and my own comment is what made that look
handled.
A mirror can be bound onto an already-open dashboard session while the scan sits on a
worker thread — the channel picker and the Slack link route both do it with no
idle-slot requirement — and the rows built afterwards carry other sessions' TITLES,
the names of the user's private work. So the reply reaches that channel's audience.
Fixed on the adjudication's own terms and with its precedent: one synchronous re-call
of refuse_caller_surface, which raises mirrored_caller through the audited deny
path, exactly as the queue drain re-checks mirror identity between admission and
delivery instead of trusting its admission.
I did NOT take the slot-identity half of the suggested fix, because it cannot fire:
get_or_create_slot returns the registered slot for an existing key and the single
put_slot publish runs only where the key was absent, so no live key is rebound to a
new object. I wrote that check, wrote a test for it, watched the test fail to trigger,
and traced why rather than faking a registry to make it pass — this PR has already
shipped one field that could never change an outcome, and a second dead check answering
a security finding would be worse. The comment records the reachability argument.
WORKSPACE equality IS kept, because that one is reassigned on a live slot
(chat_handlers commits one, channel_slots adopts one from metadata) and it is the
boundary every row is filtered on.
Mutation-checked: removing the whole re-check turns the two change tests red and leaves
the clean-caller test green; the file was restored byte-identically (sha256 verified).

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: the docstring and the spec now describe ONE marker, and say why a second could not separate anything

  • span=29914e6a98b5 the docstring and spec still described a marker I had deleted — fixed in 9f5fdd7.

Upheld, and it is the direct consequence of last round's deletion. Removing
handover_returned as a zero-consumer field left both prose sites claiming the delivery
"records when it enters the steer await and when that await returns", and
docs/system-specs/modules/session-control.md repeating "marks that await's return".
Deleting the field without the sentences that describe it turned a true-but-useless
claim into a false one.
Both now describe one marker, and both carry the reason a second is not coming back: it
could only be set once the first already was, so it would separate nothing. That is the
argument the deletion rested on, written where the next reader meets the code.
This is the sixth finding on this PR where a comment claimed more than its code, and the
first where the drift was caused by a FIX rather than by a feature. Prose describing a
field is part of that field's blast radius.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: the Problem sentence now states the gap that is actually true of list_sessions

  • span=b38d94637d8d the frozen Problem section misdescribed list_sessions — fixed in 9f5fdd7.

Upheld, and I tried to rebut it first. The clearing condition offered two routes:
evidence that the durable catalog omits closed sessions, or a human narrowing the
sentence. I went to read the evidence and it went AGAINST me —
list_sessions iterates ConversationLog().list_sessions(), the on-disk catalog, and
filters only incognito rows and other workspaces. A closed session IS listed. My
sentence ("returns what is OPEN ... simply absent") was false.
Narrowed rather than widened, which is why I made the edit at all: the frozen sections
are frozen against SCOPE creep, and this finding asks for a factually wrong claim to be
corrected to a narrower true one. The real gap is that list_sessions reports neither
who created a session nor whether it is still running — so a conductor cannot tell a
worker still working from one that died, and cannot pick its own workers out of the
workspace. That is a gap session_status genuinely closes, and it is smaller than what
I originally claimed.
Flagging it plainly for a human veto since a frozen section is involved: the Goal is
unchanged, one sentence in Problem is, and the diff is unaffected.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Integration (in-process gateway) is base breakage, not this PR's. It fails on test/integration/test_route_sweep.py asserting /api/models answers 503 while a fake model list makes it answer 200 — a file this branch does not touch, from #14269. The same job is failing on main's own head (68c64766 lineage, run 36360976080), and locally the sweep is skipped without the integration environment, so it cannot be reproduced here either way.

Rebased de25db109 -> 68c647663. Five files overlap, including validation.py and src/kiro_crew/docs/session-control.md where this PR's cap constant and its doc pin live, so the suites were re-run rather than assumed: 568 passed, and the cap is still 50 in both places with the pin intact.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=06afe54baead head=9f5fdd7d7549f631441b1c7802cb580e9795c966

Confirmed against the code, and the mechanism is worse than a lost row. chat_delivery.py:415 guards await client.steer(message) with except Exception, which does not catch CancelledError, so the budget's cancel unwinds through the RPC and skips the one reconciliation tail at :463. That tail is the only thing that pops _steer_delivery_ids, _steer_send_ids, _steer_user_origin and _steer_admissions: _settle_consumed_steers clears only _steer_attachment_meta and _steer_decision_strips (chat_runner.py:7842-7843), and _requeue_unconsumed_steers returns early once settling emptied _pending_steers (:7862). The surviving _steer_delivery_ids entry then trips the one-per-text guard at chat_delivery.py:354 for that exact text forever, and retained_steer_count (:358) unions all six maps, so it never falls back below MAX_PENDING_STEERS.

Fixed as suggested: asyncio.ensure_future(_steer_delivery()) awaited through asyncio.shield. The awaiting frame still receives the cancellation, so the broadcast reports its timeout row on schedule and _await_authorized_delivery still audits outcome=cancelled, delivery_result=unknown; the delivery runs to its own end and reconciles itself. The task is retained in a module-level set with a done callback, because a shielded task referenced only by the shield wrapper the frame just dropped can be collected mid-RPC — the very interruption the shield exists to prevent.

Pinned by TestTheShieldedSteerDelivery, driven through the REAL steer_into_running_turn with a client whose steer hangs, since the defect IS that except Exception gap. Two cases: the maps are popped after the shielded delivery finishes, and the same text steers again once the turn settles — which is the step that exposes the strand, because settling pops _pending_steers and nothing else. Mutation-checked: removing the shield reddens all three cases (including the pre-existing cancelled-audit test, whose assertion changed from "the inner received CancelledError" to "the inner was not interrupted").

_pending_steers is deliberately NOT popped by that tail and the test asserts it still holds the entry: it belongs to the turn, whose echo settles it and whose teardown otherwise degrades it to a visible queue card.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=2f6082500a24 head=9f5fdd7d7549f631441b1c7802cb580e9795c966

Correct, and verified independently: authorize_target at session_control.py:3156 is the sole raiser of app_scoped_target, created_session_status (:5084) accepts no target argument and never reaches it, while session_broadcast does reach it (:4459). The row claimed a refusal in the stricter direction on a verb that cannot be asked for it.

Rewritten to say both verbs refuse an app-scoped CALLER (app_scoped_caller), and only session_broadcast can also refuse an app-scoped TARGET, naming why: session_status accepts no target argument at all. Not overridden — the fix is one clause and the sentence was wrong.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=4464213526e3 head=9f5fdd7d7549f631441b1c7802cb580e9795c966

Same row as the GPT lane's finding on docs/feature-map/README.md; both lanes converged on it independently, which is why it was fixed rather than argued.

Took the second remedy you offered — dropping the app_scoped_target / "both directions" claim for session_status — not the roster filter. The claim is what is false: created_session_status makes no target-direction containment decision, so asserting one describes an authorization the code does not make. Routing the live rows through _broadcast_resolution_slots would be a behaviour change to the status roster, which is a separate decision from correcting a sentence; the roster's own audience question is tracked in #14213.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Rebased: onto main at b7ad967f2 and re-pushed as b1864d561. The PR had gone mergeable_state: dirty — main added session_set_model and its docs, which collided with this PR's session_broadcast / session_status in five files.

Resolved as a union rather than a side: the tool-schema import list takes both names, the MCP tool count and the docs count come from _tool_definitions() (21, both verbs present) instead of arithmetic on either side, SESSION_CONTROL_TOOLS is 11, and the feature-map row and refusal table carry both features' prose and routes. The doc test keeps this PR's number-free phrasing ("blocked from every session tool") since a count in the prose is a second place to update; the set equality pins the membership.

Scoped re-run for the overlapping files: 401 passed (test_session_broadcast, test_session_status, test_session_control, test_session_control_doc, test_mcp_dashboard_session_broadcast, test_mcp_dashboard_registration), and flake8 / isort / black / mypy all clean on the changed files.

…ers a lost worker

session_broadcast sends one message to several sessions in a required queue or
steer mode; session_status lists the sessions a caller stood up, taking the
roster from the crew log's session tree so a worker that was closed or lost is
reported gone rather than silently absent.

Both route through the existing per-target gate, so neither reaches anything a
session_send could not. The caller-side half of that gate is extracted into two
shared helpers rather than copied, keeping one implementation for the verbs that
have no target.
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=36bec42fc986 head=dc8969c300c322a66c8fbb5f68a3acb8a00350c0

Confirmed, and it is the other side of the invariant the previous round fixed in created_session_status. The entry gate runs once before any audience is read, then this verb suspends once per delivery, and every results row names one of the caller's own sessions. The channel picker (messaging/session_resume.py) and the Slack link route (slack/interactions.py) both bind a mirror onto an already-open dashboard session with no idle-slot requirement, so the payload reaches that channel's audience past a gate that passed.

Fixed as suggested: caller_workspace captured right after the entry refuse_caller_surface, and both re-checked immediately before the return. Workspace is compared because it IS reassigned on a live slot (a chat-handler commit, a channel slot adopting one from metadata); slot identity is not, because get_or_create_slot short-circuits an existing key and the single put_slot runs only where the key was absent — the same reachability argument that dropped the slot-identity half of the earlier status fix.

One deliberate difference from the status verb: the refusal is raised AFTER the allowed audit, not before. Each delivery was individually gated and has already happened, so the trail has to record them, and the refusal message says what is actually withheld — the per-target report — with an explicit "do NOT send the same text again". A caller that read this as a failed broadcast would deliver the same text twice, which is the harm the per-target rows exist to prevent.

Pinned by TestACallerSurfaceThatGoesStaleMidBroadcast: a mirror bound during a delivery refuses with mirrored_caller and the refusal carries no target key; a workspace move refuses with caller_changed_mid_broadcast and the message carries the do-not-re-send warning; a clean caller still gets its report. Mutation-checked: removing the re-check turns the first two red and leaves the clean-path case green, then restored by sha256.

New refusal code documented in the package-shipped session-control.md table.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=a294930262a0 head=dc8969c300c322a66c8fbb5f68a3acb8a00350c0

Correct, and it was a real CI red rather than only a table gap: test_mcp_tool_titles.py::test_every_listed_tool_carries_its_declared_title[kirocrew-dashboard] failed on Backend Tests (3.12, 4) and Backend Tests (Windows) (4), with both new tools reported as None.

Added to src/kiro_crew/data/mcp_tool_titles.json: session_broadcast -> "Broadcast to sessions", session_status -> "Read session roster". Both are inside the table's own 40-character single-line bound, which test_titles_are_short_single_line_copy pins. That suite is now 7 passed.

This one surfaced only after the rebase onto main, which is where the title table arrived; the lane had no such test on the previous head.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=36bec42fc986 head=47c2764c48e4241b3990a44e51fecf6e261d9168

Confirmed, and it settles a call I got wrong two rounds ago. The Opus lane offered two remedies for the same row: filter the live rows through _broadcast_resolution_slots, or drop the map's claim. I took the claim, reasoning that a sentence was the cheaper fix. This finding is the code half of that same gap, raised as reachable, and it is right: the roster loop re-stated only the ownership fence and the workspace boundary, and the four clauses it did not re-state -- _app, non-persistent memory_mode, linked_session_key, _has_channel_mirror -- are exactly what leaked. A worker linked or mirrored to a channel AFTER birth kept appearing, and display_title for such a session is derived from a conversation other people are in.

Fixed by membership in _broadcast_resolution_slots rather than by adding four more clauses to the loop: two places enforcing one containment is how they drifted apart in the first place. The set is resolved after the post-scan caller re-check, so a mirror bound during the scan is already reflected in it.

The row is dropped rather than reported title-less, on the grounds the loop's own workspace clause already states: session_send refuses this target too (linked_session_target, mirrored_target, ephemeral_target, app_scoped_target, not_creator), so a row would list work the caller cannot message.

Pinned by three cases in TestTheFenceOnRows: a worker linked after birth is not listed, a worker mirrored after birth is not listed, and an ordinary worker is still listed WITH its title. Mutation-checked: restoring the two old clauses turns the first two red and leaves the other five green; restored by sha256.

The feature-map sentence I wrote last round is now wrong in the other direction, so it is corrected too -- both verbs apply the same target containment; only the target-taking one can RAISE app_scoped_target, while the roster drops the row. The package-shipped session-control.md roster section says the same thing.

The three fix commits are squashed into one, so the PR is back to 2 commits for PR Hygiene.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=36bec42fc986 head=1cee89f2876b91a35765cfac6346a625495c9c0a

Confirmed, and it is a loss path the shield itself opened. Traced: STEER_UNAVAILABLE means the text was never handed over -- no steer-capable client, an RPC that lost it, or an identical steer already in flight -- and the shielded delivery runs its own reconciliation, so nothing downstream holds the text. The arm that queues it instead of dropping it lives in the frame the per-target budget cancels, so with the frame gone the message disappears. Before the shield the cancellation reached the RPC and left the text retained, which is why this only became reachable on the previous head.

Fixed as suggested: the retained delivery now carries its own post-outcome handling. _retain_orphaned_steer_delivery takes the unavailable outcome and a continuation, and on that outcome schedules the continuation, which re-gates on the same terms the in-frame arm does (prewarm, authorize_target, object-identity check on the resolved slot) and then calls the same enqueue_or_run_prompt with the same send_origin_meta. The re-gate is not skipped: the RPC suspended, and the queue entry records the containment for the drain to re-assert, so a snapshot taken now must not certify a link the authorization never saw. A target that resolved to a different object logs and does not queue, because queueing onto a detached object loses the text as surely as dropping it. The continuation task is held in the same module-level set as the delivery, and both its cancellation and its exception are logged rather than swallowed.

Pinned by test_an_orphaned_delivery_that_comes_back_unavailable_is_queued: the broadcast reports its timeout row with an empty queue, then the released delivery returns STEER_UNAVAILABLE and the exact provenance-wrapped text appears in the target's queue exactly once. Mutation-checked: making the fallback branch unreachable turns it red with the "lost rather than delayed" message; restored by sha256.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=2f6082500a24 head=1cee89f2876b91a35765cfac6346a625495c9c0a

Correct -- my own sentence from the previous head, and it overstated in exactly the way described. The slot is None branch emits its gone row from the attested tree before the live-row containment runs, so "never reaches its roster" is false for a contained worker that has since closed.

Rewritten to say what the containment actually buys: a contained session contributes no title and no live status, while a session the attested tree recorded still leaves its TITLELESS gone row once its slot is gone -- a row that carries no title and no live state and says only that a session the caller created is no longer held. The package-shipped session-control.md roster section carries the same two-part statement, so the map and the page agree.

Worth naming why this row is not itself the leak: gone carries no title field at all, so the exposure the containment closes (a conversation-derived display_title reaching the creator) cannot travel on it.

… both verbs

Three review rounds, one invariant: a gate's verdict does not survive an await,
and both verbs return payloads naming the caller's own private sessions.

`session_broadcast` steer delivery. The per-target budget added for a wedged
target cancels the awaiting frame, and `steer_into_running_turn` guards its own
`client.steer` with `except Exception`, which does not catch `CancelledError`.
A bare await therefore unwinds THROUGH the RPC and skips that coroutine's single
reconciliation tail while the bytes may already have reached kiro-cli: the turn
runs text no `slot.append` recorded, and the six per-text steer maps are never
popped. Nothing else pops them -- `_settle_consumed_steers` clears only the
attachment and decision-strip maps, and `_requeue_unconsumed_steers` returns
early once settling emptied `_pending_steers` -- so the surviving
`_steer_delivery_ids` entry refuses that exact text on the slot forever and
`retained_steer_count` never falls back below `MAX_PENDING_STEERS`. Awaiting a
shielded task splits the two halves: the frame still receives the cancellation,
so the broadcast reports its timeout row on schedule, while the delivery runs to
its own end and reconciles itself. The task is held in a module-level set so the
loop cannot collect it mid-RPC.

`session_broadcast` report. The entry gate runs once, before any audience is
read, and this verb then suspends once per delivery. A channel mirror can be
bound onto an already-open dashboard session in that window, so a payload built
under the entry gate reaches that channel's audience carrying private session
keys. Re-call `refuse_caller_surface` and compare the workspace captured at
entry, immediately before the return -- raised AFTER the allowed audit, because
each delivery was individually gated and has already happened, so the trail must
record them and the refusal must say that what is withheld is the REPORT.

`session_status` rows. The roster loop re-stated only the ownership fence and the
workspace boundary, and the four clauses it did not re-state are exactly what
leaked: a worker linked or mirrored to a channel AFTER birth kept appearing, and
its `display_title` is derived from a conversation other people are in. Live rows
now pass `_broadcast_resolution_slots`, the same predicate the sibling verb
resolves names against, so one place enforces the containment instead of two
drifting copies.

Slot identity is deliberately not compared anywhere here: `get_or_create_slot`
short-circuits an existing key and the single `put_slot` runs only where the key
was absent, so no live key is rebound to a new object and such a check could
never fire.

Also declare `Tool.title` for both new tools in `data/mcp_tool_titles.json`, and
correct the feature-map row: both verbs apply the same target containment, but
only the target-taking one can RAISE `app_scoped_target`.
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

disposition: fixed span=2f6082500a24 head=c898937756f2a99a2eb20eaf612588168ea245a4

Correct, and checkable in this PR's own suite: test_an_unfenced_caller_sees_a_session_the_tree_places_under_it asserts that a session the caller ADOPTED appears on its roster with a title. The tree follows the current parent edge, so "a session the caller created" is too narrow for a row that an adoption can also place.

Fixed as suggested, one phrase: the gone row now proves only that a session on the caller's own tree -- one it created, or one it holds through an adoption -- is not live. The package-shipped session-control.md roster section says the same and names why: the tree follows the CURRENT parent edge.

Not overridden. The statement was false about behaviour this PR's own test pins, and the correction costs one clause.

@buluoray

Copy link
Copy Markdown
Contributor

Reviewed at head 20adedccb4. All 96 check-runs green; the four AI lanes (Claude, Codex, Design, First Principles) each report no blocking finding on this head. I read session_control.py (both verbs, the gate split, the _resolve_slot candidates change), the two HTTP handlers, the grants in agent.py, the channel block list and the route registration. I did not run the suite locally.

Nothing blocking. The gate extraction keeps the inline order (identity before resolution, surface after), the broadcast audience is read from the same _created_by field the fence reads, every delivery still goes through send_to_target → authorize_target, session_broadcast is granted only to members (not the goal/pipeline conductors), and both verbs are on the channel-agent block list. The post-suspension caller re-check in both verbs is a good catch.

[code-reviewer] 🟡 [Correctness]: session_status silently drops a live worker whose containment changed, which is the failure this PR exists to prevent

In created_session_status, a live slot that is not in _broadcast_resolution_slots hits continue with no row and no counter. That covers a worker the user later linked or mirrored to a channel, or one whose workspace moved. A tree-attested worker in that state is neither gone nor listed, and neither tree, history_omitted nor roster_omitted changes, so a patrol reads a complete roster that is one short. That is the scenario in "Why it matters": "A patrol sees seven live workers, decides the eighth finished, and never re-dispatches it." Dropping the TITLE is right (it can be channel-derived), but dropping the ROW isn't needed for that. gone rows already show that a key-only row is safe. Suggestion: emit {"target": key, "status": "unreachable", "source": ...} with no title/queue fields (or at minimum a withheld count), and update test_a_worker_linked_to_a_channel_after_birth_is_not_listed / ..._mirrored_... to assert the title is absent rather than the row.

[code-reviewer] 🟢 [Consistency]: the timeout observation resolves the name unrestricted

broadcast_to_targets builds resolution_slots so a guessed private title never resolves, then the per-target loop calls _resolve_slot(state, name) with no candidates to get timeout_slot. On a timeout before authorization, that picks between "not handed over, safe to re-send" (a slot exists) and "target is unavailable" (none does), so it reveals whether a private title exists. That's the same oracle session_send already has, so it's minor. But passing candidates=resolution_slots costs nothing and keeps the loop consistent with the dedup step above it.

[code-reviewer] 🟢 [Description]: PR body states the cap as 32; the code and both docs say 50

The "What changed" table lists MAX_BROADCAST_TARGETS | 32, but validation.py sets it to 50, and docs/system-specs/modules/session-control.md and src/kiro_crew/docs/session-control.md both say 50 (the comment above the constant also works out 50 → 260s). Review bots read the body, so worth correcting.

Verified clean, for the record:

  • _resolve_slot's new candidates=None default path is behaviour-identical: the direct key lookup is additionally checked for membership in state._slots, and get_slot only returns registered slots.
  • Handler bounds on targets (type, count, per-element length) run before any resolution; targets=[] / all-blank lists reach target_required, never the default audience.
  • MAX_BROADCAST_TARGETS (50) ≤ MAX_SLOTS_PER_CREATOR (50), so the default-audience cap refusal is unreachable as the comment claims.
  • Client request budget (cap × 5s + margin) exceeds the backend's worst case, so a full fleet cannot lose its per-target report to the client timeout.

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving at this head. The three notes in my earlier comment are non-blocking: the silently dropped session_status row for a worker whose containment changed (🟡), the unrestricted timeout-observation lookup (🟢), and the stale cap of 32 in the PR body (🟢). They are fine as follow-ups.

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.

3 participants