fix(orchestrator): Keep agent output attached after a mid-turn steer

[mwolson]

Carried from another PR

• The Waiting implementation through
  fix(orchestrator): Hide Stop after runtime parks is carried for
  #4378 orchestrator-v2-background-waiting.
  Review those commits there, not here.
• fix(orchestrator): Keep agent output attached after a mid-turn steer and
  fix(orchestrator): Preserve delayed wake summaries belong to this PR.

#4378 orchestrator-v2-background-waiting
is included because both PRs change the same continuation gate in
bufferWakeMessage. On t3code/codex-turn-mapping that gate reads
!isPendingTaskNotification && !isPendingSubagentNotification && message.type !== "result";
the dependency rewrites the surrounding region and adds an
isNativeOpaqueWakeFrame clause that holds assistant and user frames until a
background-task notification has been buffered. Written against the base alone,
this PR's change would conflict with that rewrite and could drop the dependency
clause.

Stacking it makes the intended end state explicit: the two conditions are
additive, so a stranded assistant frame opens a continuation while the
background-notification gating stays intact. If
#4378 orchestrator-v2-background-waiting
merges first, drop its commits from this branch and the remaining diff applies
unchanged.

Summary

Steering a Claude turn while a tool is running settles the run while the agent
is still working. The reply to the steer then has no live turn to attach to, so
it is buffered and, with nothing asking for a continuation, silently dropped:
the thread goes quiet and returns to Ready with the steer unanswered.

There are three independent defects behind that. Fixing only the steering
handoff or only the post-settle wake leaves a real failure standing, so this
fixes the complete path.

Problem and Fix

Problem and Why it Happened	Fix
isClaudeActiveSteeringAbortResult matched only terminal_reason: "aborted_streaming", which the CLI reports when a steer interrupts a streaming message. A steer landing while a tool runs is queued instead and delivered when the tool result arrives, and the CLI ends that native turn with aborted_tools, answering the steer in the next one. That result did not match, so the turn finalized while the CLI kept working.	isClaudeSteeringHandoffResult recognises a handoff by delivery state: the CLI cut the turn short (aborted_streaming or aborted_tools), or the turn ended cleanly with nothing to say. Each accepted steer swallows exactly one result, so the turn still ends on the result that answers it.
A handoff leaves the turn depending on a native turn the CLI has not opened yet. Nothing else would terminalize it.	The wait is bounded. If no frame reaches the turn within 60 seconds it settles as a failure, not a quiet completion: an accepted steer that was never answered is exactly the silence this change exists to stop.
When a run terminalizes early while the query is still live, later assistant text goes to the wake buffer. It previously requested no continuation and could remain stranded until the session recycled.	Assistant text requests a continuation immediately when no relevant background work exists. When same-thread background work is wake-eligible, it waits for notification detail with a two-second fallback so output cannot remain stranded.
A same-thread query replacement or an unroutable offer could clear the wait owner without safely handing off the buffered output.	Preserve buffered output across same-thread replacement, cancel only the obsolete notification wait, and clear fallback ownership on every offer exit.

A result carrying text still terminalizes the turn even with a steer
outstanding, and max_turns, background_requested, tool_deferred and the
hook reasons are real terminals even as an empty success. Only completed, or
an older CLI that omits the field, means another native turn is coming.

Validation

message_steering_mid_tool is a newly recorded transcript from a real session,
not a hand-written one. It captures the shape the old guard missed: subtype: success, terminal_reason: "aborted_tools", empty text, then a fresh native
turn carrying the answer. Recording it needed a steerAfter: "tool_use" mode in
the replay recorder, waitForTurnItemType on fixture steer steps so the
replayed steer waits for the tool item instead of racing the transcript, and
stream_event acceptance in the replay decoder, since every query sets
includePartialMessages and fixtures recorded before that option have none.

Each major path was confirmed to fail with its corresponding fix reverted:

• message_steering_mid_tool replay fixture: without the guard fix the steer's
  answer never reaches the projection.
• Steer handoff keeps the turn alive; a result that answers it still
  terminalizes; max_turns still terminalizes; the bound settles a silent turn.
