fix(native-chat): turn facts come from the turn record, and /compact is a message the chat sends

[brennanb2025]

	Files	Added	Deleted	Net
Test	129	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​6668	$\color{#cf222e}{\Huge{\mathbf{−}}}$​1678	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​4990
Prod	144	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​4030	$\color{#cf222e}{\Huge{\mathbf{−}}}$​1654	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​2376

Builds on #22835 and #22944, both now merged; this PR targets main.

ELI5

Typing /compact in a structured chat used to paint its result inside the previous turn: the "Conversation compacted" line folded away under the last answer's "Worked for", the previous turn's timing moved, and the sidebar re-dated the chat as if new work had finished. Messages typed while it ran were refused. Now /compact is a message the chat sends like any other: it gets its own row, its own "Worked for", a visible result, and the turn before it is left alone. Messages typed meanwhile wait and are sent right after it.

Scope: which chat this affects

• Structured chat (desktop and mobile): /compact behaves as described above; rows are grouped under the turn they belong to instead of the user message above them; error rows and the compaction separator never fold away. It is behind the experimentalStructuredNativeChat setting, off by default.
• Default chat view: no change. It has no journal, so it keeps today's grouping by position.
• Terminal agents and plain terminals: no change.

What Changed

Terms used below: the journal is the saved record of every row in a structured chat; the delivery loop is the host step that hands queued messages to the agent one at a time; a provider's translator is the code that turns the agent's output into journal rows; a steer is a message sent while the agent is still working on a turn.

Before

• /compact ran outside the send path. The host wrote a status row that pretended to be a running turn and later overwrote it with the result, so the result drew inside the previous turn and folded under its "Worked for".
• A 180 s timer decided when a compaction was "unconfirmed"; after it, a late result could still arrive and rewrite the row.
• Sends were refused while a compaction ran, on the host and in the desktop composer.
• After /compact the sidebar showed "/compact" as the latest prompt, raised a completion notification and moved the row's "done" time.
• Rows were grouped by position: every row belonged to the last user message above it. A message typed into a running turn split it in two, and output from a turn the provider started on its own (a Claude background wake) folded under the previous turn.
• A child that died mid-turn wrote its "exited unexpectedly" row as an ordinary status row, which folded away. A Claude child that died after echoing a message often wrote no exit row at all.

After

• /compact is accepted into the chat's queue as the user's message, marked with command: {name: 'compact'}. The existing command RPC is a front door to that path and replies once the command is handed over to the agent: completed now means "started".
• When the delivery loop reaches it, it opens the command's own turn record and hands /compact to the provider. From then on the provider's translator owns that turn exactly as it owns any turn: it ends it from the provider's own frames and writes the result (the compaction separator, or the provider's error).
• While a command's turn runs on a live agent, the loop hands nothing else over. Messages typed meanwhile wait, are drawn below the "Compacting the conversation" line, and are delivered after it, even if it fails. Each takes its place in the transcript, and starts its "Worked for", at the moment it is handed over.
• A compaction counts as done only when the provider reports the compaction itself. Without that, it is "stopped" if Orca interrupted it and "failed" otherwise.
• Stop interrupts a command like any turn. If the provider cannot take the interrupt (Codex before it opens the compaction's turn), or a second Stop finds the first went unanswered, Stop restarts the agent and the command ends as interrupted.
• If the agent exits mid-command, the exit row is shown on that command's turn and the next message starts a new agent.
• There is no completion deadline. The command ends when the provider reports its end, when the agent exits, on Stop, or on a host crash (the next open settles it as for any turn).
• Every journal row states which turn it belongs to (turnScope). Desktop and mobile group rows by that, anchored on the message that opened the turn, or on the turn itself when the provider opened it unasked. The live turn is the one actually running, so a background wake's tools stay live and the previous turn keeps its "Worked for". Since fix(native-chat): show the "Working for" bar while a turn runs #23537 moved a running turn's clock from the bottom activity line onto the turn's own bar, the wake's running "Working for" bar draws at the wake's first row and settles there to "Worked for"; a turn opened by a message draws it under that message, as fix(native-chat): show the "Working for" bar while a turn runs #23537 does.
• A message Claude answers in its own turn after the running one draws after every row the running turn wrote after it, so the earlier turn's answer stays under the earlier turn's bar. fix(native-chat): keep a turn's bar on the prompt that opened it #23573 (a turn's bar stays on the prompt that opened it) and fix(native-chat): group chat rows by the turn that produced them #23671 (rows grouped by the turn that produced them) keep their behaviour on this model: hosts that state turnScope group by it, and fix(native-chat): group chat rows by the turn that produced them #23671's journal-order grouping remains for older hosts that state none.
• Rows that report how a turn ended (an error, the compaction separator) never fold.
• The sidebar's prompt, preview, verdict and time, the completion feed and restart resume all read past a command to the last real request. A /compact neither notifies nor re-dates the row.
• Rewind keeps each retained row's turn and producer, so a subagent's row stays the subagent's after a rewind, and each turn keeps the message that opened it.

Why

The bug class came from one fact being derived from position instead of read from its record: which turn a row belongs to. /compact was the loudest case, but messages sent into a running turn, turns the provider started on its own, and the exit row all hit the same rule. Stating the turn on the row, at the write that creates it, removes the rule instead of guarding each case.

/compact joins the send path because the send path already owns ordering, idempotency, withdrawal on Stop, crash recovery and "not sent" with Retry. The separate command runner duplicated a weaker version of each, which is why it needed the 180 s timer, the late-result repair and a record that blocked every send after a crash.

A command ends the way every turn ends: the provider's translator reads it from the provider's frames, and the agent's exit settles anything left running. The delivery loop keeps no state about the command; it only declines to hand over while the journal shows a command running on a live agent. An earlier revision kept a separate compaction tracker beside the journal, and review kept finding defects in it (a stalled queue when Codex exited, a late Stop cancelling the next compaction, a stopped compaction swallowing the next reply); removing the tracker removed that class.

Alternatives considered:

• Keep the runner, fix the fold with a rule for status rows. Rejected: it adds a second rule beside the positional one and leaves messages sent into a running turn and provider-started turns wrong.
• Wait for the command to finish before replying to the RPC. Rejected: with no deadline, mobile's 195 s request timeout would report every long compaction as unconfirmed. Replying at handover is what the reply shape can honestly mean.
• Keep a deadline. Rejected: Stop always ends the command, so a hung compaction reads "Working" until the user stops it, rather than being guessed at.
• A command tracker in each provider adapter, correlated per input. Rejected after review: it keeps a second record of "a command is running" that can disagree with the journal.

Persisted fields (decided once)

• turnScope: {kind: 'turn', turnItemId} | {kind: 'thread'} on the journal row base, lifecycle mutations, dispatch{pending} rows and render items. It names the turn record's journal key, not a provider turn id, so it survives rewinds and provider changes, and it answers membership, anchoring and "belongs to no turn" with one field. Rows stored without it get one on replay from the root turn open when they were created, so no migration is needed.
• command: {name} on a user message body. The text stays what the user typed; the marker says which command it is, so no reader parses text.
• providerTurnId on a turn record, written only on a command turn once Codex opens a turn for it. Nothing else can re-derive that claim after the command settles, and rewind needs it to place that turn's rows.
• Optional turnScope and producer fields on a rewind record's retained rows. Records written before them replay through the same derivation.

Differences from the common pattern

• Matches: a compaction travels the ordinary send path as the user's message, marked as a command rather than recognised by its text; each row carries the turn it belongs to; a turn with no opening message anchors on itself; Stop interrupts a compaction and never settles it by itself; the command reply returns once the work has started.
• The command's turn is opened by the delivery loop and ended by the provider's translator. The common pattern opens the compaction's turn inside the provider adapter. Claude opens no turn for /compact, so Orca writes the record at handover; on Codex the provider's turn is claimed into it.
• Held messages are saved when accepted and placed when handed over. The common pattern keeps them in a separate queue and adds them to the conversation only when sent. Saving them at once keeps them across a restart; placing them at handover gives the same order on screen.
• Messages held behind a failed compaction are delivered. The common pattern cancels them or leaves them waiting. A user's messages are their intent to talk to the agent, and a failed compaction does not withdraw that intent; the context is simply left as it was.
• No completion deadline. The common pattern times out after minutes and latches "may still be running". Here Stop always ends the command, so nothing needs to be guessed.
• Readers skip a command more widely. The common pattern skips a compaction only for the chat's title; here the sidebar preview, verdict, completion notification and restart resume skip it too, because none of them describes the user's work.
• The fold never hides error or compaction rows. The common pattern hides a compaction only alongside other work; this is stricter.
• Mobile gets the grouping keys and the held-message placement; its fold behaviour is unchanged in this PR.

Mixed versions

• New optional fields only: turnScope (row, render item, dispatch row), command (message body), providerTurnId (turn body), rewind-record fields. No new item kind, stream opcode, status value, RPC parameter or capability.
• Old client, new host: turnScope and command are ignored, so the client groups by position; /compact shows as an ordinary "/compact" bubble with its own rows after it. The command RPC reply now means "started" (an intentional meaning change); an old desktop re-enables its own sends at that point.
• Clients without accepted-send replies (every mobile build today): a message sent while a command runs is answered "sent" once it is saved and queued behind the command, instead of waiting for the handover (which would outlast mobile's 15 s send timeout). This path is moot once mobile adopts accepted-send.
• New client, old host: no scope on the wire, so today's positional grouping. The desktop keeps refusing to send while a command is pending when the host states no turn scopes (a legacy branch, removable once those hosts age out); otherwise an old host would refuse each such message as "not sent".
• An older host opening a newer journal ignores the new fields; an epoch it rebuilds drops them and the newer host derives them again. A newer host opening an older journal derives every row's scope, and an older build's leftover compaction record no longer blocks sends or commands; a replay of that operation id is answered from the ledger without running it again.
• Codex chats rewound by an older build lost the link from each turn to the message that opened it, and it cannot be recovered. In those chats each turn's work is drawn apart from its message.

Risks

• Codex could start a turn of its own between the compaction request and the compaction's turn (for example a goal continuation), and it would be claimed as the compaction's. thread/compact/start returns an empty response and turn/started carries no marker that tells a compaction turn apart. The window has never been observed, so no guard is added.
• A compaction the provider never reports reads "Working" until Stop. Stop always ends it: a second Stop restarts the agent.
• "Worked for" now counts from the handover for every message, so a message sent while the agent was starting no longer counts the start.
• Known: on Claude, a message sent mid-turn draws inside the running turn until Claude decides what it is. Claude either folds such a message into the running turn or answers it in a turn of its own afterwards, and Orca only learns which when Claude does one or the other. Until then the message draws inside the running turn, as a folded message would, and the running turn's remaining rows, including its answer while it streams, draw below it under that turn's single bar. The moment the message's own turn opens, it moves below everything the earlier turn wrote, so the earlier answer never ends up under the new message's bar. On main (with fix(native-chat): group chat rows by the turn that produced them #23671), that answer stays under the new message's bar for good.
• Codex reports a failed turn twice (an error, then a failed turn/completed). This PR makes a failed /compact settle once; the same pattern on ordinary Codex turns is on main today and is fixed separately in fix(native-chat): a failed Codex turn keeps its failure and "Worked for" #23514.
• A stopped /compact collapses to its "Worked for"; "Cancellation requested." shows when expanded, as for any stopped turn.

Linked Issue

Follow-up to #22944 (turn facts, part B of the plan); no separate issue.

Visual Proof

Live Electron QA ran on a separate Mac with a background-launched development build and a fresh profile per run. Real Claude and Codex where marked; a scripted Claude that reproduces the captured /compact frames for the failure, Stop and exit cases.

Real Claude: /compact has its own row, "Worked for" and separator; the turn before it is untouched, and the sidebar keeps the last real prompt and time.

Real Claude, Stop during /compact: it ends stopped, with no error; the next message was then answered in its own turn.

Real Claude, a failed /compact ("Not enough messages to compact."): the error sits on that /compact, and the message typed behind it was still delivered and answered.

Real Codex: one separator and its own "Worked for".

A message typed during /compact waits below the live "Compacting the conversation" line...

...and lands after the separator once it is sent, with its own "Worked for".

The agent exits mid-/compact: one exit row inside that turn, and the waiting message is delivered to the restarted agent.

Scripted Claude, Stop during /compact: ends stopped, no error row.

Scripted Claude (the captured frame order), a message sent while a turn runs and answered after it: the first turn's answer stays under the first turn's "Worked for", then the new message, its own bar and its reply.

The same case before Claude opens the new message's turn: the message draws inside the running turn, with the running turn's answer streaming below it under one bar (see Risks).

Testing

• I manually tested these changes locally (on the review machine; see Visual Proof)
• Automated tests added/updated, or explained why not below

Every test below was proven red by removing the code it pins, then restored:

• Real frames: a captured Claude /compact (a success, then a Stop) is pinned as a fixture. Success needs the compaction boundary; the stopped capture reads as a cancellation with no error row. Ablation: reading the result's own verdict makes the Stop read as a success.
• The Claude command turn at each place a turn's end is handled: reopen suppression, subagent settle, context settle, the provider fallback, and dropping the command's own frames.
• Codex: one turn record per command, the claim persisted, the claimed turn's rows scoped to it, one separator, and a Stop before the claim restarting the agent.
• Stop: a second Stop on a command the provider never answered restarts the agent; a Stop naming an older command ends nothing; after an interrupted Claude /compact the next message gets its own answer; a late result for the first /compact does not end a second.
• The queue: messages typed during a command wait and are delivered after it, in order, even when it fails; the queue is held only while an agent runs the command, so a crashed agent's leftover command is settled by the next start; every journal commit re-wakes the queue, so none is lost.
• Exits: a Claude or Codex agent exiting mid-command writes exactly one exit row, scoped to that command's turn.
• Placement: a held message draws below the live activity while it waits and after the separator once handed over; an ordinary mid-turn message stays put.
• Mixed versions: a phone send during /compact answers once queued; an older host keeps the desktop's local send block; an older build's compaction record blocks nothing.
• Grouping and readers: stated scopes, steers, provider-started turns, the live turn, old hosts and no journal; rewind keeping openers and producers; completion feed, sidebar, restart marker and legacy label reading past /compact.

Checks run on the final head: node, web and CLI typechecks; mobile typecheck, tests-typecheck and the touched mobile tests (in a copy with mobile dependencies installed); oxlint; the changed-lines quality gate including React Doctor and the anti-slop audit on this PR's files; the native-chat, Claude, Codex, runtime and renderer suites for the touched areas.

Not run locally: the cross-version wire suite (CI runs it).

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

Author X: @BrennanKB5

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 turn membership and journaling across chat and agent systems.

The PR does not appear safe to merge while existing pre-backfill Codex homes are excluded from account-history bridging.

Findings

1.  Unrelated Claude output can disappear ▶

Summary

The PR records turn ownership on structured-chat journal rows and sends /compact through the ordinary message queue, giving it its own turn and keeping later messages in order. Subsequent changes also adjust transcript grouping, Codex account-history bridging, and related UI and CI behavior.

• Structured-chat rows and timing now follow turn records on desktop and mobile.
• A pre-backfill Codex state DB prevents the new history bridge from running.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart LR
  A["User sends /compact"] --> B["Message queue"]
  B --> C["Command turn record"]
  C --> D["Provider frames settle turn"]
  D --> E["Journal rows with turnScope"]
  E --> F["Desktop and mobile transcript"]
  B --> G["Later messages wait"]
  D --> G
  G --> H["Delivery resumes"]

Loading

_{Reviews (3) · Last reviewed commit: "fix(native-chat): typecheck main's Stop ..."}

[greptile-apps]

Unrelated Claude output can disappear

While /compact is open, this check suppresses every root assistant or stream frame without checking which input produced it. The translator then returns before recording the frame. If Claude emits output from an independent background wake during that window, it will be missing from the transcript. Please correlate frames with the command input before suppressing them.

[pullfrog]

ℹ️ No critical issues — one edge case inline.

Reviewed changes (delta since the prior pullfrog review at 436d1771dd)

• Reconciled onto main's typed failure facts. Two merges (066b4eea78 bringing #23116, acdd559fd9 bringing #23608, #23682, #23456, #23605, #23618, #23702, #23614) move the branch's command/compaction code from string error verdicts to agentSessionFailureFact / agentSessionFailureWords, and the mobile footer's waiting-rows split is extracted into mobile-native-chat-list-footer.tsx. The writer/reader mapping was checked file by file and no verdict, row or rejection was dropped or doubled.
• A failed start that was carrying /compact now says to run it again. structuredAgentSessionFailureWordsContext can carry any conversation command, derived from the oldest awaited submission, and the /compact RPC reply names it directly (90b68d30d9).
• A Codex /compact ends only on its turn/completed. The command turn notes when Codex's turn-ending error row has already been written and its end adds no second row; retried stream errors are not counted (7b9fb3f699).
• Test adaptations. Two commits state turnScope on main's new journal test rows and settle a dead /compact on its recorded exit.

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

[pullfrog]

A turnId-less error frame leaves failureShown false. The row-writing path resolves the turn as readCodexTurnId(payload) ?? activeTurn(threadId), so during a claimed command turn Codex's own row still lands inside the command's turn — but errorShown reads only readCodexTurnId(params), so end() then adds the command's own Compaction failed… row beside it, exactly the duplicate this commit removes. Mirror the fallback where errorShown is called (readCodexTurnId(event.params) ?? activeTurns.current(event.threadId)), or give it a fallback turn-id parameter.

Technical details

# `errorShown` misses a turnId-less error the row path still journals

## Affected sites
- `src/main/codex/codex-journal-command-turn.ts:149` — `readCodexTurnId(params)` with no active-turn fallback.
- `src/main/codex/codex-structured-journal-generic-frames.ts:82` — the row path resolves `readCodexTurnId(payload) ?? this.activeTurn(threadId)`, so the error row is still journaled and scoped to the command turn.
- `src/main/codex/codex-structured-journal-translation.ts:268-270` — the call site; `activeTurns` is in scope here.
- `src/main/codex/codex-structured-journal-translation-turn-boundaries.ts:74-107` — a claimed command turn is remembered as the active turn, so the fallback resolves to it.

## Required outcome
- A `willRetry:false` error frame that carries no `turnId` but is journaled inside a claimed command turn must set `failureShown`, so `end()` adds no second failure row.

## Suggested approach
- Resolve the turn where the row path does: call `commands.errorShown(readCodexTurnId(event.params) ?? activeTurns.current(event.threadId))`, or give `errorShown` a fallback turn-id parameter.

## Open questions for the human
- Is a `turnId`-less `error` during a command turn reachable in the Codex versions you support? `codex-structured-journal-translation.test.ts:381` pins that exact frame shape for an ordinary turn.

[pullfrog]

✅ No new issues found.

Reviewed changes (delta since the prior pullfrog review at 1e6c37ddd4)

• Reconciled a base sync of two overlapping base PRs. The head advanced through two merges of origin/main (#23573, #23621, #23801 and others, then #23808). #23573's turn-bar fix is ported onto the PR's nativeChatTurnMembership instead of kept as a second owner lookup: the membership now returns barTurnKey beside liveTurnKey, and activeTurnOpenedBy, selectNativeChatActiveTurnKey and selectStructuredAgentTurnBars' openedBy are removed. Where a host states each row's turn the two keys agree; where it states none, the bar follows the running record's named opener while liveness follows position.
• Kept main's queued-send clock in the PR's timing read. StructuredAgentTurnTiming gains queuedUntil, and the selector is refactored into one pass keyed by anchor and turn id; structuredAgentTurnOrigin and completedStructuredAgentTurnSeconds now count a queued send from the previous turn's end. selectStructuredAgentTurnBars returns {settledTurns, runningTiming}, and both the desktop and mobile timing hooks read it.
• Desktop and mobile read barTurnKey. The two turn-status hooks, the slot builder's activeTurnKey, and NativeChatMessageList consume it; liveness still follows liveTurnKey, and mobile's private unanchored key folds into the shared constant.
• The Claude translator contract carries both features. #23621's openTurnInLiveProviderCycle sits beside the PR's command-turn members, and the result branch — which had grown past the file's line budget — moved unchanged into claude-result-journaling.ts. #23801's Codex child path and the PR's Codex /compact guard both stand.

The prior review's one open inline thread (codex-journal-command-turn.ts:149) and the earlier commandBlocked, anchorOf, completion-feed owesWork, and stop-note scoping threads are unchanged by these merges, so they are not re-raised.

Verified locally: the shared turn-bars/timing/membership suites, the desktop transcript-slot and turn-indicator/turn-membership suites, the Claude journal-translation and fold-steer suites, codex-command-turn-claim, and structured-conversation-compaction (the previously-red exit-row case is now green) all pass; tc:web and tc:node are clean.

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

[pullfrog]

Important

nativeChatTurnDrawOrder, the new reordering this delta adds, leaves a queued opener in place when the earlier turn was provider-opened — the same misattribution it removes for user-opened turns. One reachable shape is affected.

Reviewed changes (delta since the prior pullfrog review at bda9ff153e)

• Merged origin/main and reconciled it onto the persisted-turn-scope design. The merge brings row grouping by the producing turn, Stop from the moment a message is sent, terminal-backed chat through the structured turn status [#22090], and others; the PR's reconciliation makes main's nativeChatRowTurnKeys/nativeChatTurnBarRows/journal-order grouping the base of nativeChatTurnMembership, drops barTurnKey (the live turn is now also the bar owner), and routes the Codex/Claude cancels through the narrowed requestedTurnId with performCancel split into structured-agent-session-turns-cancel.ts.
• A message that opened a later turn now draws after the earlier turn's remaining rows, just before its own turn's rows. nativeChatTurnMembership returns a drawOrder from the new nativeChatTurnDrawOrder, computed on both the scoped and no-scope paths; desktop and mobile reorder messages/turnKeys through nativeChatRowsInDrawOrder, and each turn's bar is re-read from the reordered rows.
• Merged tests and typechecks adapted. #23026's Stop tests call the changed compact/appendItem APIs, and the Claude compaction interrupt reads the narrowed turn id.

Everything else touched by the merge is base-branch content, out of this PR's diff scope. Verified locally at 898daaef: tc:web and tc:node clean, and the grouping/membership, transcript-slot, queued-turn-order, turn-fold, Stop/conversation-stop, compaction, Codex restore-grouping and main-agent-working suites all pass (202 tests).

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

[pullfrog]

nativeChatTurnDrawOrder does not move a queued opener when the earlier turn was provider-opened. That turn's anchor is not a message row, so firstRow.get(turnKey) is its first surviving row, which sits after the opener, and firstRow.get(turnKey) > index then misreads the earlier turn as a later one; the opener stays put and the earlier turn's row renders under the opener's bubble — the same misattribution this commit removed for user-opened turns.

Technical details

# Provider-opened earlier turn leaves a queued opener in place

## Affected sites
- `src/shared/native-chat-turn-grouping.ts:111-116,130` — `firstRow` is the first row *in `messages`*, used as a proxy for where the turn opened; for a turn whose anchor has no message row it is the turn's first surviving row.
- `src/shared/native-chat-turn-membership.ts:151,169` — both membership paths pass `anchoring`/`anchoringUserItems`, which contain provider-opened (record-anchored) turn keys with no matching message.
- Consumers inherit the wrong order identically: `src/renderer/src/components/native-chat/native-chat-transcript-slots.ts:155,168-175` and `mobile/src/session/use-mobile-native-chat-turn-disclosure.ts:79-80,130`.

## Reachable shape (a send during a provider-opened wake)
- messages: `B(user)`, `p1(assistant)`, `b1(assistant)`
- journal: `wake` record (`userItemId` = its own item id) → user `B` → `p1` scoped to `wake` → `tB` record (`userItemId: B`) → `b1` scoped to `tB`
- `turnKeys = ['B','wake','B']`, `openers = {'wake','B'}`; `nativeChatTurnDrawOrder` returns `null` (verified with a throwaway test against the pure function).
- Draw order stays `B, p1, b1`: `wake`'s bar (drawn `above`) renders over `p1` immediately below `B`'s bubble, so `p1` reads as `B`'s reply.

## Required outcome
- A queued opener must draw after an earlier turn's rows that the journal wrote after it, whether that earlier turn was opened by a message or by the provider (or its opener is outside the loaded transcript).
- A regression test should pin a provider-opened (or missing-opener) earlier turn; the current `nativeChatTurnDrawOrder` cases only use user-opened earlier turns.

## Suggested approach
- Give the function the earlier turns' journal open order (the membership already holds `journal.items`): order turn keys by their record's position and treat a turn as "earlier" when its record precedes the opener, rather than inferring it from `firstRow`.

[brennanb2025]

Status: ready for review

Head: 898daaef37c. CI is green (23 passed, 12 skipped), and the PR is mergeable. Typecheck is clean for node, web, CLI and mobile, and the mobile test typecheck ratchet passes.

Since the last status

• Current main merged in. It brings fix(native-chat): keep a turn's bar on the prompt that opened it #23573 (a turn's bar stays on the prompt that opened it), fix(native-chat): a message Claude folds into its running turn no longer splits the turn #23621 (a message Claude folds into its running turn no longer splits it), fix(native-chat): group chat rows by the turn that produced them #23671 (rows grouped by the turn that produced them), fix(native-chat): Stop is there from the moment a message is sent #23026, test(native-chat): main's Codex child tests expect a turn to end on its own turn/completed #23783 and others. fix(native-chat): keep a turn's bar on the prompt that opened it #23573 and fix(native-chat): group chat rows by the turn that produced them #23671 now run on this PR's turn model as one mechanism, not two side by side:
  • hosts that state turnScope group rows by it;
  • fix(native-chat): group chat rows by the turn that produced them #23671's journal-order grouping remains only for older hosts that state none;
  • the bar and the live turn read one key;
  • desktop and mobile share the bar rows.
• Fix for a case fix(native-chat): group chat rows by the turn that produced them #23671 leaves on main. When Claude answers a message sent mid-turn in a turn of its own, the earlier turn's answer used to end up under the new message's bar. It now stays under the earlier turn's bar. The new desktop and mobile tests fail on the previous head, on both host kinds.
• Codex /compact ends only on Codex's own turn completion. Codex's error stays a row inside the command's turn, following fix(native-chat): only Codex's turn completion ends a Codex turn #23682.
• Provider-death rows use fix(native-chat): each chat failure says why in plain words, on the thing that failed #23608's wording.

Live QA

Separate Mac, background-launched build of this head, fresh profile with hooks off, scripted Claude replaying the captured frame order. Desktop only.

Queued message. A message sent while a turn runs, and answered after it.

While the second message waits, the only bar is the running turn's:

Before Claude opens the second message's turn, the first turn's answer streams below the message, under one bar. This is disclosed under Risks.

Once it opens, the first turn's answer moves under the first turn's bar:

Fold-in. A message Claude folds into its running turn: one turn, with one bar.

Single send.

Not covered

• Mobile: blocked. The emulator's text input could not enter the pairing code reliably. The mobile rendering tests pass on both host kinds.
• Real Claude was not used for the queued and fold-in cases. The scripted Claude replays the order of frames captured from the real CLI.