Skip to content

fix(chat): never hold the session's own messages behind sub-agents - #21369

Merged
kyleseaman merged 2 commits into
mainfrom
fix/chat-past-subagent-hold
Nov 7, 2026
Merged

kyleseaman merged 2 commits into
mainfrom
fix/chat-past-subagent-hold

Conversation

@kyleseaman

@kyleseaman kyleseaman commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A person can keep talking to their own session while its background sub-agents run, instead of their messages waiting until every sub-agent finishes.

A message typed into a session's composer while sub-agents were still running was parked in the queue until the last child finished, unless the composer's busy-send mode was Steer. With the default Queue choice, or with a Queue card sent while the main turn was running, the session looked impossible to talk to: an hourglass card sat under the transcript for the whole wave, and the only way out was spotting the card's Run-now button.

Why it matters

Sub-agent waves routinely run for many minutes. During that time the main agent is idle or only digesting results, yet the person who owns the session cannot ask it anything. The Queue setting's own description says "Queue waits for the turn to finish", and background sub-agents are not that turn, so the behaviour contradicted the setting it was driven by.

Not a goal

  • Releasing automated input past the hold: a peer session's session_send, a messaging-channel message, an app's send, and a loopback internal-secret send (an MCP tool or a cron script's send_to_session) all still wait for the wave.
  • Changing how sub-agent results are delivered, ordered or summarised.
  • Any composer, button or setting change.

What changed (motivation → approach → change)

Your own messages no longer wait for background sub-agents. Typed while only sub-agents are running, a message starts a turn at once, whatever the busy-send mode. Queued while the main agent is mid-turn, it runs when that turn ends.

You send while… Before After
sub-agents run, main agent idle, mode Queue parked until every sub-agent finishes starts a turn now
main agent mid-turn, you pick Queue (or auto picks it) waits for the turn, then for every sub-agent runs when the turn ends
a peer, channel, app, MCP tool or cron script sends waits for the wave unchanged

The hold parked every user message and let only system injections through; a steer that missed its turn was the one exception, marked meta.steer_intent. That mark is now meta.composer_send (COMPOSER_SEND_META in chat_utils_injected_rows.py) and api_chat (chat_api/chat_send.py) stamps it on every composer send that reaches the queue, including one queued behind a message parked while its child was live, so releases_past_subagent_hold lets it drain at the turn's end. Two holds main added since keep their force: while an open queue editor holds the queue (queue_edit_hold), the drain (_start_next_queued_turn) takes system injections only and a named card passes only through Run now, so a marked composer send waits behind the edited card; a deferred conversation discard (teardown_hold_active) already drains system injections only. A send counts as the composer's only when token_auth gave it the positive is_dashboard_user mark (a validated dashboard token with no app claim), so an MCP tool, a cron script or any future caller nobody marked still waits; on an idle slot the hold now applies only to those other sends. _start_next_queued_turn (chat_runner.py) also runs a card the turn-end read hands the floor (required_queue_id) when the hold releases it, where it used to refuse every card under the hold.

A parent turn the person starts can now run while children still edit files, which Steer already allowed on the base: the person chose to talk to the session, and holding them is the defect. Continue still refuses while children run, because it replays the interrupted turn's own unfinished work as runner-authored input rather than carrying the person's new words. Sub-agent results still reach the main conversation the same way: one that lands during your turn waits for it, then runs as its own turn, and your messages and results drain one turn each in arrival order. The session and learn-cron-dashboard system specs describe the new rule, and chat_api/continue_turn.py's comment names which sends api_chat still holds.

Backwards compatibility

Breaking: the queue-entry meta key steer_intent is renamed composer_send. A steer queued on an older gateway that survives the restart as a restored entry waits for its wave once instead of running at its turn's end, and its drained row keeps the stale key, which no reader consults. Writer sweep on origin/main @ 9fba246: chat_delivery.queue_for_next_turn and chat_turn/steer_queue._requeue_unconsumed_steers were the only writers; both now write composer_send; the slot ladder comment (state_parts/slot_ladder.py) names the new key.

Reader: src/kiro_crew/dashboard/chat_utils_injected_rows.py:releases_past_subagent_hold -- chat -- reads COMPOSER_SEND_META; test_queue_during_subagents.py::TestDequeueSteerIntent
Reader: src/kiro_crew/dashboard/chat_runner.py:_start_next_queued_turn -- chat -- pops COMPOSER_SEND_META before writing the row; test_queue_during_subagents.py::TestSteerFallbackSurvivesTheHold::test_unconsumed_steer_drains_while_children_run
Reader: src/kiro_crew/dashboard/slot_queue_repository.py:sanitize_restored_queue -- chat -- strips COMPOSER_SEND_META from a restored entry (main's #22224 strip, renamed); test_queue_drain_revalidation.py::test_a_restored_entry_loses_its_composer_send_mark
Reader: src/kiro_crew/dashboard/chat_utils.py facade -- chat -- re-exports COMPOSER_SEND_META; STEER_INTENT_META leaves test/campaign_facade_inventories/kiro_crew.dashboard.chat_utils.json on purpose; test_campaign_facades_base_public_names.py

Tests

  • test_queue_during_subagents.py: a Queue send made mid-turn carries the mark and runs at the turn's end while a peer message stays parked; a turn-end card runs under the hold only when it is the person's own; a sub-agent result and a follow-up drain in arrival order both ways round while a sibling still runs; an idle composer send starts a turn while a child is live.
  • test_chat_mode_security.py: an app's send is still held, and the gate queries the slot's parent key.
  • test_queue_during_subagents.py::TestApiChatSubagentQueueGate::test_send_behind_parked_message_carries_composer_mark: a composer send queued behind a parked message carries the mark (so a hold the drained turn reinstates still releases it); a non-composer one does not.
  • test_queue_during_subagents.py::TestApiChatSubagentQueueGate::test_non_composer_send_is_held_by_running_subagents: an internal-secret send, and a send carrying no mark at all, is held on an idle slot and queued without the mark on a busy one.
  • test_queue_drain_preserve_attachments.py / test_queue_drain_preserve_send_id.py: the hold branch's sendId and attachment lists are proven through the branch a composer send still reaches (a stalled child with a parked message ahead).
  • Reverting each production hunk turns its new tests red, including the unmarked-caller case when the rule falls back to reading what a send lacks.
  • Determinism: the changed tests ran 20 times at -n0 and 10 times at -n 4 --dist loadgroup --max-worker-restart=2 with two sibling files, all green; a shuffled run of the three queue files (seed 20875, 98 tests) passed.

Manual verification

N/A — unit coverage sufficient: the change is the queue's hold and drain decisions, which the tests drive through /api/chat and _start_next_queued_turn directly; no UI changed.

Related Issues

No tracking issue: opened directly at the maintainer's request.

Pattern harvest

Not generalizable: the hold encoded a product rule (Queue waits for the wave) that was itself the defect, not a reusable code shape.

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

@kyleseaman
kyleseaman requested review from a team and KiroCrewCaptain as code owners October 16, 2026 20:20
@kyleseaman

Copy link
Copy Markdown
Contributor Author

Local pre-push review on 2577d69 (content-identical rebase of ae4f6287f0): GPT lane and Opus lane both no findings; the Opus lane's rejected candidate (internal-secret callers skipping the hold) was tightened anyway, and a focused verifier confirmed it. One Low left on purpose: an internal-secret POST with steer=true that its turn ends before consuming is requeued with the composer mark (steer_into_running_turn's user_origin covers internal callers). No shipped caller sends steer that way, and narrowing user_origin would change unrelated provenance rules, so it stays out of this PR.

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 16, 2026
@github-actions

github-actions Bot commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision cee497aa65cb997c46779bb0c9e29f05baefad47 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Does not block merge.

@github-actions

github-actions Bot commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of cee497aa65cb997c46779bb0c9e29f05baefad47 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks: the rule being reversed is named as the defect, at the maintainer's request, and the other holds (editor, discard, crew pause) still apply in the drain.

Notes

  • Deleting test_queue_choice_still_waits_for_the_wave reverses a pinned rule, and docs/decisions/ has no entry recording it. Adding one would stop a later "regression" fix from quietly putting the hold back.

[DESIGN-REVIEWED] cee497a

Description read

[DESCRIPTION-READ] d5b36a5a76365698730b69f734c8b060f33bf384ecc28cc609127f81dfbde12f

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 .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of cee497aa65cb997c46779bb0c9e29f05baefad47 — 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 does not.

First-Principles-Verdict: PASS

Nothing blocks. The one open question is whether a reversed default needed a recorded decision. The description argues it restores the setting's documented meaning, so this is a note, not a blocker.

Notes

  • Item 2 — inherited (product shape, no record): the diff deletes the pin test_queue_choice_still_waits_for_the_wave and the base spec rule "an auto send Jev decided to queue all wait for the wave". That changes what the default Queue mode does during every sub-agent wave. The description's support is "opened directly at the maintainer's request". That is not a non-draft RFC or an /ai-review override on this head. The only RFC on the base list that touches this area (rfc-subagent-backend-selection) is draft.

What this change ships

Inventory (9 items) — 8 justified

Intent: let a person keep talking to their own session while its background sub-agents run. This is a FIX.

  1. A message you type on an idle session with live sub-agents now starts a turn at once, in any busy-send mode — justified
  2. A Queue or auto-queued message sent mid-turn now runs when that turn ends, not after the wave — inherited (no recorded decision)
  3. A message you send behind messages parked by a stalled child carries the release mark — justified
  4. A turn-end card that is your own now runs under the sub-agent hold — justified
  5. An open queue editor now holds your marked sends behind the card being edited — justified
  6. A steer you take back to the queue keeps its release mark — undeclared
  7. Queue-entry meta key steer_intent renamed to composer_send — justified
  8. Sends from MCP tools, cron, apps, peers and unmarked callers still wait for the wave (needs a positive is_dashboard_user) — justified
  9. The session and learn-cron-dashboard specs now describe the new rule — justified

[FIRST-PRINCIPLES-REVIEWED] cee497a

Description read

[DESCRIPTION-READ] d309a5691139d62b18ad23b33e6c484d13a06685cc68f4e26339bc41669ccfdb

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

[OPUS-REVIEWED] cee497a

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

False positive or not applicable? A repository writer can comment:
/ai-review override fable cee497aa65cb997c46779bb0c9e29f05baefad47 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Oct 16, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of cee497aa65cb997c46779bb0c9e29f05baefad47 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] cee497a

