[brennanb2025]

	Files	Added	Deleted	Net
Test	17	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1839	$\color{#cf222e}{\Huge{\mathbf{−}}}$​208	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1631
Prod	29	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​704	$\color{#cf222e}{\Huge{\mathbf{−}}}$​471	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​233

What this fixes, and where

The bug. You press Steer on a queued message, which sends it into the running turn, and then press Stop before the agent has picked that message up. About 1.5 seconds later Orca sends the same message again on its own, as a new turn you never asked for. Claude and Codex both do this.

Scope. Native (structured) Claude and Codex chats, with the mid-turn message queue switched on. The queue is still switched off on main, so no user can reach this today. Terminal agent tabs and ordinary sends are unaffected. SSH and local hosts behave the same, because the change is on the host that runs the agent.

Why it happened. Stop stored a separate "the queue is paused" record, and only when, at that instant, the queue held a card that was waiting. The steered message was not waiting: it was still being handed to the agent. So no pause was recorded. The agent then gave the message back when the interrupt landed, and it returned to the queue with nothing pausing it. The queue sent it again.

What this PR does. Every Stop that takes effect now writes one Stop event into the chat's own history: why the agent was stopped, which turn, when, and who asked. The queue's pause is worked out from a person's Stop event every time the queue checks it, and the stored pause record is gone. A message that comes back after a Stop is always behind that Stop's event, so it is always paused, however its hand-off to the agent ended.

This PR is part A of a three-part plan (below): it adds the Stop event in its final shape, writes it from the user's Stop, and makes the queue pause its first reader.

Where this fits

The plan for messages sent while the agent is working

A message you send while the agent is working waits as a card above the message box. The card has Steer (send it now, into the running turn), Delete and Edit, and it sends by itself when the turn ends. Stop pauses the queue ("Queue paused because you interrupted") and shows a Resume button; nothing is thrown away.

The queue landed in three PRs: #23726 (host), #23731 (desktop) and #23736 (phone). It stays switched off (the host doesn't advertise it) until the remaining pieces land: #21062 (Codex steer), #23935 (/clear saved as one write), and this PR. Turning it on is then a one-line change.

The plan for the Stop event (this PR is part A)

Today why a stop happened (the user's Stop, the user closing the chat, the host stopping the agent, or an eviction such as quit or idle release) exists only in memory. It is passed from about ten places through the host's stop step into each agent adapter, and it turns into one lasting fact, "this turn was cancelled", only when the turn ends. If Orca restarts before that, the cause is lost and the turn reads Failed or "Couldn't confirm" even though you pressed Stop. One Stop also leaves three unrelated lasting traces (the queue pause, the "Cancellation requested." line and the operation record) that nothing connects.

• A (this PR): the Stop event itself, { reason, turnId?, at, caller? }, written by the user's Stop, and the queue pause derived from it.
• B (next): every other stop (closing the chat, the host stopping the agent, evictions) writes its event too. The turn's end, and the settling of a turn after a restart, write Interrupted or Failed from the event, which fixes the restart case above. The "Cancellation requested." line is written from the event, and the in-memory cause passed through the adapters is deleted.
• C (after B): a remote client's close carries its reason to the host, behind a new capability so an older host is never sent a field it rejects.

This PR was found while rebuilding #21062. It replaces the first version of this fix, which widened the stored record's rule.

ELI5

Before, Stop wrote a separate sticky note saying "the queue is paused", but only if it saw a card waiting right then. A card that was in the middle of being sent didn't count, so no note was written. When the agent handed that card back, nothing held it, and it was sent again.

Now Stop writes a line in the chat's own history: "you stopped here, during this turn". The queue reads the history and stays paused until you send your next message or press Resume. A card that comes back later is still after that line, so it stays paused too. Nothing needs to be cleaned up, because there is no note, only the history. Later, the same line will also tell Orca, after a restart, that a turn ended because you stopped it.

What Changed

Before (for you):

• A card you steered, then stopped, could be sent again by itself about 1.5 s later.

After (for you):

• A card you steered, then stopped, comes back to the queue once, as a waiting card under "Queue paused because you interrupted". It is never sent again unless you press Resume, send a message yourself, or press Send on the card.
• Stop pauses the messages that were queued before it, and a steered message it takes back, until you send your next message or press Resume. Brennan's decision: a message you queue after a Stop is a new instruction and sends normally, except that it never jumps ahead of messages the Stop is holding. So with nothing held ahead of it, it sends as usual. Behind held messages, it waits with them, and they all send in order once you release them. It gets no caption of its own; the pause header says why.
• A Stop pressed while the agent is still starting pauses the same way: a card queued before it waits.
• After /clear, the cards carried to the new chat wait under "Queue paused after you cleared the conversation" until you send a message there or press Resume. This is unchanged.
• After an Orca restart, cards written before it wait under "Queue paused because Orca restarted". This is unchanged, and a Stop's pause never hides it.

Mechanism.

• The Stop event (JournalStopEvent in journal-row-schema.ts): reason is one of the host's four existing stop causes, user-stop, user-close, host-stop or evict (the same type the host already passes to the adapters; no new value). turnId is the turn the Stop named, else the one running when it took effect. at is when it took effect, and a rewind's restatement keeps it. caller is who asked. This PR writes only user-stop, and only a user-stop event pauses the queue.
• Where it is written (structured-agent-session-host-mutations.ts, through runRecordedStop in structured-agent-session-queued-stop.ts): in the Stop's serialized step, after it withdraws queued sends, and before the interrupt and before anything that ends the agent: the stop of an agent still starting, the stop of a running command, and any kill added after the interrupt. That order is an invariant a follow-up relies on: a Stop that ends the Claude process after the interrupt finds the event already written.
• A Stop that stopped nothing writes nothing. An idle Stop writes an event only if it withdrew a queued send. A repeated Stop (a second press while the first still holds the same turn) and a late Stop (naming a turn that already ended) write nothing new, so a message queued between two presses is not held by the second. A failed write is reported and the Stop still interrupts.
• Where each card was queued. Each card records the journal position it was queued at (new nullable queued_epoch and queued_sequence columns). The Stop pause holds a card only if it was queued before the Stop event. A steer the Stop withdrew keeps its original position, so it is held. A card from before a rewind, or from a build that recorded no position, counts as queued before, so it is held.
• Resume (agentSession.queuedMessagesResume, unchanged on the wire) appends its own marker row. It also adopts cards left from a restart, as before.
• The pauses are computed, not stored (deriveQueuePauses in queued-message-pause.ts). Every pause in force is derived from the journal fold and the cards:
  • "stopped": the latest Stop event is a person's (user-stop), and nothing has ended it since. A later Stop event of any reason ends it (a later person's Stop starts its own pause), and so does a Resume or a turn a person asked for that was sent after it and accepted. Turns Orca starts itself never end it: orchestration mail, restart continuations, launch prompts, the queue's own sends.
  • "cleared": a card that /clear carried in is waiting, and no person's turn or Resume has happened in the new chat. Each carried card records the chat it came from (a new nullable carried_from column).
  • "restarted": unchanged. It is still worked out per card from the host process that wrote it.
• One rule decides which cards are held (queuePauseHolding): a card is held if any pause in force holds it, and it names the first that does, so a Stop that holds nothing never hides a restart's pause. The queue's automatic send, the pause header and the send's own database transaction all use it. The header names the pause holding the first card Resume would send. Holding every waiting card instead is a one-line switch (PAUSE_HOLDS_CARDS_QUEUED_AFTER_IT).
• The queue never reorders. The drain picks the oldest card and stops at the first held one, as it already did for a returned card, so a newer card never overtakes a held one. The send's own transaction re-checks with the same rule (nextSendableQueuedCard). Stop and the drain share one serialized lane, so today a Stop can't land between the drain's pick and its hand-off; the re-check keeps the rule true for anything written outside that lane.
• Rewind. A Codex rewind replaces the chat's history with a new epoch. The new epoch restates what the pauses read: first a Resume marker if a person's turn or a Resume had already lifted /clear's pause, then the Stop event still in force, unchanged. So a rewind neither releases cards you stopped nor brings back a /clear pause you already lifted.
• Deleted:
  • recordPause and the stored-pause table functions (queued-message-pause-table.ts), and the table's creation on open;
  • queuePauseHoldsBack, retireQueuePauseIfNothingHeld and the hook that ran it on every appended journal row;
  • Stop's heal step, which existed only to feed the recorded pause;
  • mayReturnToWaiting and its row overlay;
  • the six tests that only proved the stored record retires.

Why

Derived beats stored. The old record was a latch: it was written only when it held something, and deleted by a check on every write once it held nothing. Every new way a hand-off could end, or a new order of the agent's replies, had to be taught to that check, or the record retired early and a card came back unpaused. The first version of this fix widened the check to cover "hand-off still unanswered". It still left a hand-off in the "unknown" state uncovered. Now nothing is stored beside the history, so there is nothing to retire and nothing to strand. The pause follows from what happened in the chat: who stopped, who resumed, and who sent the next turn.

Why one general Stop event rather than a queue-only row. The queue is only the first thing that needs to know a person stopped the agent. Whether a turn reads Interrupted or Failed after a restart needs the same fact, and today it is lost because it lives only in memory. Writing it once, in its final shape, lets parts B and C add readers without a second record of the same Stop.

Why a row in the chat's history and not a table. The pause has to be read in the same order as the sends it gates. The journal already orders every send, acceptance and interrupt. Deriving from it means the pause survives a restart or crash with no repair step.

Why the event rides the "remove an item" row type instead of a new row type. An Orca build that is already released treats a row type it doesn't know as corruption. When a user downgrades, it deletes every history row from that point on (journal-open.ts:93-99 marks the truncation point; journal-store-open.ts:55-58 deletes the rows). Bumping the row version instead would make an older build open the chat read-only. So the Stop event and the Resume marker are written as a "remove item" row, each for its own id that no item ever uses, with the event or marker as an extra field (stopEvent, queueResume). Older builds already ignore unknown fields on a row, so to them it removes nothing. The row is never sent to apps, and it never counts as the history that makes a rebuilt chat usable.

Differences from the common pattern

• Intended: the Stop event carries both the turn it stopped and why. Orca must match a Stop to the turn it ended across a restart, and must tell a person's Stop from the host stopping the agent, so it needs both.
• Intended: a steered message that Stop withdraws comes back to the queue as a waiting card. That is because Stop withdraws the hand-off before the agent accepted it (structured-agent-session-host-mutations.ts:185-189, the queued-send withdrawal at the top of Stop), which is already how main behaves; this PR only makes sure the card comes back paused.
• Intended: a Stop holds only the messages that were already queued when you pressed it. Example: messages A and B are queued, then you press Stop, so A and B are held. If the agent is idle, your next message C sends right away, and A and B send after it. If the agent is still busy, C waits in the queue behind A and B, and all three send in order when you press Resume. While the agent is busy, C never jumps ahead of A or B. The alternative was to hold every message after a Stop, including C, until you press Resume. Brennan chose the first.
• Intended: when you press Stop, messages you queued before it wait, even if the agent had already finished that turn (Codex can say so). You see "Queue paused because you interrupted" with Resume, and no "Cancellation requested." line, because nothing needed cancelling. Holding is the safe direction: nothing is lost or sent twice.
• Intended: only a turn a person asked for lifts the pause. Turns Orca starts itself never do (orchestration mail, restart continuations, launch prompts, the queue's own sends). Orca runs such turns after a Stop, and they must not drain a queue the person stopped. This was already the rule before this PR.
• Intended: a restart pauses the cards written before it, worked out per card from the host process that wrote it. This was already the rule before this PR; the history has no row for a crash to derive it from.
• Temporary: the Stop event and the Resume marker reuse the "remove an item" row type with an extra field instead of their own row type. A released Orca deletes the chat history from the first row of an unknown type. A test now replays this build's rows in release v1.4.218's own journal code: it keeps every row and folds the history after the Stop. Follow-up: make an older host skip a row kind it doesn't know instead of deleting from it; once that has shipped for a release, a row kind of its own replaces the tombstone.
• Temporary: Stop waits for its event's write until fix(native-chat): one ordered journal writer #24127 lands; then the write is issued and never awaited. On main today journal writes aren't synchronous, so this matches how main already waits for its queue pause.

Decision (Brennan)

A message you queue after a Stop is a new instruction and sends normally, except that it never jumps ahead of messages the Stop is holding. Holding every message instead (including ones queued after the Stop) is a one-line switch, PAUSE_HOLDS_CARDS_QUEUED_AFTER_IT in queued-message-pause.ts.

Linked Issue

None; found while rebuilding #21062.

Visual Proof

Live on a second Mac with Claude, the queue switched on in a local build only (never committed), at c0d96898dc8. The later commit only adds a guard for malformed rows.

A card queued during a turn	Steer, then Stop: held, not sent again	Your own message after Stop, then the held card

Two held cards under the pause	Pressing Stop twice	Cards carried after /clear

Your message lifts the /clear pause	Held after an Orca restart	Resume after the restart

Testing

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

The original bug, for both agents. A card is steered and then stopped. It comes back once as a waiting card under the "stopped" pause, and it is not sent again within a quiet window after the stopped turn ends.

• Codex: real host and Codex adapter, fake Codex process (structured-agent-session-codex-turn-end-settlement.test.ts).
• Claude: real host and Claude adapter, fake CLI (structured-agent-session-claude-queued-stop.test.ts).

The Stop event through the real host (structured-agent-session-stop-event.test.ts, 4 tests):

• It is in the journal when the interrupt reaches the agent, with the reason, the named turn and who asked.
• At an agent still starting, it is in the journal before the start is ended, and a card queued before the Stop stays held.
• An idle Stop writes one only when it withdrew a queued send.
• A Stop event written between the queue's pick and its hand-off still holds the card. This interleaving is forced in the test, since Stop and the queue share one serialized lane.

The queue under a Stop through the real host (structured-agent-session-queued-stop-row.test.ts, 10 tests): an empty-queue Stop holds nothing; a card queued after the Stop waits behind held ones and all send in order after Resume; only a person's accepted turn lifts it; a withdrawn steer comes back once and is not re-sent; a crash keeps the pause; a Stop never hides a restart's pause; /clear's carried cards; no pause table is read or written.

Journal level (queued-message-pause.test.ts, 23 tests; journal-stop-and-resume-rows.test.ts, 3 tests): only a user-stop event pauses (a close, host stop, eviction or unknown reason holds nothing); the event records its reason, turn, caller and its row's time; which cards each pause holds; the automatic send is refused in its transaction; a rewind restates the same Stop event and keeps a lifted /clear pause lifted; the rows never reach an app and never count as history that makes a rebuilt chat usable.

A released build (tests/e2e/cross-version-wire/agent-session-stop-event-downgrade.unit.test.ts): this build's rows, including a Stop event and a Resume, are replayed from release v1.4.218's own journal database with its own code. Every row is kept, the chat is not marked corrupt, the history after the Stop folds, and an older client is sent only removed ids that no item uses.

Ablations (each break undone after its run; the working tree was clean after every run):

Break	Result
Write the event after the stop of a starting agent	red: no event when the start was ended
Write the event after the interrupt	red: no event when the interrupt reached the agent
Write no event at a starting agent	red: the card queued before the Stop was sent
Idle Stop writes an event with nothing withdrawn	red
Idle Stop that withdrew a send writes nothing	red
Drop who asked from the event	red (3 tests)
Skip the pause check inside the send's transaction	red: the card was sent
A failed event write stops the Stop	red: the interrupt never ran
Let any reason pause the queue	red
Rewind restates no lift of /clear's pause	red (3 tests)
Rewind restates the lift after the Stop	red: the Stop no longer held
Rewind writes a new event instead of the same one	red
The batch to apps includes the rows	red
The rows count as history when a chat is reopened	red (2 tests)
Carry the event on a new row type (released-build test)	red: the released build truncated the journal

Runs: every test file that imports a touched module, plus the queue, Stop, pause, journal and cross-version tests (110 files, not counting real-CLI, real-binary and integration tests): 1169 of 1170 passed. The one failure, release-checkout.unit.test.ts ("loads a baseline module whose source imports another checkout-root file"), is the release-extraction harness's own test; it timed out at 30 s under the parallel run and passes on its own, and it imports nothing this PR touches. oxlint is clean on the changed files, and the changed-code quality gate passes. I did not run the typecheck locally; CI covers it.

AI Disclosure

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

• SSH / remote: the change is on the host that runs the agent, so local and SSH hosts behave the same.
• Mixed versions (wire): no new field, value or RPC. The published pause keeps the same shape and reasons (stopped, cleared, restarted).
• Mixed versions (published content): the pause now also shows when a Stop's only held message is a steer that came back. Older desktop and phone clients already render stopped.
• Mixed versions (the Stop event and Resume rows): these rows are never sent to apps; the stream to desktop and phone skips them and only moves the history position.
• Downgrade: an older host reads the Stop event and Resume rows as removing nothing, and ignores the new carried_from, queued_epoch and queued_sequence columns. The waiting cards were written by another host process, so it pauses them as "restarted" until you press Resume or send a message. The queue is switched off in every released build, so no released user can hit this.
• Every Stop that takes effect writes one small row, even while the queue is switched off. It moves the history position and the chat's last-activity time, as the Stop's own note already did. A repeated Stop that stops nothing writes nothing.
• Composes with fix(native-chat): one ordered journal writer #24127, which makes journal writes synchronous: the Stop event is one call before the interrupt. Composes with fix(native-chat): every chat action press is its own action #23916, which adds a host-side join for repeated Stop presses at the front of Stop; the combined order is join, withdraw queued sends, write the Stop event, then interrupt or end the agent.

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)

[greptile-apps]

Confidence Score: 4/5

[High risk] Refactors how the queue pause state is tracked and derived.

The PR does not appear safe to merge until the outstanding rewind ordering issue is fixed.

Findings

1.  Rewind holds newer cards ▶

Summary

This PR replaces the stored queue-pause record with a pause derived from Stop events and journal history, so a withdrawn steered message remains held instead of being sent again.

• It records queue positions, preserves pause markers across epoch replacement, and adds host and downgrade tests.
• Since the previous review, the PR adds its existing downgrade test to the cross-version CI job.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart LR
  A[Queued card] --> B[Steer into running turn]
  B --> C[User Stop event in journal]
  C --> D[Withdrawn card returns to queue]
  D --> E[Derive pause from Stop and card position]
  E --> F[Hold until Resume or accepted user turn]

Loading

_{Reviews (6) · Last reviewed commit: "Merge remote-tracking branch 'origin/mai..."}

[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

🧰 Additional context used

📚 Code guidelines (1)

AGENTS.md — auto-discovered

📝 Walkthrough

Walkthrough

The change replaces persisted queue-pause facts with pauses derived from journal Stop and Resume rows and queued-card state. Queued-message rows now store their source conversation and queue-time journal cursor. Stop handling appends qualifying journal events, while Resume appends a resume row. Queue draining, publication, restart adoption, and epoch replacement use the derived pause state. Tests cover journal replay, queue behavior, host restarts, and cross-version compatibility.

Priority: ⬇️ Low

Merge Risk: 🔵 Low · up to a029d

In a narrow race, a Stop that names an already-finished turn could pause the queue even though nothing was stopped. Resume clears the pause, and the mid-turn queue is still switched off on main. This is worth fixing but need not block the merge.

Security Architecture Review

Security architecture risk: 🔵 Low · up to a029d

The change strengthens Stop handling for queued messages and retains existing access checks. Remaining uncertainty concerns storage failures and behavior when switching versions. The queue is reported to remain disabled by default.

Retained concerns
No architecture-level concerns identified.

Security review details

Security Blast Radius

• inferred — The inspected changed control flow is scoped to the admitted session's journal and queued cards. Unintended redispatch would send a preserved message into that session's existing agent execution path; broader transport, credential and environment exposure was not established by this review.

Trust Boundaries and Controls

• observed — Resume reaches the journal through the existing caller-aware conversation-write mutation path. Admission binds the operation fingerprint to the session, requires an attached journal, handles replay and supplies the lease-derived runtime fence. This verifies local admission, not upstream transport authentication.

Resilience and Maintainability Implications

• observed — A failed Stop-event append is logged while interruption proceeds, leaving no Stop-derived pause. The base implementation likewise swallowed separate pause-record failures. This is a pre-existing failure-containment limitation, not an established PR regression; the head includes a test explicitly expecting pause loss on append failure.

Hardening Proposals

• proposed — Consider preserving an automatic-dispatch hold when Stop recording fails, without delaying the immediate interrupt, and validate its recovery after storage becomes writable or the host restarts. This would strengthen an existing limitation rather than address a verified new vulnerability.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

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

✅ Passed checks (4 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly describes the main fix: deriving Stop pauses from chat history prevents steered messages from being sent again.
Description check	✅ Passed	The description is detailed and covers the user impact, mechanism, rationale, testing, visual proof, compatibility, and scope. It does not provide the required linked issue and leaves some checklist i…
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.

Full details: Docstring Coverage

Explanation

Docstring coverage is 57.84% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 102 functions across 46 files. (1 skipped: 1 unsupported.)

• Fix all pre-merge checks with AI

✨ Finishing Touches 💡 2

📝 Generate docstrings 💡

• Commit to this branch
• Create a new PR

🛠️ Fix failing CI checks 💡

• Commit to this branch
• Create a new PR

---

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

[pullfrog]

✅ No new issues found.

Reviewed changes — the full diff at 6ce9464a1c (10 files, +432/−30), the five production files and the six touched test suites, verified locally.

• The fix (queued-message-settlement.ts) — owedBackToWaiting is widened and renamed to mayReturnToWaiting: a dispatched draft whose submission is pending (a Stop may yet withdraw it) now counts as held, alongside the pre-existing "rejected and still owed a return to waiting" case.
• Judging the appending row (mayReturnToWaiting's row argument) — the row currently being committed counts as already applied, so a submission row for the consumed card keeps the pause across the hand-off, and an accepted dispatch row retires the pause in its own write. Terminal submissions are never reopened (journalDispatchRowApplies).
• Threading (journal-queued-messages.ts) — pauseScope(row) is passed from the standing onRowInTransaction hook and consumeInTransaction; queuedMessageConsumeHook now returns JournalRowTransactionHook.
• Companion edits — queued-message-pause-table.ts and structured-agent-session-queued-stop.ts carry the parameter/doc rename only; no logic change.
• Tests — new red-first cases for Claude and Codex, a new six-case suite covering every way a hand-off ends, two store-level tests, and a test-only restartable rig option.

Verification. Traced the "pause can't get stuck" claim through every path that ends a hand-off (withdraw, accept — dispatch row and echo-accept item row, provider death/close/restart settling to unknown, owed-but-skipped settlement, /clear behind messagesUnsettled) and confirmed each either appends a row that re-runs retireQueuePauseIfNothingHeld or is lifted by retireEndedQueuePause; found no latch. Publication is still gated by hasResumableQueuedMessage, so a pending dispatched card shows no pause until it returns to waiting. Ran queued-message-store.test.ts, structured-agent-session-queued-pause-handoff-end.test.ts, structured-agent-session-claude-queued-stop.test.ts, structured-agent-session-codex-turn-end-settlement.test.ts (62 tests pass) and pnpm tc:node (clean). The widened predicate intentionally also covers host-origin auto-drained cards, which the PR body states explicitly.

  ^{｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

Important

One logic gap in the new stopReachesUnrecordedWork can write a Stop event — and so pause the queue — for a Stop that stops nothing. It is not user-reachable today (the queue is off), but it is the one place this PR's own documented invariant ("a Stop that stopped nothing writes nothing") does not hold, and part B will read these events when settling a turn after a restart. Details inline; the rest of the derived-pause rework held up under a deep pass.

Reviewed changes — the full diff at 989f90bd (40 files, +2368/−672), all 27 production files and the 13 test suites, plus surrounding callers.

• Stop event — a person's Stop appends one JournalStopEvent ({ reason, turnId?, at, caller? }), written after it withdraws queued sends and before the interrupt / at-start stop / kill, so a card the interrupt sends back comes back under the pause.
• Carrier — the event and a Resume marker ride tombstone rows with extra stopEvent / queueResume keys, so a released build reads them as removals of an unused id rather than an unknown row kind it would truncate from.
• Derived pause — queued-message-pause.ts replaces the stored queued_message_pauses fact with deriveQueuePauses over the journal fold and the cards (stopped / cleared / restarted); queuePauseHolding / nextSendableQueuedCard / resumableQueuePause become the single rule the drain, its consume re-check and publication all read.
• Card position — new carried_from / queued_epoch / queued_sequence columns give each card its journal position; a Stop holds only cards queued before it.
• Deleted — recordPause, the pause table and its read/write/retire helpers, queuePauseHoldsBack, mayReturnToWaiting, and Stop's heal step.
• Rewind — replaceJournalEpoch restates a Resume row then the live Stop, so a rewind neither releases stopped cards nor resurrects a lifted /clear pause.

ℹ️ Nitpicks

• deriveQueuePauses's cleared guard (queued-message-pause.ts:124) is existential — latestPersonTurnSequence === 0 && marks.resumedSequence === 0 — while the header says no person turn or Resume happened since the carry. A carried card inserted after an unrelated Resume/person turn would not be held. Not reachable through today's one /clear-only producer, but the comment states a stronger invariant than the code enforces.

  ^{｜ Fix all ➔ ｜ Fix 👍s ➔ ｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

live is captured before isMainAgentWorkingOnceFlushed flushes, and the post-flush active turn is never compared against namedTurnId. A Stop that names a turn which already ended can therefore fall through to inForce === null and return true (writing an event and pausing the queue) even though performCancel will refuse to stop anything — the exact case the docstring calls out as "writes nothing".

Technical details

# `stopReachesUnrecordedWork` misses a turn published by its own flush

## Affected site
- `src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts:64-76` — `live` is read at line 64; `isMainAgentWorkingOnceFlushed` (line 69) awaits `flushStreamedEvents()` and re-reads `activeTurnId()`, but the guard only uses the pre-flush `live`.

## Why it writes when it should not
A phone (or any client) taps Stop naming `turn-A`, which ended before the Stop was admitted, so the pre-flush `activeTurnId()` is `null`. A newly-started turn `turn-B` has its provider echo buffered (Claude's echo lands one sink write before its turn row — `structured-agent-session-turns-cancel.ts:16-17`). The flush publishes `turn-B`, `isMainAgentWorkingOnceFlushed` returns `true`, and the guard evaluates `('turn-A' !== null) && (null !== null || !true)` → `false`, so it does not short-circuit. `userStopInForce()` is `null`, so line 74 returns `true` and `tookEffect()` writes a Stop event naming `turn-A`. `performCancel` then passes `turnId: 'turn-A'` to an adapter whose live turn is `turn-B`, which both Claude (`claude-structured-prompt-ownership.ts`) and Codex (app-server rejects a mismatched turn id) refuse. Net: an event with no effect, plus a derived `stopped` pause holding cards queued before it.

## Required outcome
A Stop that names neither the pre-flush nor the post-flush active turn must write nothing. The "named turn may still be opening" case (pre-flush `live === null`, post-flush `live === namedTurnId`) must keep writing.

## Suggested approach
Re-read `ctx.journal.activeTurnId()` after the `await isMainAgentWorkingOnceFlushed(ctx)` and, when it is non-null and `!== namedTurnId`, return `false`.

## Tests
The existing `names a turn already over … writes nothing` case builds a rig with no child, so it exits at the `!child || !inFlight` branch in `structured-agent-session-host-mutations.ts:202` and never reaches `stopReachesUnrecordedWork`; `names a turn that ended while the next card is sent but shows no turn yet` covers a flush that yields no turn, not one that yields a different turn. A case where the flush publishes a turn other than the one named is the gap.

[pullfrog]

The comment says these are ids "no item ever takes", but they are not reserved. agentJournalItemKey({ provider: 'orca', clientMessageId }) is the same orca:<clientMessageId> shape agentJournalSubmissionKey builds from a submission's wire clientOperationId, which is only validated as a non-empty trimmed string. A client sending clientOperationId: 'stop-event' (or 'queue-resume') owns a live item at the mark's id; this build skips the tombstone removal (isJournalStopOrResumeRow short-circuits the reducer) but a released build would remove that real item on a downgrade — which also means it reappears on re-upgrade.

Technical details

# Mark ids collide with the client-controlled `orca:` identity namespace

## Affected sites
- `src/main/native-chat/agent-session-journal/journal-stop-and-resume-rows.ts:10-17` — the two mark ids.
- `src/shared/agent-session-journal-item-key.ts:142-144` — `orca` items are `<provider>:<clientMessageId>`.
- `src/shared/agent-session-journal-item-key.ts:154-156` — `agentJournalSubmissionKey` uses the same shape.
- `src/main/native-chat/agent-session-journal/journal-reducer.ts:112-118` — this build skips the removal for a mark row; a release does not.

## Required outcome
No client-chosen `clientOperationId` can address the Stop/Resume marks, so a release reading a mark tombstone can only ever remove an id no item holds.

## Suggested approach
Use ids outside the client namespace (e.g. a provider/prefix a submission key can never equal), or reject a `clientOperationId` equal to the two marks at admission.

## Open question
Is the intended invariant just "no *current* client mints these", which the `<digits>-<hex>` client format already satisfies for normal traffic? If adversarial/older clients are out of scope, this is documentation only.

[coderabbitai]

Actionable comments posted: 1

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: 45eb6b7e-6b04-4afb-b831-c17bea12f05c

📥 Commits

Reviewing files that changed from the base of the PR and between 989f90b and 506c4fa.

📒 Files selected for processing (8)

• .github/workflows/pr.yml
• src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-stop-ends-session.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-restore-without-import.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
• src/main/runtime/structured-agent-session-codex-turn-end-settlement.test.ts

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

• src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts

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

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Read the active turn again after the flush.

The function reads live before isMainAgentWorkingOnceFlushed flushes streamed events. Suppose a Stop names an ended turn turn-A, and the flush publishes a new turn turn-B. In that case isMainAgentWorkingOnceFlushed returns true, so the guard does not return false. The function then reaches inForce === null and returns true. The Stop writes an event and pauses the queue. performCancel then refuses the mismatched turnId. Line 93 also compares against the stale live. This problem is still present from the earlier review.

Proposed fix

-  const live = ctx.journal.activeTurnId()
+  let live = ctx.journal.activeTurnId()
   // No turn published yet while the agent works: the named one may still be opening.
-  if (
-    namedTurnId !== undefined &&
-    namedTurnId !== live &&
-    (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx)))
-  ) {
-    return false
-  }
+  if (namedTurnId !== undefined && namedTurnId !== live) {
+    if (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx))) {
+      return false
+    }
+    live = ctx.journal.activeTurnId()
+    if (live !== null && live !== namedTurnId) {
+      return false
+    }
+  }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	const live = ctx.journal.activeTurnId()
	// No turn published yet while the agent works: the named one may still be opening.
	if (
	namedTurnId !== undefined &&
	namedTurnId !== live &&
	(live !== null || !(await isMainAgentWorkingOnceFlushed(ctx)))
	) {
	return false
	}
	let live = ctx.journal.activeTurnId()
	// No turn published yet while the agent works: the named one may still be opening.
	if (namedTurnId !== undefined && namedTurnId !== live) {
	if (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx))) {
	return false
	}
	live = ctx.journal.activeTurnId()
	if (live !== null && live !== namedTurnId) {
	return false
	}
	}

[pullfrog]

Important

Re-review at the merge head 506c4fab: the only change since the prior pullfrog review (989f90bd) is merges of origin/main, and the outstanding logic gap in stopReachesUnrecordedWork still stands. The derived-pause rework itself held up under the prior deep pass.

Reviewed changes — the full diff at 506c4fab (42 files, +2447/−672), base main (3a6148e6); all production files and the touched suites. Delta from the prior review at 989f90bd is merge-only: the PR's own files are unchanged, and stopReachesUnrecordedWork is byte-identical, so the finding below carries forward.

• Stop event — a person's Stop appends one JournalStopEvent ({ reason, turnId?, at, caller? }), after it withdraws queued sends and before the interrupt / at-start stop / kill, so a card the interrupt sends back comes back under the pause.
• Carrier — the event and a Resume marker ride tombstone rows with extra stopEvent / queueResume keys, so a released build reads them as removals of an unused id rather than an unknown row kind it would truncate from.
• Derived pause — queued-message-pause.ts replaces the stored queued_message_pauses fact with deriveQueuePauses over the journal fold and the cards; queuePauseHolding / nextSendableQueuedCard / resumableQueuePause become the single rule the drain, its consume re-check and publication all read.
• Card position — new carried_from / queued_epoch / queued_sequence columns give each card its journal position; a Stop holds only cards queued before it.
• Deleted — recordPause, the pause table and its read/write/retire helpers, queuePauseHoldsBack, mayReturnToWaiting, and Stop's heal step.
• Rewind — replaceJournalEpoch restates a Resume row then the live Stop, so a rewind neither releases stopped cards nor resurrects a lifted /clear pause.

  ^{｜ Fix all ➔ ｜ Fix 👍s ➔ ｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

live is read before isMainAgentWorkingOnceFlushed flushes, and the post-flush active turn is never compared to namedTurnId. So a Stop naming a turn that already ended can still fall through to inForce === null and return true, appending a Stop event (and, once the queue is on, deriving a stopped pause) while performCancel acts on a different turn or refuses it — the case the docstring calls out as "writes nothing". This is the same gap flagged in review 5373943316 and is unchanged at this head.

Technical details

# `stopReachesUnrecordedWork` misses a turn published by its own flush

## Affected site
- `src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts:66-93` — `live` is captured at line 70; `isMainAgentWorkingOnceFlushed` (line 75) awaits `flushStreamedEvents()` and re-reads `activeTurnId()`, but the guard only uses the pre-flush `live`.

## Why it writes when it should not
A client taps Stop naming `turn-A`, which ended before the Stop was admitted, so the pre-flush `activeTurnId()` is `null`. A newly-started turn `turn-B` has its provider echo buffered (Claude's echo lands one sink write before its turn row). The flush publishes `turn-B`, `isMainAgentWorkingOnceFlushed` returns `true`, and the guard evaluates `('turn-A' !== null) && (null !== null || !true)` → `false`, so it does not short-circuit. `userStopInForce()` is `null`, so line 80 returns `true` and `tookEffect()` writes a Stop event naming `turn-A`. `performCancel` (`structured-agent-session-chat-stop.ts:84`) passes `turnId: 'turn-A'` while the adapter's live turn is `turn-B`, so the interrupt either refuses or acts on `turn-B` under an event that names `turn-A` — part B settles turns from exactly this field.

## Required outcome
A Stop that names neither the pre-flush nor the post-flush active turn must write nothing. The "named turn may still be opening" case (pre-flush `live === null`, post-flush `live === namedTurnId`) must keep writing.

## Suggested approach
Re-read `ctx.journal.activeTurnId()` after `await isMainAgentWorkingOnceFlushed(ctx)` and, when it is non-null and `!== namedTurnId`, return `false`.

## Tests
`names a turn already over … writes nothing` builds a rig with no child, so it exits at the `!child || !inFlight` branch before reaching this function. `names a turn that ended while the next card is sent but shows no turn yet` covers a flush that yields no turn, not one that yields a different turn. A case where the flush publishes a turn other than the one named is the gap.

[coderabbitai]

♻️ Duplicate comments (1)

src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts (1)

74-81: 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Read the active turn again after the flush and compare it with namedTurnId.

The function reads live at Line 74, before isMainAgentWorkingOnceFlushed flushes. Consider a Stop that names an ended turn turn-A when the flush publishes turn-B. The guard does not return false. If userStopInForce() is null, the function returns true. The Stop then writes an event and pauses the queue. performCancel then refuses the mismatched turn, or acts on a different turn. Line 96 also uses the stale live. An earlier review reported this problem, and the code still has it.

Proposed fix

-  const live = ctx.journal.activeTurnId()
-  if (
-    structuredAgentSessionStopNamesTurnNotLive(namedTurnId, live) &&
-    (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx)))
-  ) {
-    return false
-  }
+  let live = ctx.journal.activeTurnId()
+  if (structuredAgentSessionStopNamesTurnNotLive(namedTurnId, live)) {
+    if (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx))) {
+      return false
+    }
+    live = ctx.journal.activeTurnId()
+    if (live !== null && live !== namedTurnId) {
+      return false
+    }
+  }

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: 930c2b40-8c85-4601-8a22-2812290be69a

