@standardagents/code 0.13.0 → 0.13.2

package/README.md

@@ -17,14 +17,22 @@
 **A best-in-class terminal coding agent.**
 
 The LLM loop runs remotely on a [Standard Agents](https://github.com/standardagents) instance;
-every filesystem and shell tool executes locally on your machine via this CLI — so the agent
-works in *your* environment, against *your* code, with *your* permissions.
+every filesystem and shell tool executes on your own machine, through that machine's Standard
+Code **daemon** — so the agent works in *your* environment, against *your* code, with *your*
+permissions. The CLI is the terminal you watch and steer it from, and it never executes tools
+itself: a session survives closing the terminal, and any client can attach to it.
 
 ```
 ┌─────────────────────────┐         bridge (WebSocket)          ┌──────────────────────┐
-│ Standard Agents instance│  ── tool_request ──────────────▶    │  Standard Code CLI   │
+│ Standard Agents instance│  ── tool_request ──────────────▶    │ Standard Code daemon │
 │  (the agent's LLM loop)  │  ◀──────────── tool_response ──     │  (your machine)      │
 └─────────────────────────┘                                     └──────────────────────┘
+             │                                                             ▲
+             │  conversation, steering, approvals                          │  same machine,
+             ▼                                                             │  or a VPS
+┌─────────────────────────┐
+│  Standard Code CLI      │  the terminal you watch and steer from
+└─────────────────────────┘
 ```
 
 </div>
@@ -51,8 +59,13 @@ we're letting new folks in every week.
 
 ## Why Standard Code
 
-- **Your machine, your rules.** Tools run on your host — read/write/edit files, list, grep, glob,
-  bash, delete — never in some sandboxed cloud container. The agent edits the same files you do.
+- **Your machine, your rules.** Tools run on your own machines — read/write/edit files, list,
+  grep, glob, bash, delete — never in some sandboxed cloud container. The agent edits the same
+  files you do.
+- **The daemon is the executor.** Every machine that runs sessions installs one
+  (`standardcode daemon install`); the CLI, web console, and macOS app all attach as clients.
+  Work continues on that machine after you close the terminal, and a machine without a daemon
+  still runs the full CLI as a watcher of sessions executing elsewhere.
 - **Permission-aware by design.** A single auto-accept level (1–5) controls what runs unattended;
   anything riskier prompts you first. A catastrophic-command guard blocks dangerous shell calls
   at *every* level, so you can't accidentally `rm -rf` your way into a bad day.
@@ -65,9 +78,10 @@ we're letting new folks in every week.
   transitions, stream and idle execution-bridge heartbeats use Durable Object hibernation
   auto-responses, and transcript safety requests run only while the agent is active. The bridge
   switches to an observable liveness heartbeat only during a forwarded tool or approval, so
-  leaving a terminal attached does not continuously wake an idle thread. A machine daemon keeps
-  one account user stream and opens a per-thread execution bridge only while forwarded work is
-  active.
+  leaving a terminal attached does not continuously wake an idle thread. Each running client owns
+  one account user stream; a machine daemon opens a per-thread execution bridge only while
+  forwarded work is active. Stream transitions update machine presence once. Remote filesystem
+  responses arrive through account events and trigger one response read, with no response loop.
 - **Subagents & research built in.** Delegate focused subtasks to a coding subagent, or spin up a
   non-blocking web-research agent that returns source-backed findings.
 - **MCP, first-class.** The CLI is a Model Context Protocol host — connect local MCP servers
@@ -83,8 +97,11 @@ we're letting new folks in every week.
 
 ## Quick start
 
-Standard Code is a zero-dependency CLI (Node built-ins only). For local development it
-runs through `tsx`; published builds are bundled with `tsup`:
+Standard Code has one exact runtime dependency on its version-matched
+`@standardagents/code-network` package. Both packages use Node built-ins and
+web-platform APIs without third-party runtime dependencies. For local
+development the CLI runs through `tsx`; published builds are bundled with
+`tsup`:
 
 ```bash
 pnpm install        # installs dev dependencies
@@ -120,8 +137,14 @@ environment on the instance — shared by the CLI, web console, and macOS app
 and the CLI itself never sees or stores the OpenAI key. Sama One sessions are
 not limited by the simultaneous-thread lease.
 
-You only do this once per machine. It then offers to **resume** a session tagged for this
-project + machine, or **start a new one**.
+You only do this once per machine. Session start then asks **where the session should run** —
+this machine or any machine whose daemon is online — and offers to **resume** a session for that
+project or **start a new one**.
+
+The first time you choose this machine, the CLI offers to install its daemon in one keypress
+(the same flow as `standardcode daemon install`), because that daemon is what runs sessions
+here. Declining leaves local execution unavailable; remote machines and watching stay available,
+and the command sets it up any time.
 
 Use `--endpoint [url]` or `-e [url]` to point a single CLI run at a different Standard Agents
 instance (local dev, self-hosted). If you omit the URL, the CLI prompts for it. Tokens are
@@ -138,14 +161,16 @@ remembered per endpoint, but this override does not change the saved default end
 
 ## Features
 
-- **Forwarded tools** executed on your host: read/write/edit files, list, grep, glob, bash, delete.
+- **Forwarded tools** executed by the session's machine daemon: read/write/edit files, list,
+  grep, glob, bash, delete.
 - **Permissions**: a single auto-accept level 1–5 (shift-tab cycles it); risky calls prompt;
   a catastrophic-command guard blocks dangerous shell commands at every level.
 - **Durable, resumable** long-running/permission-gated tool calls (park & resume over HTTP).
 - **Background processes** tracked in the thread (survive resume from any machine).
 - **Subagent delegation** and non-blocking web research.
-- **MCP (Model Context Protocol)**: connect local MCP servers — the CLI is the MCP host,
-  negotiating JSON-RPC over stdio. Manage them with `/mcp`; install new ones in natural
+- **MCP (Model Context Protocol)**: connect MCP servers on your machine — the daemon is the MCP
+  host, negotiating JSON-RPC over stdio. Manage the machine's server list with `/mcp` (the daemon
+  connects the enabled ones when it next starts a session there); install new ones in natural
   language ("install the playwright mcp server") and the agent researches + installs them.
 
 ---
@@ -162,13 +187,15 @@ pnpm test           # typecheck + MCP client/protocol + install actuator (no bac
 
 Standard Code is the **client** half of a two-part system. The agent loop and tool definitions
 live on the Standard Agents instance ([agentbuilder](https://github.com/standardagents/agentbuilder));
-this CLI connects to a thread, executes the agent's forwarded tool calls on the host, and renders
-the session.
+this CLI connects to a thread and renders, steers, and approves the session, while the machine
+daemon (`src/daemon.ts`) executes the agent's forwarded tool calls.
 
 See **[`AGENTS.md`](./AGENTS.md)** for the full source map, bridge protocol, MCP internals,
 test layout, and contributor conventions.
 
-- Zero runtime dependencies — Node built-ins only, run via `tsx`. No build step for development.
+- Two version-locked packages: `@standardagents/code` and its shared
+  `@standardagents/code-network` client. Both use Node built-ins and
+  web-platform APIs without third-party runtime packages.
 - `src/progressive-markdown.ts` is the canonical structured streaming parser shared with the web
   and native heads. Run `pnpm markdown:sync` after changing it and `pnpm markdown:check` in CI.
 - The hosted instance's generated `src/session-state.ts` owns live-draft accumulation as well as