False positive or not applicable? A repository writer can comment:
/ai-review override gpt cee497aa65cb997c46779bb0c9e29f05baefad47 false-positive: <reason, 20 to 500 characters>

@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Oct 16, 2026
@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch from 2577d69 to f358e90 Compare October 16, 2026 21:23
@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Who counts as the composer span=001a42d668ba
    self-added: yes
    mechanism: composer recognised by token_auth's positive is_dashboard_user mark

fixed in f358e90: _from_composer = request.get("is_dashboard_user") is True (chat_api/chat_send.py). token_auth sets that mark True only for a validated dashboard token with no app claim; the internal-secret branch returns before setting it and an app gets False.
A future /api/chat caller nobody marked now fails closed and waits for the wave; test_non_composer_send_is_held_by_running_subagents[unmarked] pins it and goes red when the rule falls back to reading what a send lacks.

@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Concurrent writes span=25c243304f69

rebutted: a parent turn racing its children's writes is the requested default, not an oversight. On the base a composer Steer already started a turn on an idle slot with children live (chat_send's not steer opt-out), so the exposure is not new; the PR extends the person's choice to Queue, and holding the person until the wave ends is the defect being fixed.
Continue stays refused while children run because it replays the interrupted turn's own unfinished work as a synthetic recovery entry (runner-authored input, the same class as other automated sends that keep the hold), not the person's new words. The description's What changed section states both, and continue_turn.py's comment names which sends api_chat still holds.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

