* fix(dictation): keep a held dictation through settings changes and insert it on blur
* test(dictation): name the callback re-creation test after what it does
* fix(dictation): keep a held dictation when keybindings are refetched
#38638 moved journal-payload-bounds.ts and journal-reasoning-row.ts into
agent-session-journal/item-lifecycle/; #38956 then listed them at their old
paths, which fails the path-literal ratchet on every PR.
* Preserve native model choice when restoring ACP chats
* Forward startup observations through the OpenCode connection
* Use fixed time in the connection regression fixture
* Complete the model-command fixture session identity
* fix(dictation): keep the last word when dictation stops
Streaming models got no trailing audio before inputFinished, so the
encoder never saw the lookahead frames it needs to emit the final word.
Pad 0.66 s of silence at stop, as sherpa-onnx's own decoders do.
The renderer also tore the mic down the instant stop was pressed,
dropping the unread processor buffer. Keep capturing 250 ms after a
user stop before closing the stream.
* refactor(dictation): let the stop tail rely on the capture generation check
* refactor(dictation): keep the capture hook's stop-tail import on one line
* fix(dictation): leave a session an error tore down during the stop tail
* 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(runtime): cache OMP and Grok model discovery
* perf(runtime): share a slow model probe for its whole timeout
* refactor(runtime): key and probe model discovery from one input
The streaming worker posted the current hypothesis after every 100 ms feed,
so desktop IPC and the phone's text version churned about ten times a second
with unchanged text. A 5 s clip now sends 11 partials instead of 42.
* refactor(agent-session): share the model-snapshot rules with the phone
Move the pure snapshot selection and record rules, the account settings that make held lists stale, and the saved-only preload decision into src/shared so the phone can seed its model picker from the same rules. The renderer keeps its per-host store and sync.
* refactor(agent-session): tidy the shared snapshot rules
* 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(runtime): stat the device registry at most once a second
* test(runtime): restore real timers after each revocation test
* test(runtime): drop the registry read-count test
* refactor(runtime): trim the registry throttle comments
* fix(runtime): pairing and delegation planning read the device file unthrottled
* 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
A new streaming stream starts with empty encoder caches, and zipformer
en-20M then drops most of the first second of speech: the first word was
wrong on 71 of 73 LibriSpeech clips. Each session's stream now takes a
second of silence before its first audio. That cuts per-utterance WER from
27.0% to 16.1%. The priming runs on the first feed so stop never waits for it.
Offline models decode the whole utterance after stop, so their thread count
is the user's wait. On the shipped sherpa-onnx, 4 threads cut a 5 s
utterance from about 190 ms to 122 ms with the same transcript and memory.
The recognizer configs move from stt-worker.ts into stt-worker-model-config.ts
so the worker has room under its line cap.
* fix(emulator): distinguish used and unavailable devices in picker
* fix(emulator): retain older usage timestamps and English review fixtures
* Share emulator recency metadata and valid-selection guard
* Align PR 36548 with current checked types and component contracts
* fix(i18n): remove keys from replaced controls
* fix(emulator): reset picker search and keep retries usable
Clear the picker search after choosing a device and keep Connect available
when the host should choose its default device on a retry.
* ci: refresh emulator picker checks after main repairs
---------
Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
* 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
terminal.subscribe accepts capabilities.outputAck and echoes outputAck with a device-bound streamToken. Output beyond a fixed 512 Ki-unit window waits for terminal.ackOutput; held output past the pending budget is replaced by one recovery snapshot once the link drains.
* 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
Terminal rename closed its sheet before sending terminal.rename, then
ignored a refused reply and swallowed errors, so the typed name vanished
with no message. The sheet now stays open with the name while the desktop
answers, shows the refusal with Retry, and closes only after the desktop
accepts, the same way the workspace rename sheet works.
A second WebView renderer loss in the same screen showed "The workspace
stopped responding", even hours after the first remount recovered. The
remount budget now refills once the remounted page paints, so only a loss
before paint shows the failure screen.
* fix(mobile): ask before discarding an edited automation
* fix(mobile): switch hosts after the picker closes so the discard prompt can show
* refactor(mobile): own the automation leave guard in the editor