Dictation was a built-in plugin in name only: its model, microphone and
protected insert all lived in the app, and the plugin needed a new engine
permission. Make it what it is:
- src/dictation.rs talks to zeron_voice directly. No plugin lease, backend
trait or catalog, and no engine, MCP or plugin-system changes.
- ds.Composer takes one `dictation` prop instead of twelve, and sends on its
own, so lane_tab's send no longer has to move.
- Settings → Voice: turning dictation on downloads the model, then the
microphone, shortcut and Remove, as the shipping app's page has them.
- The shortcut is in Settings → Shortcuts' table.
Fixes along the way: Send while transcribing never sent (retiring the words
ran the effect again, which stopped its timer); the waveform stayed flat (its
level was never passed), so it breathes from time again and nothing publishes
a level every 40 ms; and an unknown data folder panicked the window.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cover native editor revisions and IME, Unicode selection and undo, cancellation, explicit Send and Queue, shortcut holds and release outside the microphone. Keep dictation scoped to its compositor, preserve the collapsed editor geometry, support Zeron v2 and avoid polling while idle. Reuse the device model cache and pin the shared ONNX runtime.
Validation: voice tests, engine manifest and dictation permission tests, ZGX dictation integration, split/template tests and locked cargo check pass. Five unrelated ZGX unit failures also reproduce on the base revision; pre-existing debug-leftover checks fail too. Physical microphone and macOS/Windows package checks remain to be run on those platforms.
* CI: one entry workflow with run admission and a fast pull request tier
Pull request checks took a median of ~3 hours from push to done, and ~110
minutes of that was jobs waiting for a runner. Each push asked for ~207
runner-minutes on 15-20 jobs, almost all of it compiling, so bursts of
pushes queued hundreds of jobs and every run held a few runners while the
rest of its jobs waited behind other runs.
- ci.yml is the only pull request / main / merge queue entry point. `plan`
picks the suites a change needs; `admit` waits until every runner the
run needs is free, then all its jobs start together and each runner is
released when its job ends (scripts/ci/admit.py, first come first served
with conservative backfilling, state read from the Actions API so fork
pull requests work). `CI result` is the one check to require.
- Pull requests get a fast tier: Windows, macOS, voice and Android run only
when the change looks platform specific (their files, platform
conditionals or APIs in changed code); `ci:full` or CI_PR_TIER=full runs
everything. Main and the merge queue run the full tier.
- Voice: 14 `cargo test` builds capped at 2 jobs (~40 min) become core-tests
additions plus one nextest build for audio and the mobile voice core; the
workflow no longer runs uncancelled on every push or saves caches from
pull requests.
- Windows: three test jobs become one nextest build; one shared cache
instead of four (~4.5 GB of the 10 GB repository cache).
- Linux UI and browser share one job and cache; edge coordinator and vault
share one job; the macOS app is built with the test dependencies instead
of a `cargo check` that recompiled everything; iOS no longer waits for
the frame-source job, which only runs when the GPUI pin can change.
- Only main saves Rust caches.
* CI admission: cap reservations read from other runs, expire unseen ones
A pull request can edit its own ci.yml, so the reservation in its admit job
name is untrusted. Cap it at the largest plan.py makes, and stop counting an
admitted run's never-created jobs 90 minutes after admission, so one run
cannot hold more than a full run's runners or hold unused ones for long.
* CI: reuse passes on unchanged inputs; ci:priority, ci:lock and an emergency workflow
Reuse. plan fingerprints every suite's inputs in the tree under test (the
merge with main for pull requests): workspace manifest, lockfile, toolchain,
CI files, the suite's workflow and non-Rust files, and for Rust suites the
packages it tests plus every workspace package they depend on, plus any file
outside those that their sources name with a ../ path (scanned every run).
Every job records its pass in the Actions cache under that fingerprint as its
last step; a suite whose jobs all passed is skipped and reserves nothing, and
single Windows and voice jobs are skipped on their own. Pull requests trust
their own passes and main's; main and the merge queue trust only main's;
ci:full and manual runs reuse nothing. Callers are split per suite so each
records under its own fingerprint.
Priority and locks (labels, so triage or above). ci:priority puts a pull
request's runs at the front of the admission queue; ci:lock keeps a full
run's runners out of everyone else's budget while the pull request is open
(until unlabelled, merged, closed or CI_LOCK_HOURS), and admits its runs
first. Runs name their pull request in the admit job; the claim counts only
when that pull request's head is the run's commit. ci-emergency.yml (write
access) locks a pull request, cancels the other pull requests' CI runs and
re-runs its own if needed.
* CI reuse: fail closed
The merge queue, the last gate before main, reuses nothing. A pull request
that changes a Rust build file no selected suite's fingerprint covers reuses
nothing. Sources that build a path from CARGO_MANIFEST_DIR's parent in code
make their suite read the whole workspace. concat!(.., "/../x") paths and
.cargo/ count as inputs.
* CI result: fix the result listing (shell quoting)
* CI: run less on pull requests, more on schedule, and merge tiny test binaries
Measured in CI, test execution is a small part of every job; compiling and
starting jobs that run little is the cost. So:
- Voice: only the audio stack (zeron-audio, which nothing else builds yet)
and the packaged Windows media runtime remain, for their own files. The
mobile voice/orb tests were a subset of ios-core, the macOS/Windows
`cargo check` of harness+engine duplicated the platform builds, and the
voice-media tests join the Windows nextest build.
- Fast tier gating of jobs and steps to their own files: Windows packaging
(`app`), the iOS simulator tests and their bindings, the Linux and macOS
browser/preview fixtures. Android builds the APK on pull requests for the
app, the FFI crate and dependency changes; the iOS mobile-core paths come
from zeron-mobile's Cargo closure. Gated jobs and optional steps are part
of the reuse fingerprint.
- GPUI frame-source runs only when the pinned zui revision moves.
- Version bumps (only `version = "..."` lines in Cargo.toml/Cargo.lock)
select nothing and are left out of fingerprints.
- nextest `ci` profile for pull requests and main leaves out the slow/soak
tests (48-chat and real-quantum doc_host sync, the codex dying-server
backoff, preview leak, two sleep-bound discovery tests); the cursor_shim
stress test runs 14 rounds (ZERON_STRESS_ROUNDS, 100 by default). Preview
discovery tests run one at a time (fixed port).
- Nightly ci.yml schedule runs everything in full; weekly-tests.yml runs the
engine integration binaries and crate tests no workflow ran.
- Linux core no longer builds the 8 test binaries that run nothing there
(Windows-only or all-#[ignore]d). The small harness, engine and preview
integration suites move into one `tests/misc` binary per crate. The orb
geometry tests move to zeron-orb (they tested its re-export); the
assertion-free microbenchmark is dropped. The macOS app builds with the
tests instead of rebuilding zeron-ui without the fixture feature.
* CI: pass the nextest config to the build-only steps too
NEXTEST_PROFILE=ci names a profile from scripts/ci/nextest.toml; the macOS and
Windows `--no-run` builds did not load that file, so nextest refused the
unknown profile.
* Engine: keep the git identity setup inside the home it is given
configure_git_identity pinned HOME but inherited XDG_CONFIG_HOME, and
`git config --global` writes $XDG_CONFIG_HOME/git/config when that file
exists. With a sandbox or test home, the identity landed in the developer's
real git config: running the engine tests on a machine with XDG_CONFIG_HOME
set replaced the user's name and email with the test's. An XDG_CONFIG_HOME
outside the given home now gives way to the home's own, and the test pins it
for its own git calls too.
* CI: iOS simulator tests in parallel with ios-core; Windows UI tests side by side
- The C header and module map the simulator tests link are committed in
apps/ios/CoreFFI (outside Xcode's synchronized folders) and refreshed by
scripts/ios/build-core.sh like the Swift bindings; ios-core checks all
three are current. ios-tests no longer waits for ios-core's artifact, so
the iOS path is one job long instead of two.
- The simulator core for the unit tests builds in the dev profile, not the
optimized `mobile` profile the app ships.
- Windows runs zeron-ui's tests side by side: nextest gives each its own
process, so the in-process `--test-threads=1` restriction no longer applies.
* CI admission: budget defaults at the organization's runner limits
20 jobs in total and 5 on macOS (the organization's concurrency limits), and
at most 10 on Windows so Linux keeps half the pool. The repository variables
still override them.
* CI: skip the browser steps when the Linux setup failed
They run after a failed UI test on purpose (a separate signal), but without
the system packages (an apt mirror stall) they can only fail too.
* CI: retry the WebRTC terminal path test (a known race)
remote_terminals' network-change test asserts no keystroke goes through the
relay once the path reports Direct; in a loaded run one did. Retried like the
other timing-sensitive tests in nextest.toml until the race is fixed.
* Fix two races that failed CI on loaded runners
- Muse: a crash usually shows first as "Muse stdout closed", racing the
process exit; `try_wait` lost that race under load and users got the bare
protocol error instead of "Muse exited unexpectedly" with Muse's last
stderr lines. Wait up to 250 ms for the exit, as the Pi driver already
does (a_crash_mid_turn_reports_muses_last_words failed this way).
- Remote terminals: a subscription reported TerminalPath::Direct before
attaching the direct writer, so a keystroke typed by whoever saw Direct
could still go through the relay (a_terminal_rides_a_real_webrtc_pair_
through_a_network_change failed this way). Report Direct once writes
ride the link. The CI retry for that test goes.
Both tests pass 25 runs in a row under CPU load.
* CI reuse: count only the CI files a suite runs
Every suite's fingerprint included all of scripts/ci and the composite
actions, so a change to the planner or the scheduler (which decide what runs,
not whether it passes) re-ran every suite. Each suite now counts the CI files
it executes: nextest.toml and the Linux or Windows setup for the Rust suites,
test-core.sh for core, the macOS fixture runner for macOS, apt-install.sh for
the installer. ci.yml still counts for all.
* docs: changing the fingerprint inputs reruns everything once
* CI admission: no circular waits
Two ways admission could deadlock (until the fail-open timeout):
- Each waiting run counted every other waiting run's admit job as a busy
runner, including runs queued behind it. With a full run (16 of 20) at the
head and five or more waiting behind it, the head waited for their runners
and they waited for it. A run now counts only the admit runners ahead of it.
- Two ci:lock labels each reserved 16 of 20 runners and counted the other's
reservation, so neither locked pull request (nor anyone else) could start.
Locks are now ordered by when their label was added: an older lock ignores
a newer one's standing reservation.
Every wait now points forward in one order, so no cycle can form. A test
simulates 3000 random queues (sizes, priority, overlapping locks, polling
order) and checks they all drain; the previous scheduler deadlocked in 309.
The fail-open timeout drops from 5 h to 2 h as the backstop for the one case
outside the model (waiting admit jobs taking every runner in the pool).
* CI admission: waiting admit jobs yield when they starve the pool; ignore runs that never take their turn
Waiting costs a hosted runner from the same pool as the suites. With about
20 runs waiting, their admit jobs held the whole pool, admitted runs' jobs
got no runner, and nothing moved until the 2-hour fail-open. When an
admitted run's Linux or Windows job has queued 10 minutes, every running
admit job but the first quarter of the budget now starts its run without a
reservation, giving its runner back. A new test models GitHub's runner pool
as well as admission: without yielding most 30-run queues never drain, with
it all 200 do.
A reservation read from another run is not trusted, but a run whose edited
admit step never finished still held everyone behind it for 2 hours (and a
fake admitted run held a full run for 90 minutes). A waiting run that could
have been admitted for 3 minutes but still waits is now ignored, and an
admitted run's jobs that have not appeared 10 minutes after admission stop
counting, except the late result and publish jobs.
Polling backs off further from the head of the queue (5 min, 10 min under
400 requests left): the GITHUB_TOKEN quota is shared with releases, the
Cursor SDK update and CI emergency.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* CI: voice and the Linux browser fixture nightly only; forks reuse only main's passes
Over two weeks the voice jobs left after the move into core-tests (AEC3
and the packaged Windows runtime) never failed, and the Linux browser
fixture's failures were window-timing flakes and package downloads. Both now
run nightly, on manual runs and with ci:full. The zeron-ui tests stay on
every change: 2,046 tests in 29 s, and the only check that caught one real
regression in that window.
A fork's earlier runs could save a pass entry for the fingerprint of a
later, clean-looking commit, so its suites would be skipped and the pull
request would still show a green CI result. Until the merge queue (which
reuses nothing) is the required gate, forks reuse only main's passes;
CI_FORK_REUSE=own turns their own back on (ci.yml passes it to plan in the
workflow commit that follows).
Docs: admission's new yield and unresponsive-run rules and polling.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Engine: keep the user's own XDG_CONFIG_HOME when the git identity home is theirs
The XDG_CONFIG_HOME guard replaced any XDG_CONFIG_HOME outside `home` with
`home`'s. When `home` is this process's own, that hid an identity the user
keeps in an XDG_CONFIG_HOME elsewhere, and the machine identity went into
~/.gitconfig, which wins over it. It now only applies to a sandbox or test
home.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* CI workflows: Android gets only its own secrets, on pushes to main; CI_FORK_REUSE
secrets: inherit gave android.yml every repository secret, and the merge
queue (code not on main yet) would have signed with the release keystore.
ci.yml now passes the four signing secrets and the R2 token by name, on
pushes to main only; pull requests and the merge queue use the debug key,
as forks always did.
Also: ci.yml passes the CI_FORK_REUSE variable to plan, and the comments in
ci.yml, voice-tests.yml and ui-tests.yml say voice and the Linux browser
fixture run nightly.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* CI: test-core also runs main's crates/doc/tests (attachments_roundtrip is among them)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <44917547+wingleeio@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Linux browser: WPE WebKit at the display's rate, frames shared with GPUI as dma-bufs
The sidebar browser on Linux ran WebKitGTK in an offscreen window: every
frame went through the CPU, over a pipe, into a new GPUI image, so pages
topped out near 60 fps whatever the display, and large ones fell well below.
Zeron now carries its own WPE WebKit platform (browser/linux/wpe.c) and runs
it in the helper when the build and the system have WPE WebKit 2.50+:
- WebKit renders on the GPU GPUI draws with, into dma-bufs in a DRM format
modifier GPUI's Vulkan device imports. GPUI copies only each frame's
damaged regions into the page's atlas tile, on the GPU (zeronsh/zui#18).
- Where the driver renders no layout Vulkan imports, the helper reads frames
back with OpenGL ES into a sealed memfd. Without a GPU, WebKit renders on
the CPU into shared memory. Both update the tile in place.
- GPUI's frame callbacks are the pages' vblank: WebKit hears a frame is on
screen at most once per display refresh, so pages run at 60, 144 or 240 Hz
and never render frames the display won't show. Hidden pages, and pages
replaced by their error, get none.
- WebKit runs copy, cut and paste itself, sets the pointer's cursor, and sees
click counts and the pointer leaving the page.
If the WPE helper can't start, the session uses WebKitGTK. Its helper now
renders at the output's scale (it rendered 4x the pixels at 1.5x on Wayland
and downscaled them) and sends Cairo's surface as-is instead of converting it
through GdkPixbuf, which took most of its CPU.
A helper that crashes, sends a message Zeron can't read or is still being
written by a forked child (ETXTBSY) is stopped, replaced or retried; the
tests run the real helper on every render node, in every layout its driver
renders, read back and in shared memory, at 60, 144 and 240 Hz.
* Linux browser bench: shown frames, pacing, copies, press latency, memory
`ZERON_BROWSER_BENCH` measured one page's frame rate and CPU. It now loads
a fresh document for each of a 2D canvas, WebGL 2, scrolling, a CSS spinner
and, with `ZERON_BROWSER_BENCH_VIDEO`, a 60 fps video, and records for each:
the page's frame rate, when GPUI painted every new frame, the bytes copied
into the page's tile from CPU memory and between GPU buffers, CPU, PSS and
NVIDIA GPU memory for Zeron and for WebKit's processes, and a capture. It
then times 40 presses from GPUI's input to the frame showing them, and
measures an idle page. `ZERON_BROWSER_BENCH_WIDTH` sizes the browser.
The counts are kept only in fixture builds (`browser-fixture`), for both
engines, so WebKitGTK and every WPE path are measured the same way.
`ZERON_BROWSER_DMABUF=readback` keeps WebKit on the GPU but reads its frames
back, the path GPUs that render no importable layout take.
* Linux browser bench: WebGL page checks a WebGL 1 context too
The WebGL page's benchInfo() clears a WebGL 1 context and reads a pixel back, so a bench run records that both WebGL versions render.
* Linux browser: rustfmt the WPE engine and its tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Linux browser: a paste without text clears WPE's clipboard copy
The WPE helper kept the last clipboard text Zeron shared, and Zeron shared
only text. Pasting with an image or nothing on the system clipboard then
inserted that earlier text, possibly into another page. Zeron now shares
the clipboard on every paste, and empty text clears the helper's copy.
build.rs embeds an empty WPE helper, as when WPE is missing, if wpe.c does
not compile against the installed development files (an older GBM), and
detects them again when PKG_CONFIG_PATH changes. probe_gpu releases the GBM
device and render node it opened when the GPU is unusable.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Linux browser fixture: rustfmt
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Linux browser docs: the WPE vblank check needs a compositor that answers idle frame callbacks
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
---------
Co-authored-by: Wing <44917547+wingleeio@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Add browser element annotations
The browser toolbar gets an annotate button. Click an element on the page and
it lands in the composer as an "Annotation N" chip, with a numbered outline on
the page that follows scroll until the chip is removed or sent. Harnesses get
each element as plain text (selector, path, box, styles, HTML), so it works with
models that can't read images.
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Browser annotations: Zeron-styled picker, chip hover points at the page, harden page input
The in-page picker now takes the app's theme (accent, popover surface,
border, text, UI font) and reads as Zeron chrome in light and dark:
- The hovered element's outline follows its corner radius, and its label is a
popover pill (icon well, tag, #id.class, w × h) rather than an accent block.
- A hint pill names the mode and its keys (Shift adds more, Esc is done),
counts Shift-picks, and moves out of the way near the bottom of the page.
- Markers keep a chip-numbered badge that stays inside the viewport. Hovering
a chip in the composer highlights its element on the page.
- The chip uses the toolbar's annotate glyph, and its hover card shows the
element and size above the code.
Page script runs in the same world as the picker, so its output is now
treated as untrusted:
- Synthetic events never pick, and the picker object is frozen once defined.
- A session takes at most 24 picks, and ends on an explicit `gone` (or a run
of unreadable polls) rather than on any non-string script result.
- Credentials in URLs (userinfo, token/code/state/sig… query and fragment
keys) and opaque attribute values (JWTs, long base64) are redacted.
- Page text cannot close </annotation> or </browser_annotations> in any case.
Also rebased onto main: chat chips gain the annotation field, and the
fixture uses the current serve_ipc. ZERON_FIXTURE_LIGHT=1 shows light mode.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Browser annotations: numbers live in the outline, chips use a plain pointer glyph
The in-page markers wore their number as a circle stuck on top of the
outline, off-centre, and the outline drew right over the element's own
border.
- Outlines sit 2px outside the element and round like it, so they never
double its border.
- A picked element's number is a tab cut into the outline's top-left corner,
sharing its radius. An element too small to hold one wears it as a flag on
its top edge. Numbers are centred with flex, not line-height.
- The hover label is the same accent flag, growing out of the outline's top
edge (or hanging inside near the viewport top).
- A hovered chip deepens its element's fill instead of a soft glow, and the
hint is a plain popover pill with a status dot.
The annotation chip's glyph was `cursor-square`, a framed icon that read as a
box inside the chip's well. It is now `cursor`, the pointer alone at the same
stroke weight as the other chip glyphs. The fixture seeds files to @-mention,
so file chips can be compared side by side.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Browser annotations: square the labelled corner, flush-left labels, lighter hint
Every outline's top-left corner carries its label (the hover flag, a
marker's tab or a small element's flag), so it keeps a 2px radius while the
other corners follow the element, and labels sit flush against the
outline's left edge instead of starting after its curve.
The hint drops its keycap boxes and the tiny ⇧ glyph for inline text:
"Select an element | Shift-click to add · Esc to finish".
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
* Browser annotations: round a label's corners where they hang free
A label wider than its outline (or pushed left of it by the viewport edge)
rounds the corner that hangs past the outline, and the outline's top-right
corner squares off under it so its edge runs straight up into the label.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
---------
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
Co-authored-by: Wing <44917547+wingleeio@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(browser): define stable device-local profile identity
* fix(browser-linux): persist website data and cookies by profile
* fix(browser-macos): persist isolated website stores on macOS 14
* fix(browser): preserve profile lifecycle across tabs and windows
* test(browser): verify persistent storage across app launches and profiles
* docs(browser): document persistent profiles and session lifecycle
* fix(browser-linux): initialize WebKit without blocking the UI
* fix(browser): correct macOS fixture import and Windows profile test
* fix(browser): invoke macOS storage fixture wrapper through bash
* fix(browser): propagate macOS fixture failures and initialize profile cleanup
Require explicit storage results, validate deletion in every store, and preserve primary failures while attempting all profile cleanups. Add opt-in native cookie and same-process reopen diagnostics.
Validated on macOS 27 arm64: release check/build and native tests pass. Two complete storage runs correctly fail on cookies returning after process restart; all profile cleanups pass. Cookie deletion persistence remains unresolved.
* fix(browser-macos): retain profile stores for the application lifetime
* fix(browser-macos): preserve profile stores through process exit
* test(opencode): remove fixture startup and clock races
* Revert "test(opencode): remove fixture startup and clock races"
This reverts commit dffcec2cdee4d6903649fe156c5b813d91e12376.
* test(browser): verify PR state follows profile identity
* Embed the browser on Windows and preview images in tool calls
- Browser tabs render pages inside Zeron on Windows (WebView2), matching macOS and Linux.
- Expanded tool calls preview the images they touch and free them on collapse.
Right-click any transcript image to copy its path or the image itself.
- Paths, commands and output in expanded tool calls can be selected and copied.
- Fix: answering an agent question with multiple lines now grows the card instead
of spilling text below it.
* Address review: repin zui upstream, harden the Windows browser and previews
- Depend on zeronsh/zui dce5c1f (zui#15 merged) and gpui-component
47ccd07 instead of patching every gpui crate to a personal fork.
- Tool image previews: refuse UNC/device/drive-relative paths in the UI
and, before any filesystem call, lexically jail requested paths in the
engine (canonicalizing \\host\share opened an SMB session and leaked
the user's NTLM hash); read chunks on the blocking pool; bound decodes
with the shared raster limits; release keys a chip stops showing;
decode base64 off the UI thread; copy sanitized SVG; cap output lines.
- Windows browser: fail closed on unreadable navigation targets; police
subframes and cancel external-scheme launches; open tabs only for
user-initiated popups (handled first); deny permission requests;
disable web messages and host objects; cancel downloads silently
unless the page itself is the file; recover from a browser-process
exit on Reload; give each BrowserData its own InPrivate profile (no
persistent fallback); sweep only folders of exited processes; never
remount from an older composition generation.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(voice): add local Parakeet v3 capture and transcription backend
* feat(ui): add opt-in dictation settings and composer controls
* build(macos): package microphone permissions and voice attribution
* docs: describe desktop dictation behavior and runtime limits
* fix(ui): clarify dictation states and cancellation controls
* fix(ui): keep composer model controls right aligned
* feat(ui): give Voice a dedicated settings page
* fix(voice): support all native microphone sample formats
* fix(voice): retain model cleanup after interrupted downloads
* fix(ui): preserve dictation while pasted references resolve
* fix(ui): cancel dictation with Escape across composer controls
* fix(ui): refresh dictation state after empty undo and redo
* fix(ui): preserve dictated words on blank recognition results
* fix(voice): clarify retries while native inference finishes
* test(ui): verify repeated Send preserves unfinished dictation
* style(ui): format settings modules
* feat(voice): add microphone selection and streamline Voice settings
* feat(ui): visualize live dictation with a waveform and recording clock
* fix(ui): preserve waveform paint opacity
* feat(ui): morph composer controls into dictation track
* test(voice): exercise real inference on every desktop release target
* fix(voice): keep device choices fresh and cancellation accessible
* ci(voice): verify Linux release packages on x86 and ARM
* ci(voice): keep model and package probes out of permanent CI
* fix(voice): detect missing ALSA before activating Linux installs
* fix(voice): capture audio while Parakeet loads
Run capture independently of serialized model loading and inference. Retain stopped audio until the model is ready, close capture before reporting load failure, and hold admission through native work and stream teardown.
Cover loading, cancellation, device startup, rapid Stop, admission, and recording limits with deterministic coordinator tests.
* test(ui): verify and measure nonblocking dictation startup
Cover selected-draft preservation, delayed final results, single Send delivery, and late results after loading failures or finalization timeouts.
Add transcript-free debug timing from dictation activation to the Listening state and clarify asynchronous capture cancellation.
* docs(voice): explain concurrent capture and startup timing
Document audio retention during loading, cancellation and model-removal limits, race coverage, and the native startup timing procedure.
* fix(ui): stop Shell saves from reverting settings chosen elsewhere
The Shell republished its whole cached UiSettings on every save
(navigation, pane resize) and only refreshed a hand-kept list of fields
first. Anything missing from that list was silently reverted: leaving
Settings → Voice turned dictation off, and the microphone choice,
compact transcript, fit-content code fences, and diff split/wrap toggles
had the same bug.
Replace the list with a three-way merge against the store snapshot the
Shell last synced: fields the Shell changed win, every other field keeps
the store's value. The merge destructures UiSettings exhaustively, so a
new field fails to compile until it is merged too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* feat(voice): hold to talk, default Cmd+D, shortcut on the Voice page
Dictation is now hold to talk. Holding the microphone (pointer, or
Enter/Space while it is focused) or the shortcut records; releasing
transcribes. A pointer release outside the button still counts. For the
shortcut, letting go of its key or any of its modifiers ends the hold,
because macOS does not deliver key-up for Command chords. A release
within 300 ms explains hold to talk instead of transcribing a blip, and a
release that only answered the permission prompt records nothing.
Assistive-technology Click still starts and then finishes, since it
cannot hold.
The default shortcut is Cmd/Ctrl+D (unbound elsewhere). Its rebinding row
moves from Settings → Shortcuts to Settings → Voice through a reusable
ShortcutField that shares the Shortcuts page's chip and conflict rules.
Settings → Shortcuts re-reads the stored keymap while not recording, so
its own commits cannot revert a binding changed on the Voice page.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(voice): harden capture, worker and download against edge cases
- Keep the capture flags outside the sample lock. The capture loop polled
them under the mutex every 10 ms, so the real-time callback's try_lock
could fail and drop a buffer of speech.
- Catch a native panic on the worker. A panicking job killed the only
worker thread, leaving every later session "unavailable" until restart.
- Keep loaded weights when a session fails for a microphone or recording
reason; dropping them made the next attempt reload 670 MB.
- Time out a download request whose response headers never arrive.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(ui): dictation review fixes for focus, shortcuts and Windows
- Enter/Space hold on the focused microphone no longer moves focus to the
editor, which sent its key-up (and auto-repeat spaces, or Enter-to-send)
to the draft and left the microphone live.
- A key release caused by focus leaving no longer pulls focus back, and an
unparseable stored shortcut falls back to the default when matching its
release, as apply_keymap already does.
- Another source can take over a hold whose release went missing, so the
microphone or shortcut can always end it.
- Dictation cannot start while a queued row is acquiring its edit lease,
which would replace the draft and silently drop the transcript.
- With dictation off (the default) ⌘D propagates to any other binding of
the chord instead of being swallowed in the composer.
- The Voice page's shortcut row is always shown, conflicts with a feature
page's shortcut name that page, and recording stops if the window closes
so Appshots' capture shortcut is never left suspended.
- Show Settings → Voice on Windows; the PR ships the Windows backend and
only Appshots is macOS/Linux-only.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(ui): give the composer microphone its siblings' hover
At rest the microphone snapped to a different surface colour on hover;
it now uses the paperclip's eased ink wash. While live it dims like Send,
and its focus ring and tooltip match the neighbouring composer buttons.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(pi): add native RPC transport and compatibility contracts
* feat(pi): implement native harness and event normalization
* feat(pi): resume native and legacy ACP sessions
* feat(pi): support native steering and reliable cancellation
* feat(pi): expose native models commands and skills
* feat(pi): bridge extension dialogs to desktop and mobile input
* feat(pi): preserve Zeron MCP delegation in native sessions
* feat(pi): activate native RPC driver and CLI discovery
* refactor(pi): retire ACP adapter and verify native lifecycle parity
* fix(pi): preserve switched sessions empty resumes and composer drafts
* docs(pi): translate RPC migration research into English
* style(ios): trim whitespace in updated question bindings
* test(acp): wait for scenario progress before steering
* test(pi): compare canonical session paths on Windows
* fix(pi): deliver steering bursts in the same model step
* fix(ios): preserve generated Swift binding whitespace
* fix(pi): scrub nested-agent env and keep dropped-resolver semantics
Pi's native launch skipped owned::configure, so CLAUDECODE and the other
nested-agent variables the ACP launch removed leaked into pi. The engine's
new input-cancellation task also turned a dropped resolver into an empty
answer; keep it an error for harnesses (opencode rejects on error).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* ci: run the native Pi RPC driver tests
pi_rpc needs the native-fixture feature and pi_resume is an engine test;
neither ran in any workflow.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(pi): never overwrite a configured Pi steering mode
set_steering_mode persists to Pi's global settings.json. Selecting `all` on
every session start silently rewrote the user's standalone Pi preference and
undid any `/steering` choice on the next run. Select `all` only while neither
the global nor the project settings configure a mode.
PiHarness::with_agent_dir lets tests (and callers) pin PI_CODING_AGENT_DIR for
both the child and Zeron's own reads, so fixture tests never consult the
developer's real Pi settings.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(ios): don't trap on duplicate question ids when prefilling answers
Dictionary(uniqueKeysWithValues:) crashes on a repeated key; question ids come
from agents and synced docs, so keep the first instead.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* style(pi): rustfmt the steering-mode guard and its tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(pi): start fresh with a notice when a session can't be restored
The native driver hard-failed a resume whose Pi session file was missing.
The engine injects the chat's stored session id on every dispatch, so one
unwritten or deleted session file left the chat failing every message for
good. The ACP adapter and the Codex driver start a new session and announce
the lost context instead; do the same. Proven-empty sessions still keep
their UUID via --session-id.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(pi): never fail a turn over an attachment Pi can't inline
Composer uploads include SVG, HEIC, BMP, TIFF and AVIF. The native driver
errored the whole run on any of those (or an unreadable path), while the
Claude driver skips them and the retired adapter ignored attachments: the
path refs already ride the prompt text. Load images best-effort instead.
Also give native startup the 120s budget the ACP handshake gave Pi, since
extensions can start cold.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* style(pi): rustfmt the lost-session live test
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Update detection was late and fragile: the only checker lived in the engine
on a 6h monotonic timer (a laptop's sleep stretched it by the whole night),
the sidebar compared the release against whichever engine the UI attached to
(a daemon of another version hid or faked updates), nothing downloaded until
clicked, and several install paths could not update at all.
- zeron-update: hourly wall-clock schedule with failure backoff (1m→30m),
re-read on window activation; desktop (report-only) checker role; staged
payloads are unpacked beside their final name and must answer
`--version` with the promised release before they can replace anything;
up-front blockers (App Translocation, disk image, unwritable install dir)
instead of a failed download; Linux managed installs update from the app;
a service daemon restarts into a newer installed binary once idle.
- UI: app-level controller with its own checker against this binary; a found
release downloads in the background, the strip offers restart, and a
staged update installs on quit. "Check for Updates…" under About in the
macOS app menu, "Check for updates" in the account menu elsewhere, with a
live result dialog.
- Linux: the tarball's install.sh uses the self-updating ~/.zeron/app layout.
- Windows: per-user Inno Setup installer (LocalAppData, Start menu, zeron://,
uninstall entry kept current after in-app updates), built in release and
CI, with a silent install/uninstall smoke test.
- Fix: closing the window on X11 panicked in the geometry save, skipping the
engine drain and any quit hooks.
Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* Name Windows packages by host architecture so ARM64 updates resolve.
package-windows.ps1 always wrote windows-x86_64 artifacts, but the updater looks up zeron-<ver>-windows-<ARCH>.exe using Rust's architecture token. Native ARM64 builds now ship as windows-aarch64.
* Document Clang as a Windows ARM64 build requirement.
ring 0.17 has no MSVC assembly path for aarch64-pc-windows-msvc, so native ARM64 builds need LLVM clang on PATH.
* Name Windows packages by the built executable's architecture.
The PowerShell process architecture can disagree with the binary rustc
produced: x64 pwsh under ARM64 emulation reports X64 while a native
aarch64 toolchain builds an ARM64 zeron.exe (and vice versa), which would
publish an artifact the updater never looks up. Read the PE machine type
of target/release/zeron.exe instead. Also note that published releases
are still x64 only.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(ui): model transcript link targets and activation
* feat(ui): open transcript web links in session browser tabs
* feat(ui): add transcript link actions and keyboard access
* feat(ui): show full web destinations on hover and focus
* feat(ui): truncate long transcript links without losing content
* test(ui): cover transcript browser links end to end
Add native transcript link fixtures, preserve focus when action menus mount, and document interaction, Linux runtime requirements, and platform validation limits.
Fixes#351
* feat(ui): open Markdown preview links in session browser tabs
* fix(ui): make link destination tooltips compact
* fix(ui): suppress link tooltips while context menus are open
* feat(ui): add default link destination toggle
* fix(ui): use shared context menu rows for links
Resolve Cargo.toml (keep main's newer Zui/gpui-base pins), crates/ui/Cargo.toml
(keep both the windows-render-fixture and appshots-fixture examples), and
Cargo.lock (main's lockfile plus this branch's windows-sys/embed-resource
dependency entries).
Both the resolver and the spawner were hard-coded to .exe, so
npm-installed agents were undiscoverable and unlaunchable: npm leaves
only a `name.cmd` shim on PATH with the real binary buried under
node_modules. Discovery is now PATHEXT-aware — per directory,
extensions in PATHEXT order, limited to what we can launch (.com,
.exe, .bat, .cmd) — and overrides accept batch shims that exist on
disk, so availability and launches agree.
Resolved .cmd/.bat scripts spawn through `cmd.exe /d /s /c` with
cross-spawn-style per-argument escaping: the shim is the only
interpreted layer, agent arguments stay literal (spaces, backslashes,
quotes, unicode, cmd metacharacters round-trip verbatim — proven by
re-invoking a real program through a shim fixture), and Job Object
ownership covers the whole tree through cmd.exe's membership. The
codex node_modules vendor special-case is deleted: it searched the
wrong vendor subdirectory (`bin/` instead of `codex/`), and its
fixture encoded that wrong layout, so CI passed while real npm
installs failed. GUI launches additionally backfill %APPDATA%\npm,
%LOCALAPPDATA%\{pnpm,Programs\nodejs}, scoop shims, and
%USERPROFILE%\{.local\bin,.bun\bin} from PATH.
opencode and cursor resolution migrate off raw $HOME to the shared
USERPROFILE-aware home helper; cursor also probes
%LOCALAPPDATA%\cursor-agent. The engine catalog and login tests use
the real npm shim layout, batch-override harness tests assert safe
launch instead of rejection, and the shell-script fixture suites are
gated to Unix where they actually run.