#1515 gave the default's page the tab strip's window width (`width = props.width`).
v2's single-page shell has no session tabs, so it needs no such line: only its
record of the default it follows is brought up to date (ZERON_V2_BLESS=1).
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* zgx: no debugging left behind (tests/leftovers.rs passes)
- The sidebar's scroll probe (b4b8cf043, "sidebar-probe:" on every step
back) and the mention menu's M.debug prints are gone.
- The CLI's error and the Windows install's are main's own error now
(same "Error: …" and exit status 1), not an eprintln! beside it.
- The transcript's opt-in trace logs as `zeron-zgx: transcript …`, its
switch the shared value `trace.transcript` (ZERON_ZGX_TRACE_TRANSCRIPT=1
still turns it on); a stand-in part that didn't load logs as zeron-zgx.
- The activity bench's knobs are ACTIVITY_*, as its ACTIVITY_PIXELS and
ACTIVITY_ONLY already were, not DEBUG_*.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* zgx gallery: the syntax demo's editor takes its code size as the token
bcd094662 gave the textarea its size as text_size, but as the number the
theme's $zeron.prose.code.size held when the page was built, which the
design lint reads as a hard-coded 13 (tests/design_lint.rs). The token
itself follows the theme.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* zgx tests: reload's Settings scroll stubs the actions General now calls
tests/reload.rs a_reload_keeps_the_sidebar_and_settings_where_they_were_scrolled
failed for two changes the app made on purpose:
- b0e62255d (#1432): Settings → General asks account.keeps_chats_local as
it builds (src/auth.rs answers it). The test's stubs didn't have it, so
the page stopped at a runtime error with no headings: "a heading in
view". It and its setter are stubbed now, and chat.catalog_on, which
the composer invokes (src/chat.rs), whose missing stub logged an error.
- 0d8a6eb3f dropped General's Links section with "Open pull requests
in" (now the GitHub plugin's): the last scroll was at its heading. It's
at any heading in view now, as the scrolls before it are.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* zgx tests: the pointer's cursor is asked as the window asks it
tests/pointer_cursor.rs "in a split: the sidebar's edge" found no cursor
since 1b409eb0e, which put the session card's place on the card itself,
inside a root the window's size that passes the pointer through, so the
card leaving stays by its own row (ui/tests/session_card_place). The test
asked Scene::cursor_at, the front-most node's cursor whatever it passes;
the window's cursor is zgx-desktop's ui.input.cursor_at (application.rs),
which goes past what passes the pointer, as CSS's pointer-events: none.
Asked that way the sidebar's edge shows its resize cursor in the split, so
the app is right. Making the root a box of no size instead (as the anchor
around it is) brings the cursor back under Scene::cursor_at but loses the
card leaving: the presence drops it at once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* zgx tests: the CLI's helper test names the helper as this platform does
tests/cli.rs put a "Zeron Engine" beside the binary, the macOS bundle's
name; on Linux the app looks only for zeron-engine (crates/launch
ENGINE_EXECUTABLES), so the test failed there with "no engine beside".
It takes the name from zeron_launch now.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* zgx markdown: streamed words finish fading in to their ink
The streaming veil times each fade by ui.now(), the wall clock, and
repaints it by an animation on the frames' clock, run for the fade's
time left. The frames' clock can run a little ahead of the wall's, and
then the last repaint came a hair before the fade's end and nothing
painted again: the words stayed a shade short of their ink (alpha 149
of 153 in tests/thought_streaming.rs, every run on Linux). And a
paragraph's call cancelled and restarted the reply's clock for its own
fades alone, so another paragraph's longer fade could stop short too.
The reply's clock now runs until the last of its fades ends (v.ends), a
few frames past it, and on again if the wall clock isn't there yet.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* CI: the zgx jobs run apps/zgx's integration tests too
apps/zgx/tests/*.rs never ran in CI (only cargo test --bin zeron-zgx and
the Luau UI tests), so they failed on main unnoticed. scripts/ci/test-zgx.sh
tests runs them all (cargo test --test '*', --no-fail-fast: one failing
binary doesn't hide the others), the known ones skipped by exact name
(`tests:` lines in zgx-known-failures.txt, none now), on macOS and Linux
both: every one of them runs headless and passes on both here, but for
tests/full_screen_titlebar.rs, whose fix is on its way and isn't skipped.
test-zgx.sh and the known-failures list are inputs of the zgx suite now
(plan.py, reuse.py), so a change to either runs it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The tab strip kept the open tab clear of its fades (an effect) and drew
those fades (`fade_x`) from the scroll view's laid-out width. That width
eases with the tabs' start (the controls' slide out of full screen, the
sidebar's "…"), so both ran every frame of the move: 14 calls in
full_screen_titlebar's slide back.
Both now read the strip's room where it comes to rest: the window's
width less the tabs' start and right targets (the strip spans the
window), which change once per move. Checked equal to the laid-out
width at rest with the sidebar open and shut, the panel open, narrow
and wide windows, and settings.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
#1212 made ds/island's `bg` and `backdrop_blur` functions (glass, or solid
with transparency off). An animated node runs its style's functions again
each frame, and the title bar's island animates (the sidebar showing and
hiding, the controls sliding out of full screen), so each of those frames
called into Luau. The island now wears its tokens, and the window's solid
theme (ds/material `solid_theme`, worn by the shell) maps them to the
menus' solid fill, unblurred, whenever glass isn't see-through: the same
look, decided once per change rather than per frame.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* Previews: discovery leaves test servers alone
Preview discovery sent `HEAD /` to every new loopback listener a chat's
run or terminal started, within about a second of bind. Test suites an
agent runs start scripted fixture servers that answer a fixed number of
connections; the probe took one and the tests failed intermittently.
- A listener is probed only once it has stayed up PROBE_SETTLE (3 s):
seen by an earlier scan that long before. ProbeMemory tracks when each
socket (pid, start, address) was first seen and forgets sockets no
longer listed, as it does verdicts. A fixture lives for its test; a dev
server is now listed 3-5 s after it binds instead of within one 2 s
cadence. While a listener settles, the scanner waits no longer than its
settle time, so a slowed pace never delays the listing.
- Test runs are never probed: Listener::is_test_run() matches whole
words and path components (not substrings) for Rust test binaries
(target/.../deps/<crate>-<hash>, --test-threads), cargo test/nextest,
go test and *.test binaries, bun/deno test, npm/pnpm/yarn/bun [run]
test, vitest, jest, mocha and pytest, including runners' node_modules
entry points and workers. Any ancestor running tests excludes it too
(a fixture is often a plain python/node child of the test), up to but
not including the engine's own children: an agent may carry a prompt
that mentions tests in its arguments.
- The discovery integration tests wait up to 30 s for a listing.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Previews: an environment read empty is unknown, not unmarked
Discovery reads each process's environment once and keeps its origin
marker for the process's lifetime. A process caught mid-exec (seen with
Xcode's `python3` launcher) reads an empty environment, and that was kept
as "no marker": the chat's server it became was never owned, so never
listed, however long it ran. It made the discovery integration tests
flaky (a server alive but never found).
An empty read is now unknown, like an unreadable one: Origins::owned
retries it on later scans and keeps the verdict once it reads; read empty
UNREADABLE_TRIES times, the process has no environment (`env -i`) and
that is its verdict (it is still owned through the marked process that
started it). Origins::resolve never caches an empty read.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
WatchDocMessages with `known` (the app reopening a chat whose rows it kept,
or reconnecting) sent one `since` frame computed from the whole transcript:
on a cold doc every entry read from the doc, and on any doc every entry
summed. On a 20k-entry synthetic chat that was 1.0 s cold and 137 ms warm
before the first frame.
For a long chat (snapshot >= 1 MB), the engine now first reads only its
newest whole entries (`SessionDoc::read_newest_entries`, up to 48 entries /
2,048 parts, continuations joined only with their root) and sends what
changed among them, those the reader holds that differ and the new ones
after the last it holds, as an opening tail (`historyPending`). The `since`
frame follows from the whole read, measured from the rows as the reader
holds them after that tail (`zeron_doc::tail_since_known`), with its
`orderSum` as before. Nothing changed among the newest: the `since` frame
alone, as before.
No protocol change: every app that sends `known` already takes an opening
tail into held rows (replaced in place, new after them) and then the
`since` frame. A new app test pins that the two frames end in the engine's
rows with nothing fetched whole.
First frame, release, median of 7 (cold_open_first_frame_bench):
20k entries (101.6 MB snapshot, open alone 90.5 ms):
known, cold 1.0 s -> 94.8 ms known, warm 137 ms -> 3.0 ms
4k entries (20.3 MB snapshot, open alone 19.9 ms):
known, cold 163.5 ms -> 20.4 ms known, warm 27.3 ms -> 1.9 ms
The whole history (the `since` frame) costs what it did.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The split sidebar had no way to close it but ⌘B, and once it was hidden
(the companions panel stepping it aside, an unfold) nothing brought it
back and there was no New Session anywhere. The sidebar's header now has
a hide button; while it's hidden the main column shows one to bring it
back beside New Session (not on the new-session page itself).
The new-session headline squeezed the mark into the text when the space
above the composer was short (keyboard up on the folded Duo, a phone in
landscape). It now gives way whole: the mark goes first, then the line.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
0.3.8 kept 3, and switching among more chats froze for 50-100 ms or showed
a skeleton: a real chat's document is 15-80 MB, and reopening one from its
snapshot reads its whole state (45 ms for 15 MB, 280 ms for 80 MB on an
M5 Max; the M1 is about 2.5x that). The 3-doc measurement used small mock
chats and missed it.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Zeron's desktop app is the zgx interface (apps/zgx). The GPUI one it
replaced, `crates/ui` (zeron-ui, about 267,000 lines), was the only crate
on GPUI, and `apps/zeron` linked it into `zeron`, so building the engine
(`-p zeron --bin zeron-engine`) compiled all of GPUI too.
- crates/ui is gone, and GPUI, zui and gpui-component leave the
workspace and Cargo.lock.
- apps/zeron's `zeron` is the command line with the engine linked in;
with no subcommand it says to open the app or run `zeron headless`.
- What others read from crates/ui moved:
- assets/ (fonts, icons, file icons, sounds) to the repository's root;
- the file-icon manifest into crates/mobile;
- the microphone-permission source into apps/zgx/native.
Updated to the new paths: zgx's appshot sound and build script, the
Linux, Windows and macOS packaging's font licenses, Android's icon
task, and the icon and sound generators.
- CI: the UI, browser-fixture and frame-source suites and jobs and the
old app's release jobs are removed. The planner, reuse map, runner
caps and their tests follow.
- Scripts only for the old app are removed (dev bundle, browser and
preview fixtures, markdown bench, Windows window probes, demos).
scripts/staging-app.sh now builds and opens the zgx app against
staging.
cargo check --workspace --tests --examples; zgx check; tests of
zeron-text, zeron-mobile and zeron: 186 passed; CI script tests: 102
passed.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
0.3.7 plus main since (#1432–#1501):
- Auto access mode: the agent's own reviewer approves safe actions
(Claude Code's auto mode, Codex's auto review), shown as a shield on
reviewed tool calls; agents without one never fall back to more access
(#1436).
- Agents run shell commands on any of your online devices as they do on
their own (run_command); background ones show in the chat's background
band (#1458).
- Cloud chats work with your other devices, or are isolated to their own
machine: Settings → Cloud and the composer's place menu, set by you
alone (#1458).
- Keep chats on this device while signed in: Settings → General → Privacy
(#1432).
- Lighter idle, faster chat opens and switches, agents that end with their
engine (#1495); long chats open building far fewer rows (#1496); the
engine keeps less in memory per chat (#1500).
- macOS: a window snapped by a window manager keeps its title bar buttons
at its top (#1501).
Version 0.3.8.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Add Settings > General > Privacy > Keep chats on this device. With it on,
a signed-in engine opens the local workspace instead of the synced one, so
chats, the chat list and projects never join the account's rooms.
The preference is a marker file in the data dir (keep-chats-local), read
by initial_workspace_scope at startup. The app's needs_restart follows it,
restarting the engine onto the other workspace when it changes.
Pins zgx b80a8af1c: the app's pin cc3f3e2a1 plus zeronsh/zgx#2341
(cherry-picked), which measures the traffic-light buttons from the
titlebar container's top during an Accessibility setFrame, so a
Raycast/Rectangle snap no longer leaves them detached below the bar.
Co-authored-by: Wing <wing_13@live.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The default composer's reach wiring went over to v2's copy with it; record
that (ZERON_V2_BLESS). The nudge's wake runs after its reply, so the test
compares the wake's check with the nudge's own time once it has landed,
not with a clock read before it ran.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The engine kept the 12 most recently used chats' documents fully open
after they were left. Each held about 0.9 MB, and none of them is needed
to show a chat: the interface shows a chat it opens from the rows it keeps
itself, in the same frame, while the engine reopens the document from its
snapshot (~11 ms) in the background.
ademark's A10 sequence (twenty threads; M5 Max; engine footprint at 5
threads -> 20, per thread):
12 kept: 28 -> 59 MB, 2.07 MB a thread; after quit 45-50 MB
3 kept: 31 -> 49 MB, 1.20 MB a thread; after quit 38-46 MB
1 kept: 29 -> 46 MB, 1.13 MB a thread
Six chats switched through three rounds (zgx inspect frames): each
chat's rows arrive in the switch's own frame, 9-12 ms after the key,
with 12 kept or 3.
zeron-engine lib: 1,176 passed; one failure,
registry::tests::antigravity_server_path_controls_detection_and_enablement,
fails on main too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Cloud session's reach is "devices" (the default: it works with the
person's other devices as any of their computers does) or "isolated" (its
own machine and the delegates it starts). Only the person sets it: the
account default in Settings → Cloud, a new chat's in the composer's Work in
menu under Cloud, an existing Cloud chat's from its place chip.
Edge: the registry keeps each runner's reach and enforces it (row reads and
writes, registry-runner.ts); the Worker asks it before a runner reaches
another chat or device (runner-access.ts), caching only what holds in both
reaches. Isolating bumps the runner's revocation epoch and drops it out of
every room it reached (runner-revocation.ts), refusing late dials; its
registry sockets close and its next state is full. CloudAccount records the
reach, takes the account default, gives delegates their parent's, refuses
any machine caller, and limits an isolated machine's wakes to its delegates.
Engine: CloudSetReach / CloudSessionSetReach are local-only (no agent, no
other device), and a reach named by an agent's CreateChat is ignored.
zgx: the composer's existing-chat chip always opens, its device, project
and checkout shown greyed; Cloud chats lead with the cloud glyph.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
From an independent review of the PR (engine command code, edge registry):
- A background command whose chat was deleted before the chats next
changed, or that started for a chat already archived, was never
stopped: the chat follower now also re-checks as commands start.
- An agent's RunCommand/ListBackgroundCommands are filed under its own
chat (the gate sets chatId), so they stop and list with the right one.
- Commands no longer inherit Zeron's own ZERON_* variables (its edge
token, a Cloud machine's enrollment code), as the agent installer.
- The folder a command ended in is written to a file the environment
names: no path in the script, so no quoting (a curly quote in the
Windows temp path broke every PowerShell command).
- A project-canvas terminal starts in a project's folder only when the
project is this device's.
- A runner's one-time full resync is sent at most three times, writes
nothing once it's done, and its record goes with its device row.
- docs/design/cloud-device.md said a stolen runner key couldn't reach
the account or vault; through a client link to an online computer it
reaches all that computer does. Now said plainly.
Cloud stays as capable as the person's own devices: no new limits on
what a runner may write or reach that a device isn't held to.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every chat the app makes records sandbox workspace-write (zgx has no
control for it), so requiring "no sandbox" refused run_command in every
real chat. It also added nothing: full access already runs unconfined in
every harness (Codex and Muse drop their sandbox for it, Claude Code
allows every tool call), whatever level the chat records. The gate is now
full access alone, as for approving another chat's requests; a supervised
or auto-accept-edits chat is still refused.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PowerShell's WriteAllText opens the file sharing only reads, which fails
while Zeron holds it open for writing: keep just its path (TempPath, still
removed after the run). Two gate tests ran POSIX syntax and compared LF
output; they now run the platform's shell and compare trimmed lines.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Commands (redone with no shortcuts):
- commands::Commands is an engine-owned service like Terminals, shut down
with EngineCore, wired into update quiescence and the Cloud heartbeat; no
process-wide state (one engine could stop another's commands before).
- Each command runs as zeron_harness::process::owned::Child (now public):
its own process group / Job Object, TERM then KILL after a grace with
escaped descendants, killed on drop, no nested-Claude markers. Anything
a command leaves running ends with it; background: true is for that.
- The login shell's PATH and variables come from the harness's snapshot
(new compose_user_path), captured once: plain `-c`, no profile per run.
- PowerShell gets -EncodedCommand (no quoting), passes a native command's
exit code on and says where it ended; Windows-only tests for CI.
- The background band follows each device's WatchBackgroundCommands
stream instead of polling: an ended command leaves as it ends; the row
keeps the live heartbeat's cadence.
- stop waits on the command's end (watch), not a sleep loop.
Cloud regressions found in review:
- A Cloud machine that synced before it saw every row gets one full state
(RegistryRoom.runnerBehind), again until its cursor passes it.
- A Cloud machine's send wakes any of the person's sleeping sessions.
- A runner may set any field of a chat hosted elsewhere but its host, so
a branch or model set on a laptop chat lands instead of being dropped.
- Only the session chat's project resolves to a Cloud machine's checkout.
- OpenTerminal takes a chat's folder, and attaches to it, only for a chat
this device runs (as project actions already require).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The chat's host tracks each background command its agent starts with
run_command, on that device or another, and lists it on the chat's session
row with the runtime's own background processes ("on <device>"). Every 5 s,
while any are tracked, it asks each device which are still running, keeping
the row fresh and dropping ended ones (and those on a device unreachable for
2 minutes). The band's Stop and output view route cmd-… ids to the device
running the command; the output view reads the newest output without
moving what the agent reads next.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
run_command now matches an agent's local shell tool: cd carries over
between commands on a device (a POSIX shell's final folder, from an exit
trap), and background: true leaves a dev server, watcher or long build
running, read with command_output, stopped with stop_command and listed
with list_commands.
Background commands are bounded: newest 128 KiB of output each, 48 KiB a
read, 32 running per device, ended ones remembered for at most an hour.
Their process groups die when stopped, when the chat that started them is
archived or deleted, and at engine shutdown. Running commands keep a Cloud
machine awake and hold off updates.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Replaces the open/write/read/close terminal tools with one run_command:
the device runs the command in the user's login shell with no PTY and no
input, and replies with its output and exit code. Nothing is kept between
calls. The output is capped at 64 KiB (its start and end) and every run
has a timeout (at most 10 minutes). The command gets its own process group,
which is killed on a timeout or when the call is abandoned. At most 16 run
at once per device. The engine allows it only from a chat with full
access and no sandbox.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Terminals: Zeron MCP's open_terminal, write_terminal, read_terminal and
close_terminal open a shell on this device or any other online one (the
engine's OpenTerminal … CloseTerminal, forwarded by targetDeviceId as the
terminal panel does). The server follows each terminal's stream into an
emulator, returning what it printed since last read (escapes removed),
busy/exited, and the screen for full-screen programs. The engine opens them
only to an agent whose chat runs with full access and no sandbox.
list_devices says which devices are online.
Cloud: a runner sees every device, chat, project and session row, reaches
any chat's room and blobs, and dials or nudges any device as a client, so a
Cloud chat's agent lists, messages and starts chats on the person's other
devices and opens terminals there. It still never hosts another device's
room, claims or re-homes another device's rows, or touches the user's own
kinds; it may rename or archive any chat. An agent naming another device for
a Cloud chat's child starts it there instead of on the Cloud machine.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The landing page is rebuilt as an Astro project (apps/landing), prerendered
to static files and deployed as the same assets-only worker.
- The app on the page is recreated in HTML and CSS, not screenshots.
tools/recreate generates it from the zgx app's own layout tree and diffs
it against native captures: a session with its panel open (dark and
light), and the same session in six themes with the window's frosted
glass kept. Mean error is about 1 of 255 per channel.
- Sections: every agent in one window, reviewing changes, themes and
plugins, running on any machine (with the iOS session screen), what
people say, downloads.
- Download links, the latest-release lookup and the page-view counter keep
their behaviour; the download logic is typed and unit tested, and the
built pages are tested for every download link and the ids telemetry.js
counts.
- The header is in the page's flow, with no links to anchors.
- `wrangler deploy` builds first (wrangler.jsonc `build`): a clean install,
the type check, the build and the tests. The deploy workflow is unchanged
and deploys the site as it did.
- wrangler.staging.jsonc deploys the same build to site-staging.zeron.sh.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
The transcript's list guessed every row it hadn't measured at 96 points,
so a chat opened at its end built rows until 96-point guesses filled the
view: in a chat of long replies (code, tables, tool groups), nearly every
reply whole, each then measured at thousands of points and dropped again.
The list now estimates each row from its message, in Rust and with no
script a row (`ui.list`'s `estimate`): a prompt's words; a reply's blocks,
its prose wrapped in the column with its paragraphs, code lines and table
rows; each tool group a folded line; a long reply's runs at about what
one holds.
zgx inspect frames, M5 Max, main-thread instructions per open, 8 runs:
8 long mock replies of code and tables: 291M -> 120M (runs 5,481 ->
1,895, layout measurements 5,742 -> 2,539). ademark's 1,000-step thread:
53.6M -> 55.9M (its first frame 53.8M -> 51.5M, then one 2M frame as the
long reply's measured height replaces its estimate; the view doesn't move).
zgx test ui: 1,460 tests, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The ACP harness: perf's run split into `run_spawned` (a warm start's
agent taken by its run) and main's Auto check before launch meet there:
the access check now opens `run_spawned`, so a run refuses Auto on an
agent that ignores it whether its agent was started early or not. Both
sides' tests kept; zeron-v2's record blessed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
8bd5b5d66 built a finished text of up to 16 blocks whole, under one
switch. In a reply not long enough for the transcript to window, that
built every text above the view that the text's own runs held, and a
long thread of code and tables opened with more, not less: zgx inspect
frames, M5 Max, 8 long mock replies: 303M main-thread instructions per
open before, 337M with it, 291M without it (and on the M1 Max: 145M ->
154M). Back to the window of runs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A long thread's open built about 1,640 reactive runs and 1,680 layout
measurements for one screen of words and folded tool rows: each folded
group a rolling title, a loader and a whole tree of its own; each text a
window of runs and a find switch per block; each held run a three-node
switch. (zgx inspect frames, M5 Max, ademark's 1,000-step thread opened:
67.0M -> 53.8M main-thread instructions, runs 1,642 -> 1,146, measured
1,679 -> 1,184.)
- Activity: a group made done keeps its line (no roll, no loader); its
tree (its list, heights and their effect) is made the first time it
opens, easing open from nothing as one made earlier does.
- A long reply's held run is one box as tall as it was (`min_h`), its
blocks a component made only once it's near.
- Markdown: a finished text that fits one run is its blocks, made once
under one switch (its words, and a find's marks in it), not a window of
runs nor a switch per block.
- chat.rs: an opening tail's entry the same as the row held keeps what
was built from it.
zgx test ui: 1,460 tests, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`agents.cloud_key` (0.3.7) calls `preview::refuse`, but wasn't in
`BLOCKED`, so the refusal never fired: a template tried as a preview, not
kept, could save an API key every Cloud machine's agent then uses. It's
listed now, as `agents.add_key` and `agents.set_key` are.
`every_action_the_code_refuses_is_blocked` failed without it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
0.3.5-0.3.7 (Cloud account switching, the transcript's scroll away staying
away, plugin draft access, Windows message times) on top of perf. zgx stays
on perf's pin, cc3f3e2a1, which contains 0.3.7's d391ea727.
- transcript: a send's glide stops for another chat shown (perf) or a
scroll taken meanwhile (0.3.7); a chat switch also resets `resized_at`.
- chat/shared: perf's `owner` and 0.3.7's `showing_now` (the same read),
and both sides' draft readers.
- windows-sys: 0.3.7's Win32_System_Time added to perf's features.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
c0140541d (a menu shortcut drawn at once, the GPU woken) gained ~1 ms on
A11 open but built worse on A3 in most rounds on the M1 stand-in; the
other three changes (a removed subtree repaints what it showed, a native
menu item and a window's key-chosen shortcut both act before later input)
are what the ⌘N fix and the switch need.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
zgx#zeron/a11-switch, on the menu-shortcut commit zeron/fast-open-2 held
back (c0140541d: a shortcut's frame drawn at once, the GPU woken; A8 typing
lag on a quiet M5 Max, 3 runs each: p50 17.2 ms perf, 17.5 ms with it):
- a large subtree taken out (a chat's transcript as another opens)
damages its ink, not the whole window: the sidebar and title bar stay;
- a shortcut (⌘N), through the native menu or the window's own keymap,
is carried out before input queued behind its key: a key typed 1 ms
after ⌘N reached the old chat's composer.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new chat's agent, started from its first key (start-early), did its
startup at normal priority while the person was still typing: a Node/Bun
CLI's burst of several threads beside the window being typed into, on a
Mac with few cores (an M1) the same cores. It's speculative work, so it now
starts in macOS's background state (CPU, disk and network priority lowered,
the efficiency cores), and so does all it starts meanwhile. Its run taking
it (Enter) puts it back to normal at once, before its first message, and
what it started just after. Nothing changes off macOS (Linux lets no
process raise a priority again).
Checked live in the rig: the parked Claude CLI ran at priority 4 while the
draft was typed and at 31 once sent, the same process answering.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The composer took the keys on arriving at a chat a tick later (ui.after),
so a key typed straight after ⌘N reached whatever had them before. ⌘N's
command now bumps the composer's focus as it opens the new chat: one
composer, its draft already the new chat's, so that key is the new
chat's. The other half of the same bug is zgx's: a native menu item now
acts before the input that came after it.
Test: after ⌘N's handling alone, the composer has the keys and the new
chat's empty draft; typed into, it's the new chat's, and the chat left
keeps its draft, with and without the keys before. (The test runner runs
a tick's timers as it settles, so the tick this saves is proven in the
app, by the rig that posts ⌘N and a key 1 ms apart.)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The route moved first, and the chat page's store opened the chat a step
later, from the page's effect: everything that follows both (the
composer, its chips, the page) ran once for the route, seeing the old
chat with the new route, and again as the chat followed. route.open_session
now tells the store (route.opening) inside one batch with the move, so
they change together and each runs once. The page still opens what its
route says, so a route reached another way (Back, a link) opens its chat
a step later, as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Switching chats made the session page's transcript anew (keyed by the
chat shown): its scrollbar, way back to the latest, selection bar,
lightbox host, its states and effects, every switch. The transcript now
stays, one for the page, and only its list of rows is made for each chat
shown (Transcript's `session`); what was the last chat's own (where it
opens, runway, a glide under way, hover, the selection's bar, the reading
place and row sizes) starts again for the next, as a transcript made for
it would. A send's glide still under way as another chat opens sends its
prompt and leaves the next chat's view alone. The scrollbar, staying,
is told each chat's rows place themselves (Rail's `settle`), so a switch
isn't taken for a scroll (it lit and faded over ~60 frames after each).
One page, nothing kept per chat: memory is what it was.
Tests (ui/tests/chat_switch.test.luau): the scrollbar stays one node and
the list is each chat's; three chats' places and ways back hold over six
rounds of switching; drafts, models and sends stay each chat's, back and
forth; a chat left mid-glide; a switch doesn't show the scrollbar.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Opening a chat kept here again tells the engine what it holds by each
entry's sum, and letting one go weighs what it holds: both went over the
whole json of every entry still holding it, on every switch. A long
reply's json is hundreds of kilobytes (ademark's A11 thread: one entry of
2,000 parts, ~450 KB), so each switch hashed it byte by byte or wrote it
out again (~0.7 ms of a switch's main thread on an M5 Max, sampled). Each
entry now keeps its sum and size until its json changes (json_mut: words
appended, a part patched), and settling takes the sum it kept.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
0.3.6 plus:
- A Cloud chat's model menu offers Cloud's accounts again, to switch the
provider account every Cloud machine uses (#1467).
- The transcript no longer pulls you back to the end after you scroll away:
not during a send's glide, nor at a resize after a scroll (#1450).
Version 0.3.7.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A SIGKILLed or crashed engine runs no teardown, and its agent CLIs kept
running, adopted by init (the bench found five `claude --print` still
running eight minutes after killing the engine).
- Linux: agents get PR_SET_PDEATHSIG(SIGTERM), forked from one
process-lifetime thread (the signal follows the forking thread, and a
retired blocking-pool thread would take its agents with it). SIGTERM,
not SIGKILL: Claude Code saves an in-flight login refresh on SIGTERM.
- Windows: unchanged; each agent already lives in a kill-on-close job.
- macOS, and the Unix backstop: the engine records each agent (pid, start
time, image, program, group, cwd, Claude config dir) in
<data dir>/agent-processes/<pid>-<start>.json, written atomically and
pruned as agents exit. The next engine on that data dir ends what a dead
engine left: only a process with the same pid and start time, still
running what was launched, whose engine is gone; its whole tree and
groups, SIGTERM then SIGKILL; never while its Claude login refresh lock
is held (waited out first).
Every agent spawn (runs, probes, ACP/Codex/Cursor/OpenCode/Pi/Muse, login
children) goes through process::spawn_agent.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A chat on a Cloud machine had no Account row in its model menu: its
accounts were asked of the machine (`cloud-…`), which the engine doesn't
answer for, and whose accounts aren't its own anyway. Cloud's are the
vault's, every Cloud machine's alike, which this engine answers for under
"cloud" (crates/engine cloud_accounts), as Settings → Providers shows them
under Cloud (#1456). Any Cloud device (a chat's machine, the account's
Cloud device) now reads, switches and refreshes those; a machine is never
asked (it would be woken).
Test: model_accounts' "a chat on a Cloud machine reads and switches
Cloud's accounts" (fails without this: the machine was asked). Full UI
suite (1425) passes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Auto kept after switching to an agent without it (Cursor, Pi, Devin…)
showed "Auto unavailable" yet sent, and the run failed with a protocol
error. Send now stays dimmed, and Return does nothing, until another
mode or agent is chosen; the draft is kept. Rested on, the held button
says why ("Auto isn't available for this agent. Choose another access
mode to send."): a disabled button hears no pointer, so the words ride a
box over it. An agent the catalog hasn't listed yet counts as having
Auto, so a chat in Auto isn't held while the catalog loads; the engine
still refuses Auto where it can't run.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
Cursor and Pi ignore the access mode, so Auto sent to them (the composer
keeps it, marked unavailable, after an agent switch) ran with full
access. The engine now refuses Auto before launch whenever the agent has
neither an auto mode nor a stricter one to fall back to, for every
harness, not only ACP ones.
Also: cap the reviewer's risk text like its reason, show no review for a
status this build doesn't know, restore ToolDiff's lost doc line, keep
the activity row comment with its function, and rustfmt the new code.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
mimalloc hands freed pages back purge_delay (10 ms) after they're freed,
but only the next time that thread allocates or collects. An engine at
rest seldom does since its timers sleep: after agents streamed, what they
freed stayed counted against it until some later work. purge_delay 0
hands it back as it's freed.
Five replay streams on ademark's arena, the engine sampled each second:
peak 52 -> 43 MB, 4 min after 42 -> 33 MB, CPU while streaming 2.04% ->
2.08% (the same).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Opening a new chat (⌘N, New chat, the sidebar's +, the palette) started
its agent at once, held ~100 MB for the minute's lease, though most new
chats are opened and left, or opened well before anything is written.
Typing a message takes longer than the agent's start, so starting it at
the first key still has it ready by Enter. The open trigger (`intend`
and its callers) is gone; the rest (stops on clear, leaving, another
chat's draft, quit; the signed-out gate) is unchanged. Zeron v2's copy of
the shell follows, re-recorded.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Opening a new chat with no agent logged in started the chosen agent's CLI
anyway (Claude Code parked ~100 MB for the 60 s lease, on every new chat),
for a runtime that could only wait for a sign-in; found on Windows with an
empty profile.
WarmStart now does nothing when the agents' last listing has no live
login for that agent and the engine's environment holds none of the
variables its CLI signs in with (ANTHROPIC_API_KEY and kin, OPENAI_API_KEY
/ CODEX_API_KEY). Unknown stays allowed: agents never listed yet, and the
ones whose logins aren't tracked here.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A production engine signed out still has a key directory (attach_auth
sets the edge it would sign in against), so the previous change didn't
park it: with no account, check_keys found nothing to do, and the loop
rescanned and hashed every plugin folder each half minute anyway (about
35 ms of CPU each time: the engine's largest cost at rest after the git
polling). The loop now waits while there is no directory or no account;
setting either, and every sign-in change, wakes it.
Test: a signed-out engine (directory, no account) scans no plugin
folder over two and a half minutes once settled (12 scans before).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every 120 s the diff sync re-captured each open chat's checkout (seven
git processes: rev-parse, branch, two diffs, the patch, status) to find
the same diff. A checkout watched whole and live (its root within the
watch budget, and its git dir) has told of every change already, and a
lost event comes as the hub's rescan; the tick now leaves it to them.
One too large to watch live, or whose watch isn't installed, is still
captured each tick, as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ds/status's clock ("now", "5m", "3h" in every row's corner, card and
lane) moved every 30 s, waking the window and re-running every reader to
find the same labels most of the time. Each age read now says when its
label next steps (a minute while minutes, an hour while hours, a day, a
week), and the clock moves at the soonest of those, on the same
half-minute grid (labels due together move together, never later than
the old tick moved them). Corners an hour old wake the window once an
hour.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each loading row of the palette's pages (five per page: a device's
places, a folder's folders) started a breathing loop on a state, which
is the script's, not the row's: the loop outlived the row, the page and
the palette. Adding a project as ademark does left nine to fifteen of
them, each wanting every frame of the display, so an idle window in
front kept its display link running and woke ~120 times a second
(0.7% of a core on an M5 Max, 1.3% on Wing's M1) until it quit. They go
with the row now (its cleanup cancels the loop, or the wait before it).
Test: the shell fixture's engine can be slow to list folders; the
palette's pages load, close, and nothing asks for frames.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- The uninstall check looked for the app every 30 s. File-system events
on the installation (its folder and the one holding it) now say when
it moves, goes or is replaced; it looks every 30 s only once the app
is gone and work still runs, or if the folders can't be watched.
- The updater woke every 60 s to re-read the wall clock (a monotonic
sleep stops while the machine sleeps) and, as the background engine's
service, to see whether a newer version was installed. The engine now
hands it the system's wake events (follow_wakes) and pokes it as the
installation changes (follow_installs): it sleeps until the next
check is due. While a newer installed version waits for quiet it
still looks each minute, and without either source it looks each
minute as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- The terminal reaper swept exited sessions every 60 s even with no
terminal ever opened. With none, it sleeps until one opens.
- The workspace search reaper (a thread, started by the first search,
e.g. the New project picker's Home search) slept 60 s at a time
forever. With no index held, it parks until one is used again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Connectivity: the monitor looked every 5 s (every second for the first
few) from engine start. A local profile's posture is the default for
good, so once its workspace (no edge either) is wired it no longer
looks. Signed in, its settled look is on the beat grid, with the
sockets' pings, rather than between them.
- Transcript recovery: the salvage loop queried for owed recovery jobs
every 30 s forever. With none owed it now waits for one to be
scheduled (watch_sync_jobs); one owed is still tried 30 s apart.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With no key directory (no edge), the signing-key loop found nothing to
ask, then rescanned and hashed every plugin folder, every 30 s. It now
waits for a directory to be set; the folders are watched for changes
already.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed out (no edge), the workspace task still woke every 15 s to send a
heartbeat to no room and republish a device list that can't go stale.
With no edge it no longer arms that beat.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each plugin with a service (the built-in Git plugin has one) had a looker
waking every 5 s for as long as the plugin was on, even with its VM
stopped and no timers. It now sleeps until its next timer, or until its
running VM would be idle long enough to stop (a busy one is looked at
each tick, as before), and with neither until a VM starts or the slot
goes (Slot::wake).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The projection looked every 5 s, from engine start, for terminal leases
to refresh. Only an active terminal report's lease moves with the clock;
everything else in it changes by the watches it already selects on. With
no such lease it now sleeps until one of them changes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each watched checkout (every sidebar row's, the GitHub plugin's) was
inspected every 15 s: eight `git` processes (rev-parse, branch, upstream,
config twice, remote, get-url, symbolic-ref) per working directory. Five
chats in their own worktrees, left alone, spawned about 2.6 git processes
a second, which cost ~2.4% of a core in the children alone and most of
the engine's 4.5 wakeups a second at rest (M5 Max, A6 state).
A subscription now watches its checkout's git dir, common dir and refs
(FsWatchHub) and inspects again only when those files say Git's answer
could have changed: HEAD, the configs (local, worktree, global, system),
packed-refs and the remote-tracking refs (a fingerprint of stats, read
before Git runs). An index write, `git status` or a commit runs nothing.
A burst of events is one look, 250 ms after it. A checkout whose
folders can't be watched is inspected every 15 s, as before.
The provider (GitHub) is still asked on its own TTLs; a remote GitHub
can't be asked about (none, another host) is no longer retried on a
backoff timer: only a change to the checkout's Git files asks again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
It checked once a second, from engine start, whether the app had asked
it to stop when idle: about two wakeups a second (the timer and a worker)
on every engine, nearly all of them finding it hadn't. It now waits on
the request itself and checks each second only once armed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A link to another device (opened by a forwarded call or stream) stayed
open until the network or the process went: a 10 s socket ping and a
10 s end-to-end echo on both devices, for good, per peer ever reached.
The link cache now closes a link with no call awaiting a reply, no open
stream and no RPC frame either way for 5 minutes (checked each minute,
and not at all while no link is open). An open stream (the app following
a device's updates) keeps its link. The next call dials again: one
connect and the readiness round trip, the same as any first call.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every 30 s the engine asked the edge about every device whose heartbeat
was stale, forever: one HTTPS request per offline device per 30 s. An
account collects devices (Wing's has ~17, many of them Cloud machines
asleep for weeks), so most of that was asking about devices that had
been gone for days.
A device is now asked every 30 s for its first 10 minutes of quiet (the
starved-heartbeat case the probe exists for; one the probe finds alive
stays at 30 s), every 2 min up to an hour, every 5 min up to a day, and
every 10 min after. Its coming back is heard from its own heartbeat and
boot stamp, which reset this. Deleted devices (retired Cloud machines)
were already never asked: they aren't listed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each socket kept its own ping timer, started whenever it connected: the
registry and chat sockets (15 s), the device room's host socket and every
peer link (10 s, plus each link's 10 s echo), preview signaling (10 s),
the presence beat (15 s), session activity (5 s), and the relay probe,
reaper, repair and uninstall checks (30–120 s). Every one woke the engine
at its own instant.
`zeron_sync::wake::beat_interval` ticks on whole multiples of its period
of wall-clock time, so all of these now land on the same instants: with
the 5 s activity check on the grid, the engine wakes at most every 5 s for
all of them (a 10 s and a 15 s beat meet every 30 s). No interval or
lease changes, so nothing the edge expects changes: device-room hosts
still ping inside HOST_LIVENESS_MS (75 s), preview sockets inside the
coordinator's 45 s, presence every 15 s. A socket's first ping now comes
at the next beat (within one period) instead of a full period after it
connected.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On Windows a launch with no engine running (after a restart, or an update)
dialled the engine's port before starting it, and Windows says a loopback
port nobody listens on is refused only after 2 s of retries. The engine
started once that refusal came, and the connection followed ~3 s after
launch. Now:
- The engine is started as the launch begins when none holds its data dir
(`engine::start_ahead`), and the supervisor starts one before dialling
when none does. Its process is made on a thread of its own: Defender scans
a new version's 209 MB executable as it's mapped, and the first frame no
longer waits for that. One spawner serves both, so never two engines.
- A loopback dial gives up after 250 ms (an engine that listens connects in
a millisecond or two); a dial that times out reads as refused.
- The plugin preload dials only an engine that was already running.
The first launch of a version laid `.zeron` and `.live` down one file at a
time, ~2,500 new files on the window's path, each scanned by Defender as it
was written: 6 s before the first frame. Now:
- `mirror` reads and writes on up to 8 threads, and `.zeron`'s hashes come
from the bytes its copy read (`ui/` read once).
- `ui/`'s and `.live`'s stamps take each file's size and time from its
folder listing: on Windows, asking each file opened and closed it, about
120 ms of every launch.
- Windows' installed `ui/` (`beta\<version>\ui`) isn't watched, as a macOS
bundle's isn't: an update installs the next version beside it.
zgx pinned to 5a6a43963 (zgx#2223): 69ce8e184 didn't build on Windows or
Linux (`acted_since` was macOS's alone).
First frame on screen, ms from process start, RTX 4090 / i7-12700KF, three runs:
- first launch (fresh install): 6140-9233 -> 2694-2793
- after an update: 830-849 -> 428-575
- warm, no engine running: 508-527 -> 353-367
Engine connected: 3034-3082 -> 353-367 (warm), 3822-4401 -> 745-1169 (update).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new chat the person opens (⌘N, New chat, the palette's, a sidebar "+")
asks this device's engine for a warm start once its page's first frames
are out, and the first key in a new chat's draft does too; the send creates
the chat with that id, so its first message goes into the agent already up.
Never an existing chat, a launch, a window put back, a draft restored with
its page, a chat on another device or Cloud, or a worktree made as it's
sent. The warm request is the send's own (`run_request`).
It stops when the person leaves the new chat with its draft empty, keeps
it empty for 10 s, writes in another chat (one per window), closes the
window or quits, or when a send's chat isn't made; the engine's leases do
the rest. A change of agent, model, effort, folder or access starts
another. Typing renews it at most every 10 s.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`WarmStart {chatId, request, typed}` starts the runtime a new chat's first
run would start, parked with no prompt, under the id the chat will be
created with: nothing of the chat is made (no row, doc, title or
transcript). Only for a new chat: an id the workspace knows, one with a
run, a worktree made as it's sent, or a chat on another device (a warm
start there would outlive this app's quit) starts nothing. It gets the
run's own MCP token (for that chat alone, dead when it stops), the
plugins' servers and the host's credentials, and holds its CLI's
execution lease, as a run does.
The chat's first run takes it (`drive_run`), waiting for one still
launching; nothing else ever does. It is not used, and ended, when the run
is another agent's, launched otherwise, on another credential or CLI
binary, with native subagents switched, or behind a CLI update. A run that
never launches ends it.
It lives on a lease: 60 s after the open with nothing typed, then the idle
stop (2 min) after each keystroke the app reports. `WarmStop`, the app
quitting and the engine shutting down end it sooner. It is no run, so the
idle reaper never sees it, and never work in progress. At most 4 per
engine. `ZERON_WARM_START=0` turns it off.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`Harness::prewarm(key, request)` launches the runtime a run of `request`
would launch and parks it under `key`, asking no model anything;
`run_warm(key, …)` runs in it when it launched identically, else ends it
and starts afresh as `run` would; `discard_warm(key)` ends it and returns
once it has. Drivers opt in with `prewarms`. Nothing else ever ends a warm
runtime: its owner (the engine) does.
Claude: the CLI is launched and sent `initialize`, then waits on stdin for
its first user line. Its arguments, folder, environment and MCP servers
(the run's own token among them) must match, and its release too (a CLI
that updated itself since is another runtime). It is retired as the
discovery probe is: never mid login refresh (`refresh_lock::settle` before
its stdin closes and it is signalled). Codex: the app-server is launched
and answers `initialize` (bounded: 30 s) before the first message; the
thread still starts with it, so only the binary, folder and environment
must match. ACP agents: the process is launched; the handshake and any
sign-in stay the run's.
Tests: the message reaches the warm process as typed, with its images and
mentions, and a steer after it; each launch setting changed (model,
effort, context, Fast, access, plan, folder, MCP, environment), a replaced
CLI or a dead process starts afresh; a discard waits out a refresh lock;
a warm process ends with its engine.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Opening New project warmed a walk of the whole home folder, and on a Mac
that asked for access to Desktop, Documents, Downloads, Photos and Music at
once (5 prompts in ademark's warm-up), before anyone had searched for
anything.
- ~/Pictures, ~/Music and ~/Movies (media libraries, never projects) are
never walked.
- Desktop, Documents and Downloads are read only by a walk someone's search
asks for: the picker opening (an empty query) and a chat in home warming
read the rest of home; the first real query starts a walk with them,
waits for it as a search does, and answers as still indexing until it
has them. A refresh keeps what the index read.
- Other platforms walk as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
0.3.5 plus:
- Settings → Providers: Cloud is a choice again while it's on, its
accounts (Claude Code, Codex) and API keys managed there (#1456).
- Cloud: the updater and the pre-sleep tidy keep zeron-engine, which
`zeron headless` runs (#1455; the edge's install and repair, #1454, are
live).
- Plugins: read the composer's draft and set it aside; compose can replace
it or write another chat's (#1445, #1452, #1453).
- Browser: a load error over a page that drew can be dismissed (#1431).
- The "Task completed" chime and banner come on a finished turn, not your
own send; a banner's click opens its chat.
Version 0.3.6.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Zeron 0.3's Settings → Providers listed only computers, so Cloud's
providers (the vault's logins and keys every Cloud machine uses) couldn't
be managed at all. As 0.2 did, Cloud is one more choice after the
computers while Cloud is on (`agents.target("cloud")`, which the engine
answers from the vault: crates/engine cloud_accounts).
- Its cards: Claude Code and Codex, their accounts (sign in, switch,
remove), with no switch, settings or Update (`ProviderCard.fixed`), and
nothing to install or add.
- Its API keys: Anthropic's and OpenAI's, saved to the vault for the
account's Cloud device (`agents.cloud_key` → VaultPutApiKey), the key
every Cloud machine uses from its next turn.
- devices.picker takes extra choices; the page's body is Cloud's own.
Tests: ui/tests/providers_cloud.test.luau (Cloud offered while on, its
cards and keys, back to this computer; none without Cloud); agents'
`a_cloud_key_is_one_cloud_runs_for_its_device`. Full UI suite (1424) and
agents:: (12) pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Since 0.3.0 the release's `zeron` is the zgx app, whose `zeron headless`
runs the `zeron-engine` beside it. The updater (staging a release) and the
tidy (pre-sleep, on installed versions) left it out on Cloud
(`CLOUD_UNUSED_FILES`, 451822be9), so a machine that updated stopped coming
online. Nothing is unused on Cloud now. (#1454's repair, before each start,
covers the releases out there until this one is.)
Tests: the updater's (74) and transaction tests (30), with the Cloud ones
now asserting it's kept.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
New Cloud machines never came online: since 0.3.0 the release's `zeron` is
the zgx app, whose `zeron headless` runs the `zeron-engine` beside it, and
the installer deleted that file (451822be9, when headless linked the
engine). The unit exited at once ("no engine beside …/zeron (zeron-engine)"),
restarted every second, never enrolled, and the chat said "Starting a Cloud
machine…" until the 10-minute limit. 0.3.5's own updater and pre-sleep tidy
leave it out on Cloud too, so a machine updating on a wake broke the same way.
- The installer keeps zeron-engine, and downloads again a version that's
installed without it.
- A repair (`~/.zeron/repair-engine`) runs before every start of the unit
(`ExecStartPre=-`, never failing it): with `current` missing zeron-engine,
it fetches that version's release from the edge and puts the file back.
The installer sets it up, and so does every wake's first command, so
machines set up before this get it as they wake (reloading systemd once).
Tested: the install script's unit tier (keeps it, re-downloads a version
without it, the repair restores it and is a no-op once there, a failed
download never fails a start, the wake writes the repair once); the real
0.3.5 release on Linux (restored byte for byte; `zeron headless` then
starts and enrolls); edge unit (100) and Cloud workerd (77) tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
What #1446 asked for that #1445's draft API didn't cover:
- `zeron.compose(text, { replace = true, session? })` ("compose"): the
words put in place of the draft's (its chips stay, so a rewrite keeps
what it carries), and in another chat's draft (`session`). Words alone
are added after what's there, as ever. Nothing is sent.
- `zeron.draft_of(session)` ("draft"): a promise of any chat's draft as it
is, as `zeron.draft()` says it (text, chat, chips by kind and name,
never a path), read once in the host where the app keeps it.
The composer's handling of a plugin's words is one path now (words alone
come as a string). Consent: "compose" says it may replace what you wrote;
"draft" says it sees your words in any chat. Docs, SDK (and its copies).
Tests: src/plugins `compose_takes_words_alone_or_with_replace_and_a_chat`,
`a_chats_draft_is_read_where_it_is_kept_without_paths`;
ui/tests/plugin_compose_replace.test.luau. Full UI suite (1422) and
plugins:: (248) pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A finished banner (with its sound) rang as you sent. The engine's notifier
rings when a session's completion marker moves, and your own message
often moves it: a steer or a queued row taken as a turn ends publishes
that end with Working (your message carries the turn on), and a send that
replaces the runtime marks the old turn's end (a held wait's included) a
moment before your turn starts. The old app's chime kept quiet for a send
in flight; the engine, which now rings for the zgx app, never knew. Now a
finish published with the next turn running never rings, and the rest
wait two seconds to stand: a turn starting meanwhile takes the finish
with it. Questions and failures still ring at once.
Clicking a banner did nothing. The engine posts Zeron's banners, but
macOS hands a click to the app its bundle names (Zeron.app's interface),
never to the engine that posted it, so the engine's own route (`open -a
… zeron://notification/…`) never runs. Zeron.app's interface has always
taken the click itself (`notify::on_click`); the zgx app never did. It
does now: Zeron comes forward and opens the banner's chat (agent updates:
Settings → Providers), through the same route a link takes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
zgx's chimes rang done.wav whenever a chat's sidebar status turned
"done", but that status is only unseen activity, and your own message
makes it too, so every send played the completion chime (#1437).
Chat rows now carry the session's finished-turn mark (`turn`, from
lastCompletedTurn) and whether that row was fresh. The chime rings
"done" when the mark moves, as the shipping app and the engine's
banners decide it: never when the next turn is already running (a
steer, a queued message taken), never for an old row a sync brings
back or a session row returning, and only once a finish has stood for
two seconds, so a send that replaces the runtime (old turn's end, then
your turn a moment later) stays quiet. Questions and failures still
ring at once. Sends stay silent, as the sound design has it.
Fixes#1437
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`zeron.draft` was written on every key typed, the whole draft copied each
time, whether or not any plugin may read it. It's written now only while a
plugin that's on has "draft", and cleared when none does.
ui/tests/plugin_draft_read.test.luau: none written with no such plugin (or
one off); written as typed with one on; cleared as it goes off. Both fail
without this.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A folded row opens laid out compact either way (it can't be built again
as compact turns on); one built whole has it only while compact shows.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The single-page layout keeps its own copy of the panel; the same change
as the default's, recorded (ZERON_V2_BLESS).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A script is handed a table for every value of a row it reads, so opening
ademark's 1,000-step reply converted its 2,000 blocks and 1,000 tools
(about 3 ms of an M5 Max's long-thread open, more than all it builds),
though the transcript only builds its end (windowed runs). A long settled
reply's row built for a view now says its runs instead (each its first
block's id, count, height guess and a sum of what it holds, cut by the
same rule ds/transcript cuts them), and its blocks and tools stay in
src/chat.rs (Built.aside); the transcript asks for a run's blocks as it
builds that run (chat.reply_run), a find for all of them
(chat.reply_blocks), and a find's current match for the run that holds it
(chat.reply_run_of). A reply being written, a short one, or a folded row
keeps its blocks in its row as before; one settling moves between the two.
long_thread_tests, 1,000 steps opened: values handed the scripts 19,108 ->
1,886 (100 steps: 4,587 -> 3,350). Rig (M5 Max, zgx inspect frames), long
thread opened: script 63.9M -> 34.2M instructions.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every settled reply's row carried its compact layout too (Settings'
compact transcript, off by default): for a long reply, its whole work
again, built in Rust and handed to the scripts each time the chat opened
(ademark's 1,000-step reply: a second copy of its 2,000 blocks and 1,000
tools). Now only while compact shows; turning it on builds the rows kept
whole again (open chats and kept ones). A folded row opening (scrolled
to) is laid out compact too either way, as it can't be built again.
Long thread opened (long_thread_tests' 1,000 steps): values converted for
the scripts 22,117 -> 19,108.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every chat switch (and ⌘N) made the right panel's home for the new chat
while the panel was shut: about 1.8 ms of script, 4.5M instructions of
update, of a short switch's ~5 ms (rig profile, zgx inspect frames). The
home is now made only while the panel shows; a tab still stays made shut,
as before. Short switch: script 22.6M -> 15.5M instructions, update
11.1M -> 6.6M; long thread open 73.9M -> 66.8M, 25.1M -> 20.4M.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
An idle window redraws once every 30 s or so (a relative time ticking),
and each frame brought back ~200 MB of Metal driver memory for 11 s. The
pin is the current one (d0dc793b0) plus that change alone (zgx #2210).
App at rest, 1 s samples over 3 min: p90 316 -> 114 MB, seconds ~200 MB
high 21% -> 5%, median and CPU unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Two ways the view was pulled back to the end after a person scrolled
away from it:
- A send's glide (the prompt rising to the view's top, or a steer's
waiting up to 2 s for its prompt to land) went on to the end over a
scroll taken meanwhile. A wheel now stops the glide where it is; the old
reply keeps the room it held until it's out of view, so nothing shown
moves.
- A scroll begun within 300 ms of the view's size changing left the end
held, and the next resize, however much later (the sidebar, a panel,
the window), went back to it. Resting away from the end now lets it go
when a person scrolled since the last resize.
ui/tests/transcript_scroll_away.test.luau: both fail on main, pass here.
The full UI suite passes (1405).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
0.3.4 plus main since (#1331–#1440):
- Per-provider accounts for Pi, OpenCode and Hermes, API keys and Claude
for Pi; every model in the picker says its provider (#1425).
- A Codex chat's / lists Codex's commands and skills (#1403).
- A tool's result pictures show in its row (#1103, #1186).
- The composer's layout and focus hold steady through moves and resizes
(#1420); Settings reopens on the page shown last (#1416).
- A prompt the opening tail brings shows once: no frozen transcript from
the duplicate-key panic (#1433).
- Windows: messages have their time and Copy again (#1440); microphones
listed by name (#1334).
- macOS: chimes no longer trigger a kernel deadlock that hangs the Mac
(#1333).
- Edge: chat rooms can offer the relay layer (Wing's account only;
#1331, #1335).
Version 0.3.5.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The New project picker's home index held each path as two strings (as
typed and lowercased): 400,000 small blocks for a 200k-entry home, ~45 MB
in the engine, and none of it went back when the picker closed. The walk's
thread built it and had exited, so mimalloc kept its pages abandoned until
a forced collect: every use of New project left the engine ~45 MB larger,
and ademark's A5 (memory at rest after adding a project) read 330-351 MB
once the bench Mac allowed the walk into Documents.
- The index is two allocations: every path in one string and where each
ends (its top bit marking a folder), matched without case as it's
searched (ASCII in place, anything else lowercased).
- Search computes each match's depth once and orders only the first
`limit` (select, then sort): a file query matching 22k paths took 27 ms,
now 10 ms; a folder query 0.35 ms, now 0.27.
- `zeron_engine::heap`: the app binaries hand in mimalloc's forced collect,
run after a walk ends and after its index is dropped.
Engine on a 200k-entry home (release, rig): before 11 MB, picker open 58,
closed 56-58 (never returned); now 12, 22, 12.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new "draft" permission lets a plugin read what's being typed in the message box (zeron.draft) and take the whole draft out and put it back later (take_draft, put_draft, swap_draft, drop_draft). Zeron keeps a taken draft itself, so a plugin never sees file paths. This is what a prompt stash needs: write in the wrong chat, set it aside, restore it in the right one.
Each change to the chat list (a chat working on another device moves its
row every few seconds) re-ran work for UI nobody could see:
- The folded-away sidebar glided its rows to their new places: about 30
frames of the list's heights recomputed on the display link, per change.
Folded away, it now takes each new shape at once (its order, which
⌘1–9 and the next/previous session read, still follows). Zeron v2's
copy too.
- The composer's `@` list made a row for every chat on every change,
open or not. Its chats are made only while the draft holds an `@`
(draft_text.holds, read in place).
On the overnight perf build with 432 chats, sidebar closed, composer
focused, one chat touched every 3 s: the window's main thread spent
~18-20 ms per change (over two 250 ms windows, the display link running);
now ~7 ms in one, no display link. Idle with nothing changing: unchanged
(0.045% vs 0.048% of a core, the caret's two wakes a second).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Opening New project warms a names-only walk of the whole home folder. It
ran on the `ignore` crate's parallel walker, whose idle workers wake every
millisecond until every worker is done. On the bench Mac a few workers
never returned from open() on Desktop and Documents (a privacy prompt for
an ad-hoc-signed build that nobody could answer), so the rest polled for
good: ~4,800 wakeups a second and ~4% of a core in every phase, after quit
too. The cancel flag was read only between entries, so closing the picker
never stopped it.
The walk now has its own pool: workers share a queue of folders and wait
on a condition variable while it's empty. It answers with what it has at
20 s, a cancel (the picker closing) ends it at once, and a folder still
being read when a walk ends is skipped by later walks until that read
returns, so a stuck folder holds one blocked thread, not one per walk.
Home's own folders and theirs are listed one by one so the workers share
the work; a repository or anything deeper is walked whole with its ignore
files, as before.
On ~/.zeron/worktrees (40 checkouts, 250k-entry cap) the walk takes 160 ms
warm, against 215 ms before. A test holds one folder's read open: the walk
answers at its deadline with the rest, idle workers don't wake (mutation:
a 1 ms poll fails it), and the next walk doesn't enter that folder.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On Windows every message's time was missing: the timestamp formatter had a
Unix implementation only (localtime_r) and returned nothing elsewhere. The
hover strip under a message showed only when it had a time, so Copy and the
plugins' message actions vanished with it there.
- stamp() on Windows: FileTimeToSystemTime + SystemTimeToTzSpecificLocalTime
in the machine's time zone, formatted as on macOS and Linux (shared clock()).
- The strip shows for a settled message with a time or something to copy, so
a missing time can never take Copy with it again.
Tests: clock()/stamp() on every platform; a settled reply with no time shows
Copy on hover (fixture command reply_without_time).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A new side chat that switches from its parent's agent sent its config and first
message in one poll; the engine could start the run first and refuse the
switch, logged only. Now a switch awaits the config, a refusal fails the send
visibly, and a same-agent first message still goes out in one poll.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The agent MCP listener accepted any number of connections and, with no
timer set, hyper's header_read_timeout never applied, so a local client
could hold connections open forever by trickling (or never sending)
headers. Connections now take one of MAX_CONNECTIONS (128) slots before
they are accepted (more wait in the backlog until one ends), and the
connection builder gets a TokioTimer with a 10 s header read timeout. The
cap sits above 64 because every warm agent can keep a listen stream open
and its long calls one connection each.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
subscriptions/listen streams weren't among a grant's calls in flight, so
one a client kept open outlived its run's token, holding the run's tools
and their engine connection (and sending keep-alives) for as long as the
client stayed connected. Each grant now registers its listen streams and
aborts them when the grant drops; a stream the client closes leaves the
grant's set. listens_open() counts them for tests and diagnostics.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The idle window now follows whether anyone is looking at the chat:
- open anywhere (this device's app, or another device's transcript
watch): AGENT_IDLE_STOP, two minutes, as before — its person is likely
to reply;
- open nowhere: UNWATCHED_IDLE_STOP, 30 s, counted from the later of the
turn's end and the moment its last viewer left, so switching away from a
chat gives it 30 s from then.
Viewers are the WatchDocMessages streams of anyone but an agent (the
windowed one included); each holds a guard for its life, the last to
leave stamps the time, and parked runs re-work their window as viewers
come and go. Every hold is unchanged and still wins (background work, the
process-tree backstop, wake-ups, crons, questions, the version gate), and
other harnesses keep their windows. The old "another device has it open"
hold is gone: being open is the two-minute window now.
Measured (ademark A5's shape: 5 chats seeded through turns, the last left
open, then at rest): 5 agents / 598 MB until two minutes before; 1 agent /
108 MB from 45 s after. The next message to a chat stopped this way leaves
in 0.23 s (resumed, context kept), against 0.03 s warm.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The reaper counted ScheduleWakeup calls and reset the count on any wake
turn, and counted CronCreate less CronDelete. But a /loop's ScheduleWakeup
replaces the last one (and `stop: true` ends the loop), and a background
task ending starts a wake turn too: a loop rescheduled twice and stopped
held the agent forever, and a background wake turn before the wake-up's
time let the agent be stopped two minutes later, killing the loop. A
duplicate CronDelete released the other cron's hold.
The CLI doesn't say which wake-up a wake turn fired, so SelfScheduled
(self_schedule.rs) keeps the loop's one pending wake-up with its time
(delaySeconds, clamped to [60, 3600] as the CLI does): a wake turn from
its time on is its firing, and past a minute's grace it holds nothing; a
call that fails restores the one before; a call with no delay seen keeps
the old behavior (pending until a wake turn). A cron counts from a
successful CronCreate until a successful CronDelete of its id (matched in
the create's result), each id once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The new-chat page's draft is saved at most every 250 ms; what was typed
since the last save waited on a ui.after timer, and a timer never fires
once the window has closed, so quitting (or closing the window) within
250 ms of a keystroke lost it. Sending was worse: the cleared draft's save
waited its turn too, and a quit in between left the sent message saved as
the draft, back at the next launch.
The main window now sets the shared `app.closing` in its on_closed, just
before host.save() writes what the scripts saved; the page's draft saves
at once when it changes (setting a shared value runs what follows it
synchronously). And take(), which empties the draft to send it, saves the
new page's emptied draft at once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Batching kept appended lines in memory until the next append or read, so
what a turn appended after its Done (its usage) stayed out of the file
until the chat's next turn, and was lost if the engine died first. A
flusher thread now writes anything that has waited IDLE_FLUSH (1 s) with
no append to take it along; it sleeps on a condvar while nothing waits,
so an idle engine pays nothing. Appends still batch as before.
A failed write no longer drops what waits: write_pending writes what it
can, keeps the unwritten rest (continuing the line it stopped in, so
nothing is torn or written twice) and retries it with the next append,
flush or the flusher. Only past MAX_PENDING (8 MiB per chat) is it
dropped, logged as an error with the number of events lost, and returned
as an error to the append that hit it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
draft_text.token looked for the token in the 1 KB either side of the
caret first and gave up when that found none. A closed code block opened
more than 1 KB above the caret shows that window only its closing fence,
which mention_tokens counts as a block still open, so `@file`, `/cmd` and
`$skill` after it showed no list. When the window finds nothing and holds
a fence before the caret, the whole draft now decides; a window without
one still answers alone, so the common keystroke reads no more than before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ademark's A3 times ⌘N to the first frame whose new-chat composer reads the
probe keys, with the old chat gone. Measured on zeron/perf (rig, 12 runs,
the app's own key and present logs): ⌘N reaches the app ~50 ms after t0,
the new page is presented 11.6 ms later, the session's page is gone in that
frame, the composer already rests where it stays (it snaps; nothing glides),
and each probe key is presented 2.5 ms after it arrives. The test pins that
down: from a session whose composer has the keys, "ad" typed with no frame
after ⌘N is the new chat's draft and not the session's; the first frame
shows #chat-home with #chat-session gone; the composer's box in that frame
is its box 30 frames later. From focus elsewhere, the first frame gives the
composer the keys. Mutation-checked: no snap on the route switch, a route
one frame late, and no focus on arrival each fail it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When the owner-only file for a run's MCP config couldn't be made,
build_command_with_config passed the config inline, putting the run's MCP
token (an HTTP bearer header or the token env) on argv, readable by every
local user in ps. It now fails closed: the servers carrying a token are
left out with a warning, the rest are still passed, and the chat goes on
without Zeron's tools (and without the wait_on_background note that names
one of them). The decision lives in mcp_config_args, tested with a writer
that fails.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The reaper logged each unreported child of the agent as "<pid> <argv>" at
info level, and a command line can hold anything (tokens, URLs with
credentials). unexpected_descendants now describes each as "<pid> <name>",
the name being the kernel's process name (pbi_name/pbi_comm on macOS,
/proc/<pid>/comm on Linux), falling back to argv[0]'s file name. argv is
still read, only to recognise configured MCP servers.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
unexpected_descendants counted only the agent's direct children, but a
stop signals the agent's whole process group. A shell that ran `cmd &`
and exited leaves cmd re-parented to init yet still in that group, so the
idle stop SIGTERMed it two minutes in. When the agent leads its own group
(every agent started through owned::configure), every live member of the
group that is no longer under the agent now counts too, unless it is a
configured MCP server. The process table carries each process's group
(pbi_pgid on macOS, /proc/<pid>/stat's pgrp on Linux, pgid from ps).
Verified with the real Claude Code 2.1.322 against a replay server: its
Bash tool runs every command in a session and group of its own (setsid),
so `cmd &` from a foreground command lands outside Claude's group: the
stop never signals it, and it outlives the agent as it did before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A cloned repo whose .mcp.json (or .claude/settings.json) is a symlink to
/dev/zero made the MCP config reader check the path's size (0) and then
read forever; a FIFO there blocked the open. Every file the Claude MCP
config reader reads now goes through bounded_file::read: opened with
O_NONBLOCK, checked as a regular file on the open handle, and read through
take(max + 1), refusing anything over the limit.
The same reader now backs the other files read from places someone else
may control: the model-discovery hash of a project's opencode.json up its
tree (it had no check at all), Hermes's models.dev cache and .env (checked
by path, then opened), and the engine's background.json.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ademark A5 counted 5 agents (741 MB) "at rest after launch". Measured with
a private rig (real claude 2.1.322 against the replay server, data in
<home>/.zeron/profiles/local, the app's opening calls made over IPC), the
engine starts none at launch, on zeron/perf and on v0.2.136 alike,
after a graceful stop or a kill: only short probes (`claude doctor`, the
catalog/commands `initialize` probe) that are gone within seconds. The 5
agents are the seed threads' own, parked after the seed turns that
ademark's runbook sends right before A5 (§7.1 steps 8-9).
These tests hold the launch side to that: five parked chats restart with
no agent after a shutdown or a crash, the next message resumes its own
session, and a turn cut off mid-way is the one thing revived.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every new Claude chat sent Haiku requests Zeron never reads: the CLI
names any stream-json session whose first prompt is 10+ characters, so
both the titling run and a real chat's run asked for a title of their
own (~4.3 KB each). CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1 latches the
CLI's titling as done; Zeron still titles chats itself.
The zeron server's instructions ride every request whole (its tools are
deferred behind tool search), and most of them repeated the tools' own
descriptions. They now say only what an agent needs to reach for a
tool; kinds, hosts, Cloud, the one-level rule and the visual style stay
in create_chat's and show_visual's descriptions.
Replay rig (claude 2.1.322), bytes per new chat:
- "hi": 93,192 -> 86,456 (main request -2,393, CLI title request gone)
- a 120-character prompt with one tool call: 184,597 -> 171,173
Tool results (whoami, show_visual valid and invalid, send_message,
wait_on_background) are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A split pane keeps its chat's draft in step with the window's (shared
`draft_of`) both ways, and each side read the whole draft and compared it
at every keystroke, the echo of its own write included, and the picks'
mirror read the whole draft for its picks: a key in a pane's draft of
30,000 lines cost 1,025M instructions (32 ms), against 17M at 20 lines.
Each side now tells the other the length it wrote, and skips that echo by
it; the chat's draft is followed by its length (`Shared.track_draft_of`,
`draft_size_of`), and read only for a change made elsewhere; the picks'
mirror reads the picks alone (`chosen_of`); a pane's Cloud link reads
whether its draft is blank with ds/draft_text, here and in v2's copy
(recorded in step). The new-chat save follows the kept drafts by `len`.
A key at 30,000 lines: 41M instructions (16M at 20 lines); what's left is
the one copy into the focused pane's hidden composer, which keeps it the
draft the window's composer types into.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Full suite at this pin: app 718, zgx UI 1409, engine 1153, harness 544, proto/rpc 173,
engine integration 39, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`chat.send` awaited the new chat's setChatConfig answer before queueing
its first message, and that answer is read only once the frame that
builds the new chat's page is done. Both now go out in the same poll,
the config first. The message carries the same agent and model, and the
engine stamps them on a chat whose config hasn't landed yet, so the two
may land in either order; a config that fails is logged (the run goes
with its own agent and model all the same).
Through the app (beta build, inspector-driven Enter, a project chat,
24 reps each, M5 Max under load): createChat -> QueueCommand at the
engine 7.7 -> 5.4 ms. Small here; the page's frame costs more on slower
Macs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With them a rig reads the app's side of a send from the engine's log:
Enter to createChat, and createChat to the run's command.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude reports its context usage and commands at init, before its
request: counted as output, they released the title run ~100 ms before
the first request (seen through the app). Only what the agent says or
does now releases it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Joined with the dispatch, the stamp still held the drain: a command was
resolved (Applied) only once its `git` processes were done, so a fast
run could finish while its command still read Pending (e2e's
queued_run_command_executes_end_to_end and
interrupt_stamps_streaming_entry_aborted caught it). The stamp now runs
on a worker of its own and the command resolves as soon as the run is
dispatched, as it did before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude runs without --strict-mcp-config, so it also starts the stdio
servers of its user's MCP scopes, and the idle-stop process check counted
them as unexplained children: anyone with servers of their own was never
stopped. The Claude driver now reads those scopes once per run, the way
the CLI does (crates/harness/src/claude/mcp_config.rs):
- user and local: `.claude.json` (in $CLAUDE_CONFIG_DIR, else ~),
top-level `mcpServers` and `projects[<project>].mcpServers`
- project: `.mcp.json` in the run's directory or its repository root,
less what a settings file's `disabledMcpjsonServers` turns down
(`claude -p` loads the rest without asking)
- plugins: enabled ones (`enabledPlugins`) from installed_plugins.json,
their `.mcp.json` or plugin.json `mcpServers`, ${CLAUDE_PLUGIN_ROOT}
expanded
- managed: managed-mcp.json in the OS's system location
Only command and args are taken (`${VAR}` expanded); an entry's env is
never read into anything kept or logged. Files are size-bounded; a
missing or malformed one adds nothing, so its servers stay unrecognised
and hold the stop. The engine reads them at launch, off the runtime's
threads (Harness::configured_mcp_servers), and joins them into the known
children when the reaper first looks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Two backstops for the 2-minute idle stop, neither relying on what the CLI
says about its background work:
- Process check: right before the reaper stops a runtime, it reads the
agent process's live children (libproc + KERN_PROCARGS2 on macOS,
/proc on Linux; Windows not traced). Any child that isn't one of the MCP
servers the run was configured with (Zeron's, the plugins') holds the
runtime for another full window, and is logged: a background shell or
dev server the agent never reported. Zombies don't count; an unreadable
process table holds. (zeron_harness::process::unexpected_descendants;
drivers say which pid is the agent: TurnControl::set_agent_pid.)
- Version gate: Claude takes the 2-minute window only from CLI 2.1.312,
the first live-verified to report every background task
(background_tasks_changed); an older or unknown version keeps the
30-minute window.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
One reply of text, code blocks and a diff block, 16 characters every 50 ms
(80 tokens a second in 50 ms chunks, as A7's replay streams) for N seconds
(180 when bare): what the window spends while agents stream, measured with
the replay's shape rather than the scripted turn's many short parts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
v2's own copy of screens/chat/composer read the whole draft for its send
intent and Cloud link at every keystroke, as the default's did; it reads
ds/draft_text's `has_text` now too, and the copy is recorded in step.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each keystroke in a new chat copied the whole draft into a table and the
saved state (whose file zgx writes 250 ms later anyway). It's now saved at
the first change after a pause and then every 250 ms while typing goes
on, the last keystroke's once it has waited that long.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A dozen bindings and effects read the whole draft at every keystroke
(`get`, a copy of it into the script each): the send button and intent
(whether it's blank), the layout (whether it has a break), the metrics
request (which carried the draft itself, copied in and out again at each
of its reads), the mention list, its references and dictation. In a draft
of 30,000 lines that was 5 ms of copies a key.
ds/draft_text reads what each needs where the draft is held: `len` to
follow its edits, a plain `find` for a break or a reference, the line at
the caret for a token, its first bytes for whether it's blank. With zgx's
`state:sub` (zeronsh/zgx#2184) nothing copies the draft; on the pinned zgx
the reads that still need it fall back to `get`. A key at 30,000 lines:
5.8 ms on the pin (17.3 before), 2.5 ms with #2184, as at 20 lines.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A break (Shift-Enter, or Enter where it breaks lines) walked every line
before the caret to find its own, then matched them all for fences,
before knowing the line was a list item at all: 40 ms and 1G instructions
of a break in a draft of 30,000 lines. The line's start is found back
from the caret, and fences are counted (by a plain search) only for a list
item's line: 2 ms, 15M instructions. Tests for what a break does, which
none covered.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every keystroke looked for a `/` command across the whole draft with an
unanchored pattern (and for fences across all of it), twice for the
completions and once for the composer: 9 ms of a keystroke in a draft of
30,000 lines. A token never crosses a line, so only the caret's line (its
last 1,024 bytes at most) is read; fences above it are found with a plain
search, and only where a trigger is. 343M instructions a key at 30,000
lines down to 68M; the same tokens.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The plugins came with the engine's connection, after the first frame, and
loading them reloaded every script in the window: on an M5 Max 176 ms of
the main thread, as the first keys were typed. The engine outlives the app,
so a relaunch usually finds it running: the launch now asks it which
plugins it allows (`WatchPlugins`' first word, read on the spot within
150 ms, engine::rpc::ask_now) before the window's first load, which loads
them with it (+33 ms there). The list the connection then brings is the
one loaded and changes nothing. Only what the engine says is loaded, as
ever; with no engine running (a cold start) the dial is refused at once
and nothing changes.
Rig, engine left running, 6 relaunches each: the post-connect reload gone
(sampled), typed text read 818 -> 750 ms (worst 1303 -> 841). Cold
launches unchanged (716 vs 727 ms, 8 each).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Seeds mock chats, holds the watches the app holds at rest, streams mock
runs, and times QueueCommand to a client's first frame and one device's
write to another's view.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Relay maintenance looked at each admitted chat every second, reading
every pending outbox row's bytes from SQLite each time. It now rests
(until its 10 s mode refresh) once the room has answered, the doc has
caught up, nothing is left to retire or heal and no commit came since
the last look; a commit or a peer's kept update wakes it at once.
Leftover rows are adopted when relaying begins and with each mode
refresh, not every second: a relaying host relays its own commits as
it makes them.
- Retired outbox rows are deleted in one transaction per look, not one
store call (and block_in_place) each.
- The store now notes which docs' outbox rows changed. The sync
scheduler skips the pass an outbox change would wake when every such
doc is a started chat whose client sends its own rows. While agents
streamed, those passes (each several store reads, each through
block_in_place) ran ten times a second, and the blocking pool's lock
they contended on was the largest cost of a signed-in streaming engine.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every agent event was its own write(), under the one lock all chats'
appends share: with 5 agents streaming, workers spent more time waiting
on that lock than anything else in the engine.
Appended lines now wait in memory and are written when 100 ms old (at
the next append), at 64 KiB, at a turn's Done, with each doc commit of
the run (so the journal never trails its transcript), before any read of
the journal, when its file is evicted, and at shutdown. A line is
serialized from a borrowed event rather than a clone.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Discovery scanned every 2 s while anything a chat started was alive. An
engine at rest keeps a warm agent process for every recent chat, so it
scanned forever: every process on the machine (a KERN_PROC_ALL sysctl)
plus every socket of each chat's processes. With 20 parked agents that
was ~0.8 ms of CPU a second, most of an idle engine's work.
It still scans every 2 s while a run works or a terminal is open, and
whenever what a chat left running changes (a process starting or exiting,
a new listener). While nothing about those processes changes, each scan
waits twice as long as the last, up to 30 s; a run or terminal starting,
the chats changing, or a preview losing its process wakes it at once. A
server that a process left running starts listening on later can take up
to 30 s to be listed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The monitor (started at assembly by desktop banners, and never stopped)
recomputed every second, walking every open chat. It still looks every
second while the posture is changing, degraded, or timing a degradation's
grace; once it has held healthy or local for 3 s it looks every 5 s. A
fresh outage is reported up to 4 s later than before (on top of the 4 s
grace it already waited); recovery from one is still seen within 1 s.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The background engine's main thread ran a CoreFoundation loop with a 1 s
repeating timer and a 1 s run-mode timeout, and the clock-comparing wake
detector (zeron_sync::wake) woke a tokio worker every second as well: two
or more wakeups a second with nothing happening.
- The main run loop now waits on a run-loop source that `finish` signals
(race-free: a source signaled before the wait is served when it starts).
- It also registers for IOKit power notifications and broadcasts each
wake (kIOMessageSystemHasPoweredOn) through `wake::notify_wake`,
answering sleep requests at once. `wake::use_os_wake_events` keeps the
polling detector from starting (or stops it); other processes keep it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The title run is a second agent process (the cheapest model). Started
with the chat's own run, both CLIs booted side by side, and the title's
claude spawned first and reached its request first. It now starts at
the agent's first output (anything after its session start), or when
the run ends without any, so it never competes with the startup that
stands between Enter and the first word.
Rig (M5 Max under load, 24 reps each, alternated): first request
377 -> 300 ms median with the source-context change; the title lands
365 -> 601 ms after Enter against an instant replay model (it trails the
first word by about one title run instead of racing it).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every fresh dispatch stamped the conversation's source context first:
three `git` processes one after another, ~25 ms (M5 Max, rig median)
before the agent was even spawned, on a new chat's first message and on
each next message alike. They now run side by side, and beside the
dispatch: the agent spawns 2.5 ms after the command lands instead of
34 ms. The stamp still records the checkout the agent observes; the
agent reads nothing of it for ~250 ms (its own startup).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The owner-only file holding a run's MCP token lives only as long as the
run that reads it at once. `sync_all` on macOS is `F_FULLFSYNC`, a
disk-cache flush, and it held every agent start: 4 ms on an M5 Max,
6 ms with builds running (spawn moved from 6.6 ms to 0.3 ms after the
run was prepared, in the first-word rig).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Debug-level marks, off unless RUST_LOG names `first_word`: the command
queued and picked by the drain, the fresh dispatch, the run prepared,
the CLI spawned and its first stdout lines, the title run, and the first
segment commit. With them a rig joins the engine's side of a send with
the replay server's request time, stage by stage.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Two ways the composer's arrival went wrong at launch:
- An arrival was marked before its keys were given (the next turn). With
an engine already running (a relaunch), its plugins came in as the window
opened and loaded the window's scripts again in between: that turn's
callback went with the old scripts, and the new ones found the arrival
marked. It's marked now as the keys are given. (Rig, engine left
running: main timed out 5/5, this 0/5 at 0.72 s.)
- A session's project, known once the engine lists the chat, counted as a
move, so the keys jumped to the composer whenever the list came in,
from whatever had them by then (a dialog opened at launch). For a
session the project is the chat's own and no longer part of the
arrival; on a new chat it still is.
Zeron v2's copy follows; its base is recorded again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
publish_page walks every element of the window and wrote Settings →
Plugins on each ask: before the first frame (the view known) and twice
more as the engine answered, a tenth of a second of a launch's main
thread that nothing a launch shows reads. Asks in a row now make one
publish, 1.5 s after the launch's first ask and 200 ms after any later.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every launch copied Zeron's interface into <data>/templates/.zeron and laid
.live down again (sync_zeron, compose), reading every file of Zeron's at
least twice to write none: about a quarter of a second on the main thread
before the window on an M5 Max, warm, and more from a cold disk.
The launch now keeps a stamp of what it laid down (.launch-stamp.json:
this Zeron's version, ui/, the active template and .live as it left them,
each by path, size and time written, nothing read). The next launch that
finds the same runs .live as it is; anything changed (an update, a
template switched or edited, .live written by anyone, a file gone) lays
everything down as before. prepare_live: ~250 ms to ~10 ms.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Since c865bf3be the composer took the keys on arriving at a chat, but the
window opening was left out on purpose, so a launch gave the keys to
nothing. They only reached the composer by accident: a restored session's
project resolving once the engine's chat list came in counted as an
arrival. A launch onto a new chat, or a session the engine was slow to
list, never had them, and ademark's A1 (which types from the launch with
no click) timed out on every run.
The window opening on a chat is now an arrival too; a reload still isn't.
Zeron v2's copy follows, and its base is recorded again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Two ways the composer's arrival went wrong at launch:
- An arrival was marked before its keys were given (the next turn). With
an engine already running (a relaunch), its plugins came in as the window
opened and loaded the window's scripts again in between: that turn's
callback went with the old scripts, and the new ones found the arrival
marked. It's marked now as the keys are given. (Rig, engine left
running: main timed out 5/5, this 0/5 at 0.72 s.)
- A session's project, known once the engine lists the chat, counted as a
move, so the keys jumped to the composer whenever the list came in,
from whatever had them by then (a dialog opened at launch). For a
session the project is the chat's own and no longer part of the
arrival; on a new chat it still is.
Zeron v2's copy follows; its base is recorded again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On (the default) quitting the app leaves the engine running, as before,
now with idle agents stopped. Off: the app asks its engine as it quits
(QuitCheck) and tells it (AppQuitting), and the engine stops once nothing
is pending — turns, questions, background work — after 5 quiet seconds.
Work still running is never ended silently: the app asks "N chats are
still working. Keep running in the background until they finish, or stop
them now?" and only "Stop them now" stops them (each chat's own Stop).
Any later call from this device's app calls the stop off; a relaunch
doesn't ask.
- engine: crates/engine/src/keep_running.rs (setting in
{data_dir}/background.json, the quiet wait), the background engine's
ManagedRpc serves Get/SetBackgroundSettings, QuitCheck, AppQuitting
(local-only methods)
- app: Settings → General row (engine switch), the quit question as a
native alert after the run loop ends (src/quit_prompt.rs) in the
language shown (words handed over from the scripts), en + zh-Hans
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A runtime parked between turns used to keep its agent CLI for 30 minutes
(each Claude ~120-200 MB plus its MCP servers). Drivers whose resume brings
the session back whole (`Harness::stops_when_idle`: Claude, via --resume)
now stop it after `AGENT_IDLE_STOP` (2 minutes); the next message resumes
the session. The others keep the 30-minute window.
Never stopped, whatever the window:
- a turn running (the reaper only arms between turns)
- background work or a subagent (the driver's own report; a silent
subagent is presumed lost only after 4 hours, as before)
- the agent said it waits on background work (`wait_on_background`)
- a wake-up or session cron it scheduled (ScheduleWakeup / CronCreate,
until the wake turn starts or CronDelete)
- a question waiting on the person
- another device has the chat's transcript open (a peer's
WatchDocMessages holds a guard for the stream's life)
- a voice call, an accepted agent update (unchanged)
Claude teardown already waits out a live .oauth_refresh.lock before any
signal or EOF (refresh_lock::settle), so a stop never lands mid refresh.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- long_thread_tests: ademark's A11 thread built by src/chat.rs; its
open holds fewer nodes than a tenth of it (782 vs 18,340 before) and
stays under budgets of 2,000 nodes and 2,500 script calls (962 vs
43,091 before), with LONGTHREAD-END in view; scrolled up a step a
frame it moves by each step through to its first, and Jump to latest
takes it back to its end.
- transcript_paint_tests: the same thread opened and scrolled draws what
a whole repaint draws.
- chat_find: a match far up its one reply is found, its run built and
scrolled into view.
- chat_fixture `long_thread`: the thread as Tall replies (s7).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A reply's blocks were all built whenever its chat opened: ademark's A11
thread (one reply of 1,000 steps, ~2,000 blocks) took one frame of
~44,000 script runs and ~32,000 node layouts (1.1G script, 1.1G update,
0.28G layout instructions), ~230 ms on an M5 Max and 380 ms on an M1,
though only its end shows. Switching back cost the same each time.
A reply of more than 48 blocks, or one being written, now holds its
blocks in runs of about 32, as a long text's are (ds/markdown's window):
a run is built while it's within 600 pt of the view and is a box of its
last height (a guess until laid out) away from it. Run boundaries come
from block ids alone, so the engine's opening tail and then the whole
reply, or a reply being written, keep the runs they don't reach. The
runs within a view and its overscan of the end are built as it's made,
and kept until the view has been near them and gone, so the reply opens
whole in its first frame with no frame after it. A run built above the
view moves the view by its difference, as markdown runs do; a find's
current match and a streaming reply's last run are always built.
A11 at 1600x1000 pt (cmd+1/cmd+2): open and switch 228-259 ms -> 20-28
ms to settled on an M5 Max, no frame after the first paint; 3,371 runs
and 95M/43M/25M instructions. CPU while a reply streams into the long
thread: 2.6 s -> 1.0 s over 8 s. Footprint with it open: 540-580 MB ->
310-360 MB.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A prompt of `/longthread [N]` (1,000 when bare) answers as ademark's A11
replay does: N steps, each a short text (one in five with a code block)
and a call reading a small file, the last text holding LONGTHREAD-END,
streamed unpaced. One reply of 2N+1 parts, for timing a long thread's
open, switch and scroll against a private engine.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every agent run used to start the whole engine binary as its own `zeron
mcp` stdio server (10 engine processes for 5 streaming chats). The engine
now serves those tools itself over loopback Streamable HTTP
(crates/mcp/src/http.rs), stateless per the 2026-07-28 revision with
2025-era clients still answered:
- no per-connection state: each request carries its run's bearer token
and stands alone; `initialize` (2025) is answered without a session id,
`server/discover` and `subscriptions/listen` (2026) are served, the
MCP-Protocol-Version / Mcp-Method / Mcp-Name headers are checked against
the body (400 + HeaderMismatch), GET/DELETE answer 405
- long calls answer within their own POST (SSE with progress and
keep-alives); closing the stream, or a 2025 `notifications/cancelled`,
stops the call
- each run gets its own token (32 random bytes), naming its chat and
revoked when the run ends; the calls behind it reach the engine as that
agent (agent_allowed methods only), with the calling-chat methods
pinned to the token's chat (zeron_rpc::agent_service)
- 127.0.0.1 only, on a port of its own; Origin present → 403, a Host that
isn't loopback → 403 (DNS rebinding), no token → 401
Claude gets `{"type":"http"}` in an owner-only (0600, in a 0700 dir)
--mcp-config file instead of inline JSON on argv; Codex gets url +
http_headers in its thread/start overrides; ACP agents that advertise
mcpCapabilities.http get the http form. Everything else gets
`zeron-engine mcp-proxy` (crates/mcp/src/proxy.rs): std only, no engine
setup, a stdio-to-HTTP forwarder of ~2 MB.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A failure reported after the page's own document committed (WebView2
calls a page with an HTTP error status, such as Google's 429 "unusual
traffic" check, a failed navigation; WebKit's didFailNavigation) no longer
covers the page with "Couldn't load this page". A real failure (one that
never committed, or the page's process ending) still shows it, now with
Dismiss beside Try again (Escape too), for that navigation only.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
publish_page walks every element of the window and wrote Settings →
Plugins on each ask: before the first frame (the view known) and twice
more as the engine answered, a tenth of a second of a launch's main
thread that nothing a launch shows reads. Asks in a row now make one
publish, 1.5 s after the launch's first ask and 200 ms after any later.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every launch copied Zeron's interface into <data>/templates/.zeron and laid
.live down again (sync_zeron, compose), reading every file of Zeron's at
least twice to write none: about a quarter of a second on the main thread
before the window on an M5 Max, warm, and more from a cold disk.
The launch now keeps a stamp of what it laid down (.launch-stamp.json:
this Zeron's version, ui/, the active template and .live as it left them,
each by path, size and time written, nothing read). The next launch that
finds the same runs .live as it is; anything changed (an update, a
template switched or edited, .live written by anyone, a file gone) lays
everything down as before. prepare_live: ~250 ms to ~10 ms.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Since c865bf3be the composer took the keys on arriving at a chat, but the
window opening was left out on purpose, so a launch gave the keys to
nothing. They only reached the composer by accident: a restored session's
project resolving once the engine's chat list came in counted as an
arrival. A launch onto a new chat, or a session the engine was slow to
list, never had them, and ademark's A1 (which types from the launch with
no click) timed out on every run.
The window opening on a chat is now an arrival too; a reload still isn't.
Zeron v2's copy follows, and its base is recorded again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 22:10:50 -07:00
1776 changed files with 49049 additions and 291434 deletions