@vzlentin/harness 0.2.3 → 0.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 Observable, persistent subagents on [Pi](https://github.com/earendil-works/pi)'s libraries and
 [pi-durable](https://www.npmjs.com/package/@earendil-works/pi-durable). Each subagent is a conversation in a durable
-host process. You can spawn it, check its status, wait for its answer, steer it, and watch it live in a viewer.
+host process. You can spawn it, check its status, wait for its answer, steer it, and talk to it live in Pi.
 
 ## Install
 
@@ -14,9 +14,9 @@ npm install -g @vzlentin/harness
 ```
 
 This works with npm 11 and npm 12. It gives you the `harness` command, and a setup runs `pi install` on the `pi/`
-folder of the package, which adds the `subagent` tool, the `/subagent` command and the subagents widget to Pi. Pi and
-the `harness` command use the same host. npm 12 runs no install script by default, so there the first `harness` command
-does the setup. When `pi` is not on your `PATH`, or the step fails, the setup prints the command to run later:
+folder of the package, which adds the `subagent` tool, the `/subagent` and `/harness` commands and the subagents widget
+to Pi. Pi and the `harness` command use the same host. npm 12 runs no install script by default, so there the first
+`harness` command does the setup. When `pi` is not on your `PATH`, or the step fails, the setup prints the command to run later:
 
 ```sh
 pi install "$(realpath "$(npm root -g)/@vzlentin/harness/pi")"
@@ -39,12 +39,15 @@ harness spawn --name review --prompt "Review the current diff"
 harness list
 harness wait <handle>
 harness send <handle> "Focus on error handling"
-harness attach <handle>     # live viewer
+harness attach <handle>     # open it in Pi
 harness stop <handle>
-harness main                # talk to the agent of the main project
+harness main                # open the agent of the main project in Pi
 ```
 
-[docs/spec.md](docs/spec.md) describes all the commands, the tool, the viewer, projects, the host and its state.
+In Pi, `/harness <project>` opens a session that shows the agent of the project in Pi's own chat, and sends what you
+type to it. Without a project, it asks for one. `pi --harness <project>` starts Pi in such a session.
+
+[docs/spec.md](docs/spec.md) describes all the commands, the tool, the Pi extension, projects, the host and its state.
 
 ## Development
 

package/dist/answer.js

@@ -5,7 +5,7 @@
 import { copyJson } from "@earendil-works/chord";
 import { Type, validateToolArguments } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
-import { Json } from "./protocol.js";
+import { errorMessage, Json } from "./protocol.js";
 /**
  * The user message that asks again for a `respond` call after an answer of a `schema` ask without one. A reminder is
  * known by its exact text, so a user prompt with the same text counts as one.
@@ -49,7 +49,7 @@ export function createAnswers(durable) {
             catch (error) {
                 return {
                     isError: true,
-                    output: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+                    output: [{ type: "text", text: errorMessage(error) }],
                 };
             }
             await api.commit(async (tx) => {

package/dist/cli.js

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { addProject, checkProject, MAIN_PROJECT, projectDir, readProjects } from "./projects.js";
-import { AGENT_HANDLE, statePaths } from "./protocol.js";
-import { setupOnce } from "./setup.js";
+import { request } from "./client.js";
+import { piEnv } from "./herdr.js";
+import { piArgs } from "./mirror.js";
+import { addProject, checkProject, MAIN_PROJECT, projectDir, readProjects, resolveProject } from "./projects.js";
+import { AGENT_HANDLE, errorMessage, statePaths } from "./protocol.js";
+import { setupOnce, userPath } from "./setup.js";
 import { runTool, sendToHost } from "./tool.js";
 function fail(message) {
     throw new Error(message);
@@ -178,25 +182,36 @@ async function hostCommand(args, project) {
     await host.closed;
     process.exit(0);
 }
-/** Opens the viewer of a child in this terminal. */
+/** Opens a child in Pi in this terminal. */
 async function attachCommand(args) {
     const [handle] = args;
     if (args.length !== 1 || handle === undefined)
         usage();
-    await openViewer(handle);
+    await openInPi({ project: resolveProject(process.env, process.cwd()), handle });
 }
-/** Opens the viewer of the agent of the project `name`, which is `main` or a project, in this terminal. */
+/** Opens the agent of the project `name`, which is `main` or a project, in Pi in this terminal. */
 async function agentCommand(name, project) {
     if (project !== undefined)
         fail(`harness ${name} takes no --project`);
-    // The viewer's connection resolves the project from the env.
-    process.env.HARNESS_PROJECT = name;
-    await openViewer(AGENT_HANDLE);
+    await openInPi({ project: name, handle: AGENT_HANDLE });
 }
-async function openViewer(handle) {
-    const { ProcessTerminal } = await import("@earendil-works/pi-tui");
-    const { attach } = await import("./viewer.js");
-    process.exitCode = await attach(handle, { terminal: new ProcessTerminal(), env: process.env });
+/**
+ * Runs Pi in this terminal with a mirror session of `target` (see the Pi extension), and exits with its code. It starts
+ * the host when none runs. A first watch fails before Pi starts for an unknown child and for a project agent without a
+ * model.
+ */
+async function openInPi(target) {
+    await request({ type: "watch", handle: target.handle }, { start: true, project: target.project });
+    const result = spawnSync("pi", piArgs(target), {
+        stdio: "inherit",
+        env: { ...piEnv(process.env), PATH: userPath() },
+    });
+    if (result.error !== undefined && "code" in result.error && result.error.code === "ENOENT") {
+        fail("pi is not on PATH. Install Pi to open the agent");
+    }
+    if (result.error !== undefined)
+        throw result.error;
+    process.exitCode = result.status ?? 1;
 }
 /**
  * Runs a command as a call of the `subagent` tool. The caller is `PI_SESSION_ID`, or `cli` outside Pi, and the defaults
@@ -246,6 +261,6 @@ async function main() {
     process.stdout.write(text);
 }
 main().catch((cause) => {
-    process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+    process.stderr.write(`${errorMessage(cause)}\n`);
     process.exitCode = 1;
 });

package/dist/client.d.ts

@@ -11,6 +11,8 @@ export declare class Client {
     /** The project of the host. `connect` sets it. */
     project: string;
     constructor(socket: Socket);
+    /** Whether the connection closed. A request that failed then may have reached the host or not. */
+    get ended(): boolean;
     request<T extends Request["type"]>(request: Extract<Request, {
         type: T;
     }>): Promise<Replies[T]>;
@@ -26,14 +28,16 @@ export declare class Client {
     abort(cause: unknown): void;
 }
 /**
- * A connection to the host of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`), after its `hello`.
- * When no host listens and `start` is true, it starts one, detached, with its output in `host.log`, and tries to
- * connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
+ * A connection to the host of `project`, or of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`),
+ * after its `hello`. When no host listens and `start` is true, it starts one, detached, with its output in `host.log`,
+ * and tries to connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
  */
 export declare function connect(options: ConnectOptions): Promise<Client | undefined>;
 type ConnectOptions = {
     readonly start: boolean;
     readonly signal?: AbortSignal | undefined;
+    /** `main` or a project name. Without it, the project comes from `HARNESS_PROJECT` and the cwd. */
+    readonly project?: string;
 };
 type OneShot<T extends Request["type"]> = Extract<Request, {
     type: T;

package/dist/client.js

@@ -4,7 +4,7 @@ import { createConnection } from "node:net";
 import { Readable } from "node:stream";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { MAIN_PROJECT, resolveProject } from "./projects.js";
+import { checkProject, MAIN_PROJECT, resolveProject } from "./projects.js";
 import { cliPath, onLines, PROTOCOL_VERSION, statePaths, } from "./protocol.js";
 const START_TIMEOUT_MS = 10_000;
 /** A line from the host: a reply, or an event of the watch. The value of a reply and the event are not checked here. */
@@ -50,6 +50,10 @@ export class Client {
         socket.on("error", () => this.#end());
         socket.on("close", () => this.#end());
     }
+    /** Whether the connection closed. A request that failed then may have reached the host or not. */
+    get ended() {
+        return this.#ended;
+    }
     request(request) {
         if (this.#ended)
             return Promise.reject(new Error("The harness host closed the connection"));
@@ -87,12 +91,12 @@ export class Client {
     }
 }
 /**
- * A connection to the host of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`), after its `hello`.
- * When no host listens and `start` is true, it starts one, detached, with its output in `host.log`, and tries to
- * connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
+ * A connection to the host of `project`, or of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`),
+ * after its `hello`. When no host listens and `start` is true, it starts one, detached, with its output in `host.log`,
+ * and tries to connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
  */
 export async function connect(options) {
-    const project = resolveProject(process.env, process.cwd());
+    const project = options.project === undefined ? resolveProject(process.env, process.cwd()) : checkProject(options.project);
     const paths = statePaths(project);
     let socket = await tryConnect(paths.socket);
     if (socket === undefined) {

package/dist/context.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { createFindTool, createGrepTool, createLsTool, DefaultPackageManager, formatSkillsForPrompt, getAgentDir, loadProjectContextFiles, loadSkills, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { defineExtension, defineTool, section, } from "@earendil-works/pi-durable";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@earendil-works/pi-durable/tools";
+import { errorMessage } from "./protocol.js";
 import { savedTrust } from "./trust.js";
 /** A Pi coding agent tool as a durable tool that runs in the calling conversation's directory. */
 function piTool(create) {
@@ -45,7 +46,7 @@ async function resourcesOf(cwd) {
         return await found;
     }
     catch (error) {
-        process.stderr.write(`warning: ${cwd}: ${error instanceof Error ? error.message : String(error)}; no project instructions or skills\n`);
+        process.stderr.write(`warning: ${cwd}: ${errorMessage(error)}; no project instructions or skills\n`);
         return { context: [], skills: [] };
     }
 }

package/dist/herdr.d.ts

@@ -1,38 +1,26 @@
+import { type MirrorTarget } from "./mirror.ts";
 import { type ChildInfo } from "./protocol.ts";
-export type ViewerTarget = {
-    title(child: ChildInfo): string;
-    project: string[];
-    resume: string[];
-};
 export type AgentReporter = {
     report(busy: boolean): void;
     release(): Promise<void>;
 };
-/**
- * How the viewer of `handle` on `project` shows and resumes it: the title of its child, the `--project` words, and the
- * words after them that open it again. The project agent is `harness <project>`, with no `--project`; a child is
- * `harness --project <project> attach <handle>`.
- */
-export declare function viewerTarget(handle: string, project: string): ViewerTarget;
-/**
- * The words of the command that runs the viewer of `handle`, with this Node and this package's CLI, so it does not
- * need the CLI on PATH. Herdr wants a plain command name as the first word of a resume command, so it starts with
- * `env`.
- */
-export declare function viewerCommand(handle: string, project: string): string[];
+/** Whether this process runs in a Herdr pane, also as the Pi that the CLI starts there. */
+export declare function inHerdr(env: NodeJS.ProcessEnv): boolean;
+/** The environment of the Pi that the CLI starts: in a Herdr pane, `HARNESS_HERDR_PANE` in place of `HERDR_ENV`. */
+export declare function piEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /**
  * Runs `herdr` with `args` and gives its output. When `herdr` fails, it rejects with the stderr of `herdr`, or with the
  * error of `execFile` when stderr is empty.
  */
 export declare function herdr(args: readonly string[], env: NodeJS.ProcessEnv): Promise<string>;
 /**
- * Opens a Herdr tab that runs the viewer of `child`, on the project of `env` and this process's cwd. It rejects when a
+ * Opens a Herdr tab that opens `child` in Pi, on the project of `env` and this process's cwd. It rejects when a
  * `herdr` call fails or gives no pane ID.
  */
-export declare function openViewerTab(child: ChildInfo, env: NodeJS.ProcessEnv): Promise<void>;
+export declare function openChildTab(child: ChildInfo, env: NodeJS.ProcessEnv): Promise<void>;
 /**
- * Reports the state of the agent `label` to the Herdr pane of this process, with the viewer of `handle` on `project` as
- * the resume command. Both methods do nothing outside Herdr.
- * The calls run one after another, so `--seq` reaches Herdr in order.
+ * Reports the state of the agent `label` to the Herdr pane of `HARNESS_HERDR_PANE`, with the command that opens
+ * `target` as the resume command. Both methods do nothing without that variable, so only a Pi that the CLI
+ * started in a Herdr pane reports. The calls run one after another, so `--seq` reaches Herdr in order.
  */
-export declare function agentReporter(env: NodeJS.ProcessEnv, label: string, handle: string, project: string): AgentReporter;
+export declare function agentReporter(env: NodeJS.ProcessEnv, label: string, target: MirrorTarget): AgentReporter;

package/dist/herdr.js

@@ -1,31 +1,33 @@
 import { execFile } from "node:child_process";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
+import { harnessArgs } from "./mirror.js";
 import { resolveProject } from "./projects.js";
-import { AGENT_HANDLE, childLabel, cliPath, runDisplayName } from "./protocol.js";
+import { childLabel, cliPath } from "./protocol.js";
 const HERDR_SOURCE = "custom:harness";
+/**
+ * The variable that gives the Herdr pane to the Pi that the CLI starts there, in place of `HERDR_ENV`. Without
+ * `HERDR_ENV`, Herdr's own Pi integration does not report, so the pane shows the state of the mirrored agent, which the
+ * extension reports, and not the state of Pi's own agent, which does not run.
+ */
+const PANE_VARIABLE = "HARNESS_HERDR_PANE";
 /** The part of the output of `herdr tab create` that has the pane of the tab. */
 const TabCreated = Type.Object({ result: Type.Object({ root_pane: Type.Object({ pane_id: Type.String() }) }) });
 /**
- * How the viewer of `handle` on `project` shows and resumes it: the title of its child, the `--project` words, and the
- * words after them that open it again. The project agent is `harness <project>`, with no `--project`; a child is
- * `harness --project <project> attach <handle>`.
+ * The words of the command that opens `target` in Pi, with this Node and this package's CLI, so it does not need the
+ * CLI on PATH. Herdr wants a plain command name as the first word of a resume command, so it starts with `env`.
  */
-export function viewerTarget(handle, project) {
-    // The agent's name already says what it is; a child's shows its handle too.
-    if (handle === AGENT_HANDLE)
-        return { title: childLabel, project: [], resume: [project] };
-    return { title: runDisplayName, project: ["--project", project], resume: ["attach", handle] };
+function openCommand(target) {
+    return ["env", process.execPath, cliPath(), ...harnessArgs(target)];
 }
-/**
- * The words of the command that runs the viewer of `handle`, with this Node and this package's CLI, so it does not
- * need the CLI on PATH. Herdr wants a plain command name as the first word of a resume command, so it starts with
- * `env`.
- */
-export function viewerCommand(handle, project) {
-    const cli = cliPath();
-    const target = viewerTarget(handle, project);
-    return ["env", process.execPath, cli, ...target.project, ...target.resume];
+/** Whether this process runs in a Herdr pane, also as the Pi that the CLI starts there. */
+export function inHerdr(env) {
+    return Boolean(env.HERDR_ENV || env[PANE_VARIABLE]);
+}
+/** The environment of the Pi that the CLI starts: in a Herdr pane, `HARNESS_HERDR_PANE` in place of `HERDR_ENV`. */
+export function piEnv(env) {
+    const { HERDR_ENV, ...rest } = env;
+    return HERDR_ENV && env.HERDR_PANE_ID ? { ...rest, [PANE_VARIABLE]: env.HERDR_PANE_ID } : env;
 }
 /**
  * Runs `herdr` with `args` and gives its output. When `herdr` fails, it rejects with the stderr of `herdr`, or with the
@@ -42,10 +44,10 @@ export function herdr(args, env) {
     });
 }
 /**
- * Opens a Herdr tab that runs the viewer of `child`, on the project of `env` and this process's cwd. It rejects when a
+ * Opens a Herdr tab that opens `child` in Pi, on the project of `env` and this process's cwd. It rejects when a
  * `herdr` call fails or gives no pane ID.
  */
-export async function openViewerTab(child, env) {
+export async function openChildTab(child, env) {
     const project = resolveProject(env, process.cwd());
     // The tab must find the same host and projects as `statePaths()` in protocol.ts and `projectsPath()` in projects.ts.
     const state = env.XDG_STATE_HOME;
@@ -71,19 +73,19 @@ export async function openViewerTab(child, env) {
     if (!Value.Check(TabCreated, output))
         throw new Error(`herdr tab create gave no pane ID: ${created.trim()}`);
     const pane = output.result.root_pane.pane_id;
-    const viewer = viewerCommand(child.handle, project)
+    const command = openCommand({ project, handle: child.handle })
         .map((word) => `'${word.replaceAll("'", "'\\''")}'`)
         .join(" ");
-    await herdr(["pane", "run", pane, viewer], env);
+    await herdr(["pane", "run", pane, command], env);
 }
 /**
- * Reports the state of the agent `label` to the Herdr pane of this process, with the viewer of `handle` on `project` as
- * the resume command. Both methods do nothing outside Herdr.
- * The calls run one after another, so `--seq` reaches Herdr in order.
+ * Reports the state of the agent `label` to the Herdr pane of `HARNESS_HERDR_PANE`, with the command that opens
+ * `target` as the resume command. Both methods do nothing without that variable, so only a Pi that the CLI
+ * started in a Herdr pane reports. The calls run one after another, so `--seq` reaches Herdr in order.
  */
-export function agentReporter(env, label, handle, project) {
-    const pane = env.HERDR_ENV ? env.HERDR_PANE_ID : undefined;
-    const resume = pane === undefined ? [] : ["--", ...viewerCommand(handle, project)];
+export function agentReporter(env, label, target) {
+    const pane = env[PANE_VARIABLE] || undefined;
+    const resume = pane === undefined ? [] : ["--", ...openCommand(target)];
     let calls = Promise.resolve();
     let seq = 0;
     let reported;

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { type Models } from "@earendil-works/pi-ai/models";
+import type { Models } from "@earendil-works/pi-ai/models";
 export type Host = {
     /** Resolves once the host has closed, by `close()`, the idle exit, or a store failure. */
     readonly closed: Promise<void>;

package/dist/host.js

@@ -1,35 +1,27 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { randomBytes } from "node:crypto";
 import { once } from "node:events";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { mkdirSync, rmSync } from "node:fs";
 import { createServer } from "node:net";
-import { join, resolve as resolvePath, sep } from "node:path";
+import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { pathToFileURL } from "node:url";
 import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
 import * as ai from "@earendil-works/pi-ai";
-import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/models";
-import { createEventBus, DefaultPackageManager, getAgentDir, ProjectTrustStore, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+import { getAgentDir, ProjectTrustStore, SettingsManager } from "@earendil-works/pi-coding-agent";
 import * as durable from "@earendil-works/pi-durable";
 import { AgentDoc, createRegistry, defineDoc, Harness, } from "@earendil-works/pi-durable";
+import { createCodemodeExtension } from "@earendil-works/pi-durable/codemode";
 import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { createChildren, resolveModel, } from "./children.js";
 import { ChildContext } from "./context.js";
-import { readEntries } from "./entries.js";
-import { AGENT_HANDLE, onLines, PROTOCOL_VERSION, RequestLine, } from "./protocol.js";
+import { loadEntries } from "./load-entries.js";
+import { AGENT_HANDLE, errorMessage, onLines, PROTOCOL_VERSION, RequestLine, } from "./protocol.js";
 import { abortTask, startableTasks, startTask, taskInfo, waitTask } from "./tasks.js";
 import { subagentTool } from "./tool.js";
+import { viewChange } from "./view-change.js";
 /** The host exits after this long with no connection, no live task and no request. */
 const IDLE_EXIT_MS = 5 * 60_000;
 const IDLE_CHECK_MS = 60_000;
@@ -74,7 +66,7 @@ export async function runHost(options) {
     const settings = SettingsManager.create(stateDir, agentDir, {
         projectTrusted: new ProjectTrustStore(agentDir).get(stateDir) === true,
     });
-    const warn = (cause) => process.stderr.write(`warning: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+    const warn = (cause) => process.stderr.write(`warning: ${errorMessage(cause)}\n`);
     // The store is there once the harness is open; entries get `place` before, and use the store in their tasks.
     let harness;
     const place = {
@@ -88,7 +80,7 @@ export async function runHost(options) {
             return registry.snapshot();
         },
     };
-    const entries = await loadEntries(stateDir, agentDir, settings, place, warn).catch((cause) => {
+    const entries = await loadEntries(stateDir, agentDir, settings, place, library, warn).catch((cause) => {
         lock.close();
         throw cause;
     });
@@ -107,7 +99,9 @@ export async function runHost(options) {
         caller: async (api) => String(api.conversationId),
         send: (request, signal) => handleRequest(request, { ...base, signal }),
     });
-    const selected = [ChildContext, tool, ...entries.extensions];
+    // Each script runs in a worker thread, in a VM of at most 256 MB, as in Pi.
+    const sandbox = new CodemodeSandbox({ memoryLimitBytes: 256 * 1024 * 1024 });
+    const selected = [ChildContext, tool, createCodemodeExtension({ sandbox }), ...entries.extensions];
     try {
         for (const extension of selected)
             registry.install(extension);
@@ -148,7 +142,7 @@ export async function runHost(options) {
         }
         catch (error) {
             await harness.close(context);
-            const message = error instanceof Error ? error.message : String(error);
+            const message = errorMessage(error);
             if (!message.includes("(subagent.children) requires migration from version"))
                 throw error;
             throw new Error(`${join(stateDir, "durable.sqlite")} was written by an older pi-subagent (${message}). Stop the host, remove the file and run the command again.`);
@@ -188,7 +182,7 @@ export async function runHost(options) {
                     };
                 }
                 catch (error) {
-                    reply = { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    reply = { ok: false, error: errorMessage(error) };
                 }
                 if (socket.writable)
                     socket.write(`${JSON.stringify(reply)}\n`);
@@ -210,6 +204,7 @@ export async function runHost(options) {
         });
     }).catch(async (cause) => {
         await entries.close();
+        await sandbox.close();
         await harness.close(context);
         lock.close();
         throw cause;
@@ -224,8 +219,10 @@ export async function runHost(options) {
             for (const abort of aborts)
                 abort.abort();
             try {
-                // Entries close first: an entry may still need the open harness.
+                // Entries close first: an entry may still need the open harness. The sandbox closes before the harness, so a
+                // script that runs gets no outcome and continues after a restart.
                 await entries.close();
+                await sandbox.close();
                 await harness.close(context);
                 for (const env of envs.values())
                     await env.cleanup(context);
@@ -279,8 +276,6 @@ async function handleRequest(request, handler) {
             return abortChild(request, handler);
         case "configure":
             return configureChild(request, handler);
-        case "models":
-            return modelInfos(handler.place.models);
         case "watch":
             if (handler.connection === undefined)
                 throw new Error("A watch needs a connection");
@@ -452,7 +447,7 @@ async function waitChild(request, handler) {
 /**
  * The requests of `sent` from `read` on that a wait for `main` gives before the answer to `main`, and the new `read`.
  * When `main` is a request of the caller, they are the ones before it, and `main` counts as read; a send after it
- * stays unread. Otherwise, such as for viewer input, they are the caller's requests known when the wait started.
+ * stays unread. Otherwise, such as for the input of a mirror session, they are the caller's requests known when the wait started.
  */
 function unreadBefore(sent, read, main, atStart) {
     const index = main === null ? -1 : sent.indexOf(main);
@@ -532,15 +527,6 @@ async function childTarget(handler, handle, record) {
         record,
     };
 }
-async function modelInfos(models) {
-    return (await models.getAvailable()).map((model) => ({
-        provider: model.provider,
-        id: model.id,
-        name: model.name,
-        contextWindow: model.contextWindow,
-        thinkingLevels: getSupportedThinkingLevels(model),
-    }));
-}
 async function childRecord(harness, handle) {
     const state = await harness.snapshot(Children, context);
     const record = recordOf(state, handle);
@@ -619,10 +605,10 @@ async function setUpAgent(root, models, settings, project, cwd) {
 }
 /**
  * Opens a watch of `handle` on `connection` and returns the reply, with the view and the child. After the reply, each
- * commit to the child's conversation and each rename gives one `{ event: WatchLine }` line. It waits for a slow socket
- * to drain, so pi-durable replaces the frames it holds back with one frame of the whole view. The watches stop when the
- * socket closes, when setup fails, or when the connection ends; a wait for `drain` then stays on the closed socket and
- * goes with it. When the child stops, the viewer gets a `stopped` event and the connection ends; when the conversation
+ * commit to the child's conversation gives one `{ event: WatchLine }` line with its change, and each rename one with
+ * an empty change. It waits for a slow socket to drain, so pi-durable replaces the frames it holds back with one frame
+ * of the whole view. The watches stop when the socket closes, when setup fails, or when the connection ends; a wait for
+ * `drain` then stays on the closed socket and goes with it. When the child stops, the client gets a `stopped` event and the connection ends; when the conversation
  * watch ends for another reason, the connection ends.
  */
 async function serveWatch(handler, handle, connection) {
@@ -668,14 +654,14 @@ async function serveWatch(handler, handle, connection) {
         // pi-durable runs the callbacks of one watch in order, but not those of two watches. Both watches write through
         // this one chain, so a line never has older info than the line before it.
         let queue = Promise.resolve();
-        const send = (ops) => {
+        const send = (change) => {
             queue = queue.then(async () => {
                 // Some store reads per commit; cache the agent fields if streaming gets slow. A store failure drops this
                 // line. A stopped child still gives `idle` here, and its `stopped` line follows.
                 const child = await found.info().catch(() => undefined);
                 if (child === undefined || !socket.writable)
                     return;
-                if (!write({ ops, child }))
+                if (!write({ change, child }))
                     await once(socket, "drain").catch(() => { });
             });
             return queue;
@@ -690,10 +676,10 @@ async function serveWatch(handler, handle, connection) {
             }
             else if (next.name !== found.record?.name) {
                 found = { ...found, record: next, info: () => childInfo(handler, handle, next) };
-                await send([]);
+                await send({});
             }
         });
-        conversation.start((_view, ops) => send(ops));
+        conversation.start((view, ops) => send(viewChange(view, ops)));
     });
     return { view: conversation.value, child: last };
 }
@@ -756,72 +742,3 @@ function liveTasks(tasks) {
     }
     return tasks.length - dead.size;
 }
-/** A `package.json`, which is a JSON object. */
-const PackageJson = Type.Object({});
-/** The part of a package's `package.json` that names its entries. */
-const Manifest = Type.Object({
-    piDurable: Type.Optional(Type.Object({ extensions: Type.Optional(Type.Array(Type.String())) })),
-});
-/**
- * The `piDurable` entries of the installed packages in Pi's `settingsManager` for `cwd`, then the entries of
- * `entries.json` (see `readEntries`), in one shared event bus, as one entry whose `close()` closes each of them and
- * passes its errors to `warn`. When an entry fails to load, the entries loaded before it close. Missing packages are
- * skipped, not installed, and so is an entry module that does not exist, such as one of an uninstalled package.
- */
-async function loadEntries(cwd, agentDir, settingsManager, place, warn) {
-    const modules = new Set();
-    const roots = new DefaultPackageManager({ cwd, agentDir, settingsManager })
-        .listConfiguredPackages()
-        .flatMap((found) => found.installedPath ?? []);
-    for (const root of new Set(roots)) {
-        const path = join(root, "package.json");
-        const manifest = JSON.parse(await readFile(path, "utf8").catch(() => "{}"));
-        if (!Value.Check(PackageJson, manifest)) {
-            warn(new Error(`${path} is not a valid package.json`));
-            continue;
-        }
-        if (!Value.Check(Manifest, manifest)) {
-            warn(new Error(`${path} has an invalid piDurable field`));
-            continue;
-        }
-        for (const path of manifest.piDurable?.extensions ?? [])
-            modules.add(resolvePath(root, path));
-    }
-    for (const module of Object.values(readEntries()))
-        if (existsSync(module))
-            modules.add(module);
-    const events = createEventBus();
-    const entries = [];
-    const close = async () => {
-        for (const result of await Promise.allSettled(entries.map((entry) => entry.close()))) {
-            if (result.status === "rejected")
-                warn(result.reason);
-        }
-    };
-    try {
-        for (const module of modules) {
-            const entry = await importEntry(module);
-            entries.push(await entry.default({ durable, ai, events, children: library, place }));
-        }
-    }
-    catch (error) {
-        await close();
-        throw error;
-    }
-    return {
-        extensions: entries.flatMap((entry) => entry.extensions),
-        tasks: entries.flatMap((entry) => entry.tasks ?? []),
-        close,
-    };
-}
-/**
- * Imports the entry `module`. Node does not strip types under `node_modules`, where Pi installs npm packages, so jiti
- * loads a TypeScript entry there.
- */
-async function importEntry(module) {
-    if (module.endsWith(".ts") && module.split(sep).includes("node_modules")) {
-        const { createJiti } = await import("jiti");
-        return createJiti(import.meta.url).import(module);
-    }
-    return import(__rewriteRelativeImportExtension(pathToFileURL(module).href));
-}