fix(orchestration): Preserve Claude subagent attribution after settle

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.

[mwolson]

Summary

• Persist Claude native-task and tool-use attribution across settled root turns
  and fresh buffered continuations.
• Keep child narration, tools, results, and distinct terminal output in child
  threads without changing ordinary root assistant text.
• Replace raw task summaries in provider-owned root continuations with a fixed
  generic Claude prompt, preserve other providers' requested detail, and hide
  automatic provider entries from queue controls.

Problem and Fix

Problem and Why it Happened	Fix
Claude child SDK frames can arrive after the root turn settles. The fresh continuation no longer has the launch turn's tool-use maps, so child text, tools, and results can leak into the root thread.	Keep task identity, launch and resume aliases, bounded registration-race buffering, and resume state together in native-thread-scoped session state. Every attributed child frame resolves through that durable state.
A boolean or one-result latch cannot distinguish streamed narration, an equivalent notification fallback, and a genuinely distinct terminal Agent result across resumes.	Track bounded native identities and normalized terminal equivalence per generation. Equivalent fallback text is suppressed, while distinct narration, summaries, and terminal results survive once.
task_notification.summary was used as the provider-owned Claude continuation input and could render as raw child text labelled as another agent's message. A shared override would also erase Codex background-command context.	Give Claude an explicit fixed root text, Background task completed., while preserving provider-specific continuation detail for Codex. Omit provider-owned automatic entries from visible queue controls.
Unknown attributed lineage must not silently become root output.	Buffer a fixed number of lineages and frames until task registration. Overflow is logged and dropped child-side, never projected into the root.
Multiple pending Agent launches cannot safely recover an omitted task_started.tool_use_id by arrival order.	Infer only a single unambiguous launch. Ambiguous siblings wait for an explicit SDK alias, which atomically binds the task, preserves launch identity, and drains its child buffer.
Agent launch results and child approval requests can arrive before task_started registers their alias. A structured agentId can also appear in ordinary root tool output.	Remember bounded launch identities, route known native task IDs directly, fail closed for unknown child-looking approvals, and prefer an existing root tool call before interpreting incidental agentId data.

Defensive Fixes

Problem and Why it Happened	Fix
A failed continuation dispatch without a buffered terminal result left a native-thread-wide drain marker. A later sibling completion on the same Claude session could be mistaken for stale output and failed.	Record the exact task IDs represented by the failed offer. Stale frames for those tasks fail closed, known sibling tasks clear the drain and continue normally, and native-process replacement clears the scoped state.
A sibling completion could append after dispatch failed but before failIfCurrent, where a live-buffer rescan pulled the sibling into the failed cohort.	Freeze the failed cohort at offer time and replay later frames through normal wake buffering, so appended siblings receive their own continuation and are never projected failed.
A declined or cancelled Agent approval remained in the per-turn launch-inference queue, making a later alias-free valid launch look ambiguous.	Remove only the rejected approval from pending per-turn inference while retaining its durable session launch identity.
Native query replacement, interrupt timeout, or session disposal could delete Claude's registry while durable child projections still said running.	Fail-close every still-running native child with one static session-ended artifact before deleting aliases or process state. Already-terminal children remain unchanged.
An unresolved Agent result inside a multi-result SDK frame buffered the whole frame and returned, so later sibling results could be delayed or replayed more than once.	Split buffered results into one-block messages and continue through the batch, preserving independent lineage even when aliases arrive in reverse order.
A split multi-result user frame could retain the original frame-level tool_use_result, then incorrectly apply that shared structured result when one buffered block replayed.	Remove frame-level structured output from split messages and derive each replayed result from its own content block.
The bounded pending Agent launch queue could evict an unresolved launch while leaving implicit alias inference enabled, allowing a later alias-free start to claim the final retained sibling alias.	Disable implicit launch-alias inference for the rest of the turn after overflow. Explicit SDK aliases remain authoritative and drain only their own child buffer.

