Skip to content

Sync with Zeron through 46f18fe4 - #111

Open
ShriD5 wants to merge 38 commits into
mainfrom
upstream-sync/2026-11-17
Open

ShriD5 wants to merge 38 commits into
mainfrom
upstream-sync/2026-11-17

Conversation

@ShriD5

@ShriD5 ShriD5 commented Nov 17, 2026 •

Copy link
Copy Markdown
Owner

Ports Zeron commits from 7437e3e9 through 09766b39. That range has 888 commits (627 non-merge, 333 of them apps/zgx only). 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 in docs/godspeed/UPSTREAM.md (Deferred 2026-11-17).

Ported (20)

  • b4aa53fc keep a rejection's reason from a racing drain
  • 52e49c6c queue files sent with no words while a turn runs (zgx UI parts dropped)
  • 77940184 commit the first streamed change after a pause at once
  • a21a52bd never open a chat without an id
  • 728551c5 WatchChats/Sessions/Devices send changes to clients that opt in ({"changes": true}); older clients still get the whole list
  • 75fbbbb6 a long reply's changed parts travel alone to a viewport that asks (partPatches); test drops the deferred a2113ac8 Tool fields
  • 4089747b use discovered names for configured Claude Code models
  • 40e79949 a terminal's writes reach it in the order they were sent
  • d071ed2d a message from another chat never stops the running command
  • d44bbc30, 2e0147e0, 2718721e, 0f5bf22b Windows terminals: PowerShell first, -NoLogo, Ctrl+C, a consistent name
  • 6ab00cf5 + dee83c38 a send issued before the running turn started is its own turn (without the provider-switch hold, which needs cc7da5c2)
  • 2b2c1e8d, e8124841 show_visual: hover doesn't move the page
  • 50ba9b78 the Claude 200K context window choice really limits the window (CLAUDE_CODE_DISABLE_1M_CONTEXT); the long-context rows now default to 1M; test rewritten for Godspeed's harness
  • ac1700f2 an attachment reaches the agent by its path on the device that runs it (upstream's update-status test hunks dropped; Godspeed doesn't have those tests)

Needs a look

  • c1168b6b dropped: it picked cleanly, but its own perf test still saw a send in a 3,000-entry chat wait 195 ms (vs 17 ms in a new chat). It needs the deferred read-cache series to help.
  • Deferred standalone features worth dedicated ports: 9290078c (deleting a chat ends its run), 61d91d37 (libproc preview scan), the device_stats MCP tool, tool result images, model picker provider names, provider accounts, upstream's Auto access mode.

Skipped

  • Version bumps
  • Edge-only, CI and release scripts
  • Relay design docs
  • 0f9a7500: Godspeed has no crates/cli
  • 2252f736: it fixes a codex account_id check Godspeed doesn't have
  • 749ed748: a test for upstream's generic TranscriptFrame::reset
  • 58236762: Linux release LTO
  • d0c77e9c, 7cf2ba66

Tests

All of these pass:

  • cargo build -p godspeed
  • cargo check --workspace --tests
  • zeron-engine --lib: 826 passed
  • zeron-engine e2e, always_on_agents, telegram_bot, message_queue, queue_attachments, restart_resume
  • zeron-engine device_routing, run with --skip mcp_standalone_session_executes_on_the_selected_device, which overflows its stack on main too
  • zeron-harness --lib: 444 passed
  • zeron-ui --lib: 2187 passed
  • zeron-doc, zeron-visual, zeron-mcp

Added 2026-11-18: 09766b39..c58f65e8

150 upstream commits (124 non-merge, 49 of them apps/zgx only). Upstream retired the GPUI app (crates/ui, fee8cfa1b), so its interface work is all zgx now.

Ported (13):

  • 45b79a8f1 connectivity monitor looks every 5 s once nothing changes
  • 98924b823 relay presence probes back off for long-gone devices (added the probed map an earlier upstream commit had)
  • f1ecad286 home search: a bounded walk whose idle workers sleep
  • 445f70a00 home search: no privacy prompt for opening New project (without the packed-index case test)
  • 1d82a5c16 home search bench macOS only
  • 6191678a6 launch-over-parked-chats tests (without the cut-off-turn test: Godspeed doesn't revive a turn cut off by a graceful shutdown)
  • fafbf7435 + 039e10c22 the source-context stamp runs beside the dispatch, on its own task (kept Godspeed's instance/worktree/env prelude)
  • e51676b29 + 73ed0423b run journal writes in batches (without the deferred tool_exchange); e2e recover_stale_journal_settles_chips_in_completed_local_entries now drops its journal before the engine opens one
  • c19d45922 no presence beat for a local profile (by hand)
  • f38065825 harness half only: CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1 (Zeron's MCP-instructions rewrite not taken)
  • 8815fb235 bounded_file reader + 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_word tracing, 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 godspeed ok; cargo check --workspace --tests ok; zeron-engine --lib 835 passed (skip as before); e2e 31 passed (harness_emitted_input_twin_is_dropped_and_answer_resumes failed once under load, passed on rerun), always_on_agents 10, telegram_bot 10, launch_agents 2; zeron-harness --lib 448 passed; zeron-ui --lib 2187 passed.

Added 2026-11-20 (c58f65e8..2e3513c6: 24 commits, 20 non-merge)

Ported (1, by hand):

  • bc14b5b1 preview discovery leaves test servers alone. A listener is probed only after it has stayed up 3 s, and listeners from test runs are never probed (the runner itself or any ancestor up to the engine's children: cargo test, nextest, vitest, jest, pytest, go test, and so on). Godspeed's discovery matches servers to projects by working directory, so the ancestor check runs over the process table each scan already collects. Upstream's "environment read empty" half is for its origin-marker cache, which Godspeed doesn't have, so it isn't ported.

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):

  • 865308ff voice: leave out ort's copy-dylibs feature. ort-sys rc.13 panics on Windows under Cargo 1.100's new build-dir layout, and Godspeed's toolchain is stable, so it hits this too. Godspeed had no direct ort dependency, so this adds one at the version parakeet-rs already resolves (no lockfile version change), with ort's default features minus copy-dylibs. parakeet-rs drops its defaults and keeps cpu + api-28. cargo tree shows 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 same home_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 ✓.

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
@ShriD5 ShriD5 changed the title Sync with Zeron through 09766b39 Sync with Zeron through c58f65e8 Nov 18, 2026
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
@ShriD5 ShriD5 changed the title Sync with Zeron through c58f65e8 Sync with Zeron through 2e3513c6 Nov 20, 2026
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
@ShriD5 ShriD5 changed the title Sync with Zeron through 2e3513c6 Sync with Zeron through 46f18fe4 Nov 21, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant