[brennanb2025]

	Files	Added	Deleted	Net
Test	36	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​2527	$\color{#cf222e}{\Huge{\mathbf{−}}}$​55	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​2472
Prod	67	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1891	$\color{#cf222e}{\Huge{\mathbf{−}}}$​423	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1468

ELI5

When Claude or Codex stops to think before acting, Orca's chat should say so while it is thinking, and only then. Today it gets this wrong. On the Claude version Orca launches now, Claude's thinking reaches Orca empty, so Orca never says "Thinking" at all. On slightly older Claude versions, "Thinking" shows up only after the thinking is over, and then stays on screen while Claude writes out a large file (up to 30 seconds in real recordings).

This PR is step 1 of 2. It makes Orca ask Claude for a readable summary of its thinking, and gives every reasoning row in the chat a real "still thinking / finished" state that the host records. While Claude or Codex is thinking, you can open the single "Thinking" line and read the thinking as it streams. When the block ends it becomes a collapsed "Thought for 12s" row in the transcript (still open if you opened it). Step 2 (the next PR, stacked on this one) moves the "Thinking" label on the activity line onto a live signal from the host.

What Changed

What you see (before → after):

	Before	After
Claude reasons, current CLI	No reasoning row, no "Thinking" at all (thinking arrives empty)	The activity line says "Thinking"; open it to read the summary as it streams (height-capped, scrolls). When the block ends, a "Thought for 25s" row takes its place, still open if you opened it; the next block starts closed
Claude reasons, then writes a large file	"Thinking" appears after reasoning ends and sticks through the file write	"Thinking" shows on the activity line only while the reasoning block is open (from its first summary text; step 2 makes it start at the block itself); the file write reads "Working…"
Reasoning row header	Tiny grey inline text (older code path), no duration	Collapsed row led by a brain icon in the same column as tool-row icons: "Thought for N s", "Thought" when no span was seen, "Reasoning" for rows from an older host
Mobile	Reasoning drawn inline as dimmed text	The same: tap the "Thinking" line to read the live text, and the finished block becomes the same collapsed row with the brain icon. On Android, a long press on the opened text (live or finished) offers Copy message / Select text, as on every other message
Stray row	A "claude · message:stream_event:ping" status row in some chats	Gone (keep-alive pings write nothing)

How it works:

• A lifecycle on reasoning rows. Journal message rows gain two optional fields, state (running / completed) and completedAt, modelled like the existing tool-call state. The host writes them: a row opens when its first reasoning text arrives and is stamped with the time its block (Claude) or item (Codex) started. It closes when the block or item finishes, when the turn ends or is interrupted, when the provider exits, and in the crash and stale-session sweeps. Readers only treat a row as live when its own turn is still running, so a missed close can never show as thinking.
• A brain icon on the row. The collapsed row starts with a brain icon in the same 16px slot tool rows use for their icons, and its header is laid out like a tool run's header, so its icon and text line up with the rows around it. The icon is a named entry in the shared native-chat icon list, like the other row icons. The opened text starts under the headline. The chevron follows the headline: hidden until you hover or focus the row with the keyboard, always shown on touch screens, and turned down while the row is open. Mobile leads its row with the same icon, spaced like its tool rows. This follows the common pattern, where the reasoning row carries a brain icon like every other activity row, on desktop and mobile.
• No blank rows. A row is written only once there is text, so already-shipped mobile builds never draw an empty reasoning gap.
• One live indicator you can open. The activity line is the only live "Thinking". Once the open block has text, the line becomes a disclosure for that text; the block's own row is hidden for exactly as long as the line shows it, and appears when the block closes. Both facts come from one shared value (src/shared/native-chat-live-line.ts), used by desktop and mobile, so a row can never be hidden without the line showing it, and "Thinking" is never said twice. The line and the finished row share one open/closed key, so a block you opened stays open when it lands. Rows never say "Thinking"; any other unfinished block (a subagent's, or one whose line gave way to a question card) draws in place as an openable "Reasoning" row. Screen readers hear the line's label change, not the streaming text.
• The spinner's "Thinking" (still the old "newest row" rule until step 2) now counts a reasoning row only while it is running. That stops "Thinking" sticking through a file write.
• Readable Claude thinking. Claude launches with --thinking-display summarized, which asks Claude Code for summaries of its thinking. Orca never passes --thinking, so a user who turned thinking off stays off. The flag exists from Claude Code 2.1.94. Because Orca runs the user's own claude, it checks the version first: it runs <claude> --version with the launch's own folder and environment (so version managers like asdf or mise pick the same binary), with credentials removed. It remembers the answer per binary and folder. A launch waits for that check at most 1.5 s (measured warm: 20–66 ms), once per binary per folder per Orca run. If a CLI still rejects the flag ("unknown option '--thinking-display'"), Orca remembers that and leaves the flag off from the next launch.
• Codex. Reasoning rows close on item/completed and at turn or session end, timed at the moment the host received each event. Eviction, settlement and a completion with no text now share one rule for how an unfinished item ends. Orca does not request Codex summaries, so Codex rows only appear for users who turned summaries on in their own Codex config.

Cost and privacy of thinking summaries: summaries are produced on Anthropic's side from thinking Claude already does, so they don't add thinking. They add the summary text to the output. The text is saved in the chat journal on the machine running the agent and syncs to paired clients like any other row. Claude Code also keeps it in its own transcript, as the terminal CLI already does with summaries on.

Why

The root cause was that "Thinking" was guessed from history. Orca looked at the newest row in the transcript, and if it was reasoning, it said "Thinking". Journal message rows had no open/finished state (tool calls did), so a reasoning row that had finished hours ago, in effect, still looked like "now". The same kind of bug was fixed for the activity line's tool text in #24218.

The common pattern is to track a reasoning block's lifecycle (open while it streams, closed when it finishes, the turn ends or it is interrupted) and show "Thinking" only while one is open. This PR follows that for the rows. Differences from the common pattern, each labelled:

• The lifecycle is stored on the durable row by the host, rather than recomputed by each reader from raw events. Intended: Orca's journal is the durable projection, and remote and mobile clients can't re-derive it from provider frames.
• Whether a block was cut short comes from its turn, not a separate "interrupted" state on the row. Intended: one source of truth.
• The summaries flag is version-checked, where the common pattern passes it unconditionally. Intended: Orca runs the user's installed binary, and an old one fails to start on an unknown flag.
• The open block is hidden by its row id while the line shows it, rather than never being a transcript row. Intended: the host records the open block in the journal so other clients and reloads see it; the shared value hides exactly that row and nothing else.
• The line keeps the short label "Thinking" rather than previewing the text; the text is one click away. Intended: one label for every provider, including Codex, whose reasoning is often blank.
• A subagent's open reasoning draws in its own section as "Reasoning", which you can open. Intended: Orca draws subagents as sections inside the parent chat, so this keeps their thinking readable while it streams without a second "Thinking".
• The live "Thinking" for a block with no text yet (Claude takes 2–4 s from block start to its first summary text; Codex reasoning is blank on Orca's settings) shows as "Working…" here until the first text arrives. Temporary: step 2 adds a typed "reasoning is open" signal on the host's live turn activity, driven by the same lifecycle.

Alternatives considered: writing a blank "open" row at block start (rejected: shipped mobile builds draw blank reasoning rows as empty dimmed gaps); asking Claude after start via a control request (rejected: its semantics are unverified and the first turn would race it); relaunching without the flag after a refusal (rejected: the refusal lands after the session is published and the user's first message is already rejected).

Known effect on apps that haven't updated: desktop and mobile builds from before this change still use the old "newest reasoning row" rule. With Claude summaries on, their "Thinking" appears 2–3 s late and stays while tool input streams. That is the same pattern they already show on older Claude versions. Already-shipped mobile builds also draw the summary inline as dimmed text. Both are cosmetic, and updating fixes them.

Linked Issue

Maintainer change; no issue.

Visual Proof

Reading reasoning while it streams (head 09546329717). A stand-in claude replayed a real Claude 2.1.280 recording at 1x into a hidden, isolated test build on a separate Mac; no real Claude or credentials.

	Dark	Light
While thinking: one "Thinking" line, no row
Opened: the summary as it streams
Block ends: the row takes its place, still open; the line says Working…
Turn over: collapsed rows in the tool-icon column

Keyboard focus on the live line shows the focus ring and its chevron:

An in-page check sampled every 250 ms over five replays (dark, light, keyboard): never a row next to the "Thinking" line for the same block, never two "Thinking" labels, and the live and landed text measure the same colour. The brain icon and the row text start at the same x as the tool rows' icon and label (measured earlier: 518.5 px and 539.5 px).

The reasoning lifecycle, before → after (earlier QA, before the icon and before the line could be opened):

Same real recording of Claude 2.1.280 thinking and then writing a large file, replayed at 1x into a hidden test build of each version on a separate Mac (dark theme unless noted).

While Claude is thinking (15 s into its thinking block)

Before (main)	After

While Claude writes the file (5 s into the Write input, thinking already over)

Before (main)	After

The finished row, expanded (dark and light)

Dark	Light

Measured over the whole turn (250 ms sampler): before, "Thinking" showed for 41.5 s and 12.5 s while Claude wrote the two files and never while it was thinking; after, never during the writes, and during thinking from its first summary text (2.3 s and 3.2 s after each block started; step 2 closes that gap).

Testing

• Automated tests added/updated. Real Claude 2.1.280 and Codex 0.159 sessions were recorded and replayed through Orca's real translators. Replay spans match the recordings exactly (Claude 24.6 s / 6.3 s / 4.65 s / 12.95 s; Codex 5.6–8.5 s). Journal writes per thinking block are bounded by the same throttle streamed text uses (a 2.5 KB block: 14 writes). Every new close path, the version gate, the probe budget, the self-heal and the row-visibility rule has a test that fails when its fix is removed.
• After merging current main (Oct 5): node, web and mobile typechecks green locally; the 503 test files covering what this PR touches pass (5,215 tests), as does the full mobile suite apart from 6 timing-sensitive tests that also pass when rerun on their own.
• After the icon, its review fixes and a second merge of main (Oct 5, head e88916d45de): node, cli, web and mobile typechecks and the mobile tests-typecheck check green locally; the affected desktop, main-process and mobile test files pass (408 + 92 tests). New tests cover the icon going through the shared icon list, the chevron's reveal on hover, focus, touch and open, the mobile icon, the Android long-press sheet on opened reasoning, and the Claude exit flag passing through the connection wrapper; each fails with its fix removed.
• After making the live line readable (Oct 6, head 09546329717, current main merged in): node, web, cli and mobile typechecks green; the affected desktop, shared and mobile test files pass; new tests cover the shared live-line value, the row hidden only while the line shows it, the open state carrying to the finished row, the slot that keeps a turn bar or diff rollup not drawing the hidden row, the single live region, and Android copy on the live text, each failing with its fix removed.
• CI: fully green on 09546329717 (one test shard rerun after its runner was shut down).
• Rendered checks (Oct 5 and 6): the same stand-in replay on the separate Mac: the icon before and after, and the readable live line in dark and light, opened and closed, landing, and keyboard focus (screenshots above).
• Typecheck (node, web, cli) green locally. Mobile typecheck, tests-typecheck and tests green in CI.
• Manual QA on a separate Mac (macOS): a stand-in claude replayed the real recording above into hidden test builds of main and of this PR, both in isolated profiles, with no real Claude or credentials involved. Checked the activity line over time, the collapsed and expanded rows, light and dark themes, and that the launch passed --thinking-display summarized and never --thinking.
• Not verified: Windows probe timing and exit ordering (covered by the 1.5 s cap and the existing spawn path); mobile UI on a device, including the live line, the mobile icon and the Android long-press sheet (no test host with a reasoning chat could be paired without touching a live Orca; covered by mobile unit tests); Windows and Linux rendering, a touch screen, a narrow pane, and a real screen reader.

AI Disclosure

Author: @BrennanKB5

Review

Three rounds of independent review (host lifecycle, Codex and wire, launch and renderer, merge audit, design challenge, mobile) plus a release-readiness pass (SSH/remote, crash/growth, security, performance, correctness, backward compatibility, cross-platform, organization), all with no P0/P1 open. Every P0–P2 finding is fixed. A further round on Oct 5 reviewed the icon commit and the merges of main (merge resolutions, layout and accessibility, mobile parity, a design challenge, and readiness). It fixed: the mobile row lacked the icon; the chevron had become hover-only, hiding it from keyboard and touch users; the opened text started left of the headline; the icon bypassed the shared icon list; the first merge had dropped Android's long-press Copy / Select text sheet from reasoning rows; and the second merge would have made every Stop or quit of a Claude chat look like a crash, because the branch's connection wrapper dropped a new exit argument from main (the wrapper now forwards every argument). Deferred P3: the focus ring's left edge overlaps the icon, and the row repeats the tool-run header's styling instead of sharing it; tool rows have the same ring, and a shared header component is the follow-up for both. On Oct 6, reading reasoning while it streams was added to match the common pattern, followed by a full review round (desktop, mobile, a design challenge), a re-review of its fixes, a review of the main merges, and a readiness pass. It fixed: a row that also carried its turn's status bar or file-change summary still drew under the live line, so the text showed twice; the line's condition and the hidden row are now one shared value; the screen-reader region is now kept across label changes; Android could not copy the live text; the mobile line's touch target and indent; the Android copy sheet closing or reopening on its own; and the live text being brighter than the finished row's. Deferred (P3): keyboard focus returns to the page when a block you opened from the line finishes; an open Android copy sheet closes if the line itself goes away at turn end. Earlier deferred P3s: a Claude API retry inflates that block's duration by the retry wait; after a reconnect on older Codex, a measured duration reads "Thought"; with over 256 concurrent Codex items, an evicted row can stay running until the next sweep, though readers never show it live.

Agent skill upstream boundary

• Not applicable.

Notes

Security: the version check runs the same binary the launch runs, with Claude credentials removed; there are no new dependencies or network calls. Cross-platform: the check goes through Orca's shared process runner (Windows .cmd shims handled). Remote SSH: structured Claude and Codex run on the execution host only; the new row fields are optional and older clients ignore them. Performance: see Testing.

Checklist

• This PR is small and focused (step 1 of 2)
• I explained what changed and why
• Before/after screenshots attached
• Self-reviewed for correctness, security, and performance
• Cross-platform, SSH/remote, and path/shortcut impact considered
• Typecheck and targeted tests pass locally; CI covers the rest

[coderabbitai]

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

📝 Walkthrough

Walkthrough

Claude streaming now translates thinking blocks into bounded reasoning messages and manages their identities and lifecycle. Codex reasoning items now use message bodies with the reasoning role, while plans remain status bodies. Native chat renders reasoning messages in a collapsible row with streaming duration labels and markdown support. Tests cover translation, projection, streaming, reconciliation, truncation, and rendering behavior.

Priority: ➖ Normal

Merge Risk: 🔵 Low · up to 9bcb7

For turns containing multiple reasoning entries, already-settled entries may incorrectly remain labeled “Thinking...” and display a duration for the full turn. This is a bounded presentation issue but should be corrected before relying on per-block timing.

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (2 warnings)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 25.00% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 12 functions across 14 files. (1 skipped:…	Write docstrings for the functions missing them to satisfy the coverage threshold.
Linked Issues check	⚠️ Warning	The description states that no issue URL was supplied, although the template requires an issue link in every pull request.	Link the pull request to the relevant issue using a valid issue reference, such as Fixes #123.

✅ Passed checks (3 passed)

Check name	Status	Explanation
Out of Scope Changes check	✅ Passed	The production changes, renderer updates, localization, projection updates, and tests all support rendering structured reasoning as collapsible transcript messages. No unrelated changes are identified…
Title check	✅ Passed	The title clearly summarizes the main changes: reasoning rows now have a real open/finished state, and Claude thinking is readable. It is specific and concise enough to identify the change.
Description check	✅ Passed	The description is detailed and covers the template’s required sections, including the user-facing change, rationale, linked-issue exception for a maintainer, visual proof, testing, review, compatibil…

Full details: Docstring Coverage

Explanation

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

• Fix all pre-merge checks with AI

✨ Finishing Touches 💡 2

📝 Generate docstrings 💡

• Create stacked PR
• Commit on current branch

⚔️ Resolve merge conflicts 💡

• Resolve merge conflict in branch brennanb2025/nc-reasoning-row

---

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

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

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

[coderabbitai]

Actionable comments posted: 1

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Team

Run ID: 9c2fb807-60b9-4aee-b0be-d4f2eeb0423e

📥 Commits

Reviewing files that changed from the base of the PR and between 2ccf35b and 533bb68.

📒 Files selected for processing (14)

• src/main/claude/claude-streamed-block-identity.ts
• src/main/claude/claude-streamed-thinking.ts
• src/main/claude/claude-structured-journal-translation.test.ts
• src/main/claude/claude-structured-journal-translation.ts
• src/main/claude/claude-structured-reasoning.test.ts
• src/main/codex/codex-structured-item-translation.test.ts
• src/main/codex/codex-structured-item-translation.ts
• src/main/codex/codex-structured-journal-translation-settlement.test.ts
• src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
• src/renderer/src/components/native-chat/NativeChatReasoningRow.test.tsx
• src/renderer/src/components/native-chat/NativeChatReasoningRow.tsx
• src/renderer/src/i18n/locales/en.json
• src/shared/agent-session-journal-schemas.test.ts
• src/shared/structured-agent-session-projection.test.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 1 remains after this review.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Trim the reasoning text before bounding it.

text?.trim() only checks whether the body is blank. The original text is still passed to boundInlineText. This preserves avoidable whitespace and allows a large blank prefix to consume the payload limit before the actual reasoning content.

Store the trimmed value and pass it to boundInlineText.

Proposed fix

 function reasoningItem(text: string | null): CodexJournalItem {
+  const trimmed = text?.trim() ?? ''
   return {
-    body: text?.trim()
+    body: trimmed
       ? {
           kind: 'message',
           role: 'reasoning',
           blocks: [
-            { type: 'text', text: boundInlineText(text, DEFAULT_JOURNAL_PAYLOAD_LIMITS).text }
+            { type: 'text', text: boundInlineText(trimmed, DEFAULT_JOURNAL_PAYLOAD_LIMITS).text }
           ]
         }
       : null,

[pullfrog]

ℹ️ One rough edge worth a look — minor suggestion inline.

Reviewed changes

• Reasoning emission — Claude and Codex structured-journal translation now emit reasoning as message items with role: 'reasoning' (bounded text blocks) instead of kind: 'status'.
• Claude streamed thinking — new createClaudeStreamedThinking reuses the block registry and text checkpoints for thinking deltas; createClaudeStreamedBlockRegistry is generalized with a blockType parameter.
• Collapsible rendering — new NativeChatReasoningRow collapses reasoning behind a first-line summary, mounting CommentMarkdown only on expand; MessageRow early-returns it for role === 'reasoning'.
• Tests — new coverage for both providers, journal admission, the shared projection, disclosure states, blank reasoning, and plan fallback.

The change is clean and well-scoped: the wire schema already accepts role: 'reasoning', the shared projection passes it through, and mobile already renders it, so desktop now aligns with mobile. Single-thinking-block reconciliation is correct.

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

[pullfrog]

finalize reconciles only the first streamed thinking block (blocks.reconcile shifts one identity from awaitingFinal), but claudeThinkingText joins every thinking part in the envelope into a single body. If one assistant message carries multiple thinking blocks (interleaved thinking), streaming mints one identity per block, so the second and later blocks' streamed rows are never reconciled or forgotten — they linger as duplicate partial reasoning beside the joined final row.

Technical details

# Multi-thinking-block reconciliation gap

## Affected sites
- src/main/claude/claude-streamed-thinking.ts:54 — `blocks.reconcile(envelope)` consumes only one identity, while `claudeThinkingText(envelope)` (claude-structured-item-translation.ts:159) joins all thinking parts with `\n`.

## Required outcome
- Either reconcile/forget one identity per thinking block in the envelope, or collapse a message's thinking into a single streaming identity so the final join has exactly one row to land on. The streaming and final paths must agree on how many reasoning rows one message produces.

## Open questions for the human (optional)
- Is interleaved thinking (multiple thinking blocks per message) a supported input today? If not, this is latent; if it can be enabled, it produces duplicate rows.

[pullfrog]

ℹ️ No new issues in the latest commit — the prior minor finding is unchanged and still applies.

Reviewed changes

• Main sync — b51f4f8 is a merge of origin/main into the branch. It brings in the structured-agent-session-adoption-replay test that the PR body flagged as failing on shard 6 (a test introduced on main and previously absent from this branch), so that CI integration failure is resolved by the merge rather than by a change to this PR's code.
• No PR code delta — the branch's 14 changed files are byte-for-byte identical to the prior head 533bb68; the only diff offset is the en.json hunk shifting by 4 lines (4 unrelated upstream entries added to main).

The multi-thinking-block reconciliation gap flagged in the prior review (createClaudeStreamedThinking.finalize reconciles one identity while claudeThinkingText joins all thinking parts) is untouched by this merge and remains the single open item.

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

[brennanb2025]

Manual UI validation — reasoning row (Electron, CDP, hidden renderer)

Driven in a real Orca dev build from this branch on an isolated dev profile (ORCA_BACKGROUND_LAUNCH=1, private renderer port, CDP screenshots of a hidden window — no focus steal, no OS input). The pane is a real native-chat surface reading a real Codex transcript through the production decoder, so every row below went through decodeCodexTranscriptLine → MessageRow → NativeChatReasoningRow.

Verdict: all five behaviors hold, in both themes.

1. Collapsed by default, with a meaningful one-line summary (dark)

The reasoning row sits between the user prompt and the assistant prose as its own row — chevron + left rule + muted text — and is data-state="closed" on first render; the summary is the reasoning's whole first line, not a mid-sentence truncation.

2. Expanded reveals the full reasoning body (dark)

Clicking the trigger rotates the chevron and reveals the complete reasoning text with its markdown (paragraphs and the ordered list) intact, rendered italic/muted so it still reads as an aside rather than assistant prose.

3. Collapsing works

A second click returns the row to data-state="closed" and hides the body again — the transcript is back to the one-line summary.

4. No thrash or flicker while streaming

With the first row left open, 14 further frames were appended to the live transcript. A MutationObserver pinned to that row's DOM node recorded 0 removals and 0 spontaneous data-state flips, and the same node stayed mounted and open throughout — the only state change in the whole run was the click I made myself. New reasoning arriving mid-stream (rows 2 and 3 here) correctly appears collapsed without disturbing the open one.

5. Empty / whitespace-only reasoning produces no row at all

Turn 1 carries a normal reasoning payload and gets a row. Turn 2 carries a whitespace-only reasoning payload and renders nothing — no chevron, no rule, no empty strip. The reasoning row count stayed at 1 while the frame that followed the blank payload rendered, proving the payload was ingested and then deliberately dropped rather than never arriving.

Both themes

Light theme, collapsed: the reasoning rows stay muted with their left rule while assistant prose stays full-contrast body copy and the system line (Conversation interrupted) stays smaller and chrome-free — three visually distinct registers.

Light theme, expanded: same disclosure behavior and the same muted/italic treatment for the revealed body.

Notes for the author

• Minor, non-blocking: the summary line is repeated as the first line of the expanded body (visible in screenshots 2 and 7), so the reader sees the same sentence twice on expand. Dropping the first line from CollapsibleContent, or leaving the trigger as a static label, would read cleaner.
• No regression seen in the surrounding transcript: user prompt cards, assistant prose, the system aside, and the composer all render as before.
• A sidebar error card unrelated to this PR appeared once from my synthetic folder workspace (trimStart in sidebar.worktrees); the string does not appear anywhere in this diff. It is a rig artifact and was dismissed before the screenshots.

[brennanb2025]

Status: ready for review

Plan review

Reviewed before any code was written. APPROVE WITH AMENDMENTS, all applied. The load-bearing question was wire safety, and it was proven rather than assumed: MessageBody validates role as z.string().min(1) — an open string by deliberate design — so emitting role: 'reasoning' is a safe additive change and needs no new journal item kind. Amendments applied: reuse the existing prose pipeline rather than forking a second markdown path; pin the Codex plan journal body byte-for-byte with a test, since a parallel lane owns that branch; and emit no row for whitespace-only reasoning on both providers, not just one.

Code review loop

Same-model subagent review returned clean. readiness-checklist run at start and end — both PASS, including the mobile backward-compatibility subcheck. 122 focused tests pass.

Verification

• Central typecheck: exit 0.
• Merged with origin/main, two parents verified.

Manual UI validation

Real Orca dev build, hidden renderer over CDP (ORCA_BACKGROUND_LAUNCH=1, isolated profile, no window shown or focused). 7 screenshots attached above. All five behaviours hold in both themes:

• renders as its own row, distinct from assistant prose and from the system aside
• data-state=closed on first render, with the reasoning's first line as the summary
• expands to the full markdown body and collapses again
• no thrash while streaming — a MutationObserver pinned to the open row recorded 0 removals and 0 spontaneous state flips across 14 appended stream frames
• whitespace-only payload renders no row at all

Process deviations, stated plainly

• The review loop's $orchestration arm was not used. Nested worker depth is 1 in this install, so a dispatched worker cannot dispatch its own workers (nested_worker_depth_exceeded). The UI validation lane was run directly by the coordinator at depth 0. The substance of the loop — subagent review to clean, readiness bookends, independent UI validation with visual evidence — was carried out in full.
• readiness-checklist's severity-counsel step was unavailable for the same depth reason, and is recorded as unavailable rather than reported as a verdict.
• Validation ran on Claude, not the originally-planned agent, which ran out of quota mid-programme.

Known-red, not caused by this PR

structured-agent-session-adoption-replay.test.ts:188 fails on a clean detached origin/main checkout — reproduced independently by two lanes, byte-identical failure. It is a pre-existing break on main and was deliberately not touched.

[pullfrog]

ℹ️ No new issues in the latest commit — the prior minor finding is unchanged and still applies.

Reviewed changes

• Main sync (11b9b9b) — merged origin/main, pulling in #19218 (hover/focus message timestamps) and #19226 (subagent-group and tool-row identity), both of which touch NativeChatMessageRow.tsx.
• Reasoning re-integration — the reasoning early-return to NativeChatReasoningRow survived the merge intact; reasoning rows render the collapse toggle but still omit the timestamp and agent controls.
• Test strengthened — NativeChatMessageRow.test.tsx now asserts reasoning rows render exactly one button (the collapse toggle) and no time/copy/scroll controls, replacing the prior "zero buttons" chrome-free assertion.

The claude-streamed-thinking.ts multi-thinking-block reconciliation gap from the prior review is untouched and remains the single open item.

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

[brennanb2025]

Fresh alignment screenshots — these supersede the earlier alignment shots above.

The expanded reasoning uses pl-5 (20px), exactly matching size-3.5 (14px) + gap-1.5 (6px). In both themes, the summary and first body paragraph measured at the same x coordinate (415px). The rail, italics, summary, and disclosure behavior are unchanged.

Captured through Playwright CDP in this branch’s existing hidden Electron instance, launched with ORCA_BACKGROUND_LAUNCH=1; no window was revealed or focused. A temporary Codex transcript was loaded through the production decoder into the real native-chat pane, temporarily mounted in the app’s content area with surrounding chrome. The temporary pane and transcript were removed afterward; no fixture code is included in the change.

Dark, collapsed: summary starts past the chevron.

Dark, expanded: full reasoning begins directly under the summary text.

Light, collapsed: the same summary inset.

Light, expanded: matching text edges with the existing italic treatment.

Validation: focused NativeChatReasoningRow and NativeChatMessageRow suites passed (12 tests); changed-file oxlint passed. Typecheck remains with the coordinator.

[coderabbitai]

Note

GitHub couldn't provide a complete incremental comparison for this pull request, so CodeRabbit is performing a full review instead. This review may take a little longer.

[brennanb2025]

Fresh reasoning-row screenshots — these supersede all earlier reasoning-row screenshots on this PR.

The left rail and its padding are removed. The summary starts at the row’s left edge, the nonshrinking chevron sits at the right edge, and the expanded italic body uses pl-4 (16px) relative to the summary. Existing disclosure rotation, reduced-motion class, accessible label, and summary derivation are unchanged.

Captured the real native-chat pane through Playwright CDP in this worktree’s hidden Electron instance with ORCA_BACKGROUND_LAUNCH=1, without revealing or focusing a window. A temporary Codex transcript was loaded through the production decoder; the temporary pane and transcript were removed afterward.

Dark, collapsed — no rail; chevron points right at the end of the summary row.

Dark, expanded — chevron points down; italic reasoning is indented 16px from the summary.

Light, collapsed — matching rail-free layout and trailing chevron.

Light, expanded — matching body indentation and italic treatment.

Validation: both focused reasoning-row/message-row suites passed (12 tests), and changed-file oxlint passed. At a temporary 300px trigger width, the summary truncated with ellipsis and the chevron stayed 14px wide at the right edge. Typecheck remains with the coordinator; sending messages and SSH execution were outside this visual check.

[brennanb2025]

This supersedes all earlier reasoning-row screenshots on this PR, including the initial version of this comment. Final code: ab0675aed2.

The headline uses fixed, muted 13px copy: Thinking..., an interpolated locally observed duration, or Thought for a few seconds for replayed history. The first reasoning line appears only after expansion.

Duration follows this block’s own locally observed text revisions. The row starts on first rendering active and records its last text revision; settlement freezes that interval. Later answer/turn work is excluded, and already-settled history never receives a number. No journal timestamp, receipt timestamp, or turn-duration value is used.

Fresh full-window screenshots were captured through CDP from this worktree’s hidden Electron renderer with ORCA_BACKGROUND_LAUNCH=1, using controlled session data through the production message list and composer. The timed state shows Thought for 14s while the separate turn row says Worked for 17s, because three seconds of later turn work were excluded. Live agent sends and SSH transport were not exercised.

The expanded body stays italic with a 16px indent. The chevron remains 14px wide at the right edge and rotates to 90° when expanded, with no left rail. The existing reduced-motion guard is preserved; the CDP media-emulation probe still reported a 0.15s transition, so runtime reduced-motion behavior is not claimed as verified.

Focused reasoning/message-row suites: 15 tests passed, including a regression for reasoning finishing before the turn. Changed-file oxlint and React Doctor lint passed; no pnpm tc was run.

Replayed history, collapsed: no inferred number.

Dark	Light

Replayed history, expanded: reasoning stays visually secondary.

Dark	Light

Observed streaming: Thinking... uses the existing pulse treatment.

Dark	Light

Settled: 14s of observed reasoning, excluding later turn work.

Dark	Light

[coderabbitai]

Actionable comments posted: 1

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: a6a4b243-87ad-44e3-bdd9-a977658f3a6f

📥 Commits

Reviewing files that changed from the base of the PR and between d09f3b8 and 9bcb747.

📒 Files selected for processing (4)

• src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
• src/renderer/src/components/native-chat/NativeChatReasoningRow.test.tsx
• src/renderer/src/components/native-chat/NativeChatReasoningRow.tsx
• src/renderer/src/i18n/locales/en.json

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

• src/renderer/src/i18n/locales/en.json

Included review availability: Your plan provides up to 10 included reviews per hour; 6 remain after this review.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

🔎 Supported by static analysis

🏁 Script executed:

#!/bin/bash
# Description: Inspect how activeTurnIsWorking is supplied to MessageRow.
rg -nP -C 6 '<MessageRow' --type=tsx --type=ts src/renderer/src
rg -nP -C 4 '\bactiveTurnIsWorking\b' src/renderer/src --type=ts --type=tsx

Repository: stablyai/orca

Length of output: 215

---

🏁 Script executed:

#!/bin/bash
set -e
printf '%s\n' '--- candidate files ---'
fd -t f 'NativeChatMessageRow|MessageRow|native-chat' src/renderer/src | head -80
printf '%s\n' '--- activeTurnIsWorking references ---'
rg -n -C 8 '\bactiveTurnIsWorking\b' src/renderer/src
printf '%s\n' '--- NativeChatMessageRow outline ---'
ast-grep outline src/renderer/src/components/native-chat/NativeChatMessageRow.tsx

Repository: stablyai/orca

Length of output: 50369

---

🤖 get_repo_knowledge executed:

get_repo_knowledge stablyai/orca /tmp/coderabbit-repo-knowledge/stablyai-orca-89dc44e4/learnings

Length of output: 15364

---

🏁 Script executed:

#!/bin/bash
set -e
printf '%s\n' '--- MessageList render path ---'
sed -n '180,260p' src/renderer/src/components/native-chat/NativeChatMessageList.tsx
printf '%s\n' '--- reasoning row implementation ---'
fd -t f 'NativeChatReasoningRow' src/renderer/src/components/native-chat
sed -n '1,220p' src/renderer/src/components/native-chat/NativeChatReasoningRow.tsx
printf '%s\n' '--- message assembly and reasoning-message shape ---'
rg -n -C 5 'role:\s*['"'"'"'"'"]reasoning|reasoning.*message|type:\s*['"'"'"'"'"]reasoning' src/renderer/src/components/native-chat --glob '*.ts' --glob '*.tsx' | head -160

Repository: stablyai/orca

Length of output: 7730

---

🏁 Script executed:

#!/bin/bash
set -e
printf '%s\n' '--- reasoning message producers ---'
rg -n -C 4 "role: ['\"]reasoning|role:\s*['\"]reasoning|role:.*reasoning" src/renderer/src/components/native-chat --glob '*.ts' --glob '*.tsx' | head -180
printf '%s\n' '--- turn grouping and message list inputs ---'
rg -n -C 5 'messages\s*=|NativeChatMessage\[\]|turnKeys|group.*turn|reasoning' src/renderer/src/components/native-chat/NativeChatMessageList.tsx src/renderer/src/components/native-chat/native-chat-message-grouping.ts src/renderer/src/components/native-chat/native-chat-assembler-merge-parity.test.ts | head -220

Repository: stablyai/orca

Length of output: 10437

---

Limit isStreaming to the active reasoning message.

NativeChatMessageList passes the same current-turn activeTurnIsWorking value to every MessageRow. If a turn contains multiple reasoning messages, every NativeChatReasoningRow shows Thinking... while the turn is active. Each row then measures elapsed time until the turn ends, not only for its own block. Pass true only to the latest reasoning message, or derive it from message-level lifecycle state.

[pullfrog]

ℹ️ No critical issues — one minor, defer-able observation inline.

Reviewed changes

• Timing labels replace the summary headline — NativeChatReasoningRow now shows Thinking... (pulsing) while active, Thought for {{duration}} on settlement, and Thought for a few seconds for replayed history, instead of a 120-character first-line excerpt.
• Local per-block observation clock — the row tracks startedAt/elapsedMs keyed by blockId, freezing the observed duration when the row settles; MessageRow forwards message.id and activeTurnIsWorking.
• Tests and i18n — five new deterministic Date.now-mocked timing tests plus three native-chat locale keys; the earlier summary-length/first-line tests were rewritten to match.

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

[pullfrog]

ℹ️ ab0675a cleanly resolves the turn-scoped duration concern — no new issues in this delta. Approval is still held by one pre-existing open finding.

Reviewed changes

• Duration excludes later turn work — NativeChatReasoningRow now freezes lastUpdatedAt at the block's last text revision and computes elapsedMs = lastUpdatedAt - startedAt, so tool execution and final prose no longer inflate Thought for. The effect deps gain markdown.
• Mocked-clock regression test — excludes later turn work after the block stops changing pins 12s (not the full turn span) under mocked Date.now.

Remaining open item (unchanged by this delta)

• createClaudeStreamedThinking.finalize reconciles a single streamed identity while claudeThinkingText joins every thinking part, so an interleaved multi-thinking-block message would orphan the later streamed rows. Latent today — the app does not currently emit interleaved thinking — but still open.

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

[pullfrog]

ℹ️ No new issues in this merge — the prior multi-thinking-block finding is unchanged and still applies.

Reviewed changes

• Main sync (0c80264) — merged origin/main, pulling upstream refactors into the Claude and Codex structured-journal translators (appendUnmodeledClaudeContent now owns unmodeled content; Codex plan items gain a presentation: 'plan-document' field).
• Reasoning re-integration — the PR's reasoning emission survived the merge: Claude thinking still flows through streamedThinking.finalize, and appendUnmodeledClaudeContent skips thinking parts because isModeledClaudeContent returns true for them, so nothing is emitted twice.
• Verification — 152 tests pass across the touched Claude/Codex/shared/renderer suites; the PR's own behavioral surface is unchanged from ab0675a.

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

[greptile-apps]

Confidence Score: 4/5

[Medium risk] Adds reasoning message display to chat UI.

The PR does not appear safe to merge while the Claude capability cache can reuse a result across launch environments that select different CLI versions.

Findings

1.  CLI capability cache ignores environment ▶
2.  Replay label misses fallback ▶

Summary

The PR renders structured Claude and Codex reasoning as collapsible transcript messages and carries reasoning lifecycle information through the journal to desktop and mobile. Since the previous review, it has consolidated the providers’ reasoning-body helpers and adjusted Codex retention ordering. No new actionable issue was established in those latest changes.

_{Reviews (5) · Last reviewed commit: "test(claude): read the launch PATH the w..."}

[pullfrog]

ℹ️ No new issues in the latest commits — the icon, Android long-press, and exit-argument changes are clean. One minor test-coverage suggestion.

Reviewed changes

• Brain glyph on the reasoning row — brain joins the shared NativeChatToolIconName vocabulary and the row leads with NativeChatToolRunIcon iconName="brain", drawn through the same 16px slot a tool row uses; mobile leads with the same Brain at 15pt and indents the opened text to match.
• Chevron reachable without hover — the row's chevron now hides only behind can-hover:opacity-0, so touch and keyboard users still see it; group-focus-visible/reasoning and group-data-[state=open]/reasoning reveal it. This matches the established hover-reveal ordering already in use (HostSectionHeaderMenu, TabBarQuickCommandItem).
• Android long-press on opened reasoning — the actions sheet is restored on reasoning rows: Content moves to MobileNativeChatLongPressContent, the expanded body renders through it, and the reasoning branch renders MobileNativeChatMessageActionsSheet so a long press on the opened text offers Copy / Select text.
• Claude exit arguments forwarded — openClaudeConnectionOf's onExit wrapper now spreads every argument to the session handler rather than forwarding a fixed pair, so an argument the connection adds later still reaches the session.

ℹ️ Nitpicks

• The new hover-reveal control in NativeChatReasoningRow.tsx is not in HOVER_REVEAL_FILES in hover-reveal-touch-action-visibility.test.ts, the ratchet that keeps a hover-only hide off touch devices. Adding the path (one line) would lock in the can-hover: gate this row now depends on.

The pre-existing createClaudeStreamedThinking.finalize multi-thinking-block reconciliation gap (thread PRRT_kwDORpCz1s6f0K_V) is unchanged and still latent; it is not re-raised here.

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

[pullfrog]

ℹ️ No new issues in this delta — the two origin/main merges resolve cleanly. Approval is still held only by the pre-existing open multi-thinking-block finding on claude-streamed-thinking.ts, which this delta did not touch.

Reviewed changes

• Main sync (0362442292) — merged origin/main, adopting main's opaque provider-handle API in claude-structured-launch-resolution.ts (head.nativeId, agentSessionProviderHandleRoot, claudeProviderHandleLeafUuid) while keeping the branch's early cwd/env resolution for the thinking-display probe. git diff 086b06c1d6..HEAD on that file is exactly the branch's probe additions on top of main, so the conflict resolution lost nothing. The reasoning-sweep test now builds its identity with codexProviderHandle.
• Main sync (616255036b) — merged origin/main, bringing the relay director deploy driver and a codexProviderHandle test fix; no PR code delta.

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

[pullfrog]

ℹ️ No new issues in this merge — the conflict resolution is behavior-preserving. Approval remains held only by the pre-existing open multi-thinking-block finding on claude-streamed-thinking.ts, which this merge did not touch.

Reviewed changes

• Main sync (c6253cc431) — merged the current origin/main (9756dae). The only authored conflict resolution is in src/shared/agent-session-journal-schemas.ts, where both sides had extracted an inline schema: the merge takes main's AgentSessionFailureFactSchema and AgentJournalAnsweredTurnSchema while keeping the branch's AgentJournalThreadGoalStateSchema and the message body's state/completedAt. Each import replaces an identical inline definition, so the wire behavior is unchanged.
• Both sides preserved — codex-structured-session-state.ts carries the branch's CODEX_RECEIPT_TIMED_METHODS alongside main's answeredInTurn dispatch-settlement field, and the locales keep the branch's reasoning/thought/thoughtForDuration keys alongside main's new translations.
• Verification — agent-session-journal-schemas.test.ts (36 tests) and pnpm run verify:localization-catalogs pass; the merge adds no net behavioral change.

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

[brennanb2025]

Review and QA, Oct 6: reading reasoning while it streams

This replaces the Oct 5 comment, which described the earlier design.

The problem. Before this change, a reasoning block's row was hidden while it streamed, and the activity line just said "Thinking". So you couldn't read what Claude or Codex was thinking until the block ended. Main today draws reasoning inline as it streams (when it has text), and the common pattern lets you open the live indicator and read it. This PR had taken that away.

What changes for you.

• While thinking: the single "Thinking" line on the activity line can be opened (click, keyboard, or tap on mobile) to read the summary as it streams, height-capped with its own scroll.
• When the block ends: a "Thought for N s" row with the brain icon takes its place, still open if you opened it, and the line goes back to "Working…". The next block starts closed.
• Labels: "Thinking" is never shown twice, and a row is never hidden unless the line is showing it. Any other unfinished block, a subagent's or one whose line gave way to a question card, draws in place as an openable "Reasoning" row.
• Mobile: the same, including Android long-press Copy / Select text on the live text.
• Blank blocks: still never drawn. A block with no text yet still reads "Working…" until its first text arrives; the stacked step-2 PR's live signal covers that gap.

How. One shared value (src/shared/native-chat-live-line.ts), used by desktop and mobile, decides what the line shows and which row it hides, so the two can't disagree. The line and the finished row share one open/closed key. No host or wire change, so older apps are unaffected.

Fixed during review (a full round on the design, a re-review of its fixes, a review of the main merges, and readiness):

• A row that also carried its turn's status bar or file-change summary still drew under the live line, so the text showed twice.
• The line's condition was restated by hand on desktop; it is now the shared value.
• The screen-reader region was rebuilt on every label change.
• Android couldn't copy the live text.
• The mobile line's touch target and indent.
• The Android copy sheet vanished when the block ended and reopened on its own on the next one.
• The live text was brighter than the finished row's, so it dimmed on landing.

Earlier merges of main also needed a line-limit split in a Codex file.

Deferred (P3):

• Keyboard focus returns to the page when a block you opened from the line finishes.
• An open Android copy sheet closes if the line itself goes away at turn end.
• Smaller items are in the review notes.

For the stacked step-2 PR (#24545):

• It should only swap where "Thinking" comes from, to its host signal.
• It should drop its own row-hiding code.
• It should drop its per-subagent "Thinking" labels: no common pattern shows a second live indicator.
• It should rewrite its "no row while a block is open" note.

Verified:

• Rendered check: a hidden, isolated test build on a separate Mac replayed a real Claude 2.1.280 recording at 1x through a stand-in claude (no real Claude or credentials), in dark, light and keyboard focus, over five replays.
• In-page sampler: never found a row next to the line for the same block or two "Thinking" labels, and the live and landed text measured the same colour.
• Checks: typechecks and the affected tests pass locally, and CI is fully green on 09546329717.

While thinking	Opened, streaming	Landed, still open	Turn over

Not verified:

• Mobile on a device: no test host with a reasoning chat could be paired without touching a live Orca; mobile is covered by unit tests.
• Other platforms and assistive tech: Windows and Linux rendering, a touch screen, a real screen reader.
• Codex reasoning rows: not checked rendered.