Commit Graph
168 Commits
Author SHA1 Message Date
Brennan Benson 50ecb96893 Offer only the speeds the model lists (#40257)
A speed the chat reports that no model lists, in practice Flex from the
user's own Codex config, is no longer added to the Speed choices. It
still runs and is still sent. A chat with no model of its own keeps its
saved speed when some model lists it, so Standard can still turn it off.
2026-11-09 15:08:48 -08:00
Kelvin Amoaba f9a10a75f1 feat(native-chat): bring back the New divider behind a setting (#40490)
Restores the line above messages that arrived while you were away, the scroll to it on return and the screen-reader announcement, all removed in #38044. A new Chat > Behavior switch, "Mark new messages when returning to a chat" (on by default), turns it off; off tracks nothing.
2026-11-09 22:16:18 +00:00
Brennan BensonandClaude Opus 5.5 b7ac7e5178 perf(native-chat): keep streaming chats from re-projecting their whole transcript (#40251)
* perf(native-chat): keep streaming chats from re-projecting their whole transcript

Each stage of the streaming transcript pipeline (reducer merge, question
pass and receipts, message projection, desktop list fold) keeps its
previous input and output and re-derives only revised or appended rows,
falling back to the existing full projection whenever another row could
change. Desktop folds through the phone's fold units, now shared, and live
trims batch by a bounded slack so appends keep row positions.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* perf(native-chat): reuse appended subagent rows and batched revisions

Appended rows in chats with subagent rows extend their turn chunk when
earlier turn inputs are unchanged; batch merges and multi-row revisions
do one pass each; rows without journal positions keep in-place reuse.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* perf(native-chat): look up subagent chunks once per appended batch

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* test(native-chat): pin the live trim slack

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-09 13:46:36 -08:00
Kelvin Amoaba acf3aead78 fix(agent-status): show Codex's mid-turn async question as waiting for the user (#39087)
* fix(agent-status): show Codex's mid-turn async question as waiting for the user

* fix(agent-status): keep Codex's async question waiting on paired hosts under its working title

The phone's PTY-title renewal turned the waiting row back into working, because Codex keeps its working title while the question waits.

* fix(agent-status): clear Codex's open async questions when the user sends a plain message

Orca's chat card answers an async question as a quoted message, not Codex's reply wrapper, so the pane stayed waiting until the turn ended.

* refactor(agent-status): move the legacy status test seed out of listener-state
2026-11-09 20:42:22 +00:00
Brennan Benson 3ee128db1a Keep Claude background tasks attached to their subagent after restart (#39958)
* Keep Claude background tasks linked to their subagent across restarts

* Keep task ownership scoped to each Claude invocation

* Keep partial task events scoped to their invocation

* Distinguish pending task facts from admitted invocations

* Wait for saved task ownership before interpreting Claude events

* Verify journal binding order and saved task liveness

* Keep owned task updates from reopening Claude root turns

* Exercise owned historical notifications with provider identity
2026-11-09 12:33:19 -08:00
Brennan Benson b602376e8b Show AskUserQuestion option previews on desktop and phone (#40109)
* Show AskUserQuestion option previews on desktop and phone

Claude can attach a preview (a mockup or snippet) to each option of a
single-select question. Orca dropped it, so users chose between bare labels.
Options now carry the preview through the journal, terminal asks and the
phone, and the question card shows the selected option's preview as plain
monospace text. Questions with previews confirm explicitly instead of
auto-advancing, so the preview stays readable.

* Keep phone previews bounded and digit focus on the named option

Phone previews get a capped height with their own vertical scroll, and
opening one never scrolls past its top. A digit always focuses its row
before the chosen-row check, so Enter confirms the option the user named.
Tighter preview line height, a stable phone row root, and a persistence
test whose expected previews come from the fixed input.

* Narrow the reopened question with a type guard instead of a cast
2026-11-09 12:31:52 -08:00
Brennan BensonandSeaBee 55fb5584c0 OpenCode subagents show in Chat UI and keep a chat open while they run (#40141)
* fix(native-chat): show OpenCode subagents and keep a chat open while they run

OpenCode reports each subagent as a child session when the client opts in.
Orca now opts in, files each child's tool calls and replies under its own
subagent, and keeps the subagent open until the child reports that it
completed, failed or was interrupted, including after the parent turn ends.

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>

* fix(native-chat): keep a subagent's tool context when its rows are read back from the journal

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>

* fix(native-chat): a Stop also ends running OpenCode subagents, and each subagent can be stopped from the strip

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>

* fix(native-chat): only a chat Stop closes OpenCode subagents, an early subagent Stop stays available, and the close request has a deadline

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>

* fix(native-chat): a subagent Stop that the subagent confirms while the request is out reads stopped

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>

* refactor(acp): close child sessions from the agent connection

Keeps the session runtime under the line limit after the main merge.

* test(acp): read a child command through a type guard

* fix(native-chat): a subagent that reports its ending reads stopped even when the close request fails

A child Stop's session/close now asks the agent to drop the call on timeout instead of withdrawing the write.

* test(native-chat): OpenCode subagent calls group with other agents' subagent calls

---------

Co-authored-by: SeaBee <85791528+seabee33@users.noreply.github.com>
2026-11-09 12:03:55 -08:00
49e79c0498 fix(native-chat): show approved Codex automatic reviews as neutral notices (#40161)
Codex reports both approved and denied automatic approval reviews on the
guardianWarning channel. Orca rendered every one as a yellow "safety review
warning", so routine approvals looked like problems. Approved reviews now
render as a neutral "approved this action" notice on desktop and mobile;
denials and timeouts keep the warning tone.

Co-authored-by: Sean876-alt <224890246+Sean876-alt@users.noreply.github.com>
Co-authored-by: Neil <neil@stably.ai>
2026-11-09 04:45:08 -08:00
Pr1pandNeil e3d8e7e9cb fix(native-chat): group deferred context rows separately in the usage popover (#39917)
Claude reports deferred categories (MCP tools, system tools loaded on
demand) that sit outside the used total, but summarizeContextUsage
dropped the flag, so the popover listed them as window percentages next
to real usage and the rows summed to well over 100%.

Keep the deferred flag on each summary row and render deferred rows in
their own group under a divider, with token counts instead of a share of
the window and a note that they are not counted in the used total.

Fixes #39878

Co-authored-by: Neil <neil@stably.ai>
2026-11-09 03:42:24 -08:00
OrcaWinandOrcaWin f10be535ca test: remove low-value mobile renderer and rate-limit suites (#40188)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-09 01:46:01 -08:00
Brennan Benson 9a798602fe Continue every usage-limited chat at once, and stop after five automatic refails (#40055)
* fix(native-chat): continue every usage-limited chat at once and stop after five automatic refails

The automatic continue sent one chat per 10 s sweep, so chats stopped by the same limit resumed one by one. Its retry budget belonged to the cut, so a continuation that hit the limit again started a fresh budget and could repeat indefinitely.

Send every due chat in one pass, one at a time. Count consecutive automatic continues that ended in another usage limit from the journal: each continue's message id names the cut it answered, and the next cut's turn is joined to that submission through its key or provider item. After five, the chat shows that Orca won't continue it automatically.

* fix(native-chat): read the usage-limit continue chain from the tail, not the whole conversation

The chain walk built a map over every journal row and rescanned history for each link. Walk back from the end instead, so the work is the chain's own rows; add an N/10N contract. Replace the fan-out test's casts with typed fixtures.

* test(native-chat): count a Claude echo-opened continue in the usage-limit chain

* fix(native-chat): derive the usage-limit continue chain once per cut

A status rebuild for the same cut reuses the chain it already derived, since only history before the cut decides it; the turn's limit is read without copying its rows.

* fix(native-chat): skip slash-command turns when walking a usage-limit continue chain

A /compact run after a usage limit sits between the cut and its automatic continue; the latest-turn read skips it, so the chain walk must too. Count visited rows in the perf contracts with typed getters.

* test(native-chat): type-guard the recorded Claude capture events

* fix(native-chat): recompute the usage-limit chain when a late receipt attributes its opener

Reuse across rebuilds is keyed on the cut, its turn row's revision and the newest send, so a late attribution that completes a join is counted instead of keeping a stale zero.

* test(native-chat): guard usage-limit chain reuse at the status projection

Drives StructuredAgentSessionJournalProjections.read through real journal invalidations at 100 and 1000 turn rows: one chain derivation for an unchanged cut, again for a new cut or epoch, and a recount when a late receipt attributes the continue's opener.

* fix(native-chat): reuse a usage-limit chain only while everything it read is unchanged

The chain walk now reports the turn rows it looked up and the oldest submission it examined; the status projection keys reuse on their revisions and join evidence, so a late receipt for any link, not just the newest send, recounts the chain.

* fix(native-chat): derive the usage-limit chain fresh on each status rebuild

Reuse across rebuilds kept missing inputs the walk reads (late receipts, revised failure rows) and its key re-serialized settled history. The status projection's own cache still skips unchanged reads; each rebuild now walks only the chain's tail. Contract tests at the projection count total reads: independent of earlier history, linear in the chain's rows, one scan of the sends when no opener matches.

* fix(native-chat): find an echo-opened turn's opener without reading the turn before it

A Claude echo-opened turn names the provider's key while its opener row keeps the submission's, so the slash-command check scanned the whole previous turn and missed echo-opened commands. It now stops at the nearest root user row.
2026-11-09 01:11:12 -08:00
OrcaWinandOrcaWin c0d3d2e0db test: remove 13 low-value suites and redundant cases (#40138)
* Remove low-value file, runtime and chat test cases

* test: remove low-value shared contract and timing suites

* test: remove leaking browser IPC mock suite

* test: isolate legacy relay bridge transport fixture

---------

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-08 21:51:31 -08:00
Kelvin Amoaba a086693d78 fix(native-chat): show newly installed skills in the Codex $ menu before the first message (#40012)
* fix(native-chat): show newly installed skills in the Codex $ menu before the first message

Resting Codex chats served the background probe's skills/list from a
5-minute cache, so a skill installed in that window showed "No matching
skills", even in a new chat. Each menu open now compares a cheap stamp
of Codex's skill folders and skill/plugin config with the one taken
before the last scan, and rescans only when it changed.

Probe requests always force a reload, and probe pools are keyed by the
catalog's launch generation instead of the whole env, whose 10 s refresh
started a second Codex on every rescan.

Fixes STA-14359

* fix(native-chat): keep the structured session hook within its line limit
2026-11-09 02:25:15 +00:00
OrcaWinandOrcaWin 53b1a5e650 test: remove 10 low-value mailbox, push and timestamp tests (#40035)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-08 16:16:36 -08:00
Brennan Benson 8ffb618a5c Fork copied replies from their original chat (#39823)
* Keep inherited fork actions with the original chat

* Keep fork boundary tests aligned with inherited actions

* Keep inherited fork actions with their original chat

* Keep fork refusal tests within their typecheck projects

* Allow phone forks for supported agents beyond Claude and Codex

* Gate inherited tip forks on host original-chat support

* Require current host proof for inherited fork offers

* Bind inherited fork actions to the current host runtime

* Keep unsent browser forks definitive and offer accurate retry guidance

* Offer copied tip forks only at the fork point and name their source

* Offer forks on all completed copied replies

* Explain which original response can be forked
2026-11-08 16:06:30 -08:00
Jinjing 139e954009 Show dates on older chat messages (#40001) 2026-11-08 15:03:16 -08:00
Brennan Benson 87947ae868 Show CI results as one-line cards on desktop and phone, following the desktop setting (#39658)
* Show CI result lines on the phone, following the desktop setting

The host now sends nativeChatCiResultLines resolved in settings.get, the
ready snapshot and a nativeChatCiResultLinesChanged event, from one
publisher that tracks each pushed chat preference separately. The phone
keeps one store per desktop connection and preference, reads the CI value
only from the paired desktop, and hides the lines until that desktop
reports one. CI rows stay in the projection and are filtered after it, so
a flip rebuilds nothing. The phone draws the line with links to the pull
request and commit.

* Let the phone CI line wrap and select like other notices

Long repository names at large font scale no longer push the commit link
past an ellipsis: the line wraps, centered, with the icon on its first
line. Its text follows the system-notice selection policy, so iOS selects
natively and Android keeps the long-press actions sheet. The CI strings
are translated in every mobile locale, the filter copies only once it
meets a CI row, and the tests drop a token assertion and a duplicate case.

* Draw CI results as one-line cards on desktop and phone

The CI result line becomes a one-line card in the same frame as the
opened pull request card, with the Hide button inline at its right end
on desktop, and in the phone's chat card frame without one. Only the
lead and pull request name truncate, so the commit link and the Hide
button stay reachable on narrow widths. The fixture uses real
percent-encoded item ids so its links render.

* Make the CI card's whole lead open its pull request

A translated lead at large font scale can push the ellipsis before
repo#N, which left no visible way to open the pull request. The
truncating segment is now the pull request's target on desktop and
phone, named for it, while "at <sha>" stays the commit's own target.
The ja, zh and zh-Hant leads use a plain colon so the space after it
isn't doubled.

* Read the CI result lines setting only for structured chats

CI result lines come only from structured sessions' journals, so a
terminal chat no longer sends the setting read. The prompt-controller
fixture stubs the setting hook: its tests count only the chat's prompt
writes, and the structured chat's one read per desktop connection is
expected.
2026-11-08 10:05:27 -08:00
Neil 83f8e6340d refactor(shared): organize file operations and storage owners (#39746) 2026-11-07 22:58:35 -08:00
Brennan Benson 1f5a5e155c /btw asks a side question in a fork beside the chat (#39268)
* feat(chat): /btw asks a side question in a fork beside the chat

In a Chat UI chat that can fork, /btw <question> (or /side) forks the chat
through its newest finished response, sends the question there, and moves the
fork beside the chat the way dragging it does. The source chat is untouched;
the draft clears only once the question went out. Agents that cannot fork keep
their own /btw.

* fix(chat): type-guard the side chat command names

* fix(chat): side chats own the screen from Send and never place an unsent question

- Placement starts at Send, retires for good on any other selection in the
  workspace or on leaving it, and looks only at the requesting workspace.
- A question that never went out leaves its fork in the background; an
  unconfirmed one says to check the side chat before asking again; a failure
  the new chat already reported is not repeated.
- The command menu shows "Available after the first reply" / "when this reply
  finishes" while it is open, using the drawn turn order.
- File pills count as attachments; picking /btw completes the row.

* fix(chat): /btw reads the newest response the drawn transcript offers Fork on

The menu reason and Send now follow the transcript's own Fork rule as drawn,
reported when it changes, instead of rebuilding turn membership in the composer.

* fix(chat): side chat failures always reach the source; watch window starts when the fork opens

- A failed side question toasts in the source even when the fork recorded it,
  since the fork stays in the background.
- The 60 s placement window starts once the fork exists, not at Send.
- The fork-point scan stops at a /clear and, for tip-only agents, at the
  newest turn; split placement looks only in the requesting workspace.

* fix(chat): /btw forgets a fork point the transcript no longer offers

- Send and the menu reason refuse a reported response that is no longer
  forkable, and an unmounted transcript reports nothing to fork.
- The fork-point scan skips subagent sections before its early stops.

* perf(chat): /btw steps over a running turn instead of walking its rows

The slot builder groups root responses by turn in its existing pass; the side
chat's fork point reads those groups newest first and skips a running turn
whole, so streamed replies add no per-row work.

* fix(chat): /btw looks past responses outside any turn and skips the scan when nothing is forkable

* perf(chat): find the /btw fork point while laying out the transcript

Per the review ruling: the slot builder keeps the newest row that offers Fork
in its existing pass, only when /btw listens, and returns one point; the
response groups and their second search are gone.

* test(chat): /btw fork point contract through the transcript and Send hooks

* refactor(chat): response rows and /btw share one Fork rule

* test(chat): /btw fork point ignores pending-only renders and an emptied conversation

* test(chat): /btw contract counts every eligibility lookup and covers an undrawn transcript

* fix(chat): /btw shows ahead of agent commands, sends on one Enter, and focuses the side chat

- Side-chat rows lead the slash menu, so a long agent catalog no longer
  pushes them past the menu's row limit.
- Enter on a fully typed /btw sends it instead of only completing the row.
- Placing the side chat also moves keyboard focus to its composer.

* fix(chat): picking /btw completes the row again, as the common pattern does

Sending a fully typed /btw from the menu bypassed a same-named skill's
release and sent on a mouse click; a pick now always leaves '/btw ' to
add a question to.

* fix(chat): on layout-owner builds the moved side chat keeps its composer focus

Main selects a tab it moved once its frame shows it there, so placement no
longer selects it first in the source pane; moveTabToNewPaneColumn reports
whether main or this window moved it, as moveTabToGroup does.

* fix(chat): side chat placement owns main-drawn moves through to the drawn result

Per the review ruling: the placement claim stays alive while main draws the
move, reads the side chat's own new pane and selection as its own, and selects
and focuses the side chat once the frame shows it moved, in place when main
refuses, and never after the user selected elsewhere. The owner command takes
an optional completion in place of its own moved-tab selection.

* fix(chat): selecting the side chat in the pane it is leaving still retires the claim

Only what main's move changes elsewhere (a new pane holding only the side
chat, another pane showing it) reads as the request's own; the selection
counter in the placement contract reads every pane's selection, and the move
helpers' completion is exercised through main's frame transport.

* fix(chat): a side chat main never moves is selected where Fork put it

When main neither draws nor answers the move before the watch ends, the
side chat is selected in place rather than left hidden; the owner command's
completion path (no moved-tab intent, hand-back asks first) is tested.

* fix(chat): a side chat this window moves keeps its focus request

The move's own changes count as the request's from before the move starts,
so a synchronous move no longer retires the claim before the side chat is
selected and focused.

* fix(chat): picking an unavailable /btw row does nothing, as the common pattern does

* refactor(native-chat): keep /btw hooks compilable by React Compiler

* fix(chat): say side chats aren't ready while a fork from the chat is opening

* test(chat): assert the opening-fork refusal without its copy

* fix(native-chat): share one latest-turn scan between /btw and transcript rows
2026-11-07 22:14:45 -08:00
Brennan Benson fd334f1e99 Show CI results in the chat that opened or pushed to a pull request (#39020)
Shows CI result lines in the chat that opened or pushed to a pull request. They're hidden in the terminal overlay and on the phone until the phone app gets the setting.
2026-11-07 16:34:21 -08:00
Kelvin Amoaba 659f279a0f fix(mobile): chat follow-ups for held replies, per-chat zoom and streamed math (#39403)
* fix(mobile): chat page follow-ups

- clear the touch state when the chat hides, so a held reply lands on return
- keep the chat pinch scale per chat
- record waiting display-math openers in the math plugin instead of a line regex
- share the details markup test and the orphan row id predicate

* fix(mobile): record math openers whose scan reaches the end, skip no-op pinch commits

* fix(mobile): fall back to a whole parse only for details section tags

* refactor(mobile): drop a repeated comment
2026-11-07 23:39:23 +00:00
Brennan Benson c6e243d640 feat(native-chat): add /fork to fork a chat from its latest response (#39257)
* feat(native-chat): add /fork to fork a chat from its latest response

Typing /fork in a native chat now runs the same fork as "Fork from this
response", through the newest response still in context, instead of
passing the text to the agent. It is offered only where the host and
agent can fork, and answers with a composer notice while a response is
still running, before any response exists, while a fork is opening, or
when text follows the command.

* fix(native-chat): keep /fork off the transcript rows' fork surface

* fix(native-chat): read /fork's response from the hook's latest input
2026-11-07 11:56:39 -08:00
OrcaWinandOrcaWin 5c487a8be4 test: remove 328 low-value tests (#39525)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 07:44:08 -08:00
OrcaWinandOrcaWin 9b98b38506 test: remove 137 low-value tests (#39522)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 07:20:11 -08:00
OrcaWinandOrcaWin 95fadd01ba test: remove 321 low-value main and shared tests (#39429)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 01:37:39 -08:00
OrcaWinandOrcaWin 1e3eb5701c test: remove 186 low-value main, scripts and shared tests (#39404)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 00:54:22 -08:00
OrcaWinandOrcaWin 4468deb34e test: remove 76 low-value fork and UI tests (#39321)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-06 22:49:58 -08:00
Kelvin Amoaba 2980a713c8 perf(mobile): use mobile-only chat coalesce and reveal timings (#39183) 2026-11-07 04:55:44 +00:00
Brennan Benson c6f07596ad Phone chat: empty Cmd/Ctrl+Enter steers the first queued message, and holding Cmd/Ctrl shows what it will do (#39215)
* fix(mobile): Cmd/Ctrl+Enter on an empty chat composer steers the first queued message

Matches desktop (#38732) in the paired web page: with nothing typed, the
chord steers the head waiting card through that card's own Steer, only
where its other way is steer.

* fix(mobile): empty Cmd/Ctrl+Enter sends the first queued card after a Stop, as desktop does

Desktop's rule (#38877) also sends the head card when no turn runs, and
goal mode keeps the empty chord inert. The queue list's handle now runs the
head card's own Send when idle, and steers mid-turn only where the chord's
other way is steer.

* test(mobile): type the queued-card handle refusal cases

* feat(mobile): holding Cmd/Ctrl in the phone chat composer shows what Cmd/Ctrl+Enter will do, as desktop does

Desktop's held-modifier preview moves into src/shared so the phone web
composer runs the same rule: Send becomes Queue, Steer or Steer queued
and the head queued card lights while the chord's modifier is held
alone on a hardware keyboard. The queue's empty-chord rule is one
function the preview and the press both read.

* fix(mobile): build the held-chord preview with the phone's own React, and offer only presses that act

The shared hook now takes its React hooks from the caller, as the shared
attachment preview does: the phone bundle resolves a different React copy
than the repo root, so importing react from src/shared broke every phone
web composer (Invalid hook call).

The preview also matches what a press does: one pill press per hold (a
double-click can't send a card after the draft went), a picked /plan-style
skill counts as a message, a head card whose own action is on its way shows
no Steer queued, and the lit state lives in the tray so a chat switch keeps it.

* fix(mobile): held-chord pill takes one click like desktop, keeps busy state per chat, lights only the head row

- The pill ignores a click whose detail is above 1, as desktop does, so a
  deliberate later click in the same hold still acts.
- In-flight card ids are kept per chat with functional updates, so a chat
  settling after a switch can't clear the current chat's record.
- The lit state is a small store only the head row subscribes to, so a hold
  re-renders one row, not the whole queue.
- The desktop preview test moves back beside the desktop wrapper it drives.

* refactor(mobile): one owner for queued-card actions, read by both the list and the held-chord cue

The queue list owned its in-flight guard per mount and the tray mirrored it
for the composer's Steer queued cue; each mirror leaked (cross-chat and
same-chat remount overwrites, an all-chats copy per change). As desktop's
queued-messages controller does, the tray now owns one action store: pending
keys per chat, admitted synchronously, released per action, published by
copying only the changed chat. The list takes those actions as a prop (it
keeps its own only when mounted alone), and the empty chord presses the head
through the same run, so the cue and the press can't disagree. The list's
imperative handle goes away.

Also replaces a type assertion on the pill's click detail with an in guard.

* test(native-chat): desktop chord-preview wrapper re-exports the hold delay its test reads
2026-11-06 18:17:24 -08:00
Brennan Benson 969c5ddd3a Support native Plan mode in chat (#38286)
* Add session Build and Plan choices to native chat

* Refresh planning choices across connected composers

* Give composer catalog tests a complete transport fixture

* Preserve planning choices through fresh turns and older hosts

* Type planning delivery fixture choices explicitly

* Honor mode capability for retained queued command picks

* Update existing native mode contract expectations

* Keep proposed plans visible in completed chat turns

* Group chat mode with permissions and goal controls

* Keep chat composer controls accessible in narrow panes

* Preserve composer overflow ownership and editor focus

* Complete composer localization catalog and subscription checks

* Keep chat composer controls contained in narrow panes

* Use the button spacing for compact Save

* Place chat mode immediately before Goal

* Restore Plan status test dependencies after main sync

* Show an exit pill only while chat Plan mode is active

* Remove obsolete composer tooltip translations

* Remove unused Build toggle catalog entries

* Apply Plan commands immediately from composer picks

* Preserve picked skill origin in composer admission

* Supply phone platform to composer regression fixture

* Preserve mode picks until their writer admits them

* Narrow the phone mode command before its draft transform

* Document the option fixture mutation shape

* Match phone Plan controls to the composer mode pills

* Assert optimistic mode feedback in the phone fixture

* Retain the phone mode pick recovery regression proof

* Use the relocated observation imports after the main merge

* Restore the composer IME module import after merging

* Read the queue assertion helper from its relocated owner

* Point the mode fixture at the relocated selection controller

* Register the phone Plan pill localization keys
2026-11-06 12:42:48 -08:00
Brennan Benson 7033f778e8 Keep native chat responsive after reading older messages (#38920)
* Bound native chat history after returning to latest

* Keep reader return evidence aligned with measured content

* Correct transcript regression fixtures and type annotations

* Preserve reader gestures through smaller row measurements

* Keep transcript regression tests focused on behavior

* Pin transcript passthrough and send admission expectations

* Preserve source correspondence in transcript projection reuse

* Keep reader intent separate from observed scroll geometry

* Preserve pending reader movement through no-op pins
2026-11-06 10:20:16 -08:00
Brennan Benson 4cccf7b04a perf(native-chat): reuse unchanged phone transcript rows (#38956)
* perf(native-chat): reuse unchanged phone transcript rows

* fix(native-chat): narrow retained projection output reuse

* refactor(native-chat): isolate phone session status type

* Document source comparison key safety

* Use last-member array accessor

* test(native-chat): check phone captures across source boundaries

* ci(mobile): route recorded transcript decoder inputs
2026-11-06 10:14:07 -08:00
Brennan Benson ea05861c91 Show a card in chat for pull requests the agent opens (#38750)
* feat(native-chat): show a card for pull requests a chat turn opened

When a turn's own command runs gh pr create and prints the new URL, the chat
shows an "Opened orca#3" card under that turn with the PR's state, title and
changed lines, read live from GitHub. The eye-slash control hides the card kind
and a toast links to the new Settings switch.

* fix(native-chat): satisfy lint in the opened pull request card

* fix(native-chat): keep opened pull request cards through tool runs and failed rereads

The card now rides a turn's work run, a clipped create output is always read
whole (retried when the chat is shown, never while hidden), older Codex JSON
output is decoded, rereads keep the last answer and restart past an in-flight
read, failing lookups back off, and a failed hide save says so.

* fix(native-chat): detect pull requests Codex opens through PowerShell, and wait for clipped output

Codex on Windows runs commands as pwsh -Command '...', which detection now
unwraps (and cmd /c), with tests on Claude's and Codex's recorded calls. A
clipped create output is decided from its whole text, each message is scanned
once, rereads keep their bytes counted, a merged card rereads after an edit,
and the header names another repo's pull request in full.

* fix(native-chat): retry each clipped pull request output until its host answers

Each create output cut short on the wire keeps its own backoff while the chat is
visible; a host whose support is unknown stays pending, and only one that says
it can't give outputs whole is decided from the head. PowerShell options and
backtick escapes are read as PowerShell does.

* fix(native-chat): read PowerShell create commands in PowerShell's own quoting

Decoding a tool call's script moves to its own module. PowerShell launches are
lexed with its quoting (single quotes keep backticks literal, double quotes and
bare text escape with them, here-strings and comments are text) and launch
options follow the common pattern's tables; what can't be read whole opens
nothing. A cancelled retry no longer records a failure.

* fix(native-chat): decode a launch wrapper inside a PowerShell tool call

* fix(native-chat): read Codex's escaped quotes in a Windows PowerShell command

Codex on Windows writes a double quote inside a double-quoted -Command as \",
so a create with an apostrophe in its title was skipped. Tests use the three
calls recorded from Codex on Windows.

* fix(native-chat): read a PowerShell launch line in the quoting of what ran it

Codex joins argv in POSIX quoting even on Windows, splitting one word into
differently quoted pieces, so a script ending in a backslash or holding both
$ and an apostrophe showed no card. The launch line now goes through the same
POSIX word decoder as the login-shell preview, and a PowerShell tool's own
line through PowerShell's quoting.

* fix(native-chat): find a PowerShell or cmd launch anywhere in a command list

A Bash call such as `pwsh -Command 'gh pr create --fill' && echo done` lost its
card once launch lines were read as POSIX words, and Codex's joined
`cmd.exe /c 'script'` never had one. Each command in a POSIX list is now read on
its own, through one launch reader shared with argv, while Node's Windows
`cmd.exe /d /s /c "script"` form keeps cmd's own quoting. PowerShell lexing
moves to its own module.

* fix(native-chat): unwrap a PowerShell or cmd launch only when it is the whole line

Rebuilding a command list around a nested launch could pull one out of a comment
or heredoc into a false card, and an unreadable launch hid a real create beside
it. As the common pattern does, only a line that is one launch is unwrapped;
any other line is analyzed as written. A PowerShell tool's line and Node's cmd
form must likewise be a single launch.

* fix(native-chat): unwrap cmd and PowerShell-tool lines only when they are one launch

Node's cmd form now unwraps only a /c script that is one quoted string with no
quote inside, since cmd escapes none, and a PowerShell tool's line ends at a
bare line break. Text after either launch can no longer pass for its script.

* fix(native-chat): read a PowerShell line continuation as a word break

A backtick before a line break in a PowerShell tool's line joined the next line
into the current word, so an argument on the next line could pass for a
command after the launch.

* fix(native-chat): unwrap only the launch shapes agents are recorded writing

Hand-written readers for cmd launches and for a launch nested in a PowerShell
tool's script kept letting printed text pass for a create. Only argv, a shell's
whole -c line and Codex's Windows pwsh -Command line are unwrapped now; argv is
never space-joined, and detection reads a shell line as whole POSIX words rather
than through the preview's lenient prefix. cmd launches and nested launches are
intended misses until an agent is recorded using them.

* fix(native-chat): read an escaped separator as text when finding a create

An escaped \; stayed in the analyzed commands and passed for a separator, so
printf '%s\n' \; gh pr create showed a card though only printf ran. Escaped
characters are now text, like quoted strings and comments.

* fix(native-chat): remove a line continuation when finding a create

Blanking escapes also turned a backslash-newline into a word, so a create on
the line after a continuation no longer started a command and lost its card.
A continuation is now removed, as the shell removes it.

* fix(native-chat): treat only backslash-LF as a line continuation

Bash removes a backslash before LF but not before CRLF, where the backslash
escapes CR and LF still ends the command. Removing both lost the card for a
create on the line after a CRLF continuation.
2026-11-06 02:26:37 -08:00
Brennan BensonandClaude Opus 5.5 2648941358 Fork a Chat UI chat from any finished response (#38326)
* feat(chat): shared contract for forking a chat from a response

Adds the create-time fork source, the host fork capability, the agent fork
level, the forked-from record relationship and the forked-from divider row.

* feat(chat): advertise each agent's fork level and a chat's fork support

* feat(chat): carry a fork source through chat launch, reload and retry

A launch with forkFrom {sessionId, throughItemId} keeps it on the create call,
the saved launch record, reload, retry and its holders, sends no new-chat
options, and is refused before create on a host that does not advertise forks.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* feat(chat): fork a native chat from a finished response on desktop

Finished root responses offer "Fork from this response" where the host and
agent can fork: disabled while support is unknown or a fork is opening, opened
in a new tab right after the source, with one toast naming the agent on
failure. The forked-from row draws as a divider linking to its source.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* feat(mobile): fork a chat from a response in the message actions sheet

The sheet offers "Fork from this response" with the desktop's eligibility and
host capability, creates the fork through the phone's chat create, and draws
the forked-from divider with a link to the source chat.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* feat(chat): a fork create replays only as the same fork

* Add native conversation copy adapters

* Create native chat forks with derived source markers

* fix(chat): offer a fork only on rows that show the agent's own message

A displayed row can be a tool call or a status projected as a plan while
reading as a response; both clients now check the journal row's own kind.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): open phone and paired-desktop forks right after their source

The phone names its source tab as the create's placement and the host takes
that tab's group; a paired desktop sends the address captured at the click
when the fork has no tab of its own yet.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): float a mid-turn response's fork action instead of adding a line

The action on a response the turn continues past hangs from a line of no
height, as the reply controls hang into the gap, so tool-heavy turns keep
their spacing.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): follow the chat's own fork verdict on both clients

The options read already says whether the installed agent forks; an observed
no hides the action, an unanswered read keeps it disabled, and yes enables it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Preserve native copy boundaries and rewind behavior

* Preserve imported fork tips and serialize create replays

* fix(mobile): open a fork's source through the session's own chat opener

The forked-from link now asks the controller's existing opener for the source
by history id, so it follows that opener's host, selection and reveal rules
instead of navigating on its own.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Project fork markers from touched journal groups

* Retain fork group restoration for delayed readers

* fix(chat): keep a mid-turn response's fork in its own right gutter

The floated action covered the start of the next row. It now sits beside the
response's last line, in a gutter as tall as the prose, so it adds no line and
never reaches the following row.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Preserve native fork chain boundaries and durable streamed copies

* Place phone forks beside their source in window publications

* fix(tabs): adopt a host's new tab where the host placed it

First adoption put every unseen tab at the end of its group, so a fork the host
published after its source landed last. A new tab now follows its nearest host
predecessor when that tab is here; tabs already adopted keep the user's order.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): reserve the fork gutter on every root response from the first frame

The gutter came and went with the fork offer, so prose reflowed when a turn
finished or support resolved. A pane that draws forks now keeps it on all root
responses, and the fork sits only there, not also beside Copy.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Return Codex copies without automatic provider renaming

* Resolve chat placement once at the current layout owner

* Preserve chat publication when saved opens are skipped

* Retry chat opens when queued placement changes

* Bound stale chat placement retries

* test: expect the OpenCode reader's imported fork tip

* perf(chat): keep the fork offer stable while a chat streams

Every stream commit made a new forkable-id set, so the fork context changed and
every offered response re-rendered. The set is reused while its members hold,
and rows get an action object that changes only with support or pending.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix: keep the fork params and Claude fork worker inside main's new lint limits

* Test fork copy and source refresh scaling

* fix: merge duplicate imports and stringify the OpenCode fork tip id for main's lint rules

* Keep fork placement behind session tab projection boundaries

* test: annotate the Claude copy test's hoisted account homes instead of asserting

* fix: add the fork action and forked-from strings to the English catalogs

* test: give fixtures the fork copy their agents declare; add the forked-from string to the boot catalog

* test: keep registry fixtures consistent with the fork copy their agents declare

* fix(orcad): ship the Claude fork worker with the server; update tests for fork fields

* Test saved fork selections through import and first send

* Preserve ordinary chat publication while saving placement

* Show fork beside the copy button on phone chat responses

Long-press opens text selection on every current phone, so the actions sheet that held fork never opened. The fork button now sits next to each response's copy button.

* Keep the phone fork slot fixed and offer it on every forkable response

The fork slot is now held by the row's own kind, as desktop's gutter is, so finishing a turn or learning the host's support never moves the timestamp. Responses with no copyable text (a visual only) still get fork, and each button re-renders only when its own offer changes.

* Follow main's moved runtime modules in fork code and tests

* test: build the phone response-actions fixture without type casts

* Let the phone read the host's agents so its fork action can turn on

Phone QA found the fork button always disabled: the phone asks the host which agents can fork, and the host refused that read from paired phones.

* Retry the phone's agent-list read, and read again after a reconnect

A read lost to a dropped connection or a timeout left Fork disabled until the chat was reopened.

* Own the phone's agent-list retry timer in its own effect

CI's effect-cleanup check could not see a timer set inside the read's callback; each retry is now a state change with an effect that sets and clears one timer.

* Give each phone connection its own agent-list retries

A count left over from an earlier connection could leave a new one with no retries, so one failed read kept Fork disabled after the transport moved.

* Scope the phone's agent-list retries to each spell of discovery

When the host's fork support dropped and came back on the same connection, the earlier failures carried over, so one more failure got no retry. Each stretch of discovery now owns its reads, failures and retry timer.

* Keep the forked-from source link reachable by screen readers

The divider's separator role and row label hid the source chat button inside it; the rules are now decorative and the text and button read normally.

* Keep fork names owned by adopted chat records

* Use the fork icon for Fork from this response

* Show the phone meta actions only when a row has one

An empty actions group still shifted the time by the icons' edge margin on rows with no copy, fork or rewind.

* fix(chat): put Fork beside Copy in the response's hover row

The fork button sat alone in a right gutter far from the other row actions.
It now joins the response's existing hover controls next to Copy, where those
controls show, and the gutter is gone.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): keep a finished turn's actions on its last words and hold the Fork slot

A turn whose last prose was followed by tool or thought rows showed no Copy
and no Fork anywhere until it was collapsed. The actions now belong to the
turn's last prose row, decided when the transcript's rows are built, and keep
the gap below it whole so they never cover the next row. Root responses also
keep an empty Fork slot when not offered, so resolving support never moves
the row's other actions.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): give a turn's actions only to a reply with words

An image-only reply after the turn's text took the response actions but could
not draw them, so the text lost Copy and Fork. Slot construction now picks the
turn's last reply by the same words the row draws and copies.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* fix(chat): let an image-only response hold a turn's actions when its text is folded

A collapsed turn that ends in an image hides its earlier text, so no drawn row
could show the response actions and Fork vanished. Each turn's actions now go
to its last drawn response with words, else its last with images. Copy and its
context-menu target appear only where there are words to copy.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Fix Claude fork cuts after local commands

* Extract the conversation copy input contract

* Preserve caller results at Claude fork boundaries

* test: check the copied fork for the wake answer without a type assertion

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-06 02:08:24 -08:00
Brennan Benson c5f1c59009 Let users hide the changed files card in chat (#38756)
* feat(native-chat): let users hide the per-turn changed files card

Adds a Changed files summary setting under Settings > Chat > Behavior (on by
default) and a Hide button on the card that turns it off everywhere, with a
toast linking back to the setting.

* fix(native-chat): confirm Hide only after the setting saves

Show Hidden only once the setting is saved and report a failed save instead;
keep the card header one line tall; cover saved settings without the key.

* test(native-chat): import getDefaultSettings from shared constants

* feat(native-chat): reveal Hide on card hover and move the setting to Appearance

The card's Hide control is now an icon with a Hide tooltip that appears on
hover or keyboard focus, and the Changed files summary switch lives in
Settings > Chat UI > Appearance, where Reset restores it.

* fix(native-chat): put the Hide reveal classes on a wrapper, not the Button

Button owns its effects; the hover and keyboard-focus reveal now lives on a
wrapper span, as other row actions do.
2026-11-06 00:05:16 -08:00
Kelvin Amoaba a4e24a9e5a feat(mobile): show automatic continue and Switch Account on chat usage-limit notices (#38298)
* feat(mobile): usage-limit card with the host's automatic continue, Continue and Switch Account

* refactor(mobile): give the notice disclosure its own file to fit the usage-limit status

* fix(mobile): drop the cancel failure once the host shows the cut cancelled

* fix(mobile): keep the usage-limit status up while a later re-ask is pending

A re-ask at a new journal cursor no longer blanks the reset line and pills;
the cut keeps its last answer. Don't continue reports its disabled state.
2026-11-06 05:12:00 +00:00
Kelvin Amoaba 69892601e2 feat(mobile): rewind a chat to an earlier message (#38344)
* feat(mobile): rewind a chat to an earlier message

Bring desktop's "Rewind to here" to phone chats. The rewind flow moves
into a shared React-injected hook so desktop and mobile share one set of
rules; desktop behaviour is unchanged. The host now lets phones call
agentSession.rewind behind agent-session.rewind.phone.v1, so a phone on
an older host offers nothing it would be refused.

* feat(mobile): put the message time first, then copy and rewind together
2026-11-05 23:06:47 +00:00
Kelvin Amoaba ce3fe75891 feat(mobile): set, pause, resume and clear a chat's goal from the phone (#38447)
* feat(mobile): set, pause, resume and clear a chat's goal from the phone

The phone sent /goal to the agent as plain text and showed no goal. It now
has desktop's goal mode (Goal chip, goal placeholder) and a goal strip on the
composer's top edge that expands to Pause/Resume and Clear goal.

The goal logic desktop and mobile share moves to src/shared: the goal report
(journal rows over the options answer), status labels, elapsed format, the
goal-mode pick rule and the goal row filter. agentSession.threadGoal joins the
phone allowlist behind agent-session.thread-goal.phone.v1, so older hosts keep
showing the goal without offering changes.

* fix(mobile): open each new goal's strip collapsed

* fix(mobile): keep goal sends' delivery choice and scope goal locks per chat

* fix(mobile): offer goal changes only when the paired desktop relays them

* test(mobile): pin which goal changes the phone offers per host

* refactor(mobile): reuse the queued box style and keep the goal strip stable per chunk

* fix(mobile): set phone goals through the composer's changeThreadGoal
2026-11-05 22:42:44 +00:00
Brennan Benson dbb9a270d4 Keep long chats responsive: stop rescanning whole history on each status update and subagent name (#38627)
* perf(native-chat): stop rescanning whole chat history on every status update and subagent label

Status re-derived after every journal write built a map of every item body in the
chat to find conversation-command turns; index only command entries instead.
Same-named sibling subagents restarted their ordinal search at 2 for each sibling
(quadratic); resume each label's search where it stopped. Output is unchanged.

* perf(native-chat): find command turns through an indexed read on each status update

Status re-derived after every journal write still walked the whole history to
learn which turns belong to conversation commands. The host now passes a by-key
read of the same status rows (same display state, presentation membership and
stop-note projection, limited to the current /clear context), and the request,
preview and interruption readers check only the turns their backward scans reach,
the way the usage-limit reader already does. Clients without an index keep the
scan. A contract test drives real journal writes at 10x history and pins both the
constant indexed reads and the remaining per-row work.

* test(native-chat): count status body reads without Reflect.get or casts

* chore: drop accidental lockfile churn

* perf(native-chat): read the status display state once and pin indexed status parity

The host's status lookup now reads the journal's display state once per projection.
The status contract test covers the /clear boundary, an interruption verdict behind
a skipped command turn, a revised command turn, and the journal's per-row render
budget; the context-rows test expects the returned /clear sequence.

* test(native-chat): bound status work on the write that records an Orca stop

* test(native-chat): status follows a turn that becomes a command turn

* fix(native-chat): take the status lookup from the status read itself

Status read the journal's display state directly, which journals without queued
messages (test stand-ins, older wiring) do not have. The status read now returns
the by-key lookup bound to the state it rendered; readers whose status read has
none keep the scan.
2026-11-05 14:20:44 -08:00
Kelvin Amoaba b9f988be22 feat(mobile): continue a chat that Orca's stop cut off (#38287)
* feat(mobile): continue an interrupted chat from the phone

Desktop offers Continue on a turn Orca's own stop cut off; the phone only
showed the words. The offer and failure rules move to
src/shared/native-chat/native-chat-interrupted-continue.ts, desktop uses
them unchanged, and the phone drives them from its session over
agentSession.continueInterrupted when the host advertises it.

* refactor(native-chat): type the Continue answer instead of casting it

* fix(mobile): let a phone call agentSession.continueInterrupted

The host refused the method from phones, so Continue on the phone always
failed. Allow it on the execution-host route and advertise
agent-session.continue-interrupted.phone.v1, which the phone gates on:
hosts that advertise only continue-interrupted.v1 still refuse phones.

* fix(mobile): hide Continue when an older paired desktop relays the chat

A newer page on a server routed through an older desktop would offer
Continue that the desktop refuses to forward. Gate it on the relaying
desktop too; the workspace server context moves to a react-native-free
module so session hooks can read it. Long failure text now shrinks so
the banner's dismiss stays on screen.

* refactor(mobile): reuse the chat's Try Again look and shared Continue wording

The Continue button takes the Try Again pill styles and common.continue,
the shared helper takes the RPC's answer instead of a call wrapper, and
the phone hook memoizes its result and keys late answers in one place.

* fix(i18n): keep the Continue failure copy inline so catalogs rebuild it

* refactor(mobile): keep the structured session hook under its line cap

* fix(native-chat): check the session's agent audience before continuing a turn
2026-11-05 22:08:45 +00:00
Kelvin Amoaba 9055eb9344 feat(mobile): desktop chat links and code wrap on the phone (#38294)
* refactor(native-chat): move chat link rules and the file-existence checker to shared

GitHub reference linking, the reference-repo rule, chat file-path linkification,
the per-chat existence checker and the path-existence batcher are platform-free.
Move them to src/shared so the phone's chat can use the same rules; desktop keeps
its host adapters and behaves the same.

* feat(mobile): link #123 refs, check file paths and wrap code in chat

* test(mobile): pin which chat paths and refs become links

* refactor(mobile): parse repo link fields instead of casting

* refactor(mobile): own chat link state in the chat overlay

* fix(mobile): keep unchecked chat paths as precise as before

* fix(mobile): only peek at known paths while reasoning streams

* test(mobile): leave #123 splitting rules to the shared transform's tests

* refactor(native-chat): tidy shared link helpers and skip separator-free text

* test(native-chat): import the existence type from its shared home

* style(mobile): fold the code-span link handler onto one line
2026-11-05 21:24:09 +00:00
Kelvin Amoaba 7860261d18 feat(mobile): paste images and long text into the chat composer (#38591)
* feat(mobile): paste images and long text into the chat composer

* test(mobile): pin which composer pastes attach

* fix(mobile): keep a long paste as text when no upload can start

* fix(mobile): re-encode pasted images agents can't read as PNG

* test(mobile): pin composer paste routing at the composer field

* refactor(mobile): fold composer paste routing into its hook

* fix(mobile): read pasted images in the uploader so the composer needs no shell bridge

* test(mobile): stub the context ring in the composer paste test
2026-11-05 20:59:54 +00:00
Kelvin Amoaba 9b2f3105ee feat(mobile): show the context usage ring and its breakdown in the chat composer (#38371)
* feat(mobile): show the context usage ring in the chat composer

Desktop's ring reads the structured session's context facts; the phone
never read the host's contextUsage answer. The summary rules move to
src/shared so both read the same numbers, and the title card's anchored
card machinery is generalized so the ring's breakdown opens above the
composer without dropping the keyboard.

* refactor(native-chat): share the context ring's critical threshold

* test(mobile): stub the context ring where composer tests stub its siblings

* fix(mobile): keep the context card with the composer and the keyboard up

Touching the card no longer takes focus from the draft, the open card
moves with the composer as the keyboard or draft resizes it, and the
composer's own menu closes it.

* fix(mobile): close the context card when the composer hides, and let long titles wrap

* refactor(mobile): share the anchored card layer and the ring readout

* test(e2e): pass the new options arg in the permission publication test
2026-11-05 20:44:10 +00:00
Kelvin Amoaba a3f08b4075 feat(mobile): pin the agent's plan above the chat composer (#38359)
* feat(mobile): dock the chat's plan above the composer

Desktop docks the latest plan above the composer; the phone only drew it
inline in the transcript. Move desktop's docked-plan rule to src/shared and
draw it on the phone as a collapsible strip in the background-tasks box.

* perf(native-chat): keep the docked plan's identity until the plan changes

* refactor(native-chat): read the docked plan from the newest message back

* refactor(mobile): drop a cast in the docked plan's open memory

* test(mobile): pass the tray's new taskList in the recovery test
2026-11-05 20:31:10 +00:00
Kelvin Amoaba de7fa2addb feat(mobile): show background task rows in the chat transcript (#38264)
* feat(mobile): show background task rows in the chat transcript

* fix(mobile): truncate the task output path like desktop

* fix(mobile): scale and select task rows like the rest of the transcript

* fix(mobile): translate the task output line

* refactor(mobile): read task rows from the shared row content

* test(mobile): restore the text reader for task row tests
2026-11-05 20:16:34 +00:00
OrcaWinandOrcaWin 64cd31458d test: remove 31 low-value interaction and state tests (#38629)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-05 11:21:57 -08:00
Brennan Benson 61c069aac0 Keep a Claude chat's effort changeable after its first reply (#38272)
* fix(native-chat): keep a Claude chat's effort changeable after its first turn

After its first turn a Claude chat saves the model id Claude reports it ran
(claude-opus-5-5), while the model list names that model only by its alias
(opus). Every capability lookup matched on the row id, so the chat's model
had no effort choices and effort turned into display-only text on desktop
and phone.

A listed row now describes a model id by its own id or by the model it
resolves to. The match supplies capabilities only; the chat keeps showing and
sending the exact model it ran, so it never drifts when the alias moves. The
host applies the same rule to the row it adds for the chat's model, for
clients that read the answer's models.

* test(native-chat): cover exact-row precedence for a described model id

* fix(native-chat): remember an after-reply effort without changing the new-chat model

An effort pick in a chat on the resolved id it ran is remembered under the
listed row that runs that model and leaves the new-chat model untouched, as
the common pattern keeps the sticky model and updates only its options. The
resolved id is never stored as a default.

* refactor(native-chat): move the remembered-pick model choice into its own module

* fix(native-chat): keep a held effort pick from adopting a new-chat model

* test(native-chat): run the held-effort case as a Claude launch

* revert(native-chat): drop the host-side capability copy no live answer can use

Claude's live session listing carries no resolvedModel, so the host never matched there, and phones draw the host-served chat bundle, so every client already runs the shared lookup.

* Key Claude's model rows by the model each one runs

Claude's listing named rows by alias (opus), while a chat saves the model
it ran (claude-opus-5-5) after its first turn, so equivalent chats held two
kinds of model value and a chat's effort could go read-only. Rows are now
keyed by the versioned model they run, the common pattern: a pick saves the
same id the CLI reports. Aliases stay as their own rows with their own
effort levels; the picker lists one only while the chat is on it or a
search matches it, and the phone list leaves them out. A saved alias is
kept as the user picked it. A configured alias default marks the versioned
row it runs, and an effort picked in an existing or resumed chat no longer
changes the model new chats start on, whatever ids the chat and listing use.

* test: give the delayed-report alias test's timeout its reason

* Remember a new chat's picks by its first turn, and keep aliases reachable everywhere

- A chat counts as existing once it has a turn or a send, or when it was
  opened rather than launched here, not once its launch published: an empty
  new chat's effort pick adopts its model for new chats again, and every
  agent's existing chat keeps the remembered new-chat model.
- Only a row that names itself as the model it runs covers an alias, so an
  older host's alias rows stay listed beside a chat's stand-in row.
- The phone lists an alias of a listed model behind a More models toggle.
- The terminal-chat and commit-message model lists carry each row's
  resolvedModel, so they list aliases the same way; an older remote that
  omits it keeps its full list.

* fix(mobile): keep the More models toggle's state without an effect reset

* Keep commit-message aliases selectable and their resolved model out of saved settings

The Source Control model Select has no search, so it lists alias rows after
the versioned ones instead of hiding them. Discovered models are saved
without an alias row's resolvedModel, and the refresh compares that same
saved shape, so the settings cache gains no field.

* Drop an unrelated audit-tools lockfile change; reset the phone's More models toggle when its drawer closes

* test: build the saved-models test's settings without a cast
2026-11-05 00:43:23 -08:00
Brennan Benson e5a960cbf9 Show changed files directly in chat turns (#38256)
* Show changed files directly in chat turns

* Use the fixture frame for the diff interaction

* Keep changed filenames readable and preserve file actions

* Keep unconfirmed file changes in tool activity

* Capture changed files in completed transcript fixtures

* Preserve patch data with authoritative history status

* Keep mobile diff interaction coverage beside its card

* Assert the decoded patch line contract

* Exercise full returned history in catch-up coverage

* test(chat): target file summary when reopening patches
2026-11-04 17:53:16 -08:00
Kelvin Amoaba 7247685c74 feat(native-chat): let users pick when idle chat agents stop, or never (#38202)
* feat(native-chat): let users change or turn off the idle stop for chat agents

The idle sweep stopped every chat's agent after a hard-coded 30 minutes,
which broke peer messaging, Claude Remote Control and background
subagents. Settings > Chat > Behavior now picks the window, including
Never, and the sweep reads it every tick so a change applies without a
restart. Never only keeps agents running: a chat handle with no agent
still retires on the default window.

* test(native-chat): type the childless sweep fixture's journal parameter
2026-11-04 19:30:58 +00:00
Manuel MeurerandKelvin Amoaba 8fa41115a0 feat(native-chat): add a setting to keep the scroll position when sending (#38162)
* feat(native-chat): add a setting to keep the scroll position when sending

Own sends from a pane bring the latest into view and follow the reply.
A new Chat > Behavior setting, "Scroll to latest when sending" (on by
default), turns that off: a reader who scrolled up stays in place, one
at the end keeps following the reply, and Jump to latest still works.

The gate sits in the one reveal every send path reports to, so the
explicit Jump to latest button and find navigation are unaffected.

Fixes #38153

* fix(native-chat): keep following a reader at the end when reveal on send is off

A reader can sit at the end without following (a rail jump that clamps at
the end, a short nudge up). The setting's gate skipped their reveal, so
the sent message and its reply grew below the viewport. The list now
decides: off skips only readers who stopped away from the end, judged by
where they last scrolled so the send's own echo doesn't count.

* refactor(native-chat): read the scroll-on-send setting through one helper

Also drops the redundant 'scroll' search keyword (the title already
matches) and the settings switch call-shape test.

* fix(native-chat): decide the send reveal from where the reader was at the press

The last-scroll distance stayed small after output grew past a reader who
had nudged up, so a later send still jumped them with the setting off.
The list now reads live geometry, and a structured message, which reveals
only once the host admits it, captures that answer at the press, before
its own echo moves the end.

* fix(native-chat): read the reader before Resume waits for the host

Resume reveals only after the host lifts the pause, by which time the
drain may already have added rows below the reader.

---------

Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
2026-11-04 19:30:42 +00:00