Repository navigation
Conversation
UX Review (Opus 5.5, fork) — ⏭️ skippedRevision |
Design Review (Opus 5.5, fork) — ✅ PASSDesign-level review of Design-Verdict: PASS Check that a runtime replaced after a ceiling cut loses the cut-off request. The fix for that is deferred to #21223, so the agent's next turn won't know what it was doing. [DESIGN-REVIEWED] 48c1e6e Description read[DESCRIPTION-READ] 96f410e82140e8b7de0ef4219e53785a911c3f928b95b08476a0ad95c37b251e 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, fork) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Check before merge: counting What this change shipsInventory (8 items) — 8 justifiedIntent: when the backend stops answering a dashboard chat, the next message should recover instead of hanging until the turn ceiling again. This is a FIX.
[FIRST-PRINCIPLES-REVIEWED] 48c1e6e Description read[DESCRIPTION-READ] 477c0a5a51c3a86b4a96af0776776e1853f938ede577b26f6388a8fa92d8b54e That sha256 names the PR description this verdict read. Recompute it with |
GPT 6.1 Review (fork) — ✅ no blocking findingsReviewed Review detailsNo findings. |
Opus 5.5 Review (fork) — ✅ no blocking findingsReviewed |
|
Agreed, and fixed in the second commit, 957a307. The new |
957a307 to
20f2a65
Compare
iamwhatever
left a comment
There was a problem hiding this comment.
This PR resets a dashboard chat's runtime when the turn hits the dashboard ceiling, or ends with the transport's stop_reason "timeout", so the next message does not wait out the ceiling again on a silent backend. The idea is right, but two findings on head 20f2a65 are real and have no answer (the author's reply covers the persistence finding from an earlier round, not these). First, a regression for linked surfaces. The new if _stop_reason == "timeout": ... return arm (chat_runner.py ~15988-16026) returns before the Slack mirror leg and before _deliver_cross_surface_reply (~17831). On main a "timeout" turn fell through to both. Now a chat driven from a linked Slack thread or Telegram gets neither the partial reply nor the timeout notice. Fix: deliver the notice and the persisted partial text to the linked surface before returning, the way the AcpAuthRequired arm does. Second, turn_deadline_passed() (turn_dispatch.py:88) decides "the ceiling cut this turn" from the clock. _bounded_turn's own docstring rejects that, and it already records the observed fact in deadline_fired. A tab-close, idle-sweep or shutdown cancel that lands after the deadline but before the timer callback runs, which happens on a busy loop, reads as a ceiling cut and cold-starts the reopened chat this PR's "Not a goal" promises to keep. Fix: publish deadline_fired (a mutable holder in the ContextVar) and read that. Please also answer the Design question of whether a healthy turn whose native cancel came back "acked" should lose its runtime. — crew-pr-reviewer (deep re-check)
20f2a65 to
2fd7d86
Compare
|
Thanks, all three are addressed in 2fd7d86, folded into the second commit so the PR stays at two. 1. Linked surfaces. Agreed: the 2. Clock. 3. An acknowledged stop. No, that runtime should keep its session, and now does. The 16 items: red on main 7 failed and 9 passed, red on the previous head 4 failed and 12 passed, green here 16 passed, 3 of 3 runs each. Whole file: 389 passed, 3 of 3. The 239 test files that name |
|
The new commit replaces the short fixed waits that the repo's wait-discipline ratchet (test/test_wait_discipline_ratchet.py) rejects in test/test_chat_runner_coverage.py; it changes that file only. |
a168cad to
2b5e01d
Compare
|
Both review points on 6649e3a are answered on the current head, 38ef102, which is the split revision 2b5e01d plus one commit. The split (my comment above) removed the interrupted-turn restore carry from this PR, so two of the points name state that is no longer here; the evidence for each is below.
The PR body's transport-timeout clause and its test list are updated for the shared notice and the new test. |
|
span=aebe770cf81d
|
|
span=08121ccb9775
|
iamwhatever
left a comment
There was a problem hiding this comment.
REQUEST_CHANGES at f555fee.
The runtime retirement itself looks right. The ceiling arm resets only when the timer recorded in _TurnCut fired and the native stop went unacknowledged, a close no longer races the timer, and the transport-timeout arm keeps the streamed reply, its footer and the linked-surface fences. Our earlier points (linked surfaces, clock-based cut, /clear restore, docstring) are fixed or no longer apply after the split.
Please fix before this can be approved:
- The ceiling card now contradicts the fix. format_turn_timeout_card says 'Do not resume this session until it becomes idle' for every outcome in _UNACKNOWLEDGED_CANCEL (turn_dispatch.py#L410-L416). Those are exactly the outcomes that now reset the runtime (ceiling_cut_unacknowledged, chat_runner.py#L16630). So the user is told to wait when the next message is the recovery this PR adds. Smallest fix: when the reset is taken, show the 'send a message to continue' wording, for example by passing the reset decision into format_turn_timeout_card, and add a test for it. This is the Opus lane's open finding at this head, which has no disposition yet.
- The restore of the cut-off turn's request and partial answer is deferred to a follow-up PR (Not a goal), but no issue is linked. Please open one issue that covers it, including the two GPT findings left open on the carry, and link it in the description.
This PR also adds new paths that kill and replace a chat runtime, so a human reviewer needs to sign off after these are fixed.
— crew-pr-reviewer (r106)
…swered A dashboard chat turn whose backend went silent before it streamed anything ended only at a ceiling, and the slot kept that runtime. The stale-turn probe arms after a first text chunk or tool result, so a turn silent from its start never produced the stale-recover stop reason that resets the session. The dashboard ceiling's cancel and the transport's "timeout" stop reason both left needs_session_reset unset. The silent runtime still read alive, so the next message was sent to it and waited out the whole ceiling again, on every message. The "timeout" stop reason also showed the user nothing. The ceiling's CancelledError arm now sets needs_session_reset when ceiling_cut_unacknowledged() answers True: the ceiling's timer fired for this turn and the native stop it sent ended "timeout", "no_turn" or "error", the outcomes the timeout card already words as unacknowledged, now one constant both read. An acknowledged stop ended the native prompt, so that runtime keeps its session, as stop_turn keeps the runtime of an acknowledged Stop. The finally's existing reset keeps the conversation and replaces the runtime, as it does for stale-recover. The arm reads the cut from the wrapper, not the clock. _bounded_turn keeps one _TurnCut record per guarded turn, publishes it in a ContextVar, and records in it that its timer fired and how the native stop it sent ended, before it cancels the turn's task. An outside cancel the wrapper handles first disarms the timer, which could otherwise run in the same loop pass, record a cut and send session/cancel for a turn a close ended. A closed tab, the idle sweep and shutdown keep their session, as does the user's own Stop. The timeout card follows what the arm did. It used to tell the user not to resume until the session was idle for every unacknowledged outcome, but those outcomes now replace the runtime, so the next message is the recovery. When the arm sets the reset it also records that on the turn's _TurnCut (mark_ceiling_reset), the wrapper carries it on TurnTimeoutError, and format_turn_timeout_card takes it as session_reset: a replaced runtime is told to send a message to continue, while a cut that kept its runtime after an unacknowledged stop still gets the warning. A turn the transport ends with the "timeout" stop reason resets its session too. That arm first saves the text the backend streamed as the interrupted reply through _persist_partial_reply, since a save writes no chunk row, attaches the footer the end-of-turn path attaches, through the same owned-row writer, and appends UNFINISHED_TURN_NOTICE, the notice the channel driver already posts for a timed-out turn. It returns before the end-of-turn legs that take a reply to Slack and to a channel such as Telegram, so those two legs move unchanged into one nested helper, _deliver_to_linked_surfaces, called at the end of the turn and by the arm, which sends the kept reply and then the notice through the same audience fences. A normal end_turn is unchanged. The ceiling tests run the turn under a long ceiling, wait until the stream has started, and then move the loop clock past the turn's deadline so the ceiling's own timer fires, so a slow start on a loaded runner cannot let the timer land before the turn holds its slot.
|
Both points on f555fee are handled on this head.
The sign-off on the paths that replace a runtime stays with a human reviewer. |
|
span=e48125549479
|
|
|
|
HOLD at 48c1e6e for human review. Both points from our r106 review are fixed. First, the timeout card now says the runtime was replaced and to send a message whenever the ceiling arm took the reset (turn_dispatch.py#L434, set at chat_runner.py#L16671). A cut that kept its runtime still gets the wait warning. Second, the deferred restore is #21223, which covers the restore and both open GPT findings and lists acceptance criteria. All AI lanes pass on this head, and the Design and First Principles punchlines have answers backed by code. I found no new defect, and all checks are green. This PR adds paths that reset a session and replace its chat runtime, and it moves the Slack and cross-surface audience fences into a shared helper. A human reviewer needs to sign off. Our earlier CHANGES_REQUESTED review should be dismissed or superseded once that sign-off is given. — crew-pr-reviewer (r107) |
|
Closing without merging, to keep my open PRs to the ones close to landing. The Oct 16 hold found both review points fixed and left this head (48c1e6e) for human review. Since then it has started conflicting with main's split of The runtime retirement isn't on main as of 2e50054. I've deleted the branch; it can be restored from this page at 48c1e6e. |
Problem / Motivation
Goal: A dashboard chat whose backend stopped answering recovers on the next message, instead of hanging for the whole turn ceiling on every message after that.
When the backend goes silent before it streams anything for a turn, the turn ends only at a ceiling: the dashboard's own wall-clock ceiling (
agent.chat_turn_timeout_secs, 4 hours by default), or the ACP transport's own deadline, which ends the turn withstop_reason="timeout".The stale-turn probe that would end such a turn earlier, and reset the session (
STOP_REASON_STALE_RECOVER), never arms:AcpSessionHandlearms it only after a first text chunk or a finished tool.Neither ceiling ending made
_run_chatreset the slot's session. The silent runtime still reads alive, so the session manager reuses it, and the user's next message is sent to it and waits out the ceiling again.The transport's
"timeout"ending also showed the user nothing: the slot was left with no reply and no notice.Why it matters
A user whose backend hangs sees a turn that lasts the whole ceiling and ends with the "This turn hit the ... limit" card. The card says to send a message to continue. That message hangs for the same ceiling, and so does every one after it, until the user resets the chat or restarts the gateway. With the transport ending, the user does not even get the card.
Not a goal
end_turnis unchanged, and a control test pins this.session/load, which holds the turns the backend answered; the cut-off turn stays in the chat transcript and the saved history, and the next prompt carries no restore of it.session/cancelto the backend at the ceiling is PR fix(dashboard): cancel native turns before timeout unwind #18417's change, not this one. See Related Issues for how the two compose.What changed (motivation → approach → change)
In short: a ceiling cut resets the session only when the native stop the ceiling sent got no acknowledgement, which
_run_chatreads from a record_bounded_turnkeeps for the turn instead of from the clock, and the timeout card then tells the user to send a message instead of waiting; a transport timeout resets it too, keeps the reply that streamed with its footer, and sends that reply and a notice to the linked surfaces through the end-of-turn legs. Red onorigin/main, green here, 3 of 3 runs each (output under Tests)._run_chat(src/kiro_crew/dashboard/chat_runner.py) resets the session in itsfinallyonly whenneeds_session_resetis set. The ceiling unwinds into theCancelledErrorarm, which set no reset; the"timeout"stop-reason arm only recorded theTURN_TIMEOUT_CAUSEmetric. OnlySTOP_REASON_STALE_RECOVERset it. The session manager's reuse check is the provider'sis_process_alive(), which a silent runtime passes._run_chatand in_bounded_turn:CancelledErrorarm, a cancel that is not the user's Stop (read live through_stop_pressed()) setsneeds_session_reset = Trueonly whenceiling_cut_unacknowledged()answers True (dashboard/chat_runner.py:16671, defined atdashboard/turn_dispatch.py:125): the ceiling's timer fired for this turn, and the native stop it sent (session/cancel, added by fix(dashboard): cancel native turns before timeout unwind #18417) ended"timeout","no_turn"or"error". Those are the outcomes the timeout card already words as unacknowledged; the set is now one constant,_UNACKNOWLEDGED_CANCEL(dashboard/turn_dispatch.py:57), which the card reads too (dashboard/turn_dispatch.py:442). An"acked"stop ended the native prompt (with a positive wait, which the ceiling passes,providers/acp_turns.py:240answers"acked"only for acancelledorend_turnstop reason), so that runtime answered and keeps its session, asstop_turnkeeps the runtime of an acknowledged Stop. A ceiling with no owned native turn to stop (outcomeNone) keeps the session too. The other involuntary cancels keep it as before, and the user's Stop takes its own branch and keeps it, as before._bounded_turnkeeps one_TurnCutper guarded turn (dashboard/turn_dispatch.py:70) and publishes it beside the deadline in the context variable_TURN_CUT(dashboard/turn_dispatch.py:674), so code inside the turn reads what the wrapper observed instead of the clock. The record replaces the wrapper's localdeadline_firedflag, andcut.firedis still set only by the timer (dashboard/turn_dispatch.py:627). The native outcome is written before the wrapper cancels the turn's task (dashboard/turn_dispatch.py:615), so it is there when that cancel reaches_run_chat; a native request cancelled before it settles is recorded as"error", as_settle_deadline_cancelalready reports it (dashboard/turn_dispatch.py:654). A close cancels the guarded wrapper, and the wrapper then cancels the inner task. The wrapper's wakeup and a timer that has come due run in the same loop pass, so the timer could run next, while the inner task was still unwinding, and sendsession/cancelfor a turn the close ended. The wrapper now disarms its timer before it cancels the inner task (dashboard/turn_dispatch.py:705), so a cut is recorded only for a turn the timer reached first.format_turn_timeout_cardwords an unacknowledged stop two ways, by whether the turn's handler replaced the runtime (dashboard/turn_dispatch.py:434,:442). The ceiling arm records the reset on the turn's_TurnCutright after it setsneeds_session_reset(mark_ceiling_reset(),dashboard/turn_dispatch.py:144, called atdashboard/chat_runner.py:16673),_bounded_turncarries it onTurnTimeoutError.session_reset(dashboard/turn_dispatch.py:699,:718), and the card reads it. A replaced runtime gets "The native agent did not acknowledge the stop request, so its runtime was replaced and any tool it was still running ended with it. Work already written to disk is still there — nothing was rolled back. Send a message to continue." plus the limit hint, because the next message is the recovery. A cut that kept its runtime after an unacknowledged stop (the user's Stop racing the ceiling, or a turn that returned normally after the cut) takes no reset and keeps the old warning, "Do not resume this session until it becomes idle". An acknowledged stop and a ceiling with no native turn to stop keep the card they had._stop_reason == "timeout"(dashboard/chat_runner.py:14821): it setsneeds_session_reset = True, appendsUNFINISHED_TURN_NOTICE(messaging/empty_turn_copy.py:64, the notice the channel driver already posts for a"timeout"turn atmessaging/driver.py:1134) as an error entry, and returns, as the other terminal stop reasons do. That completion is the ACP handle's own: its deadline passed with no complete, and it sends nosession/cancel(acp/session_handle.py:6076), so the native prompt is still open whether or not text streamed, and the runtime still reads alive. The message is not re-queued: the user decides what to send next._persist_partial_reply("timeout")(dashboard/chat_runner.py:14830), the helper every other abnormal end uses. Text the backend streamed before the deadline is in the slot only as chunk rows, which a save does not write, so without it the saved history and the crew log would lose that text. The turn's usage row needs nothing more: the timeout'sEVENT_COMPLETEcarries the turn's stats, the complete branch writes the row from them, and the helper finds it recorded and writes no second. The arm then attaches the footer the end-of-turn path attaches (_attach_owned_turn_stats, with the event's elapsed time, credits and cost, the served model, and the time to first visible output). The footer edits the row's meta only.dashboard/chat_runner.py:14864). It returns before the end-of-turn legs that take a reply to a session linked in Slack and to one linked to a channel such as Telegram, which main ran for a"timeout"turn. Those two legs moved unchanged into one nested helper,_deliver_to_linked_surfaces(dashboard/chat_runner.py:8256), called at the end of the turn (dashboard/chat_runner.py:16641) and by this arm; the only edit is the parameter name. So the arm's text passes the same audience fences (cross_surface_withheld,slack_publication_withheld, andpublication_withheldinside_deliver_cross_surface_reply) and the same redaction as a finished reply.finallypath (await state.sessions.reset(session_key)), which keeps the conversation and replaces the runtime, as it already does forSTOP_REASON_STALE_RECOVER. No new store or file call runs on the event loop: the change sets one local and one record field, appends in-memory slot entries and edits one row's meta, and makes the same awaited sends to the linked surfaces the end-of-turn legs make.docs/system-specs/modules/session.mddescribes the reset, the record and the transport-timeout arm besidecancel_owned_turn.Rejected alternatives:
model_silent_probe_secswindow exists to protect.finish_turn_taskinturn_dispatch.py: it runs after the turn task is done, outside the turn's session bookkeeping, and the transport's"timeout"ending never reaches it.turn_dispatch.pymodule docstring names a babysit loop polling a pull request) would lose its runtime every time.loop.time()against the turn's deadline) in theCancelledErrorarm: a close, the idle sweep or shutdown can cancel a turn after its deadline has passed but before the ceiling's timer has run, and that cancel would read as the ceiling and cold-start a reopened chat._deliver_linked_slack_message, as the auth-required arm posts its notice: that helper applies no audience fence, and the reply is model text the end-of-turn Slack leg fences.TurnTimeoutError.native_cancel_outcomein_run_chat: the wrapper raises it after_run_chathas returned, too late for thefinallythat resets.Backwards compatibility
Compatible: a turn the ceiling cut while its native stop went unacknowledged, and a turn the transport's
"timeout"stop reason ended, now reset their session the way a stale-recover turn already does; the runtime that replaces it resumes the conversation. On main the next message went to the silent runtime; after a ceiling cut that session also carriedprev_turn_cancelled(cancel_owned_turnarms it for every outcome), and the reset discards that session, so the next prompt carries no cancelled-turn restore. The timeout card for a cut whose runtime is replaced no longer tells the user to wait: it says the runtime was replaced and to send a message to continue. A ceiling cut the native runtime acknowledged keeps its session, as on main. A timeout after part of an answer streamed keeps that text as the interrupted reply, with the footer main shows on it, followed by the notice; its usage row is written once, as on main; and a session linked in Slack or to a channel such as Telegram gets that reply, as on main, then the notice. One timing change in_bounded_turn: an outside cancel the wrapper handles before its timer has run now disarms the timer, so that turn records no cut and sends nosession/cancel; on main the timer could still run in the same loop pass and send it. A turn the user stops, and a turn that completes, are handled as before.Removes nothing: the wrapper's local
deadline_firedflag becomes thecut.firedfield of the new_TurnCutrecord, read the same way at every former use. Adds_TurnCut(with itssession_resetfield),_TURN_CUT,_UNACKNOWLEDGED_CANCEL,ceiling_cut_unacknowledged(),mark_ceiling_reset(), the optionalsession_resetparameter offormat_turn_timeout_cardand_report_turn_timeout,TurnTimeoutError.session_resetand the nested_deliver_to_linked_surfaces, which holds the two legs moved from the end of_run_chat.Tests
The new tests sit in
test/test_chat_runner_coverage.py, classTestRunChatRecoveryLadders, beside the stale-recover tests, on the file's_runner_stateand_set_streamharness (the real_run_chat, a scripted client), under the real_bounded_turnwherever a ceiling is involved; and intest/test_turn_dispatch.py, classesTestTimeoutCard,TestCeilingCutPredicatesandTestFinishTurnTask.test_a_turn_cut_by_the_ceiling_resets_the_session[timeout|no_turn|error]: a stream that never yields, under a 0.5 s ceiling whose native stop returns that outcome.TurnTimeoutErrorcarries the outcome,reset("dashboard:chat-cov-1")is awaited once, and the card posted for that exit says to send a message to continue and not "Do not resume".test_a_ceiling_cut_the_runtime_answered_keeps_the_session[acked|None]: the same turn, with"acked"and with no owned native turn to stop. No reset, and the card is the stopped-and-continue card.test_a_cancel_after_the_deadline_before_its_timer_keeps_the_session: a close cancels the guarded task, then the loop clock moves past the deadline before the loop runs again, so the ceiling's timer is due in the same pass. No native stop is sent and no reset runs.test_a_transport_timeout_resets_the_session_and_says_so: anEVENT_COMPLETEwithstop_reason="timeout". The reset is awaited once, the notice is shown, nothing is re-queued.test_a_transport_timeout_posts_the_shared_unfinished_turn_notice: the error entry isUNFINISHED_TURN_NOTICEitself, not a spelling of its own.test_a_transport_timeout_keeps_the_reply_it_streamed: a chunk, then the timeout. The saved history holds the streamed reply before the notice, and the crew log gets it once as interrupted.test_a_transport_timeout_bills_the_turn_once: the timeout event carries usage; one usage row, with stop reasontimeout.test_a_transport_timeout_keeps_the_cost_footer: the reply's footer holds the event's elapsed time and credits and the time to first output.test_a_transport_timeout_reaches_the_linked_surfaces: a Slack-linked session gets the echo, the reply, then the notice in its thread, and the channel leg gets the reply then the notice.test_a_finished_reply_reaches_the_linked_surfacesandtest_a_transport_timeout_keeps_the_slack_audience_fence: controls for the moved legs; a finished reply reaches both surfaces once, and a fenced turn posts neither reply nor notice.test_a_users_stop_does_not_reset_the_session,test_an_involuntary_cancel_before_the_deadline_keeps_the_session,test_a_normal_end_turn_does_not_reset_the_session: controls; no reset.TestTimeoutCard: an unacknowledged stop that kept its runtime keeps "Do not resume this session until it becomes idle", one that replaced its runtime says the runtime was replaced and to send a message to continue, and an acknowledged stop reads the same either way.TestFinishTurnTask::test_a_turn_that_replaced_its_runtime_is_told_to_send_a_message: the real_bounded_turnandfinish_turn_task; a turn whose handler callsmark_ceiling_reset()after an unacknowledged stop gets the send-a-message card.TestCeilingCutPredicates: the predicate per outcome, a timer that never fired, no guarded turn, andmark_ceiling_reset()outside a guarded turn changing nothing.Red on
origin/main(the two test files copied onto it, the 33 new or changed tests selected by name), 3 of 3 runs, every run the same 21 failures:Green here, 3 of 3 runs:
33 passed, 437 deselected, 19 warnings in 4.12s. The two touched test files whole:470 passedin each of three runs at-n 0.Mutants, each run against the same selection: the ceiling arm's reset removed fails only the three
test_a_turn_cut_by_the_ceiling_resets_the_sessioncases; the transport arm's reset removed fails onlytest_a_transport_timeout_resets_the_session_and_says_so; the transport arm's_persist_partial_reply("timeout")removed fails onlytest_a_transport_timeout_keeps_the_reply_it_streamedandtest_a_transport_timeout_keeps_the_cost_footer; the ceiling arm'smark_ceiling_reset()removed fails the same three reset cases, on the card assertion.Also green on this head:
test/test_dashboard_approval_window.py,test/test_prompt_timeout_follows_ceiling.py,test/test_turn_harness.py,test/test_session_turn_timeout.py,test/test_chat_slot_reset_conversation.pyandtest/test_session.py(627 passed); the wait-discipline, flake-pattern, pid-reader, tmpdir-helper and dir-fd-create ratchets at-n 0(132 passed);scripts/check_agent_sdk_boundary.py;black --check,isort --check-onlyandflake8on the touched files;scripts/check_comment_history.pyagainst the merge base;scripts/docs_lint.py --testandscripts/docs-lint.sh.Manual verification
N/A — unit coverage sufficient: the tests drive the real
_run_chatand the real_bounded_turnwith only the client scripted, and assert on the session manager call and the slot entries.Screenshots / video
N/A: no frontend file changes; the one new user-facing text is a chat error row, quoted under What changed.
Related Issues
#18417 ("cancel native turns before timeout unwind"), now merged, made the ceiling send
session/cancel, wait a bounded time for the outcome, then cancel the Python task, and word the card by that outcome. This change reads the same outcome: it resets the session only when the card says the stop was not acknowledged, and keeps it when the native prompt acknowledged it. Itscancel_owned_turnrecords no Stop (it callsprovider.canceldirectly, notstop_turnornote_stop), so_stop_pressed()stays False for the ceiling's cancel.Open issue #4756 (turn ceiling strands unattended work; auto-continue) is a different concern: continuing after a ceiling.
GitHub search (
gh search prsandgh search issues --repo kirodotdev/KiroCrew, open and merged) for "chat turn ceiling reset session", "turn timeout reset runtime", "stale_eligible", "silent backend chat" and "stale recover first chunk" found nothing on this defect.Pattern harvest
Rule candidate: review-prompt
Pattern: a recovery that keys on one terminal stop reason leaves every other ending that cannot reach it on the old path; when a watchdog cannot arm (no first frame), the ceiling endings must apply the same retirement rule.
Checklist
feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)Contribution License Agreement
Contributed under the project's Apache-2.0 license.