* perf(mobile): reopen Files folders from memory
* test(mobile): re-record Files explorer goldens for query reads
* fix(mobile): paint cached Files rows before the host client attaches
* refactor(mobile): share query observer options and Files' empty-state rules
* test(mobile): type the Files explorer test host
* perf(mobile): open Review with the Changes data already loaded
* fix(mobile): keep the open diff through re-keys and wait for Review rebuilds
* fix(mobile): release Review writes once their files show, retry only fixed diffs
* fix(mobile): follow language switches in Review's diff states
* fix(mobile): keep Changes' compare key out of render and type the Review adapters
* fix(mobile): reread Source Control settings when a screen opens or the app returns
* test(mobile): use the shared hook harness for the settings reread test
* feat(mobile): show a thin refresh line under the header while cached data refreshes
* fix(mobile): start the refresh line still under unknown motion and key it by execution host
* fix(mobile): draw the refresh line only once the motion preference is known
* fix(mobile): start the refresh sweep at the left edge on each reveal
* refactor(mobile): drive the refresh line from the screen's own refetch and keep its timers in the header
* test(mobile): give the Changes content fixture the new refreshing field
* perf(mobile): stop a hidden host list refetching on every change
The host list's change-event path fetched worktree.ps (and the server rows read) on every worktreesChanged or reposChanged with no throttle, even while the page was buried under a session or the app was backgrounded. Hidden pages now note what they owe and the foreground refresh catches up once; visible pages read at most once per 3 s.
* perf(mobile): count poll reads in the change throttle and queue the catch-up read
* perf(mobile): leave the poll out of the change throttle and queue the catch-up only after skipped notices
* test(mobile): drop the throttle timing test
* refactor(mobile): one owed flag and one full catch-up read for a hidden host list
* perf(mobile): skip the Suspense fallback on page boot
* fix(mobile): keep open-target boots on the lazy path
* test(mobile): pin that the page waits for its held route chunk
* refactor(mobile): preload every page layout and keep screens apart
* perf(mobile): render the cached page build first and talk only after the connection's verdict
* test(mobile): give ready shell states their page window
* feat(mobile): let pages read and write the device store
* fix(mobile): import zod as a namespace in the page store verb
The page bundle check rejects `import { z }`: it ships zod's locale tables.
* 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
* feat(dictation): stop desktop dictation after a minute of silence
A toggle dictation left running keeps the mic open indefinitely. Stop it
a minute after the last speech, with a toast, like the phone's tap mode.
A held push-to-talk key is never stopped; its release ends the session.
Mobile's timer moves into src/shared so both apps use the same rule, and
the shared meter now records when it last heard speech.
* fix(dictation): gate the silence stop on hold mode, as the phone does
* refactor(dictation): let the desktop silence hook own the hold-mode rule, as mobile's does
* refactor(dictation): move the capture meter into its own hook
* refactor(dictation): initialise the capture meter ref without a render write
* 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
* fix(dictation): space dictated text from its neighbours and keep text that can't be inserted
* fix(dictation): don't report a contentEditable insert as landed when nothing was inserted
* refactor(dictation): read caret neighbours per block and trim the spacing helpers
* feat(pairing): unscanned desktop pairing offers expire (QR 10 min, link 60 min)
Headless serve/orcad mint offers without a TTL, so they never expire.
Paired rows and rows without offerExpiresAt are unaffected.
* feat(pairing): refresh the mobile QR before it expires and show runtime link expiry
The QR re-mints a minute before expiry while visible; an unused runtime
link shows its expiry and, once expired, is replaced by a notice. Web
clients rejected while pairing now suggest asking for a new link.
* feat(mobile): say a refused pairing code expired or was replaced
A first pairing the desktop refuses (direct or Relay) now asks for a new
code instead of showing the raw transport error.
* refactor(pairing): replace type assertions in code-refusal detection and tests
* test(mobile): re-record pairing race golden for refused-code error
* fix(pairing): keep pairing codes valid across sleep and stale registry writers
- QR refresh rechecks the wall clock every 15 s and on window focus, so a
computer waking from sleep never keeps showing an expired code.
- A registry save from a process with an older copy can no longer reset a
paired row back to unscanned (which would let its offer expire).
- The QR caption says how long a copied code works.
* test(pairing): annotate the IPC handler stub cast
* 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
Multi-repo folder workspaces can parent workspaces on this machine and on paired servers, and their children nest under them in the sidebar and on the phone. Task parents are inferred at creation instead of on every lineage refresh.
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>
* feat(mobile): sign Android release builds with a dedicated release key
Add an Expo config plugin that gives the generated app/build.gradle an
env-driven release signing config, and have the Android release workflow
require the keystore secrets, fail before building when they are missing,
and check the APK's signing certificate against a pinned fingerprint.
* fix(mobile): keep the signing setup hint intact in the workflow error
* test(mobile): type the plugin import without a cast
* feat(mobile): keep debug signing until release signing is enabled
Release signing now turns on when the ORCA_ANDROID_RELEASE_CERT_SHA256
(or ORCA_ANDROID_REQUIRE_RELEASE_SIGNING) repository variable is set.
Until then the workflow keeps today's debug-signed build and adds a
warning and job summary note; once enabled, missing secrets fail.
* feat(mobile): enable v2 and v3 APK signing for the release key
* fix(automations): run lists send byte-bounded previews; Run Details reads one full row
* fix(automations): retry a failed full run read on the next history read
* fix(automations): show a full-output read failure with Retry in Run Details
* fix(automations): Run now returns the saved pending row; quiet, titled, retained run terminals
Run now answers with the durable pending row instead of waiting behind
the automation's lane; one detached handler records a launch failure.
Existing-workspace launches no longer surface their owner, a new
workspace's startup tab carries the run title, and finished-run cleanup
keeps a terminal a user opened after its process started.
* fix(automations): keep launched runs and user-opened run terminals intact
A failed flush after a launch no longer rewrites a dispatched run as a launch failure.
A user tab open marks the pane activation shows, read after any spawn it starts.
* fix(automations): own launch-failure recording in the service; quiet pending pane notice on mobile
* 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
* fix(mobile): a failed page remounts instead of re-downloading; deadlines count only foreground time
Page deadlines now pause in the background and restart on return, so React Native firing overdue timers on resume no longer reads as a page failure. A failed document remounts the same files once, then shows the failure screen; it never deletes and re-downloads on its own. Try again after a page failure or an unreadable generation deletes the host cache first, so it downloads fresh. Replaces #34550 without its file-size check.
* fix(mobile): drop reports a remounted page's retired view already queued
A failed page remounts at once, minting the replacement's session before
React commits it. A fault or ready the old view had already queued then
landed on the replacement: a second fault showed the failure screen
before the new page loaded, and a late ready marked it ready and
cancelled its load deadline. Each report now carries the session of the
view that rendered it and is dropped once that view is retired.
* perf(mobile): revalidate the "+" agent list without a login shell
The new-tab sheet forced preflight.refreshAgents on the first open of every
session screen, so switching worktrees spawned a login shell and reset the
desktop's captured environment each time. Track refreshed workspaces per
connection instead: later screens on the same connection send the cheap
preflight.detectAgents, and a reconnect refreshes once again.
* fix(mobile): spend the per-connection refresh only on a real refresh
* fix(mobile): count a refresh once it is sent
* refactor(mobile): keep a sent refresh counted
* perf(mobile): probe idle relay sessions
* perf(mobile): name relay idle probe cost in the liveness gate
* fix(mobile): don't count relay probe misses behind a pending reply
* fix(mobile): count frames during a relay probe window as liveness
* refactor(mobile): share the probe-settled reset in the liveness watchdog
* fix(mobile): stop excusing relay probe misses after a request timeout of silence
* perf(mobile): stop live input and keyboard height re-rendering the whole session
* refactor(mobile): drop the web soft-keyboard state hook nothing reads
* refactor(mobile): read the session keyboard lift from the shared occlusion hook
* test(mobile): give the command dock render probe a live input store
* perf(mobile): keep the chat mounted behind its terminal
* test(mobile): assert only what the hidden chat shows
* refactor(mobile): skip the hidden chat by element identity
* test(mobile): find the chat view without a cast
* test(mobile): typecheck the overlay toggle test
* fix(mobile): release a chat's scroll hold when it shows again
* test(mobile): typecheck the hidden-list reading-place case
* perf(mobile): share one clientEvents stream per host connection
* perf(mobile): keep the shared clientEvents stream across a same-tick rejoin
* fix(mobile): let a later subscriber retry after the shared clientEvents open throws
* fix(mobile): guard the shared clientEvents cleanup after a throwing open
* test(e2e): give the phone list's socket client the shared clientEvents shape
splitBridgeReply now returns ready frame strings: the payload is stringified once and spliced into envelopes that match the old JSON.stringify output byte for byte, and its UTF-8 size is counted once. utf8ByteLength skips the ASCII prefix with a native search, since Hermes interprets the per-unit loop.
* perf(agent-session): stream chat text as appends
* perf(mobile): read text-append support from the connection's status answer
* perf(mobile): open the chat stream once the host's append support is known
* refactor(mobile): seed text-append support from the shell's status
* fix(agent-session): stop asking for appends after one is refused
* perf(mobile): seal and decode socket frames through native bindings
* refactor(mobile): decode base64 socket messages with the canonical primitive
* refactor(mobile): share the canonical base64 decoder with socket payloads
* Protect Android insertion and selection magnifier readback
* ci: refresh Android checks against current main
* ci: refresh Android checks after main repairs
---------
Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
* test(mobile): give the review note test a query client
* build(mobile): raise the page code budget to 9.75 MiB
* build(mobile): re-measure the page chunk sweep after the speed batch
* test(runtime): follow the terminal RPC module move in the output credit test
* perf(mobile): parse only the growing markdown block and cap reveal at 30 Hz
A streaming chat reply re-parsed its whole Markdown twice on every
reveal frame and re-rendered every block. Finished top-level blocks now
keep their parsed nodes and drawn elements, only the text from the first
unfinished line is parsed again, and phone reveal steps run at most
30 times a second.
* chore(mobile): note why the markdown tree cache may be written during render
* perf(mobile): slice terminal writes and skip the page echo coalescer
xterm yields to input and paint only between writes, but the document
handed it one string of up to 512K units. The write queue now drains in
slices of at most 16 KB: it joins queued strings up to a boundary and
splits longer ones. The page document runs in-process, so it skips the
48 ms coalescer that batches writes for the native bridge hop.
* refactor(mobile): tidy the write slice join loop
* refactor(mobile): join the peeked write instead of the dequeued entry
* feat(mobile): let the host page open a target inside its own document
* fix(mobile): skip a duplicate open, re-render the stack only for a waiting route
* fix(mobile): resolve the open target through Expo and open a target that changed before mount
* test(mobile): keep Back in one open-target case
* refactor(mobile): hold routes under the top with one released flag
* refactor(mobile): own the navigator ready listener in the effect
* fix(mobile): leave single-route stacks drawn from the start
Remember each host's last good path (direct or relay) per network fingerprint and skip the 2.5 s direct head start unless the last good connection was direct on this network.
Share one in-flight status.get per connection epoch, draw the host gate at once from the status the connection already proved, and let the exact GitHub check reuse it. Routed views keep their own reads.
* feat(mobile): add an encrypted on-device store
One AES-256-GCM key in the pairing keychain seals one file per value, bound to its host, table and key. Cache rows are LRU-capped at 128 MiB; drafts are written as tmp, delete, move and refused past 16 MiB. Launch upkeep (orphan hosts, draft TTL, lone tmp recovery, cap totals) runs in idle slices after the splash, and host removal wipes the host's rows. No consumers yet.
* style(mobile): use a ternary for the cache row write
* fix(mobile): keep a lone draft tmp before reuse and settle every row read
* perf(mobile): reopen Source Control's Changes list from memory instead of rescanning
* fix(mobile): keep action errors through background status reads
* fix(mobile): let only explicit status reads clear Source Control's action error
* refactor(mobile): simplify the query layer and the Changes compare trigger
* fix(mobile): follow language switches in Changes' empty states