• Stranded assistant text requests exactly one continuation, a notification can
  add its summary before the two-second fallback, and post-settle tool frames
  request nothing.
• Same-thread query replacement preserves buffered output, failed replacement
  does not leak fallback ownership, and the no-background path offers
  immediately.

The focused Claude adapter suite passes 72 tests. vp check, the full
typecheck, and git diff --check pass on the current branch.

Live-tested on a packaged desktop build. Steering during a ~60s command, the run
now stays live 65 seconds past the steer's delivery and ends only after the last
steered reply, where it previously went terminal within about 75ms of delivery.
A second steer sent while the agent is still working is accepted rather than
refused with thread_not_sendable, and 105 status samples across the turn show
one transition, running to completed, with no blank window and no rescue
continuation run. A four-step steered instruction executed in full.

Manual re-test scenarios, in the published guide at
https://nam7nt0rbtm6.postplan.dev:

• Claude · interrupt, scenario 4 (steer a long turn twice)
• Claude · interrupt, scenario 5 (Stop while steered work is running)

Current CI Note

Test, Release Smoke, Mobile Native Static Analysis, Cursor Bugbot, CodeRabbit,
and Macroscope Correctness pass on the current head. Check is red only from the
known Vite+ stdout panic while printing warnings.

Macroscope Effect Service Conventions remains red from a claim that the queued
status rationale was removed. The rationale is still immediately above
deriveThreadActivityRun, and the review thread has the exact source
reference.

---

Note

Medium Risk
Changes core Claude turn lifecycle, wake/continuation gating, and steer counting; mistakes could leave runs stuck, double-terminal, or drop background wake detail, though coverage is heavy.

Overview
Fixes steering during a running tool and assistant text that arrives after an early turn settle so steered answers and late output are not lost on quiet threads.

Steer handoffs: Replaces the aborted_streaming-only guard with isClaudeSteeringHandoffResult, including aborted_tools and empty clean successes. Pending steers are counted per turn; each handoff result is swallowed instead of terminalizing. A 60s bound fails the turn if the CLI never opens the follow-up native turn. finalizeActiveTurn claims the active turn first to avoid duplicate terminals.

Stranded output: After settlement, assistant text in the wake buffer can trigger a continuation (immediate when no wake-eligible background work, otherwise a 2s wait for task notification detail). Post-settle tool frames still buffer without offering early. Same-thread query replacement no longer clears buffered output and continuation state the same way.

Test/replay: Adds message_steering_mid_tool fixture and recording mode active_steering_mid_tool (steerAfter: tool_use, fixture waitForTurnItemType, replay accepts stream_event). Extensive adapter tests cover handoff, timeout, continuations, and process replacement.

^{Reviewed by Cursor Bugbot for commit f3363da. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Fix agent output detachment after mid-turn steer in ClaudeAdapterV2

• Replaces the simple aborted_streaming handoff check with a broader classifier in isClaudeSteeringHandoffResult that also handles aborted_tools and empty-text completed results, preventing premature turn terminalization after a mid-tool steer.
• Tracks steer counts per turn (via a Map instead of a Set) and defers finalization until a real answer arrives or a 60s boundSteeringHandoff timeout fires, at which point the turn fails with steer_handoff_timeout.
• Detects "stranded" assistant text that arrives after turn settlement and either immediately requests a continuation (no background work) or buffers for up to 2s waiting for a task notification to own the continuation detail.
• Adds atomic active-turn claiming in finalizeActiveTurn to prevent duplicate terminal emissions.
• Adds a new message_steering_mid_tool replay fixture and associated test cases covering handoff survival, timeout settlement, stranded output continuation, and process replacement scenarios.

^{Macroscope summarized f3363da.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 029d5a06-1000-43d3-9ff2-adc5a70f010a

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces significant runtime behavior changes to turn management in the Claude adapter, including new timeout mechanisms, state tracking for pending steers, and claim-based turn finalization to handle mid-turn steering scenarios. The complexity of the orchestration changes warrants human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[mwolson]

Absorbed into #5459 settled-thread lifecycle. That PR is now the stability consolidation and includes this mid-turn steer output fix on current t3code/codex-turn-mapping.