* Show phone option preview thumbnails with a full-height viewer
* Use typed renderer host queries in preview interaction coverage
* Register phone preview viewer labels in the mobile catalog
* Keep phone preview thumbnails within the compact frame
* Count supplementary wide characters in phone option previews
* Keep the readable option preview subscribed to theme changes
* Correct mobile preview test typing and positional page identity
* Explain the immutable answer identity used to reset preview scrolling
* Preserve native preview text and measure thumbnail bounds
* fix(mobile): measure preview text at its intrinsic web width
* chore(mobile): document the web-only intrinsic width boundary
* refactor(mobile): group host catalog credentials descriptors and connection history
* refactor(mobile): import RPC sender and result types from defining owners
* refactor(mobile): colocate push delivery with registration operations
* refactor(mobile): point push recordings at delivery owner
On the phone, Codex's Standard/Fast speed was a Speed row opening a
list while Claude's Fast mode was a switch. A Fast-only speed now uses
the same switch row; more speeds, or a lone Flex, keep the list. The
lone-Fast rule moves to shared code so desktop and mobile follow one
rule.
* 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>
* 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
* feat(mobile): save the chat when the app leaves the foreground
A swipe-kill from the app switcher can end the app before the page is
hidden: iOS fires visibilitychange only at background, and Android Recents
leaves the activity resumed. The shell now sends an appInactive frame on
iOS inactive and Android window blur, to pages that declare they read it,
and the page saves any chat rows the store doesn't hold yet.
* fix(mobile): keep the leave callback out of render
* fix(mobile): notice a changed middle row before skipping a chat save
* feat(mobile): open chats on their last messages after a relaunch
The phone's store keeps each chat's newest rows (up to 512 KiB, 500 rows)
and its resume point, written when a turn settles, on hidden and when the
chat closes. A relaunched session opens on its stored chat tab, paints the
saved rows, and resumes from the stored cursor; the live read restates what
the agent is doing. Offline, the composer line says when the copy is from.
* test(mobile): keep the relaunch test typechecking
* i18n(mobile): translate the offline as-of line
* perf(mobile): encode chat copies in slices off the settle frame
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>
* feat(mobile): cancel dictation in place and show which device is transcribing
* fix(mobile): give each composer its own dictation cancel target
* fix(mobile): keep the dictating composer row on one line
* refactor(mobile): share the dictation mic face and measure the cancel target per platform
The host stops the old agent (about 0.6 s for Claude, up to 3 s with slow
MCP servers) before it writes the divider, so the old transcript lingered.
Linear: STA-14361
* 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
* 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.
* refactor(mobile): give relay and encryption concrete owners
* refactor(mobile): organize session and review feature owners
* refactor(mobile): organize RPC and host ownership
* test(mobile): point render fixtures at concrete owners
* refactor(mobile): use explicit type-only owner imports
* feat(runtime): confirm a structured chat send by clientMessageId past the first journal page
* fix(mobile): ask the send's own chat before handing it back
* fix(mobile): read send-recorded support when the deadline fires and settle rows that land mid-lookup
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.
* feat(mobile): queue chat sends while the desktop is offline
* test(mobile): cover the offline chat send queue
* fix(mobile): drop a closed chat tab's queued messages
* fix(mobile): keep offline queue order and hold drains behind terminal prompts
* fix(mobile): drain a structured chat's queue only once its session loads
* test(mobile): stub reanimated in the prompt controller render mocks
* feat(mobile): bring a queued chat message back paused after Orca closes
* fix(mobile): update the queue's send ref after render and type the queued bridge test
* fix(mobile): keep the queued send intent type free of page storage imports
* test(mobile): pass a send's chips through its intent in the kill test
* fix(mobile): hand a queued host command with a lost reply back to its queue
* 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
* perf(mobile): let the model pill take picks before the chat attaches
* fix(mobile): lock the picker while a held pick is sent and keep the mode toggle for attach
* fix(mobile): report a held pick's refusal only for its own chat
* feat(mobile): keep chat drafts and unsent text in the device store
* test(mobile): give the send tests a real draft destination
* fix(mobile): confirm reopened sends past the loaded window and save the journal id with the clear
* fix(mobile): let an open chat claim a released send, and warn on a reopened command
* refactor(mobile): share the pausable unconfirmed-send deadline between chat holds
* fix(mobile): hold every lost structured send and replace a re-held deadline; use the shared store value codec
* fix(mobile): save chip-only drafts, save only a send's own chips, and keep hold time across outages
* fix(mobile): hash a draft key the device store would refuse as too long
* fix(mobile): drop a sent message's chips in the write that settles it
* fix(mobile): return a structured host command whose reply was lost to the box
React Native Web repeats the last scroll event 100 ms after scrolling
stops. The page list cleared its record of its own scroll write on the
first matching event, so the repeat after each place-keeping correction
counted as the reader scrolling. For a parked reader that froze the
streaming reply below for 300 ms about every 0.7 s and released it in
one step, which showed as lurches of 20-40 px.
* perf(mobile): show the model picker's models as soon as a chat opens
* fix(mobile): retry skill scans and trailing command reads through the query
* fix(mobile): keep menu-read commands across a re-probe and rescan skills on demand
* refactor(mobile): read chat query state from the client and give the model catalog query its own module
* test(mobile): give the reopen seed catalog its fetchedAt
* fix(mobile): keep the query layer out of the phone options hook's module graph
* perf(mobile): trim the page bundle back under its old budget
* build(mobile): simplify the route entry anchors and zod table guard
* fix(mobile): import zod as a type in the RPC result reader
* 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
* fix(mobile): keep speech said while dictation starts and fail fast on a dead host
* fix(mobile): let a tap or long-press end dictation while it starts
* fix(mobile): wait for the host's cancel before the next dictation starts
* fix(mobile): let a start wait out the previous start on the host too
* refactor(mobile): track host dictation work per client, not per screen
* test(mobile): read the start's dictation id without a cast
* fix(mobile): finish instead of cancel when a held mic is released while starting
* Offer terminal sign-in from native chats and retain refused worker tasks
* Handle sign-in terminal failures and complete failed-start cleanup callers
* Read retry task identity from its dispatch context
* Assert retained transcript identity through the bounded worker read
* Remove obsolete private structured retry teardown assertion
* Use real signed-out Pi and OMP error frames in regression coverage
* Route chat sign-in through explicit host terminal creation
* Keep paired agent launch owner explicit in the tightened terminal contract
* Keep focus baseline pruning limited to the removed reads
* Keep terminal login recovery available for unresolved model notices
* Keep the Grok diagnostic assertion scoped to its refused delivery
* Limit chat sign-in subscriptions to eligible failure rows
* Pass the execution host in terminal creation fixtures
* Scan Pi OAuth failures linearly and verify shared sign-in bounds
* Assert failure metadata and diagnostic routing without translated copy
* Bound diagnostic matcher steps at the Pi failure boundary
* Type the diagnostic matcher receiver explicitly
* Check sign-in button elements with a DOM type guard
* Recognize Pi credential failures and keep one recovery action
* Keep Pi sign-in diagnostics behind failure details
* Verify recovery action changes while refusal wording stays stable
* Use the recorded refusal sentence in the recovery fixture
* Type the recovery fixture as a submission rejection
* Make chat sign-in actions large primary controls
* Reuse primary action styles without duplicate notice subscriptions
* Keep translated primary chat actions within narrow notices
Slash and mention suggestion menus in the phone chat composer stay reachable above the on-screen keyboard while typing.
Co-authored-by: Guderlilian <73724370+qq2144@users.noreply.github.com>
* 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