Repository navigation
Conversation
Between marking a command processed and writing its outcome, a racing drain's dead-command sweep could take a rejected message for a crash and write "interrupted before completion" over "attachments never arrived". The rejection now holds the same in-flight claim an execute does. Upstream: zeronsh/zeron@b4aa53f
A screenshot alone, sent while the chat worked, said "Your message didn't
send". The app uploads the file to the chat's host, then its own engine
writes the queue row with no words, and a queue row needs text
(`queued message text required`). So the file reached the host and no
message did. On the chat's host the same call failed the same way.
A row of files alone now says what a run of them says ("See the attached
image(s)."), written by the engine that takes the call, so every client
and an unupdated host read it. An edit that clears the words of a row
keeping its files keeps the row, where it used to delete it, files and
all; taking the files off too is how it goes.
And a send that fails from the window's composer puts its files back on
the draft with its words. Side chats already did.
Upstream: zeronsh/zeron@52e49c6
A turn's text was committed a window (120 ms) after its first change, so a turn's first token and a steer's echo waited that long before any device could see them. Now a change commits at once unless a commit went out less than a window ago, then a window after that one: still at most one commit per window while streaming. Upstream: zeronsh/zeron@7794018
A command sent to an empty chat id opened a doc for it, and its sync dialed a room the edge can't route, every few seconds, for as long as the engine ran. Upstream: zeronsh/zeron@a21a52b
The whole chat list (434 KB, 376 chats) went to every window on every
device for each change to any row, and each window watched it twice.
- zgx open_chat wrote markChatSeen on every open, with no unseen check
(the old desktop app had one). A window on home-laptop going through
~19 chats bumped lastSeenAt 70-150 times a minute in bursts. It now
marks only while the mark changes what any viewport derives from it
(last message, terminal report, end of sleep).
- Engine: WatchChats, WatchSessions and WatchDevices take an opt-in
{"changes": true}: the whole list once, then {changed, removed, order?}
with only the rows that moved, and nothing for a change that changed
no row. Without it, the whole list as before (older clients).
- zgx: one watch per list per connection (src/engine/lists.rs) shared by
sessions.rs, chat.rs and updates.rs, asking for changes; each keeps its
copy by applying them, and the sidebar rebuilds only the rows that
changed. An older engine's whole lists read the same.
Upstream: zeronsh/zeron@728551c
…hat asks WatchDocMessages took a reply's every change (a tool call arriving or finishing) as the whole entry again: a reply of 2,000 calls, sent and parsed whole for each. A viewport that asks (`partPatches: true`) now gets those parts alone (`parts`: entry, place, part, and the entry's part count as a desync tripwire) when the entry's header and part order are unchanged; anything else is the entry whole, as before. Never sent empty, so an older reader (the iOS app, older apps) never sees the field, and an older engine ignores the flag. Tests: crates/doc (a reply's changed parts travel alone when asked for, and whole otherwise; other changes whole; a patch out of place is desync) and the engine (a reply streaming through the real doc watch: a patched and a plain watcher end with the same transcript). Upstream: zeronsh/zeron@75fbbbb
The RPC server ran each call on a task of its own, and tasks spawned back
to back start in no set order: tokio runs the newest first (its LIFO
slot). Two WriteTerminal calls in a row reached the PTY swapped. zgx's
terminal (Ghostty on macOS) answers a program's queries through the
bridge, each answer its own write: termenv (gh, glamour) asks for the
background (OSC 11), then the cursor (CSI 6n), took the cursor report
first as "no colour" and stopped reading, and gh's prompt read the colour
answer after it as typed keys ("unexpected escape sequence from
terminal: ['\x1b' ']']"), the cursor reports left in the shell (`;22R`).
Keys typed or pasted fast went out of order the same way, and a remote
viewer's numbered input lost the older of two (write_sequenced took it
for a replay).
A terminal's WriteTerminal and ResizeTerminal calls now run one after
another, in the order the connection sent them, on a lane of their own:
one per terminal, so a write that blocks (a paste into a program that
doesn't read) holds back no other terminal on the connection. A call's
answer is sent beside its lane, so a client slow to read answers doesn't
hold the next write back. When the connection ends, input already sent
still goes in; every other call is aborted as before.
tests/terminal_query_order.rs (unix; the probe is Perl): over the
engine's own dispatch, a program in the PTY asks as termenv does, 300
times, and a viewer answers as Ghostty does (two writes, at once).
Before: 284 of 300 read the cursor first (298 in an earlier run); after:
300 of 300 in order, the colour's answer in 2.64 ms median, 4.29 ms p99.
rpc's tests: two terminals' interleaved writes and resizes reach the
service each in order, a stuck terminal holds back no other, and input
sent before the connection ends goes in, in order (all three fail on
the base).
Upstream: zeronsh/zeron@40e7994
Since a steer started stopping an open tool call in place (76ca2e17b),
a `send_message` from another chat did too. Claude Code words every
interrupt as the person rejecting the call ("STOP what you are doing and
wait for the user to tell you how to proceed ... The instruction to stop
and wait still stands"), so a Claude agent took the other chat's message
as an order to stop and sat waiting. Codex and Muse add no such text,
which is why only Claude stopped.
A steer carrying Zeron's "from another chat" header (which only the
engine writes) now waits for the step boundary, as the `send_message`
tool promises: the command finishes and the message lands right after
it. The person's own Steer still stops the command at once.
Upstream: zeronsh/zeron@d071ed2
A terminal tab on Windows ran %COMSPEC%, cmd.exe: a prompt with no space after its `>` and nothing coloured as it's typed. It now runs PowerShell 7 (pwsh.exe on PATH), else the Windows PowerShell every Windows has, else %COMSPEC% as before (cmd.exe when that's unset too). PowerShell starts with -NoLogo: its prompt alone, no banner on every tab. Upstream: zeronsh/zeron@d44bbc3
Windows opens its terminals through terminals/windows.rs's own CreateProcessW launch, not portable-pty's CommandBuilder, so -NoLogo given there never reached PowerShell. It's on that command line now, after the quoted executable. Upstream: zeronsh/zeron@2e0147e
…program The app starts the engine with CREATE_NEW_PROCESS_GROUP (crates/launch `spawn_detached`), which makes it ignore Ctrl+C, and every process inherits that from its creator: the shell the engine opens on a pseudoconsole, and what it runs, ignored Ctrl+C too. PowerShell got the key (char 3) but `ping -t` ran on. The engine puts normal handling back before it creates a shell; a process started any other way has it already, and the engine has no console for a Ctrl+C to come from. The new test opens PowerShell from a process ignoring Ctrl+C, runs `ping -t localhost`, sends Ctrl+C and waits for ping's summary. Like the other ConPTY tests in windows_tests, it doesn't run on WING-PC (input written to the shell never arrives there, with or without this change); the fix was checked in the app: ping stopped, the tab went on. Upstream: zeronsh/zeron@2718721
…n turn Two messages sent to a sleeping Cloud machine reach it together: the first starts a turn, and the second, read a moment later, found that turn running and was steered into it. An agent that yields on a steer (Codex) then ended the first turn with an empty reply and answered only the second. Seen on staging in every two-sends-while-asleep cycle with Codex (3 of 3). A run issued before the live turn started can't be a steer: its sender never saw that turn. It now waits for the turn to end and runs as the next one, the way a send to a turn-boundary agent already does. A send during a turn the sender can see still steers it. Upstream: zeronsh/zeron@6ab00cf
The previous commit held any run issued before the live turn started. Narrow it to the case it's for: the running turn is the latest message, started by a run issued no later than this one, and isn't this send's own. A row the host turns into a command, or a send delivered again, goes as before. Measured against the cloud attachment suite run alternately with and without the hold (12 runs each): 1 failure each, the same pre-existing row-timeout flake under load. Upstream: zeronsh/zeron@dee83c3
The tool's description now tells agents that anything they show only under the pointer (a custom readout, a detail line, a hint, a row's or canvas's hover state) must not change a visual's height: reserve its space with a placeholder or an empty line of the same height, or draw it where it takes no layout space. ui.chart's own readout already keeps its place. crates/visual checks the advice's example. Upstream: zeronsh/zeron@2b2c1e8
Says it plainly in the hover advice, now that ds/chart keeps its legend line at rest by default. Upstream: zeronsh/zeron@e812484
`is_powershell` took the shell's name through std::path, which splits at `\` only on Windows, so its test (`C:\Program Files\PowerShell\7\pwsh.exe`) failed on the Linux and macOS runners and held 0.3.4's release back. The name is now the last part at either slash, less its extension. Windows, where it runs, reads the same as before. Upstream: zeronsh/zeron@0f5bf22
…ndow * Claude: make the 200K context window choice really limit the window The 200K choice only dropped the [1m] suffix from the model id. Models whose plain id already runs 1M (claude-opus-5-5) kept a 1M window and compacted near 1M, while the picker said 200K (zeronsh/zeron#1083). Launch the CLI with CLAUDE_CODE_DISABLE_1M_CONTEXT=1 when 200K is chosen (or unset on a model whose catalog default is 200K). The CLI then resolves a 200K window and its own autocompact works from it. The variable is read at launch, so switching between 200K and 1M relaunches the process instead of reconfiguring it in place. * Claude: unset Context Window keeps 1M; only an explicit 200K caps the window The long-context rows (Fable 5/5.1, Opus 5.5, Sonnet 5) already run at 1M under their plain id, so their select now defaults to 1M and an unset choice launches exactly as before. Picking 200K sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1 as in the parent commit. * Claude: the 200K test compares runtimes that share a --model --------- Upstream: zeronsh/zeron@50ba9b7
…ng device
A Windows user's agent was told to read C:\Users\ADMIN\…\uploads\
2fbd2b3b-image.png while it ran as HP MEDIA: an upload path made by
another engine (another device, or another Windows user's engine on the
same PC), which means nothing where the agent runs. The driver couldn't
inline the picture and the agent's own Reads failed.
The host now places every attachment itself, wherever the message came
from: a run, a queued row (drained, sent now or steered) and a steer.
A `pending://` ref resolves as before. A path that doesn't exist here
but names an upload (`{id8}-{name}`, in either separator) goes by this
device's own copy, which an upload to the host commits under the same
name. That covers the paths the prompt names too, and the read-back that
draws the message's chips. A path with no copy here goes as it was.
Upstream: zeronsh/zeron@ac1700f
…hanges 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. Upstream: zeronsh/zeron@45b79a8
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. Upstream: zeronsh/zeron@98924b8
… sleep 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. Upstream: zeronsh/zeron@f1ecad2
…urn recovers 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. Upstream: zeronsh/zeron@6191678
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). Upstream: zeronsh/zeron@fafbf74
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. Upstream: zeronsh/zeron@039e10c
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. Upstream: zeronsh/zeron@e51676b
…st append 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. Upstream: zeronsh/zeron@73ed042
Linux CI couldn't compile the engine's tests with it. Upstream: zeronsh/zeron@1d82a5c
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. Upstream: zeronsh/zeron@c19d459
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. Upstream: zeronsh/zeron@445f70a
Every new Claude chat sent a Haiku request Godspeed never reads: the CLI names any stream-json session whose first prompt is 10+ characters. CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1 latches the CLI's titling as done; Godspeed still titles chats itself. Ported only the harness half: upstream's shorter MCP server instructions rewrite Zeron's text, and Godspeed's instructions are its own. Upstream: zeronsh/zeron@f380658
…n handle A project's opencode.json (hashed for model discovery, read up its tree) that is a symlink to /dev/zero or a FIFO was read forever or blocked the open. The new bounded_file reader opens with O_NONBLOCK, checks the open handle is a regular file, and reads through take(max + 1), refusing anything over the limit. Ported the reader and the model-context hash only: upstream's other users (the Claude project MCP config reader, Hermes's models.dev cache and .env, the engine's background.json) aren't in Godspeed. Upstream: zeronsh/zeron@8815fb2
Preview discovery sent `HEAD /` to every new loopback listener in a project 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 was first seen and forgets sockets no longer listed. While a listener settles the scanner waits no longer than its settle time, so the 60 s quiet cadence never delays the listing. - Test runs are never probed: Listener::is_test_run() matches whole words and path components for Rust test binaries, cargo test/nextest, go test, bun/deno test, npm/pnpm/yarn/bun [run] test, vitest, jest, mocha and pytest. Any ancestor running tests excludes it too, up to but not including the engine's own children (an agent's prompt may mention tests). Hand-ported: Godspeed's discovery attributes listeners by project cwd, not upstream's origin markers, so the ancestor check runs over the process table each scan collects, and the "environment read empty" half of the upstream change (origin-marker caching) does not apply. Upstream: zeronsh/zeron@bc14b5b
Godspeed had no direct ort dependency; add one pinned to the version parakeet-rs already resolves, with the default features minus copy-dylibs. Upstream: zeronsh/zeron@865308f
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Ports Zeron commits from 7437e3e9 through 09766b39. That range has 888 commits (627 non-merge, 333 of them
apps/zgxonly). Most of the rest is durable Cloud, the relay layer (chat2), the engine plugins API, zgx, and the update transaction and beta channel. All of those build on work already deferred (cc7da5c2, zgx, a8d1dc6e), so this PR ports only the standalone fixes. Every other commit is listed by category indocs/godspeed/UPSTREAM.md(Deferred 2026-11-17).Ported (20)
{"changes": true}); older clients still get the whole listpartPatches); test drops the deferred a2113ac8 Tool fieldsCLAUDE_CODE_DISABLE_1M_CONTEXT); the long-context rows now default to 1M; test rewritten for Godspeed's harnessNeeds a look
Skipped
crates/cliTranscriptFrame::resetTests
All of these pass:
cargo build -p godspeedcargo check --workspace --tests--lib: 826 passed--skip mcp_standalone_session_executes_on_the_selected_device, which overflows its stack on main too--lib: 444 passed--lib: 2187 passedAdded 2026-11-18: 09766b39..c58f65e8
150 upstream commits (124 non-merge, 49 of them
apps/zgxonly). Upstream retired the GPUI app (crates/ui, fee8cfa1b), so its interface work is all zgx now.Ported (13):
probedmap an earlier upstream commit had)tool_exchange); e2erecover_stale_journal_settles_chips_in_completed_local_entriesnow drops its journal before the engine opens oneCLAUDE_CODE_DISABLE_TERMINAL_TITLE=1(Zeron's MCP-instructions rewrite not taken)bounded_filereader + model-context hash only (its other readers aren't in Godspeed)Deferred (see UPSTREAM.md "Deferred 2026-11-18"): MCP over HTTP from the engine (c48876c38 chain), idle agent stop chain, warm starts, agents die with their engine (f558b51af, worth a dedicated port), the idle engine / beat grid series, keep running after quit, titles/
first_wordtracing, commands on other devices + Cloud isolation, b0e62255d (keep chats local; no UI), c58f65e8a (iOS toolbar differs), all zgx.Skipped: fee8cfa1b (retires the GPUI app), 8b2f4b02b (landing), 85c1fe2b0 (bump), bc1ecbb3f + 4e86e6bcc (cancel out), mock bench modes 9a6c3d9e3/f0ab203f6, 4b0f499ef/5b5d6a04b (private MCP config file Godspeed doesn't use; listed with the MCP chain).
Tests on this branch (2026-11-18):
cargo build -p godspeedok;cargo check --workspace --testsok; zeron-engine--lib835 passed (skip as before); e2e 31 passed (harness_emitted_input_twin_is_dropped_and_answer_resumesfailed once under load, passed on rerun), always_on_agents 10, telegram_bot 10, launch_agents 2; zeron-harness--lib448 passed; zeron-ui--lib2187 passed.Added 2026-11-20 (c58f65e8..2e3513c6: 24 commits, 20 non-merge)
Ported (1, by hand):
Deferred (see UPSTREAM.md "Deferred 2026-11-20"): d3a76091 (needs the snapshot-delta series), e66369f4 (relay layer), 17d777fa (Grok Auto: needs upstream's Auto access mode), 890c4527 (Antigravity 1.5.0 hardening + provider-switch seam: needs cc7da5c2/2e151ca6; the harness half is worth its own port), 8c5549ec (Cloud), and 8 zgx-only commits.
Skipped: version bumps c7f63a53, 29ec0489, 22eb085c, 5ac8d75a; 81cbda60 (CI); 8fe624f8 (edge config).
Tests (2026-11-20, on bd766ed):
cargo build -p godspeed✓,cargo check --workspace --tests✓, zeron-engine lib 834/835 (home_index::...a_folder_that_never_answers...failed under load and passed alone), e2e 10 ✓, always_on_agents 31 ✓, telegram_bot 10 ✓, zeron-harness lib 448 ✓, zeron-ui lib 2187 ✓, zeron-preview: all suites ✓ (including the discovery integration tests).Added 2026-11-21 (2e3513c6..46f18fe4: 19 commits, 10 non-merge)
Ported (1):
copy-dylibsfeature. ort-sys rc.13 panics on Windows under Cargo 1.100's new build-dir layout, and Godspeed's toolchain isstable, so it hits this too. Godspeed had no directortdependency, so this adds one at the version parakeet-rs already resolves (no lockfile version change), with ort's default features minuscopy-dylibs. parakeet-rs drops its defaults and keepscpu+api-28.cargo treeshows nothing else turns on ort's defaults.Deferred (see UPSTREAM.md "Deferred 2026-11-21"): 21ec6f8b (Antigravity dynamic updates + opt-in Code Mode for Codex/Muse). It edits
warm_start.rs(warm starts are deferred) and builds on 890c4527, so it should be ported together with that. Also 5 zgx-only commits (2c8001a8, 9fb81caa, 3f5381c1, 0dbdf725, 613accb2).Skipped: version bumps b7b1e2d3, 26000a74; 46f18fe4 (Cloud install script, edge).
Tests (2026-11-21, on d617dae):
cargo build -p godspeed✓,cargo check --workspace --tests✓, zeron-engine lib 834/835 (the samehome_index::...a_folder_that_never_answers...load flake; passed 3 of 3 runs alone), e2e + always_on_agents + telegram_bot ✓, zeron-harness lib ✓, zeron-ui lib ✓, zeron-voice 20 ✓.