📥 Commits

Reviewing files that changed from the base of the PR and between 506c4fa and cc2d622.

📒 Files selected for processing (7)

• .github/workflows/pr.yml
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-queued-stop.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-repeated-stop.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-turn-stop-notes.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts

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

[pullfrog]

Important

The cc2d622 refactor is clean and behavior-preserving, but the gap flagged in the two prior reviews is unchanged: a Stop that names an already-ended turn can still write a Stop event when its own flush publishes a different running turn. Details inline. The rest of the derived-pause rework still holds.

Reviewed changes — the delta since the prior pullfrog review at 506c4fab (5 files, +53/−13): the merge of origin/main, plus cc2d622bfd, a behavior-preserving refactor.

• Extracted the Stop's turn facts — structuredAgentSessionStoppedTurnId and structuredAgentSessionStopNamesTurnNotLive now live in structured-agent-session-turn-stop-notes.ts, shared by the event's turn, the note key, the session-ending condition, the running-command check and the repeat check.
• No behavior change — the three rewritten predicates (runningCommand, the endsSession guard, the note identity) are logically identical to the originals, and structuredAgentSessionStoppedTurnId reads activeTurnId() at the same point the inline expression did.
• New tests — an unnamed Stop records the running turn on its event and rewrites that turn's note as a named Stop does (structured-agent-session-repeated-stop.test.ts, structured-agent-session-stop-event.test.ts). Both suites pass locally (19 tests).

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

