fix(native-chat): the agent's exit ends its record, and an unconfirmed stop is joined instead of held

[brennanb2025]

	Files	Added	Deleted	Net
Test	30	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1106	$\color{#cf222e}{\Huge{\mathbf{−}}}$​952	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​154
Prod	57	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​945	$\color{#cf222e}{\Huge{\mathbf{−}}}$​991	$\color{#cf222e}{\Huge{\mathbf{−}}}$​46

What this fixes

The problem. When you press Stop on a native Claude chat, close the tab, or Orca puts an idle chat to rest, Orca ends the agent's process. It must confirm the process is gone before it starts a new one. #24333 handled a failed confirmation by keeping a separate record next to the chat saying "a stop is still owed". Your next message was held under a note until a later retry confirmed the exit. Review of that design found three problems:

• A message could wait for minutes. If the old process exited on its own after Orca gave up waiting, nothing noticed. The message sat under the note until your next action, or until Orca's 5-minute check retried the stop.
• Bookkeeping blocked your message. Sometimes the process was confirmed gone but a follow-up write failed: saving Claude's resume point, releasing the chat's ownership record (the lease that tells other hosts and later launches who runs the chat), or Codex's final row. Orca still treated the process as unconfirmed. The note said "couldn't confirm the process ended" even though it had, and your message waited on a retry of that write.
• The design was its own source of bugs. The separate record needed extra rules for which message had already waited through a retry, where to order the old process's end, and which caller should wake delivery. Each rule came with its own follow-up fix.

This replaces #24333's hold. It also supersedes #24362, which added a second notification to cover the first problem.

ELI5

Before, a Stop that couldn't confirm the old agent quit left a sticky note saying "stop still owed", and your next message waited behind that note. Now there is no note. The stop is simply still in progress, and anything that needs the agent waits for that same stop to finish. The moment the old process is seen to exit, it is cleaned up, whether anyone is waiting or not. If it still can't be confirmed gone, your message is sent back with "send again" instead of being held, and sending again tries the stop again.

What Changed

Before (for you):

• After a Stop whose exit couldn't be confirmed, your next message waited under the note "Orca couldn't confirm Claude's previous process ended. Messages wait to be sent until Orca confirms it has ended." It went out on a later retry: your next change, or Orca's check up to 5 minutes later.
• If the old process was gone but a follow-up write failed, the same note appeared and the message waited anyway.

After (for you):

• The usual slow exit: your next message waits for the stop already in progress, then goes to a fresh Claude that resumes the conversation. No note appears. That stop's own kill escalation bounds the wait (ask the process to exit, then force-kill it), plus at most 2 seconds for output the old process already wrote.
• A late exit: if the old process exits after Orca stopped waiting, Orca notices and cleans up right away, without waiting for your next action or a timer. Background tasks and subagents of that agent stop showing as running.
• A failed follow-up write after a confirmed exit (the resume point, handing the lease back, or a final row) is logged to the diagnostics log. It never holds your message or blocks a new start.
• When the old process doesn't exit even after Orca kills it, your message is not held. It is rejected with "Orca couldn't stop Claude's previous process. Send your message to try again.", and the failure is logged. Nothing new starts beside a process that is still running.
  • Sending again kills it again. A process that was only slow exits then, and your message goes to a fresh Claude. If it exits on its own first, Orca cleans up then, and the next message goes straight out.
  • Only the message that met the failed stop is rejected. A message sent after the rejection waits for that next try.
  • A process still running after repeated kills (for example, stuck in the kernel) keeps refusing new starts until it exits. Orca can't reuse it, because it stopped taking input the moment the stop began.
  • Model or effort changes, card answers, goal changes and rewinds in that state are refused with the existing "Orca hasn't confirmed that this chat's previous agent stopped." notice.
• A message sent after a Stop or tab close was asked for, while the old process was still exiting, goes to the fresh agent. The old process's end is now stamped where the stop was asked for, not where its exit landed, so the closed session never claims that later message as its own and fails it.
• A leftover child process of the agent, after the agent's own process is confirmed gone, is logged and blocks nothing. This holds for Claude and Codex alike.
• The same applies to Codex chats. A Codex Stop that Codex refuses or never answers also ends the Codex process.
• Closing a chat again after the first close couldn't confirm the old process exited (added when merging fix(native-chat): a Stop binds only the turn it actually stopped #24864's Stop binding): a reply that second close cuts off reads as stopped by you, as it would on the first close, not as an unexplained interruption.

Mechanism.

• The unfinished stop is the stop itself, still running. A stop records why it closed the child on the child record (child.close). That record lives only as long as the child, so nothing outlives the process it is about.
  • Joining the close means asking the adapter to close. Each adapter runs one close per child at a time (Claude's close finalization, Codex's exit proof) and bounds it by its own kill escalation.
  • A second Stop, the idle reaper, quit, a send, and model/effort changes, card answers, goal changes and rewinds all wait on that same attempt. The host keeps no attempt of its own and no outer deadline. Quit keeps its own overall bound.
  • A caller that arrives after an attempt came back unproven runs the close again (see Differences below).
  • The stored record owesProviderChildWindDown is deleted, along with everything fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333 built around it: the retry entry points, the wait note and its "already waited" rule, the ask and failure positions, and the stop's own wake.
• The verdict is the root's exit alone. A close resolves as soon as the agent's own process is proven gone. Everything after that runs in the background and logs its failures: saving Claude's resume point, the chat handle update, and Codex's final row. A hung or failing write can't make a proven exit look unproven.
• One exit handler ends every child's record (structured-agent-session-child-exit.ts), whether the exit was asked for or not.
  • Both connections report the agent's own process exit even during a close, marked expected. This covers a process that exits after its close gave up. The adapter then finishes the close through the same path as any close, so the child's background work is published as ended.
  • The handler takes the child off the record. It then attempts the lifecycle drain, the turn settlement, the lease release (keeping the exit's time and reason), the sink release and the adapter's acknowledgement. Each failure is logged and none keeps the child on record. Finally it wakes the delivery loop.
  • expected changes only what the chat is told: the stop's cause, the end stamped where the stop was asked for, no crash row, and no reader re-baseline.
  • A Claude journal-sink failure ends the child in the same step, as Orca's own fault. One exception: if it lands while a Stop or a send is already waiting on that child's close, the child ends as that stop.
• A close ends on its own chat's queue. The end of a close Orca asked for no longer waits behind another chat's crash recovery, which can run a whole reacquisition.
• A start refused for an unverifiable exit rejects what was queued in the same step, so a message that arrives during the refusal goes to the next attempt instead of being rejected with it.
• A proven Claude close waits at most 2 seconds for the output already written. Once the root's exit is proven, the close used to wait for the SDK's output reader to end, with no bound. Something outside the process tree holding the output open would have kept every send, Stop and quit that joins the close waiting. Past the bound, the close resolves as proven and the open output is logged.
• A Codex exit reported inside Orca's close keeps Orca's reason. The connection reports the app-server's exit inside the close that ends it. The session now records why Orca closed it (for example, a provider frame that couldn't be recorded), and that reason, not the connection's stderr, goes into the ended record and the lease's exit evidence.
• An exit's lease release lands whatever the length of its reason. A crash's reason can carry kilobytes of stderr, and the store refuses a lease whose death detail is over 512 characters. The record's builder now cuts the detail to that bound, so the release a start re-derives after a crash can't be refused for its length.
• Quit stops delivery before it drains exit recovery, so an exit settled during quit can't start a fresh agent that quit then kills.
• The kill no longer waits for the stop event's journal write. The journal writes rows in order, so the stop row still lands before the end rows.
• The start re-derives the lease release. A new start needs the chat's lease released. If that write failed when the exit was proven, the start and the chat handle's close write it again. They use the host's own proof of that exit, kept in memory with the last ended child. A failure is logged, never a refusal. The chat handle stays open until the release lands, so that proof isn't lost.
• The idle sweep goes back to idle reaping only. Its branch that retried owed stops is deleted, including the older form that predates fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333.
• Copy. A start refused for an unverifiable exit gets the wording above instead of "Claude couldn't restart."
  • The previousExitUnverifiable failure kind and refusal reason stay in the shared lists and catalogs, because persisted rows and fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333-era hosts carry them.
  • Its sentence now says what happened: "Orca couldn't stop {{agent}}'s previous process." The host only reaches this verdict after its own kill, on the machine that runs the agent. The reason, the failure kind and the wire shapes are unchanged; only the text in the shared copy and the 7 catalogs changes. No release carries fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333's sentence.

Why

• It removes the bug class, not the symptoms. The hold, the ordering rules, the "already waited" rule and the who-wakes-delivery question all existed only because "a stop is owed" was stored apart from the stop. Now the stop is the one thing every caller joins, and the process's own exit ends the record through one handler. Nothing is left to reconcile.
• Bookkeeping never gates a user action. Once the exit is proven, every remaining step is attempted and logged, and the lease release is re-derived from the proof.
• Mixed versions are safe. Nothing on the wire changes shape.
  • The rejection is the existing restartFailed kind, carrying a refusal reason that is already listed.
  • An older client that doesn't know the reason drops it. With the journal's record of the rejection loaded (the usual desktop case) it says "Claude couldn't restart."; otherwise it shows the host's sentence.
  • A fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333-era client says "Claude couldn't restart.", followed by "Send your message to try again." when the notice has no Retry button.
  • A client from before this PR shows its own older sentence for the same reason. None of them says the process exited.
  • Persisted wait notes from fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333-era hosts keep their stored text.
• SSH and paired hosts. The close, the exit proof and the record all live on the execution host. A close that runs out, or a host that can't confirm the exit, reads as unverifiable, never as exited.
• Alternatives considered.
  • Keep fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333's hold and add fix(native-chat): a message waiting on an unconfirmed stop goes out as soon as the old process exits #24362's late-exit notification. Rejected: it adds a second notification to patch the stored record, and leaves the bookkeeping and ordering rules in place.
  • Start a new agent once a wait runs out, without proof. Rejected: that can run two agents on one conversation, and an exit that can't be confirmed is never evidence that it happened.
  • Hold the message until the exit is proven. Rejected: holding is what produced the rules above. A rejection with "send again" loses nothing, and is rare.
  • A separate host-side wait with a 10-second bound, as this PR first had. Rejected in review: the adapter's close is already bounded by its kill escalation, and a second bound meant a second attempt to keep consistent.

Differences from the common pattern

• Intended: no new agent starts beside an old one that outlived its kill. When a stop can't prove the exit, one common shape treats the close as done once a wait times out and starts a fresh process; another keeps the failed stop as its answer and sends the next message to the old process, which is still running. In both, the next send goes somewhere. In Orca the next send goes out once a kill proves the exit, which is the usual local outcome: a slow process is killed again and the message proceeds. Orca differs only for a process that is still there after SIGKILL.
  • Orca can't reuse that process. Its input was closed the moment the stop began, and the connection refuses every write after that.
  • Orca won't start a second one beside it. Orca's durable lease names one owner process for the chat, and two agents would write one conversation. Orca hit this before: forgetting a child whose exit wasn't proven stranded that process for good (recorded in structured-agent-session-eviction.ts on main).
  • On an SSH or paired host, the close and its kill run on that host, so the verdict is the same one. Losing contact with the host only stops the client reaching it; the client never turns that into "exited".
  • Safe to keep: nothing is lost, the rejection says to send again, every send kills again, and the failure is logged.
• Intended: the start re-derives a lease release that failed. The common pattern has no durable ownership lease. Orca keeps one so other hosts and later launches can tell who runs the chat (SSH and paired servers).
  • A release that failed after the exit was proven would otherwise refuse every later start as "not resumable". This was reproduced during fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333's review: a proven exit whose follow-up writes failed left the lease unreleased, and the next send was refused as notResumable.
  • Re-deriving the release from the proven exit keeps that from blocking the send. The chat handle stays open while that write keeps failing, because the in-memory proof is the only thing that lets this host release the lease without a probe.
  • Safe to keep: the release is written only for the exact child this host proved gone (the lease's fence must still name it), and a failure is logged, never shown as a refusal.
• Intended: every new ask after a failed stop kills the process again. The next ask after a close came back unproven (a send, a Stop, quit or the reaper) runs the adapter's whole stop again: stdin closed, SIGTERM, then SIGKILL. One common shape keeps the first failed stop as the answer for every later ask; another never waits for a proof at all.
  • Safe to keep: this is what lets the next send proceed after a process that was only slow, without starting anything beside it.
  • Keeping the first failed stop as the answer is what fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing #24333 started from (commit fd5804d). After a Stop whose exit couldn't be proven, the next message failed, and so did every later one, until the idle sweep retried the stop after 30 minutes of quiet.
  • Each close is still one attempt at a time, shared by every caller waiting on it, and bounded by the adapter's own kill escalation.

Linked Issue

Replaces #24333's hold; supersedes #24362.

Visual Proof

Live QA on head 6cf2520ecce, in hidden dev builds driven over the browser debugging protocol, with isolated profiles. It tests what a message does right after Stop, two quick messages after Stop, quitting during a turn, and relaunching to resume.

Real Claude (macOS, M4 Air). A Claude Stop ends Claude's process, so this is the case the change is about. All four scenarios passed.

Stop during a running command, then send right away: the message goes out as its own turn to a fresh Claude, with no waiting note and no error.

Stop, then two quick messages: never two Claude processes at once, and both replies arrive in order.

Quit mid-turn left no Claude process behind. Relaunching the same profile kept the history, and the next message was answered.

Real Codex (macOS). All four scenarios passed. A Codex Stop that interrupts the turn keeps the same Codex process, so this shows no regression rather than the new exit path.

Not shown live: the "Orca couldn't stop Claude's previous process. Send your message to try again." rejection. It needs a process that survives a forced kill, which a test stand-in can't produce on macOS. Host-level tests cover it. Windows was not exercised live.

All QA screenshots: Claude, Codex.

Testing

New host-level tests in structured-agent-session-claude-stop-exit-ends-record.test.ts replace #24333's claude-unproven-stop-send test. They run the shipping Claude adapter and host against a fake connection that, like the real one, refuses writes once a close begins:

1. A Stop whose close can't prove the exit once: the next message joins that close and goes to a resumed Claude, never to the old one.
2. A send made while the close is still running waits on that close: one close of the old child, not two.
3. A proven exit whose resume-point write never settles still ends the record, and the next message goes out.
4. A root that exits after its close gave up: the record ends, the lease is released, and the old agent's background task is published as ended. Nothing starts.
5. A proven exit whose resume-point write and lease release both fail: both are logged, the child leaves the record, and the next message goes to a resumed Claude.
6. A close that stays unverifiable: the message is rejected with the send-again sentence. No note appears, nothing starts, and the old child stays on record.
7. A model change while unverifiable is refused with previousExitUnverifiable. Once the exit is proven, the pick is kept for the next start.
8. A leftover descendant after a proven root exit is logged and blocks nothing.
9. Quit joins an unverifiable close and releases the lease once it proves.
10. The idle reaper joins an unverifiable close and ends the record.
11. A Claude journal-sink failure ends as Orca's own fault, not a quiet rest.
12. A message accepted after a tab close was asked for is delivered, even when the late exit lands before its delivery step.
13. A refused start fails only the message it was about. A message accepted during that refusal goes to the next attempt.
14. Every ask after an unproven close runs the stop again, and the one that proves the exit lets the message through.
15. A crash with a reason over 512 characters, whose own lease release failed: the next message still starts a resumed Claude.

Test 6 also checks that the failed kill is logged (provider-close-unproven). Both connections have a test for a close after an unproven one: it runs the stop again (Codex sends SIGKILL a second time), proves the exit, and meanwhile refuses input (claude-stream-json-connection-close.test.ts, codex-app-server-connection.test.ts).

Codex (structured-agent-session-codex-stop-row.test.ts, the existing Codex Stop rig):

• an unverifiable close rejects the message and starts no Codex;
• a root exit after the close gave up ends the record, reported as Orca's close, never a crash;
• a send joins an unproven close and goes to a fresh Codex;
• a root exit whose process tree can't be proven gone is logged through the host and blocks nothing;
• a close Orca forces after a journal failure keeps its own reason. The test connection now reports its exit inside close, as the real one does.

Other new or changed tests:

• structured-agent-session-lifecycle-delivery.test.ts: a requested close ends while another chat's crash recovery is still blocked.
• Both connections report a root exit during a close as expected.
• A Claude close resolves at the proven exit and saves the resume point after it. A Codex close whose final row is refused still ends the session and logs the refusal.
• A proven Claude close resolves after 2 seconds though its output never ends (claude-stream-json-connection-close.test.ts).
• Quit stops delivery before it drains exit recovery (structured-agent-session-runtime-teardown.test.ts).

Ablations. Each one reverted one piece and ran the matching test, and every one failed. The latest round's set:

• the lease detail cut (test 15);
• the bounded output wait (the connection close test);
• the Codex close keeping its reason (the exit-blame test);
• quit stopping delivery first (the teardown test);
• the stop re-running after an unproven attempt, Claude (the connection's memo kept) and Codex (the proof memo kept): each connection test fails;
• the failed-kill log (test 6).

The round before:

• the late exit finishing through the normal close path (test 4 fails on the background task);
• the sink failure ending in the same step as Orca's fault (test 11);
• the resume-point write moved off the verdict (test 3);
• the end stamped at the stop's ask (test 12);
• the refusal and the queued rejection in one step (test 13);
• the re-run on every ask (test 14);
• Codex's tree verdict reported to the host (the Codex descendant test);
• requested closes kept off the recovery chain (the lifecycle-delivery test).

The previous round's ablations still apply: the start joining the close, the close shared between callers, the exit report ending the record, the start re-deriving the lease, the unverifiable wording, model changes joining the close, the root-exit and bookkeeping verdict mapping, quit including closing children, the reaper joining, and both connections reporting expected.

Removing the wait before the kill. The stop no longer waits up to 1 second for its stop-event write before killing. No ordering failure appeared with the wait removed. The two stop-event tests read the journal the moment the close began, so they now let the already-queued row write finish first.

Suites.

• Targeted run at this head: vitest on every structured-session test file in agent-session-wire, src/main/runtime and src/main/claude, every test file in src/main/codex, and the journal-database test: 486 files and 4820 tests passed. One file timed out under machine load (codex-app-server-client.test.ts, which this PR doesn't touch) and passes run alone. The lease release and record tests pass (16 files).
• Broad run, previous round: the same directories plus the shared failure, refusal and session tests, the renderer failure-words test and the i18n tests: 585 files and 6154 tests passed, apart from one untouched file that timed out under load and passes alone.
• Excluded: real-CLI, real-home and integration tests.
• Cross-version: the 13 tests/e2e/cross-version-wire unit test files passed on the previous round, run one at a time. At this head, the stop-event downgrade and published-field-shape files pass. In cross-version-agent-session-wire, 18 of 19 tests pass; the release-checkout test timed out at its 180-second limit with the machine at a load average of about 106, and a re-run timed out while building the checkout. This round changes nothing on the wire; CI runs that file.

Typecheck: pnpm tc:node and pnpm tc:web are clean at this head.

Lint: oxlint, the anti-slop config and oxfmt are clean on the changed files. check:code-quality:changed passes, and the max-lines ratchet reports no new bypasses.

Platforms: logic tests on macOS. Not exercised on a live Claude or Codex, Windows, Linux or a real SSH host.

• I manually tested these changes locally
• Automated tests added/updated, or explained why not below

Review

Agent skill upstream boundary

• Not applicable, or this change follows docs/reference/agent-skill-sharing-upstream-boundary.md and copies or mechanically translates no upstream skill-installer source, tests, fixtures, registry entries, path tables, comments, or documentation.

Notes

• Security: no new inputs, paths or processes; the close is the existing one.
• Cross-platform: the exit proofs are unchanged per platform. The Codex change only counts a root exit its forced kill already waited for, and reports the tree verdict.
• SSH: everything runs on the execution host. An unconfirmed exit is unverifiable, never exited.
• Mobile: reads the same shared failure and refusal modules; no mobile code changes.
• Backwards compatibility: see "Mixed versions are safe" above.
• Size: production code changes by +845/−932 lines (net −87), the locale catalogs by +7/−7, and tests and test fixtures by +1041/−950. Two small modules replace the owed-record logic in host-lifetime and agent-start: structured-agent-session-child-close.ts (131 lines) for the join, and structured-agent-session-child-exit.ts (218 lines) for the one exit handler, which replaces structured-agent-session-unexpected-exit.ts. The wait-row file and the teardown deadline file are deleted.

Checklist

• This PR is small and focused
• I explained what changed and why (ELI5, the user-facing before/after, the mechanism, and why over the alternatives)
• Before/after screenshots or videos attached for UI changes, or N/A with reason
• Self-reviewed for correctness, security, and performance
• Cross-platform, SSH/remote, and path/shortcut impact considered (or N/A)
• pnpm lint, pnpm typecheck, pnpm test, and pnpm build pass (or CI will cover; local preferred)

[brennanb2025]

Live QA (Electron)

Tested 6cf2520eccedd6ff96b58263d1c3230f99d775e4 on this laptop with a real Codex structured chat. After Stop, a message should go out on its own once the old work is gone, with no queued waiting note. Quit during a turn should not leave that Codex process behind. Opening the same profile again should keep the chat, and the next send should work.

Claude was not run (no Claude CLI on this laptop, and no stub was used). The survived-kill refusal case was not run.

• Scenario 1, stop then one send: pass from the earlier run on this same profile. Not repeated.
• Scenario 2, stop then two sends: pass. One Codex app-server the whole time (pid 33576). The sleep 70 child exited. Both messages and both replies showed up in order. No "couldn't stop" error.
• Scenario 3, quit mid-turn: pass for the Codex process. app.quit() while sleep 60 was running. 24 seconds after the main process was gone, that Codex app-server and the sleep were gone. The profile's Orca daemon and crashpad stayed up until they were stopped later by those recorded pids. They are not Codex processes.
• Scenario 4, relaunch: pass. The earlier turns were still in the chat. The next send was answered with PR24862_S4_OK.

~/.codex/hooks.json was sha256 78922a784ee78e9e50587e93628cd3b9d4dfbe49087adc4514e6781cea38cbb9 (18 bytes, 0 Orca entries) before the first launch and after the last quit. ~/.codex/config.toml was sha256 a1fe74d3e01bf6fbb43048e79bfcd59f962ea29dfdcffc3f6070f084234fc01f (69961 bytes) both times. Neither file was written.

Scenario 2, turn still running, just before Stop:

Scenario 2, both replies in order after the two sends:

Scenario 3, turn still running, just before quit:

Scenario 4, same chat after relaunch, with the earlier turns still there:

Scenario 4, the next send answered:

[OrcaWin]

Live QA (Electron, real Claude, M4Air)

SHA 6cf2520eccedd6ff96b58263d1c3230f99d775e4. Structured Claude chats on an isolated rig profile. Scenarios 1-4 passed. Scenario 5 (survived-kill refusal) was not run: a stub still dies on SIGKILL, so it cannot leave the close unverifiable.

[coderabbitai]

Navigate logical layers of code changes, visualize relationships, and explore their blast radius.

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

• Configuration used: Repository UI
• Review profile: CHILL
• Plan: Advanced
• Run ID: 6ab7d867-3154-4863-b3ad-53ea495e7f82

📥 Commits

Reviewing files that changed from the base of the PR and between 97016f3 and 4a461eb.

📒 Files selected for processing (6)

• src/renderer/src/i18n/locales/en.json
• src/renderer/src/i18n/locales/es.json
• src/renderer/src/i18n/locales/fr.json
• src/renderer/src/i18n/locales/ja.json
• src/renderer/src/i18n/locales/ko.json
• src/renderer/src/i18n/locales/zh.json

🚧 Files skipped from review as they are similar to previous changes (6)

• src/renderer/src/i18n/locales/fr.json
• src/renderer/src/i18n/locales/es.json
• src/renderer/src/i18n/locales/ko.json
• src/renderer/src/i18n/locales/zh.json
• src/renderer/src/i18n/locales/en.json
• src/renderer/src/i18n/locales/ja.json

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 8 remain after this review.

---

📝 Walkthrough

Walkthrough

Claude and Codex connections now report exits observed during close, and Claude limits post-exit reader draining. Session close handling records requested-close details and finalizes proven exits despite persistence or callback failures. The structured-session host stores close state on provider children, joins unverified closes, and processes expected and unexpected exits through shared settlement. Runtime delivery and teardown ordering, failure messages, and death-evidence detail limits are also updated.

Priority: ➖ Normal

Merge Risk: 🟡 Moderate · up to 4a461

The selected changes are translation updates and add no new risk. A previously raised concern remains open: the Claude session close no longer waits for its handle write, so a quick re-acquisition could resume from a stale point. Resolve or accept that before merging.

Security Architecture Review

Security architecture risk: 🟡 Moderate · up to 97016

Closing a chat can now finish before its final state is saved. A delayed save can adopt a replacement process's ownership identity and affect newer session metadata. Process-exit checks and permission protections remain in place; no broader account or privilege takeover was demonstrated.

Retained concerns

• Medium · security · inferred: Deferred close persistence is not bound to the originating ownership generation. Close now removes the old session before awaiting its final checkpoint, while persistHandle replaces the supplied fence with the record's current fence. If the callback runs after a replacement becomes proving or live, the old handle can become the current durable head under the replacement's authority, including its proven-handle reference. The ordering change introduces this exposure despite the fence-substitution code predating the PR. Demonstrated scope is session metadata and history anchoring, not a permission bypass or cross-account takeover.

Security review details

Security Blast Radius

• inferred — The supported concern is scoped to a named local Claude session's provider-handle chain, proven-handle reference, and history anchor. Repeated close and reacquisition provide the relevant lifecycle overlap; remote triggering, cross-account access, additional credentials, and broader infrastructure authority were not established.

Security Findings and Attack Paths

• inferred — The concerning path is old-session close, deferred checkpoint production, replacement ownership, then persistence using the replacement's current fence. The writer checks fence equality but does not independently bind this appended handle to the originating acquisition. This is an inferred stale-writer authority path; no exploit execution or direct permission bypass was demonstrated.

Trust Boundaries and Controls

• observed — Child-exit delivery requires matching fence and acquisition generation. Durable release independently rechecks the expected fence inside the transition and advances it on release. An unverifiable close refuses operations instead of authorizing a replacement alongside an unproven child.
• observed — The changed Claude prompt helpers retain session, fence, prompt-claim, and answer-generation checks before permission settlement. Background-task control retains current-session, fence, and acquisition-generation checks. Moving these operations into shared helpers does not itself expand their authority.

Resilience and Maintainability Implications

• inferred — Route acknowledgement occurs even if durable release fails, but the inspected production router is host-local and recovery retains same-fence root-exit proof. These controls do not support retaining a separate cross-host route-deletion or duplicate-live-owner concern from acknowledgement alone.

Hardening Proposals

• proposed — Keep proven-exit reporting independent of persistence, but bind deferred checkpoints to their original acquisition identity. Reconcile them through an explicit, idempotent handoff rule that cannot relabel an old checkpoint with a successor's fence or replace a newer current head.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 46.34% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 82 functions across 57 files. (6 skipped:…	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Title check	✅ Passed	The title clearly summarizes the main change: child exits end their records, and unconfirmed stops are joined instead of held. It is specific and related to the changeset.
Description check	✅ Passed	The description covers the required ELI5, changes, rationale, issue references, visual proof, testing, review considerations, and checklist. It also reports test and platform limitations.

Full details: Docstring Coverage

Explanation

Docstring coverage is 46.34% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 82 functions across 57 files. (6 skipped: 6 unsupported.)

• Autopilot · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

---

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.}

[coderabbitai]

Actionable comments posted: 1

---

ℹ️ Review info

⚙️ Run configuration

• Configuration used: Repository UI
• Review profile: CHILL
• Plan: Advanced
• Run ID: 974ad758-b15c-40db-ba02-c51e5e2d8472

📥 Commits

Reviewing files that changed from the base of the PR and between 2165558 and 1bf8f29.

📒 Files selected for processing (81)

• src/main/claude/claude-stream-json-connection-close.test.ts
• src/main/claude/claude-stream-json-connection.ts
• src/main/claude/claude-structured-requested-stop.test.ts
• src/main/claude/claude-structured-session-acquisition.ts
• src/main/claude/claude-structured-session-adapter.ts
• src/main/claude/claude-structured-session-close.test.ts
• src/main/claude/claude-structured-session-close.ts
• src/main/claude/claude-structured-session-recovery.test.ts
• src/main/claude/claude-structured-session-state.ts
• src/main/codex/codex-app-server-connection-types.ts
• src/main/codex/codex-app-server-connection.test.ts
• src/main/codex/codex-app-server-connection.ts
• src/main/codex/codex-close-turn-end.test.ts
• src/main/codex/codex-requested-close-turn-timing.test.ts
• src/main/codex/codex-structured-session-acquire.ts
• src/main/codex/codex-structured-session-adapter-fixture.ts
• src/main/codex/codex-structured-session-adapter.ts
• src/main/codex/codex-structured-session-close.test.ts
• src/main/codex/codex-structured-session-close.ts
• src/main/codex/codex-structured-session-options-catalog.test.ts
• src/main/codex/codex-structured-session-options.test.ts
• src/main/codex/codex-structured-session-state.ts
• src/main/codex/codex-structured-session-teardown.ts
• src/main/native-chat/agent-session-journal/journal-host-database.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-accept-then-deliver.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-agent-start.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-attach-context.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-child-close.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-stop-exit-ends-record.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-unproven-stop-send.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-close-verdict.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-codex-stop-row.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-conversation-close.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-conversation-lifetime.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-conversation-stop.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-delivery-loop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-eviction-deadline.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-eviction.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-eviction.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-host-stop-event.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-lease-release.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-mutation-context.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-provider-child.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-provider-exit-proof.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-binding.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-entries.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-surface-lifetime.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-wind-down-wait-row.ts
• src/main/runtime/agent-session-surface-release-transition.ts
• src/main/runtime/structured-agent-session-lifecycle-delivery.test.ts
• src/main/runtime/structured-agent-session-lifecycle-delivery.ts
• src/main/runtime/structured-agent-session-runtime-teardown.test.ts
• src/main/runtime/structured-agent-session-runtime-teardown.ts
• src/main/runtime/structured-agent-session-runtime.ts
• src/main/runtime/structured-claude-runtime-adapter.ts
• src/renderer/src/i18n/en-runtime-required.json
• src/renderer/src/i18n/locales/en.json
• src/renderer/src/i18n/locales/es.json
• src/renderer/src/i18n/locales/fr.json
• src/renderer/src/i18n/locales/ja.json
• src/renderer/src/i18n/locales/ko.json
• src/renderer/src/i18n/locales/zh.json
• src/shared/agent-session-failure-copy.ts
• src/shared/agent-session-failure-words.ts
• src/shared/agent-session-failure.ts
• src/shared/agent-session-record.ts
• src/shared/agent-session-refusal-details.ts

💤 Files with no reviewable changes (9)

• src/main/codex/codex-structured-session-options-catalog.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-unproven-stop-send.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-eviction-deadline.ts
• src/main/codex/codex-structured-session-options.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-wind-down-wait-row.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
• src/main/codex/codex-close-turn-end.test.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 4 remain after this review.

[coderabbitai]

🗄️ Data Integrity & Integration | 🟠 Major | ⚡ Quick win

🔎 Supported by static analysis

🏁 Script executed:

#!/bin/bash
rg -nP -C4 'recordAgentSessionProviderHandle|reviseAgentSessionClaudeResumePoint' src/main
rg -nP -C6 'closePersistence' src/main/claude
rg -nP -C6 'resumeLeafUuid|providerHandleChain' src/main/claude/claude-structured-launch*.ts src/main/runtime/*claude* 2>/dev/null | head -120

Repository: stablyai/orca

Length of output: 27864

---

🏁 Script executed:

#!/bin/bash
set -o pipefail
printf '%s\n' '--- reviewed close-file diff ---'
git diff --unified=8 2165558c9dc507cc9538a58ff2418b357d46f155 1bf8f29e6543a59e15540963643bf2ed787edac5 -- src/main/claude/claude-structured-session-close.ts
printf '%s\n' '--- close implementation ---'
sed -n '1,230p' src/main/claude/claude-structured-session-close.ts
printf '%s\n' '--- turn-end and close persistence bindings ---'
rg -n -C8 'persistClosedClaudeSession|settledClaudeTurnEndLeaf|resumePointWrite|closePersistence' src/main/claude/claude-structured-session-close.ts src/main/claude/claude-structured-session-state.ts src/main/claude/claude-structured-session-adapter.ts src/main/runtime/structured-claude-runtime-adapter.ts
printf '%s\n' '--- launch resolution and lifecycle call sites ---'
rg -n -C5 'createClaudeStructuredLaunchResolver|resolveLaunch|finishClaudeCloseAfterExit|closeClaudePublishedSessionForDeps|closeClaudeSession\\(' src/main/claude src/main/runtime src/main/native-chat
printf '%s\n' '--- record transition guards ---'
sed -n '1,135p' src/main/runtime/agent-session-provider-handle-transition.ts

Repository: stablyai/orca

Length of output: 28023

---

🏁 Script executed:

#!/bin/bash
set -o pipefail
printf '%s\n' '--- launch and close call sites ---'
rg -n -C6 -e 'createClaudeStructuredLaunchResolver' -e 'resolveLaunch' -e 'finishClaudeCloseAfterExit' -e 'closeClaudePublishedSessionForDeps' -e 'closeClaudeSession' src/main/claude src/main/runtime src/main/native-chat
printf '%s\n' '--- launch resolver implementation ---'
fd -i 'claude-structured-launch*' src/main/claude --type f --exec sh -c 'echo --- $1; sed -n \"1,280p\" \"$1\"' sh {}
printf '%s\n' '--- runtime persistence callbacks ---'
sed -n '70,135p' src/main/runtime/structured-claude-runtime-adapter.ts
printf '%s\n' '--- lifecycle ended handlers and lease/release flow ---'
rg -n -C10 -e \"cause: 'requested-close'\" -e \"type === 'ended'\" -e \"event.type === 'ended'\" -e 'runtimeFence' -e 'release.*lease' src/main | head -260

Repository: stablyai/orca

Length of output: 42142

---

🏁 Script executed:

#!/bin/bash
set -o pipefail
printf '%s\n' '--- matching production files ---'
rg -l 'createClaudeStructuredLaunchResolver' src/main --glob '!*.test.ts'
rg -l \"requested-close|acquisitionGeneration\" src/main --glob '!*.test.ts'
rg -l 'release.*runtimeFence|runtimeFence.*release|claimStatus.*released|releaseLease' src/main --glob '!*.test.ts'
printf '%s\n' '--- launch resolver source ---'
for f in $(rg -l 'createClaudeStructuredLaunchResolver' src/main --glob '!*.test.ts'); do
  echo "--- $f"
  sed -n '1,300p' "$f"
done
printf '%s\n' '--- ended consumer source context ---'
for f in $(rg -l \"requested-close|acquisitionGeneration\" src/main --glob '!*.test.ts'); do
  echo "--- $f"
  rg -n -C18 \"requested-close|acquisitionGeneration|type: 'ended'|event.type === 'ended'\" "$f"
done
printf '%s\n' '--- lease release matches ---'
for f in $(rg -l 'release.*runtimeFence|runtimeFence.*release|claimStatus.*released|releaseLease' src/main --glob '!*.test.ts'); do
  echo "--- $f"
  rg -n -C12 'release.*runtimeFence|runtimeFence.*release|claimStatus.*released|releaseLease' "$f"
done

Repository: stablyai/orca

Length of output: 41910

---

🏁 Script executed:

#!/bin/bash
set -o pipefail
printf '%s\n' '--- ended child release ---'
sed -n '70,165p' src/main/native-chat/agent-session-wire/structured-agent-session-child-close.ts
printf '%s\n' '--- structured start flow ---'
sed -n '95,205p' src/main/native-chat/agent-session-wire/structured-agent-session-agent-start.ts
printf '%s\n' '--- turn-end persistence implementation ---'
rg -n -C12 -e 'resumePointWrite' -e 'persistResumePoint' -e 'settledClaudeTurnEndLeaf' src/main/claude --glob '!*.test.ts'
printf '%s\n' '--- launch resolver return fields ---'
sed -n '210,310p' src/main/claude/claude-structured-launch-resolution.ts
printf '%s\n' '--- transition persistence implementation ---'
sed -n '90,130p' src/main/runtime/structured-claude-runtime-adapter.ts

Repository: stablyai/orca

Length of output: 31922

---

🏁 Script executed:

#!/bin/bash
set -o pipefail
printf '%s\n' '--- numbered decisive ranges ---'
rg -n -C5 'session.closePersistence \?\?=|persistClosedClaudeSession|type: .ended.|structuredClaudeLifecycleEvent|releaseLeaseOfEndedStructuredAgentSessionChild|startStructuredAgentSessionAgent|const record = deps.store.getRecord|const head = agentSessionProviderHandleChainHead|resumePointWrite|settledClaudeTurnEndLeaf|persistHandle: async|persistResumePoint: async' \
  src/main/claude/claude-structured-session-close.ts \
  src/main/claude/claude-structured-session-exit-lifecycle.ts \
  src/main/claude/claude-structured-resume-point.ts \
  src/main/claude/claude-structured-session-state.ts \
  src/main/claude/claude-structured-launch-resolution.ts \
  src/main/runtime/structured-claude-runtime-adapter.ts \
  src/main/native-chat/agent-session-wire/structured-agent-session-child-close.ts \
  src/main/native-chat/agent-session-wire/structured-agent-session-agent-start.ts

Repository: stablyai/orca

Length of output: 27896

---

Order close persistence before the next Claude start.

finalizeClaudePublishedSession emits ended and starts persistClosedClaudeSession without awaiting it. The next start can release the ended child’s lease and read the durable provider handle while that persistence is still pending. If the turn-end resume write failed or did not cover the final leaf, the new launch can read a stale cursor. The later handle write can then use the new lease fence or fail, and the failure is only logged.

Ensure that the next acquisition awaits a bounded closePersistence barrier before releasing the lease or resolving its launch from the durable record.

[pullfrog]

✅ No new issues found.

Reviewed changes

• The stop is the child's close. owesProviderChildWindDown and the wind-down wait row are deleted; a stop writes child.close on the provider child, and every later Stop, start, send, model/effort change, card answer, goal, rewind, the idle reaper, and quit join that same close through structured-agent-session-child-close.ts.
• One exit handler. structured-agent-session-unexpected-exit.ts is replaced by structured-agent-session-child-exit.ts: expected closes and crashes share it, every post-exit step is attempted and logged rather than gating, and wakeDelivery fires in finally.
• Lease release is re-derived. A start and the conversation's close re-write the release from the host's in-memory lastEndedChild proof when the exit handler's write failed, and the death detail is bounded to MAX_AGENT_SESSION_DEATH_DETAIL_CHARS.
• Connections report expected exits. Both connections report a root exit during a close as that close's end; Claude bounds the proven-close output drain at 2 s; Codex records the close's own reason and reports an unproven process tree.
• Copy. previousExitUnverifiable now says "Orca couldn't stop {{agent}}'s previous process." across the shared copy and the 7 locale catalogs, with the failure kind and wire shapes unchanged.

ℹ️ Quit no longer retries a lease release that failed after a proven exit

evictOwnedStructuredAgentSessions now selects sessions by session.child !== null, so a session whose child was already proven gone but whose exit-handler lease release failed is skipped at quit; it closes the journal and drops the session without re-deriving the release. This looks deliberate given the teardown comment already accepts an unreleased lease across quit, but it is a behavior change from the removed owedProviderChildWindDown, which used to outlive the child and be retried by quit.

Technical details

# Quit-time lease release re-derivation narrowed

## Affected sites
- `src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts:193-195` — filter changed from `owedProviderChildWindDown(session) !== undefined` to `session.child !== null`.
- `src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts:177-190` — the exit handler's release is best-effort and logged; on failure `lastEndedChild.rootGone` stays true and the lease stays live.
- `src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts:124-146` — teardown closes journals for non-retained sessions without calling `releaseLeaseOfEndedStructuredAgentSessionChild`.

## Context / required outcome
- Before this PR, a proven exit with a failed release left `owesProviderChildWindDown` set, so quit included the session and retried the stop (and its release).
- After this PR, only a live child keeps a session in `ownedSessionIds`; the only re-derivation points are `startStructuredAgentSessionAgent` and `closeConversation`, neither of which quit runs. A clean quit therefore leaves a `live` lease for a proven-dead owner, which next-launch reconciliation settles.
- This is consistent with the codebase's "restart reconciles a deferred lease" policy, so no change is requested — confirm the intent is to defer this to recovery rather than retry it at quit.

## Open questions for the human
- Is deferring a post-exit release failure that survives to quit to next-launch recovery the intended trade-off, or should quit also sweep `lastEndedChild` leases?

  ^{｜ View workflow run ｜ Using deepseek-v4.1-flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

✅ No new issues found.

Reviewed changes

• The refusal copy is plainer. previousExitUnverifiable now reads "Couldn't stop {{agent}} from before." instead of "Orca couldn't stop {{agent}}'s previous process.", across the shared copy and all 6 locale catalogs.
• That refusal gets its own send-again step. A new sendAgainToTryOnceMore piece ("Send your message again to try once more.") is registered in AGENT_SESSION_FAILURE_COPY, the desktop PIECES map, en-runtime-required.json, and every locale; startRetry gained a sendAgain argument, and only the previousExitUnverifiable refusal path passes it, so every other failure keeps "Send your message to try again."
• Tests pin the new wording. A new agent-session-failure-words case covers the default, /command, and Retry-control sentences, and the two host-level Stop tests now assert the new rejection text.

ℹ️ Nitpicks

• The PR description still quotes the copy this commit replaces: "Orca couldn't stop Claude's previous process. Send your message to try again." and "its sentence now says what happened: "Orca couldn't stop {{agent}}'s previous process."". The shipped text is now "Couldn't stop {{agent}} from before. Send your message again to try once more.", so those two passages read stale.

  ^{｜ View workflow run ｜ Using deepseek-v4.1-flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

✅ No new issues found.

Reviewed changes

Since the prior review at 8fb8aaf, the only new commit is a merge of origin/main (a154562) into the PR branch. It reconciles main's #25043 "one explanation for a turn cut short" with this PR's single-exit-handler design and extracts two helpers; no new behavioral defect found, and the affected host and adapter suites pass.

• child-exit.ts carries #25043's exit-row identity. The only change #25043 made to the deleted unexpected-exit.ts was switching the settlement id to PROVIDER_EXIT_ROW_PREFIX; structured-agent-session-child-exit.ts now does the same, so native-chat-cut-turn-notice.ts's dedup still recognizes the exit row.
• sendPreparation keeps both sides. The PR's finishOwedStop → joinChildClose change survives main's new admit/replay ledger signature in structured-agent-session-send-preparation.ts.
• freeingAsker extracted. Main's private adapter helper moved to settleClaudePromptFreeingChild in claude-structured-prompt-ownership.ts, with the adapter's new asker binding it; the logic is equivalent to main's.
• stopBackgroundTasks extracted. The adapter's inline "stop while still current, then publish child work" body moved to stopCurrentClaudeBackgroundTasks; behavior-identical.
• Merge-resolved tests and copy. close-verdict and conversation-close tests adopted main's newer assertions (label, ONE_NOTICE, appendLifecycleBatch.rejectsQueued), and the 8fb8aaf copy survived in every locale catalog.

No dropped side: every main-touched PR file appears in the merge's combined diff, and no dangling references to the deleted unexpected-exit.ts, owesProviderChildWindDown, or finishOwedStop remain. Ran the 4 merge-affected host test files (65 tests) and the 3 Claude adapter/helper files (63 tests) — all pass.

  ^{｜ View workflow run ｜ Using deepseek-v4.1-flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

This run was cancelled 🛑

The workflow was cancelled before completion. Please check the link below for details.

  ^{｜ View workflow run ｜ via Pullfrog ｜ 𝕏}