Validation

• The final MCP, Claude adapter, provider continuation, replay, and
  client-runtime set passed 189 tests with 1 skipped.
• vp check: passed all 2,690 files.
• vp run typecheck: passed all 15 packages.
• A fresh isolated v2.1 Nightly AppImage built from the deliberate final union
  passed the exact packaged Grok post-settlement subagent, Claude
  post-settlement subagent, and Codex background-command wake scenarios. Claude
  projected one generic provider-owned root input while keeping raw child
  output on the child; Grok and Codex retained their provider-specific
  behavior.
• Codex GPT-5.6 Luna identified the incidental root agentId collision. The
  regression was fixed and covered. Fresh Grok 4.5 high-reasoning source and deliberate-integration reviews
  returned SHIP after verifying teardown ordering, exactly-once terminals,
  semaphore safety, independent batched-result lineage, and fail-closed pending-launch overflow.

---

Note

High Risk
Large Claude adapter lifecycle refactor touching attribution, approvals, wake buffering, and continuation failure paths—behavioral regressions could mis-route subagent output or drop completions.

Overview
Fixes post-settlement leakage where Claude SDK frames for native tasks and tool use could land on the root thread after a turn settled and a fresh buffered continuation started, because launch-turn tool maps were gone.

makeClaudeAdapterV2 now holds native-thread-scoped state (task IDs, launch/resume aliases, bounded pre-registration buffering, resume/generation tracking) so child narration, tools, results, and approvals route to child threads with generation-based dedup and serialized SDK handling. Unknown lineages buffer or fail closed instead of becoming root output; launch-alias inference is single-candidate only, with overflow and session teardown paths tightened (including failIfCurrent cohorts on failed continuation dispatch).

Provider continuations: Claude root wakes use a fixed Background task completed. via optional messageText (not raw task_notification.summary); other providers keep their detail. ProviderContinuationService invokes failIfCurrent on dispatch failure. deriveThreadQueueWorkflowState omits provider-owned automatic completion messages from visible queue controls.

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

Note

Preserve Claude subagent attribution and approval routing after turn settlement

• Enables approvals to originate from subagents by routing permission requests to the correct child thread when callbackOptions.agentID is present; unknown agent requests are denied without side effects.
• Replaces per-turn subagent maps with a session-scoped Ref<ClaudeSessionSubagentState>, enabling durable aliasing between toolUseId and taskId across turn boundaries and preventing attribution loss after settlement.
• Serializes SDK message handling under a Semaphore to prevent races between buffered wake frame drains and incoming frames.
• Deduplicates emitted subagent text and terminal result artifacts using normalized text and native item IDs; adds failClaudeSubagent to emit failure terminals when wake delivery fails.
• Hides provider-buffered automatic continuation messages ("Background task completed.") from the visible thread queue in deriveThreadQueueWorkflowState.
• Risk: turn finalization now atomically claims the active turn to prevent duplicate terminal emissions, which changes the timing of teardown for steered and interrupted turns.

^{Macroscope summarized a45acc5.}

[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: 15ae4641-4c62-4546-8ffd-d4515e7c864c

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

---

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]

Effect Service Conventions review: one convention issue found in the newly added test module's service imports. Everything else in the changed Effect code (subpath namespace imports, layer construction, dependency acquisition via yield* Service, error modeling) matches the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

Diff is too large for automated approval analysis. A human reviewer should evaluate this PR.

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

[macroscopeapp]

Reviewed the changed Effect service code against the service conventions. One import-shape issue in the new server test; everything else (namespace imports from effect/* subpaths, Context.Service shapes, error modelling, and dependency acquisition in the touched orchestration/adapter code) looks consistent with the conventions.

^{Posted via Macroscope — Effect Service Conventions}

[mwolson]

Absorbed into #5456 claude-empty-prompt. That PR now carries this commit plus the blank opening-message fix on current t3code/codex-turn-mapping. Review the Claude work there.