[pullfrog]

Carried forward from reviews 5373943316 / 5377587027 and unchanged by this refactor: live is still read before isMainAgentWorkingOnceFlushed flushes, and the post-flush turn is never compared with namedTurnId. So a Stop naming an already-ended turn-A whose flush then publishes a different running turn-B falls through to userStopInForce() === null and writes a Stop event naming turn-A, while performCancel refuses or acts on turn-B. That is the exact case the docstring promises writes nothing, and it is the revised-behavior claim the ready-for-review summary makes; part B will read these events to settle turns.

Technical details

# `stopReachesUnrecordedWork` misses a turn published by its own flush

## Affected site
- `src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts:74-81` — `live` is read at line 74; `isMainAgentWorkingOnceFlushed` (line 78) awaits `flushStreamedEvents()` and re-reads `activeTurnId()`, but the guard only uses the pre-flush `live`.
- Caller `structured-agent-session-chat-stop.ts:72` short-circuits its own `isMainAgentWorkingOnceFlushed` when `turnId !== undefined`, so a named Stop reaches line 81 without a prior flush.

## Why it writes when it should not
Pre-flush `activeTurnId()` is `null` (turn-B's provider echo is buffered — `structured-agent-session-turns-cancel.ts:27-28`). The flush publishes turn-B and `isMainAgentWorkingOnceFlushed` returns `true`, so the guard evaluates `(named !== null) && (null !== null || !true)` -> `false` and does not short-circuit. `userStopInForce()` is `null` for a fresh chat, so line 83 returns `true` and `tookEffect()` writes a Stop event naming `turn-A`.

## Required outcome
A Stop naming neither the pre-flush nor the post-flush active turn must write nothing, while the "named turn may still be opening" case (pre-flush `live === null`, post-flush `live === namedTurnId`) keeps writing.

## Suggested approach
Re-read `ctx.journal.activeTurnId()` after `await isMainAgentWorkingOnceFlushed(ctx)` and return `false` when it is non-null and `!== namedTurnId`.

## Tests
The existing late-Stop case builds a rig whose flush yields no turn, so it does not cover a flush that yields a different turn.

[pullfrog]

Important

The a0f9c2e refactor is clean and behavior-preserving, and the origin/main merges (host-logger migration) integrate without issue — no new problems were found in this delta. One previously flagged logic gap is unchanged and still blocks merge, which is why this is not an approval.

Reviewed changes — the delta since the prior pullfrog review at cc2d622 (46 files at a0f9c2e, base main merge-base 198fe72066): the a0f9c2e author commit (2 files, +48/−1) plus the merges of origin/main.

• Shared Stop-turn helper in the failed-interrupt branch — performCancel now calls stillRunsStoppedTurn(ctx, stoppedTurnId) where it previously used a local input.turnId ?? liveTurnId; stoppedTurnId = structuredAgentSessionStoppedTurnId(journal, input.turnId) resolves to the same value, read at the same point before the cancel (structured-agent-session-turns-cancel.ts:149, :237).
• Codex regression test — a Stop whose Codex interrupt failed ends the child, holds a card queued before it under queuePause.reason === 'stopped', and asserts the Stop event row precedes the turn's end row (structured-agent-session-codex-stop-row.test.ts:383).
• Host-logger migration from origin/main — adoptEndedRestartPause takes a logger, Stop's failure reporting moved from console.warn to ctx.logger.warn (structured-agent-session-queued-stop.ts:94), and the wiring threads context().deps.logger; retireEndedQueuePause is removed with no stale references.

⚠️ stopReachesUnrecordedWork still writes a Stop event for a Stop that stops nothing

This was raised in the three prior reviews and is untouched by a0f9c2e (which changes turns-cancel.ts, not queued-stop.ts), so it is not re-anchored here — the open thread carries the detail. It remains the one place the PR's own "a Stop that stopped nothing writes nothing" invariant does not hold, and part B reads these events to settle a turn after a restart.

Technical details

# `stopReachesUnrecordedWork` misses a turn published by its own flush

## Affected sites
- `src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts:69-92` — `live` is read at line 69; `isMainAgentWorkingOnceFlushed` (line 73) awaits `flushStreamedEvents()` and re-reads `activeTurnId()`, but the guard only uses the pre-flush `live`.
- Caller `structured-agent-session-chat-stop.ts:74` short-circuits its own `isMainAgentWorkingOnceFlushed` when `turnId !== undefined`, so a named Stop reaches line 83 without a prior flush.

## Why it writes when it should not
A Stop names an already-ended `turn-A` (pre-flush `activeTurnId()` is `null`); a freshly-started `turn-B` has its provider echo buffered. The flush publishes `turn-B`, `isMainAgentWorkingOnceFlushed` returns `true`, and the guard evaluates `(A !== null) && (null !== null || !true)` -> `false`, so it does not short-circuit. `userStopInForce()` is `null`, so line 79 returns `true` and `tookEffect()` writes a Stop event naming `turn-A`, while `performCancel` refuses or acts on `turn-B`. Net: an event with no effect, plus a derived `stopped` pause holding cards queued before it.

## Required outcome
A Stop naming neither the pre-flush nor the post-flush active turn must write nothing; the "named turn may still be opening" case (pre-flush `live === null`, post-flush `live === namedTurnId`) must keep writing.

## Suggested approach
Re-read `ctx.journal.activeTurnId()` after `await isMainAgentWorkingOnceFlushed(ctx)` and return `false` when it is non-null and `!== namedTurnId`.

## Tests
The existing late-Stop case builds a rig whose flush yields no turn, so it does not cover a flush that yields a different turn.

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

[coderabbitai]

♻️ Duplicate comments (1)

src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts (1)

69-76: 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Read the active turn again after the flush.

live is read before isMainAgentWorkingOnceFlushed flushes streamed events. Consider this sequence. A Stop names an ended turn-A. The flush then publishes a new turn-B. The guard does not return false, so the function returns true when userStopInForce() is null. The Stop then writes an event that names turn-A and derives a stopped pause, but performCancel refuses the mismatched turn. Line 91 also compares against the stale live. Earlier reviews reported this issue, and it is not fixed.

Proposed fix

-  const live = ctx.journal.activeTurnId()
-  if (
-    structuredAgentSessionStopNamesTurnNotLive(namedTurnId, live) &&
-    (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx)))
-  ) {
-    return false
-  }
+  let live = ctx.journal.activeTurnId()
+  if (structuredAgentSessionStopNamesTurnNotLive(namedTurnId, live)) {
+    if (live !== null || !(await isMainAgentWorkingOnceFlushed(ctx))) {
+      return false
+    }
+    live = ctx.journal.activeTurnId()
+    if (live !== null && live !== namedTurnId) {
+      return false
+    }
+  }

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: 80fa45cf-ece2-4e33-b333-6c89b48929be

📥 Commits

Reviewing files that changed from the base of the PR and between cc2d622 and a029dfb.

📒 Files selected for processing (16)

• .github/workflows/pr.yml
• src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-queued-stop.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-claude-stop-ends-session.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-queued-message-rig.test-fixture.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-messages.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-pause.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-queued-wiring.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-repeated-stop.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-restore-without-import.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts
• src/main/runtime/structured-agent-session-codex-turn-end-settlement.test.ts

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