/ai-review override first-principles f358e90: agent: maintainer decision (kseam requested this change): the session's own composer sends are never held behind background sub-agents; Queue means after the current turn, not after the wave; peer, channel, app, MCP and cron sends keep the hold.

@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Item 1 (Queue during a wave) span=8fb4ccd7dbff

needs-a-decision, recorded: the maintainer (kseam) asked for this behaviour change directly; the override for the current head f358e90 names the decision (composer sends are never held behind background sub-agents; automated sends keep the hold).
The base rule it reverses ("Queue waits for the wave") is what left the person unable to talk to their own session; no RFC is added because the decision is the maintainer's ruling, recorded on this PR.

@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Item 2 (mid-turn Queue) span=2ddf03164c11

needs-a-decision, recorded: the maintainer (kseam) asked for this behaviour change directly; the override for the current head f358e90 names the decision (composer sends are never held behind background sub-agents; automated sends keep the hold).
The base rule it reverses ("Queue waits for the wave") is what left the person unable to talk to their own session; no RFC is added because the decision is the maintainer's ruling, recorded on this PR.

@github-actions

Copy link
Copy Markdown
Contributor

Human judgment recorded

@kyleseaman marked the first-principles AI finding as false positive, not applicable, or explicitly accepted for f358e90d5b2558c8cc425ccafe59273e5882fe23.

agent: maintainer decision (kseam requested this change): the session's own composer sends are never held behind background sub-agents; Queue means after the current turn, not after the wave; peer, channel, app, MCP and cron sends keep the hold.

