Setting the API key every Cloud machine uses refuses a plugin preview
(agents.rs), but the action was missing from BLOCKED, so the refusal never
fired and every_action_the_code_refuses_is_blocked failed on main.
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>
2026-11-15 04:58:06 +00:00
35 changed files with 2898 additions and 507 deletions