This decision applies only to this commit. A new push requires a new judgment.

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision labels Oct 16, 2026
@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Desktop and CLI clients reach /api/chat with a dashboard token (PASS punchline)

checked: the desktop app renders the same dashboard SPA and sends /api/chat with the dashboard cookie, which token_auth validates in its mixed-path branches and marks is_dashboard_user = not _app (token_auth.py, loopback and remote cookie/?token= branches), so a desktop send is released like a browser one.
No CLI command posts to /api/chat: the CLI's internal-secret calls (cli_commands._internal_secret) go to /api/spawn. The internal-secret callers that do post chat (cron send_to_session, MCP tools) are automation and keep the hold by design.

@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch from f358e90 to 2ec578a Compare October 16, 2026 22:15
@kyleseaman

Copy link
Copy Markdown
Contributor Author

/ai-review override first-principles 2ec578a: agent: maintainer decision (kseam requested this change): the session's own composer sends are never held behind background sub-agents; Queue means after the current turn, not after the wave; peer, channel, app, MCP and cron sends keep the hold.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in files next to this PR's (handlers_cloud.py and test imports; no file this PR edits) since this head went green (2245fd4 -> eb2dad9); CI re-running. Diff content unchanged; 1315 related tests pass locally.

@github-actions

Copy link
Copy Markdown
Contributor

Human judgment recorded

@kyleseaman marked the first-principles AI finding as false positive, not applicable, or explicitly accepted for 2ec578ad2e6b1623fe34d4415944eb66cb4e925a.

agent: maintainer decision (kseam requested this change): the session's own composer sends are never held behind background sub-agents; Queue means after the current turn, not after the wave; peer, channel, app, MCP and cron sends keep the hold.

This decision applies only to this commit. A new push requires a new judgment.

@kyleseaman

Copy link
Copy Markdown
Contributor Author
  • Parent turn racing its children's repository writes (PASS punchline)

answered, not checked by hand: the hold never coordinated file access. It only delayed the parent's next turn, and on the base a composer Steer already started that turn on an idle slot while children ran (chat_send's not steer opt-out), so a person-started parent turn beside live children is existing behaviour, not a new interleaving this PR creates.
What prevents a clobber is the agent itself: the parent dispatched the children and owns its own file ownership split (the spawn contract asks each task to state its file/worktree ownership and forbids overlapping writers), and a sub-agent given its own cwd/worktree writes outside the parent's tree. This PR changes when the person's message is answered, not what either side may write.

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 16, 2026
@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch from 2ec578a to 4dbc66f Compare October 16, 2026 23:14
@kyleseaman

Copy link
Copy Markdown
Contributor Author

/ai-review override first-principles 4dbc66f: agent: maintainer decision (kseam requested this change): the session's own composer sends are never held behind background sub-agents; Queue means after the current turn, not after the wave; peer, channel, app, MCP and cron sends keep the hold.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Nov 2, 2026
@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch from 2b9c17e to 86c4230 Compare November 6, 2026 19:22
@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 merge conflict Branch has merge conflicts with its base — author must resolve before merge labels Nov 6, 2026
@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch 2 times, most recently from 7fa87a7 to 7130f1b Compare November 6, 2026 21:23
@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 Nov 6, 2026
kyleseaman and others added 2 commits November 6, 2026 22:20
A message typed into a session's own composer while background sub-agents
ran was parked until every child finished, unless the busy-send mode was
Steer. The person could not talk to their own session.

The idle-slot hold in api_chat now applies only to an app's send. A
composer send queued behind a running turn carries meta.composer_send
(formerly steer_intent, set only for a steer that missed its turn), so the
sub-agent hold releases it when that turn ends. A card the turn-end read
hands the floor runs under the hold when it carries the mark. Peer,
channel and app messages still wait for the wave; sub-agent completions
keep draining in arrival order alongside the person's messages.
… them

GPT and Opus (upheld, two rounds): the composer mark passes the sub-agent hold
only, but main's edit-hold drain used that same selector, so a send queued while
a card's editor was open ran ahead of the edited card; and a composer send that
an editor queued on an idle slot with live children got no mark, so it stayed
parked behind the children after the editor closed.

While an editor or a deferred discard holds the queue, the drain takes system
injections only and a named card passes only through Run now. Every composer
send that reaches the queue carries the mark, including a steer the person
takes back to the queue (steer_retract.take_back). Tests cover each case. The
composer-send mirror wait uses the testing default timeout (Flake Pattern
Ratchet K19).
@kyleseaman
kyleseaman force-pushed the fix/chat-past-subagent-hold branch from 7130f1b to cee497a Compare November 6, 2026 22:43
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Nov 6, 2026

@bolichen97 bolichen97 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 cee497a. All checks pass and there are no change requests. The author already holds auto-merge, so I am not setting it.

What I checked:

  • _from_composer needs the positive is_dashboard_user mark from token_auth, and excludes agent-origin and cron sends. An internal-secret caller, an app, a peer's session_send and a channel message still wait for the sub-agent wave.
  • COMPOSER_SEND_META replaces STEER_INTENT_META everywhere it was read or written. The drain pops it, and sanitize_restored_queue still strips it on restore.
  • The mark changes ordering only. The deferred-discard hold and the open-editor hold both narrow the dequeue to system entries (system_only=teardown_held or edit_held). A required_queue_id card runs under the sub-agent hold only when it carries the mark.
  • A steer taken back to the queue keeps the mark (steer_retract.take_back).
  • The spec text in session.md and learn-cron-dashboard.md matches the code.
  • No new regex, and no new refusal.

@kyleseaman
kyleseaman merged commit fab339a into main Nov 7, 2026
98 of 99 checks passed
@kyleseaman
kyleseaman deleted the fix/chat-past-subagent-hold branch November 7, 2026 06:24
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Nov 7, 2026
bolichen97 pushed a commit that referenced this pull request Nov 9, 2026
…21369)

* fix(chat): never hold the session's own messages behind sub-agents

A message typed into a session's own composer while background sub-agents
ran was parked until every child finished, unless the busy-send mode was
Steer. The person could not talk to their own session.

The idle-slot hold in api_chat now applies only to an app's send. A
composer send queued behind a running turn carries meta.composer_send
(formerly steer_intent, set only for a steer that missed its turn), so the
sub-agent hold releases it when that turn ends. A card the turn-end read
hands the floor runs under the hold when it carries the mark. Peer,
channel and app messages still wait for the wave; sub-agent completions
keep draining in arrival order alongside the person's messages.

* fix(chat): keep a composer send behind other holds and marked through them

GPT and Opus (upheld, two rounds): the composer mark passes the sub-agent hold
only, but main's edit-hold drain used that same selector, so a send queued while
a card's editor was open ran ahead of the edited card; and a composer send that
an editor queued on an idle slot with live children got no mark, so it stayed
parked behind the children after the editor closed.

While an editor or a deferred discard holds the queue, the drain takes system
injections only and a named card passes only through Run now. Every composer
send that reaches the queue carries the mark, including a steer the person
takes back to the queue (steer_retract.take_back). Tests cover each case. The
composer-send mirror wait uses the testing default timeout (Flake Pattern
Ratchet K19).

---------

Co-authored-by: Kyle Seaman <kseam@dev-dsk-kseam-1b-55230d27.us-east-1.amazon.com>
(cherry picked from commit fab339a)

Backport note: #30549 (the queue edit hold) is not on release; lane 4
carries it. queue_drain.py drops the two edit_held terms (the hold-
release check and the system_only narrowing) and their comment lines,
and test/test_queue_edit_hold.py (added by #30549) stays absent with its
two new tests. chat_send.py keeps _from_composer and leaves out feat
#29928's crew_pause/_crew_paused check. When this is assembled after
#30549, restore the two edit_held terms and the two
test_queue_edit_hold.py tests from the main commit.
bolichen97 added a commit that referenced this pull request Nov 9, 2026
…bly)

#21369's lane backport dropped the drain's two edit_held terms because
#30549 (the queue edit hold) was in another lane, and its note asked for
them back once both are assembled. Without them a composer-marked send
passed the open editor's hold and ran ahead of the card being edited
(test_a_composer_send_queues_behind_a_held_entry failed).

Restore main's two terms in _start_next_queued_turn: a named card the
editor holds stays queued, and the held dequeue is system-only while an
editor is open. The two test_queue_edit_hold.py tests #21369 added on
main come with them.
bolichen97 added a commit that referenced this pull request Nov 9, 2026
…rt assembly)

#21369's new test_a_drop_during_discarded_delivery_settle_cannot_requeue
stubs the sub-agent manager with main's two slot-list readers. Release's
slot serializer also reads published_queued_labels (the queued wait
label), so whenever the hard Stop's slots push found its coalescing
window open the test raised AttributeError instead of asserting.

Add that reader to the stub, returning no labels as the depths reader
returns no depths. Test only.
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