@herdingchats/friday 0.1.651 → 0.1.660

package/herd.mjs

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_HERD_PACKAGE_default;
 var init_define_HERD_PACKAGE = __esm({
   "<define:HERD_PACKAGE>"() {
-    define_HERD_PACKAGE_default = { version: "0.1.651", gitHead: "60dd42f8309cea2c6700c788c92ef3732e1d517c" };
+    define_HERD_PACKAGE_default = { version: "0.1.660", gitHead: "21101252ff98a4dc317139a36c286b347f5f5933" };
   }
 });
 
@@ -3208,10 +3208,10 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 // src/friday/main.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { dirname as dirname10, join as join16 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { z as z22 } from "zod";
 
@@ -3414,7 +3414,7 @@ var HERD_FLAGS = {
   login: [],
   logout: [],
   daemon: ["--repo"],
-  attach: [],
+  attach: ["--watch"],
   builds: [],
   inbox: [],
   send: ["--json"],
@@ -4519,15 +4519,15 @@ async function readSetup(fetch2, init) {
 // src/friday/agents.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
 
 // src/activation.ts
 init_define_HERD_PACKAGE();
 init_src();
 import { randomBytes as randomBytes4, randomUUID as randomUUID3 } from "node:crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
 import { z as z21 } from "zod";
 
 // src/permissions.ts
@@ -4930,6 +4930,243 @@ async function permissionHook(raw, options = {}) {
   }
 }
 
+// src/terminals.ts
+init_define_HERD_PACKAGE();
+import { spawn as spawn4 } from "node:child_process";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync3, rmSync as rmSync5 } from "node:fs";
+import { connect as connect2 } from "node:net";
+import { join as join7 } from "node:path";
+init_self();
+import {
+  HOST_PROTOCOL,
+  hostVersion
+} from "./terminal-host.mjs";
+var hostsDir = () => join7(herdHome(), "terminals");
+var legacyHostSocketPath = () => join7(herdHome(), "terminals.sock");
+var currentHostSocketPath = (version = hostVersion()) => join7(hostsDir(), `${version}.sock`);
+var speaksProtocol = (protocol) => protocol === HOST_PROTOCOL || protocol === HOST_PROTOCOL - 1;
+var sleep = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+function askHost(path, request) {
+  return new Promise((resolve8, reject) => {
+    const socket = connect2(path);
+    let data = "";
+    socket.on("connect", () => socket.write(`${JSON.stringify(request)}
+`));
+    socket.on("data", (chunk) => data += chunk);
+    socket.on("end", () => {
+      try {
+        const reply = JSON.parse(data);
+        if (reply.ok) resolve8(reply);
+        else reject(new HerdError(reply.error ?? "The terminal host refused that."));
+      } catch {
+        reject(new HerdError("The terminal host's answer wasn't readable."));
+      }
+    });
+    socket.on("error", reject);
+  });
+}
+var isDead = (error) => {
+  const code = error?.code;
+  return code === "ECONNREFUSED" || code === "ENOENT";
+};
+var HostTerminals = class {
+  hosts = [];
+  /** Which host each terminal name was last found in. */
+  where = /* @__PURE__ */ new Map();
+  version;
+  log;
+  constructor(options = {}) {
+    this.version = options.version ?? hostVersion();
+    this.log = options.log ?? (() => {
+    });
+  }
+  currentVersion() {
+    return this.version;
+  }
+  unreachable(version) {
+    return this.hosts.some((host) => host.hello.version === version && !host.speaks);
+  }
+  /** Every host that answers, with sockets nothing answers on removed. */
+  async discover() {
+    const dir = hostsDir();
+    let names = [];
+    try {
+      names = readdirSync3(dir).filter((name) => name.endsWith(".sock"));
+    } catch {
+    }
+    const paths = [legacyHostSocketPath(), ...names.map((name) => join7(dir, name))];
+    const found = [];
+    for (const path of paths) {
+      try {
+        const hello = await askHost(path, { op: "hello" });
+        found.push({
+          path,
+          hello,
+          current: hello.version === this.version && speaksProtocol(hello.protocol),
+          speaks: speaksProtocol(hello.protocol)
+        });
+      } catch (error) {
+        if (isDead(error) && path !== legacyHostSocketPath()) rmSync5(path, { force: true });
+      }
+    }
+    this.hosts = found;
+    return found;
+  }
+  current() {
+    return this.hosts.find((host) => host.current);
+  }
+  /** Starts a host of the daemon's own version if none is running, detached so it outlives it. */
+  async ensureHost() {
+    const hosts = await this.discover();
+    for (const host of hosts) {
+      const version = host.hello.version ?? "unversioned";
+      const role = host.current ? "current" : host.speaks ? "older" : "not driveable";
+      this.log(
+        `Terminal host ${version} (protocol ${host.hello.protocol}, pid ${host.hello.pid}): ${role}.`
+      );
+    }
+    if (this.current()) return;
+    const path = currentHostSocketPath(this.version);
+    mkdirSync5(hostsDir(), { recursive: true, mode: 448 });
+    const child = spawn4(process.execPath, [herdBin, "terminal-host", "--socket", path], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, HERD_HOME: herdHome() }
+    });
+    child.unref();
+    for (let attempt = 0; attempt < 50 && !this.current(); attempt++) {
+      await sleep(100);
+      const hello = await askHost(path, { op: "hello" }).catch(() => null);
+      if (!hello) continue;
+      if (hello.version !== this.version) {
+        throw new HerdError(
+          `The terminal host started as version ${hello.version}, not ${this.version}, so its files changed as it started. Starting the daemon again picks this up.`
+        );
+      }
+      this.hosts.push({ path, hello, current: true, speaks: speaksProtocol(hello.protocol) });
+    }
+    if (!this.current()) throw new HerdError("The terminal host didn't start.");
+    this.log(`Started terminal host ${this.version}.`);
+  }
+  /**
+   * Every driveable host's terminals. A name in more than one host, as when a session moved, is
+   * the running one, or else the newest.
+   */
+  async list() {
+    if (this.hosts.length === 0) await this.discover();
+    const byName = /* @__PURE__ */ new Map();
+    for (const host of this.hosts.filter((candidate) => candidate.speaks)) {
+      const terminals = await askHost(host.path, { op: "list" }).then((reply) => reply.terminals).catch(() => []);
+      for (const info of terminals) {
+        const seen = byName.get(info.name);
+        const better = !seen || seen.info.exited && !info.exited || seen.info.exited === info.exited && info.createdAt > seen.info.createdAt;
+        if (better) byName.set(info.name, { info, path: host.path });
+      }
+    }
+    this.where = new Map([...byName].map(([name, { path }]) => [name, path]));
+    return [...byName.values()].map(({ info }) => info);
+  }
+  /** The socket of the host holding a terminal. */
+  async pathOf(name) {
+    let path = this.where.get(name);
+    if (!path) {
+      await this.list();
+      path = this.where.get(name);
+    }
+    if (!path) throw new HerdError(`There's no terminal named ${name}.`);
+    return path;
+  }
+  async askFor(name, request) {
+    return askHost(await this.pathOf(name), request);
+  }
+  async create(opts) {
+    const running = (await this.list()).find((t) => t.name === opts.name && !t.exited);
+    if (running) throw new HerdError(`A terminal named ${opts.name} is already running.`);
+    let host = this.current();
+    if (!host) {
+      await this.ensureHost();
+      host = this.current();
+    }
+    if (!host) throw new HerdError("The terminal host didn't start.");
+    const { terminal } = await askHost(host.path, {
+      op: "create",
+      ...opts
+    });
+    this.where.set(opts.name, host.path);
+    return terminal;
+  }
+  async screen(name) {
+    return (await this.askFor(name, { op: "screen", name })).screen;
+  }
+  async snapshot(name) {
+    return (await this.askFor(name, { op: "snapshot", name })).snapshot;
+  }
+  async type(name, text4) {
+    await this.askFor(name, { op: "type", name, text: text4 });
+  }
+  async press(name, key) {
+    await this.askFor(name, { op: "press", name, key });
+  }
+  async exitStatus(name) {
+    const terminal = (await this.list()).find((candidate) => candidate.name === name);
+    if (!terminal) throw new HerdError(`There's no terminal named ${name}.`);
+    return terminal.exited ? terminal.exitCode : null;
+  }
+  async kill(name) {
+    await this.askFor(name, { op: "kill", name });
+  }
+  async retire(canStop) {
+    const stopped2 = [];
+    for (const host of await this.discover()) {
+      if (host.current) continue;
+      const version = host.hello.version ?? "unversioned";
+      if (host.speaks) {
+        const terminals = await askHost(host.path, { op: "list" }).then((reply) => reply.terminals).catch(() => null);
+        if (!terminals) continue;
+        if (terminals.some((t) => !t.exited || (t.viewers ?? 0) > 0)) continue;
+      } else if (!host.hello.version || !canStop(host.hello.version)) {
+        continue;
+      }
+      if (await this.stop(host)) {
+        stopped2.push(version);
+        this.log(`Retired terminal host ${version}, which had nothing left running.`);
+      }
+    }
+    if (stopped2.length > 0) await this.discover();
+    return stopped2;
+  }
+  /** Stops a host: politely where it knows how, and otherwise by its process. */
+  async stop(host) {
+    if (host.speaks && host.hello.ops?.includes("shutdown")) {
+      return askHost(host.path, { op: "shutdown" }).then(
+        () => true,
+        () => false
+      );
+    }
+    const hello = await askHost(host.path, { op: "hello" }).catch(() => null);
+    if (!hello || hello.pid !== host.hello.pid) return false;
+    try {
+      process.kill(hello.pid, "SIGTERM");
+    } catch {
+      return false;
+    }
+    if (host.path === legacyHostSocketPath()) {
+      for (let attempt = 0; attempt < 20; attempt++) {
+        await sleep(100);
+        if (!await askHost(host.path, { op: "hello" }).catch(() => null)) break;
+      }
+      rmSync5(host.path, { force: true });
+    }
+    return true;
+  }
+};
+var DRIVER_QUIET_MS = 10 * 1e3;
+function someoneDriving(terminal, quietMs = DRIVER_QUIET_MS, now = Date.now()) {
+  if (!terminal || (terminal.viewers ?? 0) === 0 || !terminal.drivenAt) return false;
+  return now - terminal.drivenAt < quietMs;
+}
+var lookingAt = (terminal) => (terminal?.viewers ?? 0) + (terminal?.watchers ?? 0);
+
 // src/timing.ts
 init_define_HERD_PACKAGE();
 var CHECK_IN_MS = 15e3;
@@ -4943,6 +5180,7 @@ var VARIABLES = {
   agyIdleSettleMs: "HERD_AGY_IDLE_SETTLE_MS",
   promptPollMs: "HERD_PROMPT_POLL_MS",
   noticeRetryMs: "HERD_NOTICE_RETRY_MS",
+  driverQuietMs: "HERD_DRIVER_QUIET_MS",
   investigateAfterMs: "HERD_INVESTIGATE_AFTER_MS",
   idleMs: "HERD_IDLE_MS",
   watchMs: "HERD_WATCH_MS",
@@ -4986,14 +5224,14 @@ function newActivationCode() {
   return [...randomBytes4(8)].map((byte) => CODE_LETTERS[byte % CODE_LETTERS.length]).join("");
 }
 var activationTerminal = (agent) => `herd-activate-${agentShortName(agent)}`;
-var activationFolder = (root, agent) => join7(convosHome(root), ".activate", agentShortName(agent));
+var activationFolder = (root, agent) => join8(convosHome(root), ".activate", agentShortName(agent));
 var recordSchema = agentActivationSchema.extend({
   /** While it's waiting: the terminal it runs in, which `friday start` can attach to. */
   terminal: z21.string().optional()
 });
 var storeSchema = z21.object({ agents: z21.record(z21.string(), recordSchema) });
-var activationsPath = (home = herdHome()) => join7(home, "activations.json");
-var activationRequestPath = (home = herdHome()) => join7(home, "activate-request");
+var activationsPath = (home = herdHome()) => join8(home, "activations.json");
+var activationRequestPath = (home = herdHome()) => join8(home, "activate-request");
 function readActivations(path = activationsPath()) {
   try {
     return storeSchema.parse(JSON.parse(readFileSync5(path, "utf8"))).agents;
@@ -5002,7 +5240,7 @@ function readActivations(path = activationsPath()) {
   }
 }
 function requestActivation(home = herdHome(), now = Date.now()) {
-  mkdirSync5(home, { recursive: true, mode: 448 });
+  mkdirSync6(home, { recursive: true, mode: 448 });
   writeFileSync4(activationRequestPath(home), String(now), { mode: 384 });
 }
 function needsActivation(record, version) {
@@ -5019,7 +5257,7 @@ function activateDecision(request, code) {
     }
   };
 }
-var sleep = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+var sleep2 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
 var label = (agent) => AGENTS[agent]?.label ?? agent;
 var Activator = class {
   constructor(options) {
@@ -5047,7 +5285,7 @@ var Activator = class {
   }
   record(agent, record) {
     const agents = { ...readActivations(this.path), [agent]: record };
-    mkdirSync5(dirname5(this.path), { recursive: true, mode: 448 });
+    mkdirSync6(dirname5(this.path), { recursive: true, mode: 448 });
     const temporary = `${this.path}.${process.pid}`;
     writeFileSync4(temporary, JSON.stringify({ agents }, null, 2), { mode: 384 });
     renameSync2(temporary, this.path);
@@ -5094,7 +5332,7 @@ var Activator = class {
           this.log(`Activating ${label(next.agent)} once its conversations here settle.`);
         }
         while (this.options.busy(next.agent) && !this.stopped) {
-          await sleep(this.options.busyPollMs ?? BUSY_POLL_MS);
+          await sleep2(this.options.busyPollMs ?? BUSY_POLL_MS);
         }
         if (this.stopped) break;
         await this.activate(next.agent, next.version).catch(
@@ -5140,8 +5378,8 @@ var Activator = class {
     const code = newActivationCode();
     const terminal = activationTerminal(agent);
     const folder = activationFolder(this.options.root(), agent);
-    rmSync5(folder, { recursive: true, force: true });
-    mkdirSync5(folder, { recursive: true });
+    rmSync6(folder, { recursive: true, force: true });
+    mkdirSync6(folder, { recursive: true });
     const current = { agent, code, terminal, checkedIn: false, wake: () => {
     } };
     this.current = current;
@@ -5167,7 +5405,7 @@ var Activator = class {
       );
       if (open) await terminals.kill(terminal).catch(() => {
       });
-      rmSync5(folder, { recursive: true, force: true });
+      rmSync6(folder, { recursive: true, force: true });
     }
     this.record(agent, outcome);
     this.log(
@@ -5228,7 +5466,9 @@ var Activator = class {
             terminal: current.terminal
           });
         }
-        const viewers = (await terminals.list()).find((t) => t.name === current.terminal)?.viewers ?? 0;
+        const viewers = lookingAt(
+          (await terminals.list()).find((t) => t.name === current.terminal)
+        );
         if (viewers === 0 && Date.now() - startedAt >= restartMs) await start();
       } else if (reading?.state === "idle" && reading.program !== "shell" && !prompted) {
         prompted = true;
@@ -5330,7 +5570,7 @@ async function chooseAgents(options, print) {
   Object.fromEntries(choices.map((choice) => [choice.cli, choice.share]));
   const choosing = options.ask || options.given !== void 0;
   if (choosing && (!sameChoice(saved, shares) || !existsSync5(options.configPath))) {
-    mkdirSync6(dirname6(options.configPath), { recursive: true, mode: 448 });
+    mkdirSync7(dirname6(options.configPath), { recursive: true, mode: 448 });
     writeFileSync5(options.configPath, configSource(withChoice(saved, shares)), { mode: 384 });
   }
   const chosen = ADAPTERS.map(({ cli }) => cli).filter((cli) => (shares[cli] ?? "off") !== "off");
@@ -5344,7 +5584,7 @@ function askToActivate(herdHome2, now = Date.now()) {
   requestActivation(herdHome2, now);
   return now;
 }
-var sleep2 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+var sleep3 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
 function settledLine(cli, activation) {
   if (activation.state === "activated") return `${label2(cli)} is activated.`;
   return `${label2(cli)} ${activationText(cli, activation).replace(" there", " on this computer")}.`;
@@ -5395,11 +5635,11 @@ async function awaitActivations(options, chosen, since, print) {
       );
       break;
     }
-    await sleep2(pollMs);
+    await sleep3(pollMs);
   }
   return settled;
 }
-var herdConfigIn = (herdHome2) => join8(herdHome2, "herd.config.ts");
+var herdConfigIn = (herdHome2) => join9(herdHome2, "herd.config.ts");
 
 // src/friday/home.ts
 init_define_HERD_PACKAGE();
@@ -5408,32 +5648,32 @@ import { spawnSync } from "node:child_process";
 import {
   closeSync as closeSync2,
   existsSync as existsSync6,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync as openSync2,
   readFileSync as readFileSync6,
-  rmSync as rmSync6,
+  rmSync as rmSync7,
   statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname7, join as join9, resolve as resolve2 } from "node:path";
+import { dirname as dirname7, join as join10, resolve as resolve2 } from "node:path";
 var PACKAGE_NAME = FRIDAY_PACKAGE;
 function fridayPaths(herdHome2) {
-  const logs = join9(herdHome2, "logs");
+  const logs = join10(herdHome2, "logs");
   return {
     herdHome: herdHome2,
-    config: join9(herdHome2, "config.json"),
-    versions: join9(herdHome2, "versions"),
-    current: join9(herdHome2, "current"),
-    pin: join9(herdHome2, "pin"),
+    config: join10(herdHome2, "config.json"),
+    versions: join10(herdHome2, "versions"),
+    current: join10(herdHome2, "current"),
+    pin: join10(herdHome2, "pin"),
     logs,
-    daemonLog: join9(logs, "daemon.log"),
-    supervisorLog: join9(logs, "supervisor.log"),
-    updateLock: join9(herdHome2, "update.lock"),
-    status: join9(herdHome2, "supervisor.json"),
-    terminals: join9(herdHome2, "terminals")
+    daemonLog: join10(logs, "daemon.log"),
+    supervisorLog: join10(logs, "supervisor.log"),
+    updateLock: join10(herdHome2, "update.lock"),
+    status: join10(herdHome2, "supervisor.json"),
+    terminals: join10(herdHome2, "terminals")
   };
 }
-var packageDir = (versionDir) => join9(versionDir, "node_modules", ...PACKAGE_NAME.split("/"));
+var packageDir = (versionDir) => join10(versionDir, "node_modules", ...PACKAGE_NAME.split("/"));
 function alive2(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -5444,11 +5684,11 @@ function alive2(pid) {
   }
 }
 function takeLock(path, staleMs = 10 * 6e4) {
-  mkdirSync7(dirname7(path), { recursive: true });
+  mkdirSync8(dirname7(path), { recursive: true });
   if (existsSync6(path)) {
     const holder2 = Number(readFileSync6(path, "utf8").trim());
     const old = Date.now() - statSync5(path).mtimeMs > staleMs;
-    if (old || !alive2(holder2)) rmSync6(path, { force: true });
+    if (old || !alive2(holder2)) rmSync7(path, { force: true });
   }
   try {
     const fd = openSync2(path, "wx");
@@ -5457,7 +5697,7 @@ function takeLock(path, staleMs = 10 * 6e4) {
   } catch {
     return null;
   }
-  return () => rmSync6(path, { force: true });
+  return () => rmSync7(path, { force: true });
 }
 function readStatus(paths) {
   try {
@@ -5467,7 +5707,7 @@ function readStatus(paths) {
   }
 }
 function writeStatus(paths, status2) {
-  mkdirSync7(paths.herdHome, { recursive: true, mode: 448 });
+  mkdirSync8(paths.herdHome, { recursive: true, mode: 448 });
   writeFileSync6(paths.status, `${JSON.stringify(status2, null, 2)}
 `);
 }
@@ -5490,7 +5730,7 @@ function writeRoot(paths, root) {
   } catch {
     config = {};
   }
-  mkdirSync7(paths.herdHome, { recursive: true, mode: 448 });
+  mkdirSync8(paths.herdHome, { recursive: true, mode: 448 });
   writeFileSync6(paths.config, JSON.stringify({ ...config, root }, null, 2), { mode: 384 });
 }
 function insideWorkTree(folder) {
@@ -5583,10 +5823,10 @@ function pickInTerminal(choices, input = process.stdin, output2 = process.stdout
 
 // src/friday/service.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "node:fs";
 import { userInfo } from "node:os";
-import { dirname as dirname8, join as join10, win32 } from "node:path";
+import { dirname as dirname8, join as join11, win32 } from "node:path";
 var systemdBooted = () => existsSync7("/run/systemd/system");
 var LAUNCH_AGENT = "com.herdingchats.friday";
 var SYSTEMD_UNIT = "herdingchats-friday.service";
@@ -5674,16 +5914,16 @@ WantedBy=default.target
 `;
 }
 function makeLogFolder(context2) {
-  mkdirSync8(dirname8(context2.paths.supervisorLog), { recursive: true });
+  mkdirSync9(dirname8(context2.paths.supervisorLog), { recursive: true });
 }
 function writeIfChanged(path, text4) {
   if (existsSync7(path) && readFileSync7(path, "utf8") === text4) return false;
-  mkdirSync8(dirname8(path), { recursive: true });
+  mkdirSync9(dirname8(path), { recursive: true });
   writeFileSync7(path, text4);
   return true;
 }
 function launchd(context2) {
-  const plist = join10(context2.home, "Library", "LaunchAgents", `${LAUNCH_AGENT}.plist`);
+  const plist = join11(context2.home, "Library", "LaunchAgents", `${LAUNCH_AGENT}.plist`);
   const domain = `gui/${userInfo().uid}`;
   const target = `${domain}/${LAUNCH_AGENT}`;
   const loaded = async () => (await context2.run("launchctl", ["print", target])).status === 0;
@@ -5707,12 +5947,12 @@ function launchd(context2) {
     },
     async remove() {
       await context2.run("launchctl", ["bootout", target]);
-      rmSync7(plist, { force: true });
+      rmSync8(plist, { force: true });
     }
   };
 }
 function systemd(context2) {
-  const unit = join10(context2.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+  const unit = join11(context2.home, ".config", "systemd", "user", SYSTEMD_UNIT);
   const systemctl = async (...args) => {
     const ran = await context2.run("systemctl", ["--user", ...args]);
     if (ran.status !== 0)
@@ -5734,15 +5974,15 @@ function systemd(context2) {
     },
     async remove() {
       await context2.run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
-      rmSync7(unit, { force: true });
+      rmSync8(unit, { force: true });
     }
   };
 }
 function spawnInBackground(command, env, log) {
-  mkdirSync8(dirname8(log), { recursive: true });
+  mkdirSync9(dirname8(log), { recursive: true });
   const out = openSync3(log, "a");
   const [program = process.execPath, ...args] = command;
-  spawn4(program, args, {
+  spawn5(program, args, {
     detached: true,
     // On Windows, a detached process otherwise opens a console window of its own.
     windowsHide: true,
@@ -5794,35 +6034,35 @@ function serviceFor(kind, context2) {
 // src/friday/start.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { mkdirSync as mkdirSync10, realpathSync as realpathSync4 } from "node:fs";
-import { join as join14, resolve as resolve3 } from "node:path";
+import { mkdirSync as mkdirSync11, realpathSync as realpathSync4 } from "node:fs";
+import { join as join15, resolve as resolve3 } from "node:path";
 
 // src/package-manager.ts
 init_define_HERD_PACKAGE();
 import { existsSync as existsSync9 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename3, delimiter, dirname as dirname9, isAbsolute as isAbsolute2, join as join12 } from "node:path";
+import { basename as basename3, delimiter, dirname as dirname9, isAbsolute as isAbsolute2, join as join13 } from "node:path";
 
 // src/friday/versions.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import {
   existsSync as existsSync8,
-  mkdirSync as mkdirSync9,
-  readdirSync as readdirSync3,
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync8,
   readlinkSync,
   realpathSync as realpathSync3,
   renameSync as renameSync3,
-  rmSync as rmSync8,
+  rmSync as rmSync9,
   symlinkSync,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { basename as basename2, join as join11 } from "node:path";
+import { basename as basename2, join as join12 } from "node:path";
 var exec = (command, args, options = {}) => new Promise((resolve8) => {
   let stdout = "";
   let stderr = "";
-  const child = spawn5(command, args, {
+  const child = spawn6(command, args, {
     cwd: options.cwd,
     env: options.env ?? process.env,
     stdio: ["ignore", "pipe", "pipe"]
@@ -5848,9 +6088,9 @@ function currentVersion(paths) {
 }
 function installedVersions(paths) {
   if (!existsSync8(paths.versions)) return [];
-  return readdirSync3(paths.versions).filter((name) => VERSION.test(name)).sort(compareVersions);
+  return readdirSync4(paths.versions).filter((name) => VERSION.test(name)).sort(compareVersions);
 }
-var binOf = (versionDir, bin) => join11(packageDir(versionDir), `${bin}.mjs`);
+var binOf = (versionDir, bin) => join12(packageDir(versionDir), `${bin}.mjs`);
 async function versionRuns(versionDir, version, run4 = exec) {
   const ran = await run4(process.execPath, [binOf(versionDir, "herd"), "--version"], {
     timeoutMs: 3e4
@@ -5866,7 +6106,7 @@ function recordedIntegrity(dir) {
     for (const file of LOCKFILES[manager]) {
       let lock;
       try {
-        lock = readFileSync8(join11(dir, file), "utf8");
+        lock = readFileSync8(join12(dir, file), "utf8");
       } catch {
         continue;
       }
@@ -5884,7 +6124,7 @@ function npmFreeEnv() {
 async function installVersion(paths, version, { spec, integrity, run: run4 = exec, env = {}, log = () => {
 }, manager } = {}) {
   if (!VERSION.test(version)) return { ok: false, reason: `${version} isn't a version.` };
-  const dir = join11(paths.versions, version);
+  const dir = join12(paths.versions, version);
   if (existsSync8(dir)) {
     const installed2 = recordedIntegrity(dir);
     if (integrity && installed2 !== integrity)
@@ -5900,19 +6140,19 @@ async function installVersion(paths, version, { spec, integrity, run: run4 = exe
       reason: "there's no package manager to install it with: herd looked for npm, pnpm and Yarn 1 beside Node, on the PATH and in their usual folders."
     };
   sweepStaging(paths);
-  const named = join11(paths.versions, `.staging-${version}-${process.pid}`);
-  rmSync8(named, { recursive: true, force: true });
-  mkdirSync9(named, { recursive: true });
+  const named = join12(paths.versions, `.staging-${version}-${process.pid}`);
+  rmSync9(named, { recursive: true, force: true });
+  mkdirSync10(named, { recursive: true });
   const staging = realpathSync3(named);
   writeFileSync8(
-    join11(staging, "package.json"),
+    join12(staging, "package.json"),
     `${JSON.stringify(allowScriptsManifest(["node-pty"]), null, 2)}
 `
   );
   if (using.name === "pnpm")
-    writeFileSync8(join11(staging, "pnpm-workspace.yaml"), allowScriptsWorkspace(["node-pty"]));
+    writeFileSync8(join12(staging, "pnpm-workspace.yaml"), allowScriptsWorkspace(["node-pty"]));
   const fail = (reason) => {
-    rmSync8(staging, { recursive: true, force: true });
+    rmSync9(staging, { recursive: true, force: true });
     return { ok: false, reason };
   };
   log(`Installing ${PACKAGE_NAME}@${version} with ${using.name} ${using.version}.`);
@@ -5935,21 +6175,21 @@ async function installVersion(paths, version, { spec, integrity, run: run4 = exe
   }
   const broken = await versionRuns(staging, version, run4);
   if (broken) return fail(broken);
-  renameSync3(staging, join11(realpathSync3(paths.versions), version));
+  renameSync3(staging, join12(realpathSync3(paths.versions), version));
   return { ok: true, dir };
 }
 function sweepStaging(paths) {
   if (!existsSync8(paths.versions)) return;
-  for (const name of readdirSync3(paths.versions)) {
+  for (const name of readdirSync4(paths.versions)) {
     const match = /^\.staging-.+-(\d+)$/.exec(name);
     if (match && !alive2(Number(match[1])))
-      rmSync8(join11(paths.versions, name), { recursive: true, force: true });
+      rmSync9(join12(paths.versions, name), { recursive: true, force: true });
   }
 }
 function activate(paths, version) {
   const next = `${paths.current}.next-${process.pid}`;
-  rmSync8(next, { force: true });
-  symlinkSync(join11("versions", version), next);
+  rmSync9(next, { force: true });
+  symlinkSync(join12("versions", version), next);
   renameSync3(next, paths.current);
 }
 function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
@@ -5964,7 +6204,7 @@ function pruneVersions(paths, { inUse = [], keep = 3 } = {}) {
   const removed = [];
   for (const version of versions) {
     if (kept.has(version)) continue;
-    rmSync8(join11(paths.versions, version), { recursive: true, force: true });
+    rmSync9(join12(paths.versions, version), { recursive: true, force: true });
     removed.push(version);
   }
   return removed;
@@ -5997,19 +6237,19 @@ var nameOf = (command) => {
   return MANAGERS.includes(name) ? name : null;
 };
 function homesOf(name, env, home) {
-  const common = [join12(home, ".volta", "bin"), join12(home, ".local", "bin")];
+  const common = [join13(home, ".volta", "bin"), join13(home, ".local", "bin")];
   switch (name) {
     case "pnpm":
       return [
         ...env.PNPM_HOME ? [env.PNPM_HOME] : [],
-        join12(home, "Library", "pnpm"),
-        join12(home, ".local", "share", "pnpm"),
+        join13(home, "Library", "pnpm"),
+        join13(home, ".local", "share", "pnpm"),
         ...common
       ];
     case "bun":
-      return [join12(env.BUN_INSTALL || join12(home, ".bun"), "bin"), ...common];
+      return [join13(env.BUN_INSTALL || join13(home, ".bun"), "bin"), ...common];
     case "yarn":
-      return [join12(home, ".yarn", "bin"), ...common];
+      return [join13(home, ".yarn", "bin"), ...common];
     case "npm":
       return common;
   }
@@ -6032,7 +6272,7 @@ function candidatePaths(name, {
   const files = platform2 === "win32" ? [`${name}.cmd`, `${name}.exe`] : [name];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of dirs.filter(Boolean)) {
-    for (const file of files) seen.add(join12(dir, file));
+    for (const file of files) seen.add(join13(dir, file));
   }
   return [...seen];
 }
@@ -6192,22 +6432,22 @@ function frozenInstallArgs(name, { offline, yarnMajor }) {
 
 // src/friday/legacy.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync10, readdirSync as readdirSync4, rmSync as rmSync9 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync5, rmSync as rmSync10 } from "node:fs";
 import { userInfo as userInfo2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var OLD_LAUNCH_AGENT = "com.herdingchats.herd";
 var OLD_APPS = ["herd-daemon", "herd-updater"];
 function oldPm2s(paths) {
-  const dir = join13(paths.herdHome, "daemon");
+  const dir = join14(paths.herdHome, "daemon");
   if (!existsSync10(dir)) return [];
-  return readdirSync4(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join13(dir, entry.name, "node_modules", "pm2", "bin", "pm2")).filter((pm2) => existsSync10(pm2));
+  return readdirSync5(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join14(dir, entry.name, "node_modules", "pm2", "bin", "pm2")).filter((pm2) => existsSync10(pm2));
 }
 async function retireOldDaemon(paths, { home, run: run4 }) {
   const removed = [];
-  const plist = join13(home, "Library", "LaunchAgents", `${OLD_LAUNCH_AGENT}.plist`);
+  const plist = join14(home, "Library", "LaunchAgents", `${OLD_LAUNCH_AGENT}.plist`);
   if (existsSync10(plist)) {
     await run4("launchctl", ["bootout", `gui/${userInfo2().uid}/${OLD_LAUNCH_AGENT}`]);
-    rmSync9(plist, { force: true });
+    rmSync10(plist, { force: true });
     removed.push(`the login item ${OLD_LAUNCH_AGENT}`);
   }
   for (const pm2 of oldPm2s(paths)) {
@@ -6283,7 +6523,7 @@ var real = (path) => {
   }
 };
 function chooseRoot(cwd, home) {
-  return real(cwd) === real(home) ? join14(home, "friday") : resolve3(cwd);
+  return real(cwd) === real(home) ? join15(home, "friday") : resolve3(cwd);
 }
 async function runStart(options) {
   const { paths, run: run4 } = options;
@@ -6363,7 +6603,7 @@ async function runStart(options) {
     await service.stop();
     await stopped(options);
   }
-  mkdirSync10(root, { recursive: true });
+  mkdirSync11(root, { recursive: true });
   writeRoot(paths, root);
   verbose2(`installing the ${service.kind} service`);
   const changed = await service.install();
@@ -6459,11 +6699,11 @@ async function ensureInstalled(options, print) {
 // src/friday/supervisor.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import {
   closeSync as closeSync3,
   existsSync as existsSync11,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync12,
   openSync as openSync4,
   readFileSync as readFileSync9,
   realpathSync as realpathSync5,
@@ -6558,7 +6798,7 @@ var Supervisor = class {
   spawnDaemon() {
     if (this.stopping) return;
     const { daemonLog, logs } = this.options.paths;
-    mkdirSync11(logs, { recursive: true });
+    mkdirSync12(logs, { recursive: true });
     try {
       if (existsSync11(daemonLog) && statSync6(daemonLog).size > MAX_LOG_BYTES2)
         renameSync4(daemonLog, `${daemonLog}.1`);
@@ -6567,7 +6807,7 @@ var Supervisor = class {
     const out = openSync4(daemonLog, "a");
     const [program = process.execPath, ...args] = this.daemonCommand();
     const startedAt = Date.now();
-    const child = spawn6(program, args, { stdio: ["ignore", out, out], env: process.env });
+    const child = spawn7(program, args, { stdio: ["ignore", out, out], env: process.env });
     closeSync3(out);
     this.daemon = child;
     this.status.daemonPid = child.pid ?? null;
@@ -6719,7 +6959,7 @@ Agents use the herd command, which comes with this one. herd setup shows what's
 function defaults() {
   const home = homedir5();
   return {
-    paths: fridayPaths(process.env.HERD_HOME ?? join15(home, ".herd")),
+    paths: fridayPaths(process.env.HERD_HOME ?? join16(home, ".herd")),
     home,
     cwd: process.cwd(),
     run: exec,
@@ -6850,8 +7090,8 @@ function agentsFlag(args) {
   return parsed.shares;
 }
 function attachTo(paths, terminal) {
-  const herd = existsSync12(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join15(dirname10(process.argv[1] ?? ""), "herd.mjs");
-  const child = spawn7(process.execPath, [herd, "attach", terminal], {
+  const herd = existsSync12(binOf(paths.current, "herd")) ? binOf(paths.current, "herd") : join16(dirname10(process.argv[1] ?? ""), "herd.mjs");
+  const child = spawn8(process.execPath, [herd, "attach", terminal], {
     stdio: "inherit",
     env: { ...process.env, HERD_HOME: paths.herdHome }
   });
@@ -6914,7 +7154,7 @@ function runStatus(deps) {
 function readMissingFolder(herdHome2) {
   try {
     return folderUnavailableSchema.parse(
-      JSON.parse(readFileSync10(join15(herdHome2, "folder-unavailable.json"), "utf8"))
+      JSON.parse(readFileSync10(join16(herdHome2, "folder-unavailable.json"), "utf8"))
     );
   } catch {
     return null;
@@ -6935,7 +7175,7 @@ async function runLogs(args, deps) {
     return 0;
   }
   if (follow) {
-    const child = spawn7("tail", ["-n", "50", "-F", ...files], { stdio: "inherit" });
+    const child = spawn8("tail", ["-n", "50", "-F", ...files], { stdio: "inherit" });
     return await new Promise((resolve8) => child.on("close", (code) => resolve8(code ?? 0)));
   }
   for (const file of files) {
@@ -6977,16 +7217,16 @@ init_define_HERD_PACKAGE();
 
 // src/agent-sandbox.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn9 } from "node:child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync12, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { spawn as spawn10 } from "node:child_process";
+import { existsSync as existsSync13, mkdirSync as mkdirSync13, readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir6, tmpdir } from "node:os";
-import { dirname as dirname12, isAbsolute as isAbsolute3, join as join17, resolve as resolve4 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute3, join as join18, resolve as resolve4 } from "node:path";
 
 // src/build-sandbox.ts
 init_define_HERD_PACKAGE();
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { appendFileSync, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname11, join as join16 } from "node:path";
+import { dirname as dirname11, join as join17 } from "node:path";
 var DEPLOY_HOSTS = ["api.cloudflare.com", "api.github.com", "registry.npmjs.org"];
 function buildPolicy(input) {
   const platform2 = input.platform ?? process.platform;
@@ -7021,7 +7261,7 @@ var shellQuote = (args) => args.map((arg) => `'${arg.replace(/'/g, "'\\''")}'`).
 var BLOCKED_LOG = "blocked.log";
 async function runSandboxed(args, {
   usage = "Usage: herd build-sandbox <policy> -- <command\u2026>",
-  blockedLog = (_policyPath) => join16(process.env.HOME ?? ".", BLOCKED_LOG)
+  blockedLog = (_policyPath) => join17(process.env.HOME ?? ".", BLOCKED_LOG)
 } = {}) {
   const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
   const [policyPath, separator, ...command] = args;
@@ -7049,7 +7289,7 @@ async function runSandboxed(args, {
     }
   });
   const wrapped = await SandboxManager.wrapWithSandbox(shellQuote(command));
-  const child = spawn8(wrapped, { shell: true, stdio: "inherit" });
+  const child = spawn9(wrapped, { shell: true, stdio: "inherit" });
   const forward = (signal2) => () => child.kill(signal2);
   process.once("SIGTERM", forward("SIGTERM"));
   process.once("SIGINT", forward("SIGINT"));
@@ -7190,13 +7430,13 @@ var AGENT_STATE = [
   ".config/gh"
 ];
 function agentAccess(input) {
-  const home = (path) => join17(input.ownerHome, path);
+  const home = (path) => join18(input.ownerHome, path);
   return {
     read: [
       ...SYSTEM_READ,
       input.nodePrefix,
       ...HOME_READ.map(home),
-      ...HERD_READ.map((path) => join17(input.herdHome, path))
+      ...HERD_READ.map((path) => join18(input.herdHome, path))
     ],
     write: [
       .../* @__PURE__ */ new Set([
@@ -7214,7 +7454,7 @@ function seatbeltPolicy(input) {
   const access = agentAccess(input);
   return {
     network: {
-      allowUnixSockets: [join17(input.herdHome, "daemon.sock"), input.tmp, input.folder],
+      allowUnixSockets: [join18(input.herdHome, "daemon.sock"), input.tmp, input.folder],
       allowLocalBinding: true
     },
     filesystem: {
@@ -7229,7 +7469,7 @@ function seatbeltPolicy(input) {
 function worktreeGitDirs(folder) {
   const candidates2 = [folder];
   try {
-    for (const name of readdirSync5(folder)) candidates2.push(join17(folder, name));
+    for (const name of readdirSync6(folder)) candidates2.push(join18(folder, name));
   } catch {
     return [];
   }
@@ -7241,13 +7481,13 @@ function worktreeGitDirs(folder) {
   return [...dirs];
 }
 function commonGitDir(worktree) {
-  const dotGit = join17(worktree, ".git");
+  const dotGit = join18(worktree, ".git");
   try {
     if (!statSync7(dotGit).isFile()) return null;
     const line2 = /^gitdir:\s*(.+)$/m.exec(readFileSync12(dotGit, "utf8"))?.[1]?.trim();
     if (!line2) return null;
     const gitDir = isAbsolute3(line2) ? line2 : resolve4(worktree, line2);
-    const common = join17(gitDir, "commondir");
+    const common = join18(gitDir, "commondir");
     if (!existsSync13(common)) return gitDir;
     const relative3 = readFileSync12(common, "utf8").trim();
     return isAbsolute3(relative3) ? relative3 : resolve4(gitDir, relative3);
@@ -7255,10 +7495,10 @@ function commonGitDir(worktree) {
     return null;
   }
 }
-var policyPathFor = (conversationId) => join17(herdHome(), "sandbox", `${conversationId}.json`);
+var policyPathFor = (conversationId) => join18(herdHome(), "sandbox", `${conversationId}.json`);
 function writeAgentPolicy(conversationId, paths, platform2 = process.platform) {
   const path = policyPathFor(conversationId);
-  mkdirSync12(dirname12(path), { recursive: true, mode: 448 });
+  mkdirSync13(dirname12(path), { recursive: true, mode: 448 });
   const input = {
     ownerHome: homedir6(),
     herdHome: herdHome(),
@@ -7273,7 +7513,7 @@ function writeAgentPolicy(conversationId, paths, platform2 = process.platform) {
 }
 var confinementOn = (env = process.env) => env.HERD_CONFINE === "on";
 function runLandlocked(access, command) {
-  const child = spawn9(
+  const child = spawn10(
     "python3",
     ["-I", "-c", LANDLOCK_LAUNCHER, JSON.stringify(access), ...command],
     { stdio: "inherit" }
@@ -7779,8 +8019,8 @@ init_define_HERD_PACKAGE();
 // src/build-runner-key.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { chmodSync as chmodSync3, existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join18 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync14, mkdirSync as mkdirSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join19 } from "node:path";
 import { z as z24 } from "zod";
 var BUILDS_URL = "https://builds.herdingchats.com";
 var runnerKeySchema = z24.object({
@@ -7788,7 +8028,7 @@ var runnerKeySchema = z24.object({
   key: z24.string().min(20),
   url: z24.string().url()
 });
-var runnerKeyPath = () => join18(herdHome(), "build-runner.json");
+var runnerKeyPath = () => join19(herdHome(), "build-runner.json");
 function readRunnerKey() {
   const path = runnerKeyPath();
   if (!existsSync14(path)) return null;
@@ -7801,7 +8041,7 @@ function readRunnerKey() {
   }
 }
 function saveRunnerKey(key) {
-  mkdirSync13(herdHome(), { recursive: true, mode: 448 });
+  mkdirSync14(herdHome(), { recursive: true, mode: 448 });
   const path = runnerKeyPath();
   writeFileSync10(path, JSON.stringify(runnerKeySchema.parse(key), null, 2), { mode: 384 });
   chmodSync3(path, 384);
@@ -7969,8 +8209,8 @@ function formatSpeed(report) {
 
 // src/builds-admin.ts
 init_define_HERD_PACKAGE();
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync15, rmSync as rmSync10, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join19 } from "node:path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join20 } from "node:path";
 var NOT_ADMIN = "builds are only for the admin's machines";
 async function isAdmin(fetch2) {
   const response = await fetch2("/api/people/me").catch(() => null);
@@ -7978,13 +8218,13 @@ async function isAdmin(fetch2) {
   const body = await response.json().catch(() => ({}));
   return body.admin === true;
 }
-var refusalPath = () => join19(herdHome(), "builds", "refused.json");
+var refusalPath = () => join20(herdHome(), "builds", "refused.json");
 function writeBuildsRefusal(reason) {
   if (!reason) {
-    rmSync10(refusalPath(), { force: true });
+    rmSync11(refusalPath(), { force: true });
     return;
   }
-  mkdirSync14(join19(herdHome(), "builds"), { recursive: true });
+  mkdirSync15(join20(herdHome(), "builds"), { recursive: true });
   writeFileSync11(refusalPath(), JSON.stringify({ reason }));
 }
 function readBuildsRefusal() {
@@ -8258,12 +8498,12 @@ function readClaudeScreen(raw) {
 // src/worktrees.ts
 init_define_HERD_PACKAGE();
 import { existsSync as existsSync15, realpathSync as realpathSync6 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join20, relative } from "node:path";
-var worktreesRoot = () => join20(herdHome(), "worktrees");
+import { isAbsolute as isAbsolute4, join as join21, relative } from "node:path";
+var worktreesRoot = () => join21(herdHome(), "worktrees");
 var WORD_ID = /^[a-z]+-[a-z]+-[a-z]+$/;
 var conversationPrefix = (conversationId) => WORD_ID.test(conversationId) ? conversationId : conversationId.replace(/[^A-Za-z0-9]/g, "").slice(0, 12).toLowerCase();
 var conversationBranch = (conversationId) => `herd/${conversationPrefix(conversationId)}`;
-var conversationFolder = (convos, conversationId) => join20(convos, conversationPrefix(conversationId));
+var conversationFolder = (convos, conversationId) => join21(convos, conversationPrefix(conversationId));
 function folderForConversation(root, conversationId) {
   const earlier = conversationFolder(legacyConvosDir(root), conversationId);
   return existsSync15(earlier) ? earlier : conversationFolder(convosHome(root), conversationId);
@@ -8310,7 +8550,7 @@ function withStartKey(command, startKey, confine) {
   return startKey ? `HERD_START=${startKey} ${line2}` : line2;
 }
 var DEFAULT_TIMING = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep3 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+var sleep4 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
 var EXIT_WAIT_MS = 5e3;
 var AgentDriver = class {
   constructor(terminals, timing = {}) {
@@ -8338,7 +8578,7 @@ var AgentDriver = class {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
       if (Date.now() > end) return null;
-      await sleep3(this.timing.pollMs);
+      await sleep4(this.timing.pollMs);
     }
   }
   /** Waits for a terminal's output to stop changing, as a shell does once it's ready. */
@@ -8354,7 +8594,7 @@ var AgentDriver = class {
       } else if (Date.now() - stableSince >= this.timing.settleMs) {
         return;
       }
-      await sleep3(this.timing.pollMs);
+      await sleep4(this.timing.pollMs);
     }
   }
   /**
@@ -8394,7 +8634,7 @@ var AgentDriver = class {
       for (let attempt = 0; attempt < 5; attempt++) {
         if ((await this.read(name)).trustPrompt?.yesHighlighted) break;
         await this.terminals.press(name, "down");
-        await sleep3(this.timing.pollMs * 2);
+        await sleep4(this.timing.pollMs * 2);
       }
       if (!(await this.read(name)).trustPrompt?.yesHighlighted) {
         throw new HerdError(
@@ -8472,7 +8712,7 @@ var AgentDriver = class {
         }
       });
     });
-    const confirmed = () => Promise.race([hooked, sleep3(this.timing.confirmMs)]);
+    const confirmed = () => Promise.race([hooked, sleep4(this.timing.confirmMs)]);
     try {
       if (!leftover) await this.terminals.type(name, text4);
       const head = sent.slice(0, 40);
@@ -8576,9 +8816,9 @@ function readAgyScreen(raw) {
 
 // src/agy-settings.ts
 init_define_HERD_PACKAGE();
-import { lstatSync as lstatSync2, mkdirSync as mkdirSync15, realpathSync as realpathSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join21, sep } from "node:path";
-var AGY_SETTINGS_FILE = join21(".herd", "agy-settings.json");
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync16, realpathSync as realpathSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join22, sep } from "node:path";
+var AGY_SETTINGS_FILE = join22(".herd", "agy-settings.json");
 var AGY_HOOK_EVENTS = ["SessionStart", "PreInvocation", "Stop"];
 var agyHookCommand = (event2, herd) => `${herd} hook agy ${event2} || true`;
 function agyHooks(herd) {
@@ -8595,11 +8835,11 @@ function agySettings(herd) {
   return { statusLine: { type: "command", command: `${herd} statusline agy` } };
 }
 function ownFolder(worktree, name) {
-  const folder = join21(worktree, name);
+  const folder = join22(worktree, name);
   if (lstatSync2(folder, { throwIfNoEntry: false })?.isSymbolicLink()) {
     throw new Error(`${name} in the worktree is a link`);
   }
-  mkdirSync15(folder, { recursive: true });
+  mkdirSync16(folder, { recursive: true });
   if (!realpathSync7(folder).startsWith(realpathSync7(worktree) + sep)) {
     throw new Error(`${name} leads outside the worktree`);
   }
@@ -8607,13 +8847,13 @@ function ownFolder(worktree, name) {
 }
 function writeAgyFiles(worktree, herd) {
   const agents = ownFolder(worktree, ".agents");
-  writeFileSync12(join21(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
+  writeFileSync12(join22(agents, "hooks.json"), `${JSON.stringify(agyHooks(herd), null, 2)}
 `);
-  writeFileSync12(join21(agents, ".gitignore"), "*\n");
+  writeFileSync12(join22(agents, ".gitignore"), "*\n");
   const herdFolder = ownFolder(worktree, ".herd");
-  writeFileSync12(join21(herdFolder, ".gitignore"), "*\n");
+  writeFileSync12(join22(herdFolder, ".gitignore"), "*\n");
   writeFileSync12(
-    join21(worktree, AGY_SETTINGS_FILE),
+    join22(worktree, AGY_SETTINGS_FILE),
     `${JSON.stringify(agySettings(herd), null, 2)}
 `
   );
@@ -8622,7 +8862,7 @@ function writeAgyFiles(worktree, herd) {
 // src/agy-driver.ts
 var AGY_FLAGS = `--dangerously-skip-permissions --settings ${AGY_SETTINGS_FILE}`;
 var DEFAULT_TIMING2 = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep4 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+var sleep5 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
 var EXIT_WAIT_MS2 = 5e3;
 var AgyDriver = class {
   constructor(terminals, timing = {}) {
@@ -8645,7 +8885,7 @@ var AgyDriver = class {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
       if (Date.now() > end) return null;
-      await sleep4(this.timing.pollMs);
+      await sleep5(this.timing.pollMs);
     }
   }
   /** Waits for a terminal's output to stop changing, as a shell does once it's ready. */
@@ -8661,7 +8901,7 @@ var AgyDriver = class {
       } else if (Date.now() - stableSince >= this.timing.settleMs) {
         return;
       }
-      await sleep4(this.timing.pollMs);
+      await sleep5(this.timing.pollMs);
     }
   }
   /**
@@ -8727,7 +8967,7 @@ var AgyDriver = class {
         }
       });
     });
-    const confirmed = () => Promise.race([reported, sleep4(this.timing.confirmMs)]);
+    const confirmed = () => Promise.race([reported, sleep5(this.timing.confirmMs)]);
     const head = sent.slice(0, 40);
     const queuedOnScreen = async () => {
       const screen = await this.terminals.screen(name);
@@ -8774,12 +9014,12 @@ var AgyDriver = class {
 // src/bare-clones.ts
 init_define_HERD_PACKAGE();
 import { randomBytes as randomBytes5 } from "node:crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync16, readdirSync as readdirSync6, renameSync as renameSync5, rmSync as rmSync11, statSync as statSync8 } from "node:fs";
-import { dirname as dirname13, join as join22 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync17, readdirSync as readdirSync7, renameSync as renameSync5, rmSync as rmSync12, statSync as statSync8 } from "node:fs";
+import { dirname as dirname13, join as join23 } from "node:path";
 function bareClonePath(dir, remote) {
   const key = repoKey(remote);
   if (!key) throw new StoreError(`${remote} isn't a repo's URL.`);
-  return join22(dir, `${key}.git`);
+  return join23(dir, `${key}.git`);
 }
 async function ensureBareClone(store, remote, env) {
   if (existsSync16(store)) {
@@ -8793,7 +9033,7 @@ async function ensureBareClone(store, remote, env) {
     return { store, created: false, fetchFailed };
   }
   const building = `${store}.tmp-${process.pid}-${randomBytes5(4).toString("hex")}`;
-  mkdirSync16(dirname13(store), { recursive: true });
+  mkdirSync17(dirname13(store), { recursive: true });
   try {
     await git(env, dirname13(store), "init", "--quiet", "--bare", building);
     await git(env, building, "remote", "add", "origin", remote);
@@ -8808,7 +9048,7 @@ async function ensureBareClone(store, remote, env) {
     await git(env, building, "remote", "set-head", "origin", "--auto").catch(() => "");
     renameSync5(building, store);
   } catch (error) {
-    rmSync11(building, { recursive: true, force: true });
+    rmSync12(building, { recursive: true, force: true });
     throw error instanceof StoreError ? error : new StoreError(gitError(error));
   }
   return { store, created: true, fetchFailed: null };
@@ -8818,12 +9058,12 @@ function bareClones(dir) {
   const walk = (at, depth) => {
     let entries;
     try {
-      entries = readdirSync6(at);
+      entries = readdirSync7(at);
     } catch {
       return;
     }
     for (const name of entries.sort()) {
-      const path = join22(at, name);
+      const path = join23(at, name);
       if (name.endsWith(".git")) {
         try {
           const remote = gitSync(path, "config", "--get", "remote.origin.url");
@@ -9001,28 +9241,28 @@ var BuildConnection = class {
 
 // src/builds.ts
 init_define_HERD_PACKAGE();
-import { execFile as execFile2, execFileSync as execFileSync5, spawn as spawn10 } from "node:child_process";
+import { execFile as execFile2, execFileSync as execFileSync5, spawn as spawn11 } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import {
   existsSync as existsSync17,
-  mkdirSync as mkdirSync18,
+  mkdirSync as mkdirSync19,
   mkdtempSync,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync9,
   readFileSync as readFileSync17,
   realpathSync as realpathSync8,
-  rmSync as rmSync13,
+  rmSync as rmSync14,
   writeFileSync as writeFileSync14
 } from "node:fs";
 import { homedir as homedir8, tmpdir as tmpdir2 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/check-registry.ts
 init_define_HERD_PACKAGE();
-import { mkdirSync as mkdirSync17, readdirSync as readdirSync7, readFileSync as readFileSync16, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
+import { mkdirSync as mkdirSync18, readdirSync as readdirSync8, readFileSync as readFileSync16, rmSync as rmSync13, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join23 } from "node:path";
-var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join23(homedir7(), ".cache", "herdingchats", "check", "running");
+import { join as join24 } from "node:path";
+var checkRegistryDir = () => process.env.HERDINGCHATS_CHECK_RUNNING ?? join24(homedir7(), ".cache", "herdingchats", "check", "running");
 var RESERVED_MB = 6 * 1024;
 var MIN_MEMORY_MB = 1024;
 var alive3 = (pid) => {
@@ -9034,15 +9274,15 @@ var alive3 = (pid) => {
   }
 };
 function registerCheck(dir, pid, startedAt = Date.now()) {
-  mkdirSync17(dir, { recursive: true });
-  const file = join23(dir, `${pid}.json`);
+  mkdirSync18(dir, { recursive: true });
+  const file = join24(dir, `${pid}.json`);
   writeFileSync13(file, JSON.stringify({ pid, startedAt }));
-  return () => rmSync12(file, { force: true });
+  return () => rmSync13(file, { force: true });
 }
 function runningChecks(dir, isAlive = alive3) {
   let names = [];
   try {
-    names = readdirSync7(dir).filter((name) => /^\d+\.json$/.test(name));
+    names = readdirSync8(dir).filter((name) => /^\d+\.json$/.test(name));
   } catch {
     return 0;
   }
@@ -9051,12 +9291,12 @@ function runningChecks(dir, isAlive = alive3) {
     const pid = Number(name.slice(0, -".json".length));
     let entry = null;
     try {
-      entry = JSON.parse(readFileSync16(join23(dir, name), "utf8"));
+      entry = JSON.parse(readFileSync16(join24(dir, name), "utf8"));
     } catch {
       continue;
     }
     if (entry?.pid === pid && isAlive(pid)) count += 1;
-    else rmSync12(join23(dir, name), { force: true });
+    else rmSync13(join24(dir, name), { force: true });
   }
   return count;
 }
@@ -9064,9 +9304,9 @@ var memoryShareOf = (totalMb, running) => Math.max(MIN_MEMORY_MB, Math.floor((to
 
 // src/builds.ts
 init_self();
-var sandboxStatusPath = () => join24(herdHome(), "builds", "sandbox.json");
+var sandboxStatusPath = () => join25(herdHome(), "builds", "sandbox.json");
 function writeSandboxStatus(status2, now = Date.now()) {
-  mkdirSync18(join24(herdHome(), "builds"), { recursive: true });
+  mkdirSync19(join25(herdHome(), "builds"), { recursive: true });
   writeFileSync14(sandboxStatusPath(), JSON.stringify({ ...status2, at: now }));
 }
 function readSandboxStatus() {
@@ -9098,7 +9338,7 @@ var real3 = (path) => {
   }
 };
 function worktreeOf(dir, store) {
-  if (!existsSync17(join24(dir, ".git"))) return false;
+  if (!existsSync17(join25(dir, ".git"))) return false;
   try {
     return real3(git2(dir, "rev-parse", "--path-format=absolute", "--git-common-dir")) === real3(store);
   } catch {
@@ -9110,11 +9350,11 @@ function cloneFolder(from, to) {
   execFileSync5("cp", [...args, from, to]);
 }
 function moduleFolders(dir) {
-  const found = existsSync17(join24(dir, "node_modules")) ? ["node_modules"] : [];
-  for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+  const found = existsSync17(join25(dir, "node_modules")) ? ["node_modules"] : [];
+  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-      if (existsSync17(join24(dir, entry.name, "node_modules")))
-        found.push(join24(entry.name, "node_modules"));
+      if (existsSync17(join25(dir, entry.name, "node_modules")))
+        found.push(join25(entry.name, "node_modules"));
     }
   }
   return found;
@@ -9122,11 +9362,11 @@ function moduleFolders(dir) {
 function checkoutManager(dir) {
   let field;
   try {
-    const pkg = JSON.parse(readFileSync17(join24(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync17(join25(dir, "package.json"), "utf8"));
     if (typeof pkg.packageManager === "string") field = pkg.packageManager;
   } catch {
   }
-  const found = managerOfCheckout(field, (name) => existsSync17(join24(dir, name)));
+  const found = managerOfCheckout(field, (name) => existsSync17(join25(dir, name)));
   if (!found?.lockfile)
     throw new Error(
       `${dir} has no lockfile to install node_modules from: herd looked for ${Object.values(LOCKFILES).flat().join(", ")}.`
@@ -9134,7 +9374,7 @@ function checkoutManager(dir) {
   return { ...found, lockfile: found.lockfile };
 }
 function lockHash(dir) {
-  const lock = readFileSync17(join24(dir, checkoutManager(dir).lockfile));
+  const lock = readFileSync17(join25(dir, checkoutManager(dir).lockfile));
   const major = process.versions.node.split(".")[0];
   return createHash3("sha256").update(lock).update(`${process.platform}-${process.arch}-${major}`).digest("hex").slice(0, 32);
 }
@@ -9146,7 +9386,7 @@ var frozenInstall = (gitEnv) => async (dir) => {
     throw new Error(`${dir} installs with ${name}, which isn't on this machine, or doesn't run.`);
   const args = frozenInstallArgs(name, { offline: insideBuildSandbox(), yarnMajor: major });
   await new Promise((resolve8, reject) => {
-    const child = spawn10(manager.command, args, {
+    const child = spawn11(manager.command, args, {
       cwd: dir,
       env: { ...env, COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
       stdio: "ignore"
@@ -9165,11 +9405,11 @@ var BuildRunner = class _BuildRunner {
   options;
   running = /* @__PURE__ */ new Map();
   home() {
-    return this.options.home ?? join24(herdHome(), "builds");
+    return this.options.home ?? join25(herdHome(), "builds");
   }
   /** Where builds' own bare clones are, apart from the root's checkouts. */
   clonesDir() {
-    return join24(this.home(), "clones");
+    return join25(this.home(), "clones");
   }
   /** Herd's bare clone of a build's repo, for builds, whether or not it's there yet. */
   storeFor(build) {
@@ -9190,8 +9430,8 @@ var BuildRunner = class _BuildRunner {
     const store = bareClonePath(this.clonesDir(), remote);
     const env = this.options.gitEnv?.();
     const name = (repoKey(build.repo) ?? build.repo).replace(/[^A-Za-z0-9._-]+/g, "_");
-    const dir = join24(this.home(), name, String(slot));
-    mkdirSync18(join24(this.home(), name), { recursive: true });
+    const dir = join25(this.home(), name, String(slot));
+    mkdirSync19(join25(this.home(), name), { recursive: true });
     await withStoreLock(
       store,
       async () => {
@@ -9205,7 +9445,7 @@ var BuildRunner = class _BuildRunner {
           await storeGit(env, store, "fetch", "--quiet", "origin", build.sha);
         }
         if (!worktreeOf(dir, store)) {
-          rmSync13(dir, { recursive: true, force: true });
+          rmSync14(dir, { recursive: true, force: true });
           await storeGit(env, store, "worktree", "prune");
           await storeGit(
             env,
@@ -9230,30 +9470,30 @@ var BuildRunner = class _BuildRunner {
   /** Makes `node_modules` match the checkout's lockfile: kept, copied from the cache, or installed. */
   async ensureModules(dir) {
     const wanted = lockHash(dir);
-    const marker = join24(dir, "node_modules", ".herd-lock");
+    const marker = join25(dir, "node_modules", ".herd-lock");
     if (existsSync17(marker) && readFileSync17(marker, "utf8") === wanted) return;
-    const cache = join24(this.home(), "node_modules", wanted);
+    const cache = join25(this.home(), "node_modules", wanted);
     for (const folder of moduleFolders(dir))
-      rmSync13(join24(dir, folder), { recursive: true, force: true });
-    if (existsSync17(join24(cache, ".complete"))) {
-      for (const folder of readFileSync17(join24(cache, ".complete"), "utf8").split("\n").filter(Boolean)) {
-        cloneFolder(join24(cache, folder), join24(dir, folder));
+      rmSync14(join25(dir, folder), { recursive: true, force: true });
+    if (existsSync17(join25(cache, ".complete"))) {
+      for (const folder of readFileSync17(join25(cache, ".complete"), "utf8").split("\n").filter(Boolean)) {
+        cloneFolder(join25(cache, folder), join25(dir, folder));
       }
     } else {
       this.options.log?.(`Installing node_modules for lockfile ${wanted.slice(0, 8)}.`);
       await (this.options.install ?? frozenInstall(this.options.gitEnv))(dir);
-      const staging = mkdtempSync(join24(this.home(), "node_modules-"));
+      const staging = mkdtempSync(join25(this.home(), "node_modules-"));
       const folders = moduleFolders(dir);
       for (const folder of folders) {
-        mkdirSync18(join24(staging, folder, ".."), { recursive: true });
-        cloneFolder(join24(dir, folder), join24(staging, folder));
+        mkdirSync19(join25(staging, folder, ".."), { recursive: true });
+        cloneFolder(join25(dir, folder), join25(staging, folder));
       }
-      writeFileSync14(join24(staging, ".complete"), folders.join("\n"));
-      mkdirSync18(join24(this.home(), "node_modules"), { recursive: true });
-      rmSync13(cache, { recursive: true, force: true });
+      writeFileSync14(join25(staging, ".complete"), folders.join("\n"));
+      mkdirSync19(join25(this.home(), "node_modules"), { recursive: true });
+      rmSync14(cache, { recursive: true, force: true });
       execFileSync5("mv", [staging, cache]);
     }
-    mkdirSync18(join24(dir, "node_modules"), { recursive: true });
+    mkdirSync19(join25(dir, "node_modules"), { recursive: true });
     writeFileSync14(marker, wanted);
   }
   /**
@@ -9264,7 +9504,7 @@ var BuildRunner = class _BuildRunner {
     const env = {
       PATH: process.env.PATH ?? "/usr/bin:/bin",
       HOME: home,
-      TMPDIR: join24(home, "tmp"),
+      TMPDIR: join25(home, "tmp"),
       LANG: process.env.LANG ?? "en_US.UTF-8",
       HERD_BUILD_ID: build.id,
       HERD_BUILD_SECRET: build.secret,
@@ -9276,7 +9516,7 @@ var BuildRunner = class _BuildRunner {
       // The sandbox's proxy is the only way out, and Node's own requests use it only when asked.
       NODE_USE_ENV_PROXY: "1",
       // Where `srt` points TMPDIR inside the sandbox: the build's own temporary folder.
-      CLAUDE_CODE_TMPDIR: join24(home, "tmp")
+      CLAUDE_CODE_TMPDIR: join25(home, "tmp")
     };
     return env;
   }
@@ -9287,8 +9527,8 @@ var BuildRunner = class _BuildRunner {
   /** Runs `scripts/build.mjs` from the build's own commit, in a process group of its own. */
   async run(build, slot) {
     const dir = await this.prepare(build, slot);
-    const home = mkdtempSync(join24(this.options.scratch ?? scratchRoot(), "hb-"));
-    mkdirSync18(join24(home, "tmp"), { recursive: true });
+    const home = mkdtempSync(join25(this.options.scratch ?? scratchRoot(), "hb-"));
+    mkdirSync19(join25(home, "tmp"), { recursive: true });
     const run4 = randomUUID4();
     const env = {
       ..._BuildRunner.environment(build, home),
@@ -9298,7 +9538,7 @@ var BuildRunner = class _BuildRunner {
       env.HERD_CHECK_CPUS = String(Math.max(1, Math.floor(this.options.cpus())));
     if (this.options.memoryMb)
       env.HERD_CHECK_MEMORY_MB = String(Math.max(1, Math.floor(this.options.memoryMb())));
-    let command = [process.execPath, join24(dir, "scripts", "build.mjs")];
+    let command = [process.execPath, join25(dir, "scripts", "build.mjs")];
     let policyPath = null;
     if (this.sandboxed()) {
       const policy = buildPolicy({
@@ -9313,8 +9553,8 @@ var BuildRunner = class _BuildRunner {
         main: build.main,
         buildsUrl: build.url
       });
-      mkdirSync18(join24(this.home(), "policies"), { recursive: true });
-      policyPath = join24(this.home(), "policies", `${build.id}.json`);
+      mkdirSync19(join25(this.home(), "policies"), { recursive: true });
+      policyPath = join25(this.home(), "policies", `${build.id}.json`);
       writeFileSync14(policyPath, JSON.stringify(policy), { mode: 384 });
       env.HERD_BUILD_SANDBOX = describePolicy(policy);
       command = [process.execPath, HERD_BIN, "build-sandbox", policyPath, "--", ...command];
@@ -9322,7 +9562,7 @@ var BuildRunner = class _BuildRunner {
       env.HERD_BUILD_SANDBOX = insideBuildSandbox() ? "Inside the sandbox of the build that started this one." : "";
     }
     const [executable, ...args] = command;
-    const child = spawn10(executable, args, { cwd: dir, env, stdio: "ignore", detached: true });
+    const child = spawn11(executable, args, { cwd: dir, env, stdio: "ignore", detached: true });
     const done = new Promise((resolve8) => {
       child.on("error", () => resolve8(1));
       child.on("close", (code) => resolve8(code ?? 1));
@@ -9342,8 +9582,8 @@ var BuildRunner = class _BuildRunner {
       unregister();
       await this.stopBuildProcesses(run4, dir, entry.pid);
       if (this.running.get(build.id) === entry) this.running.delete(build.id);
-      rmSync13(home, { recursive: true, force: true });
-      if (policyPath) rmSync13(policyPath, { force: true });
+      rmSync14(home, { recursive: true, force: true });
+      if (policyPath) rmSync14(policyPath, { force: true });
       markEnded();
     }
   }
@@ -9363,7 +9603,7 @@ var BuildRunner = class _BuildRunner {
    * It goes only by where they run from, never by a build ID, since the daemon a build's own tests
    * start must never stop the build it runs in.
    */
-  static async sweep(home = join24(herdHome(), "builds"), list = listProcesses) {
+  static async sweep(home = join25(herdHome(), "builds"), list = listProcesses) {
     const left = buildProcesses(list(), null, home);
     await stopPids(left);
     return left.length;
@@ -9375,37 +9615,37 @@ var BuildRunner = class _BuildRunner {
    */
   static async probe(options = { buildsUrl: "" }) {
     if (insideBuildSandbox()) return { ok: true };
-    const herd = options.home ?? join24(herdHome(), "builds");
-    const dir = mkdtempSync(join24(scratchRoot(), "hp-"));
-    const secret = join24(dir, "owner", "secret");
+    const herd = options.home ?? join25(herdHome(), "builds");
+    const dir = mkdtempSync(join25(scratchRoot(), "hp-"));
+    const secret = join25(dir, "owner", "secret");
     try {
-      mkdirSync18(herd, { recursive: true });
-      for (const sub of ["work", "git", "home", "owner"]) mkdirSync18(join24(dir, sub));
+      mkdirSync19(herd, { recursive: true });
+      for (const sub of ["work", "git", "home", "owner"]) mkdirSync19(join25(dir, sub));
       writeFileSync14(secret, "probe");
       const policy = buildPolicy({
-        ownerHome: join24(dir, "owner"),
-        root: join24(dir, "owner"),
-        convos: join24(dir, "owner"),
-        worktree: join24(dir, "work"),
-        store: join24(dir, "git"),
-        worktreeGitDir: join24(dir, "git"),
-        home: join24(dir, "home"),
+        ownerHome: join25(dir, "owner"),
+        root: join25(dir, "owner"),
+        convos: join25(dir, "owner"),
+        worktree: join25(dir, "work"),
+        store: join25(dir, "git"),
+        worktreeGitDir: join25(dir, "git"),
+        home: join25(dir, "home"),
         nodePrefix: nodePrefix(),
         main: false,
         buildsUrl: options.buildsUrl || "https://builds.herdingchats.com"
       });
-      const policyPath = join24(herd, "probe-policy.json");
+      const policyPath = join25(herd, "probe-policy.json");
       writeFileSync14(policyPath, JSON.stringify(policy), { mode: 384 });
       const script = [
         'const fs = require("node:fs");',
         `try { fs.readFileSync(${JSON.stringify(secret)}); process.exit(10); } catch {}`,
-        `fs.writeFileSync(${JSON.stringify(join24(dir, "home", "ok"))}, "ok");`
+        `fs.writeFileSync(${JSON.stringify(join25(dir, "home", "ok"))}, "ok");`
       ].join(" ");
-      const child = spawn10(
+      const child = spawn11(
         process.execPath,
         [HERD_BIN, "build-sandbox", policyPath, "--", process.execPath, "-e", script],
         {
-          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join24(dir, "home") },
+          env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: join25(dir, "home") },
           stdio: ["ignore", "ignore", "pipe"]
         }
       );
@@ -9419,7 +9659,7 @@ var BuildRunner = class _BuildRunner {
       clearTimeout(timer);
       if (status2 === 10)
         return { ok: false, reason: "the sandbox let a build read the owner's files" };
-      if (status2 !== 0 || !existsSync17(join24(dir, "home", "ok"))) {
+      if (status2 !== 0 || !existsSync17(join25(dir, "home", "ok"))) {
         const why = stderr.trim().split("\n").at(-1) || `the probe exited with ${status2}`;
         return { ok: false, reason: why.slice(0, 300) };
       }
@@ -9427,7 +9667,7 @@ var BuildRunner = class _BuildRunner {
     } catch (error) {
       return { ok: false, reason: String(error).slice(0, 300) };
     } finally {
-      rmSync13(dir, { recursive: true, force: true });
+      rmSync14(dir, { recursive: true, force: true });
     }
   }
   /** Stops a build's process group and every process it started, however it got away. */
@@ -9456,7 +9696,7 @@ function listProcesses() {
 function listFromProc() {
   let pids = [];
   try {
-    pids = readdirSync8("/proc").filter((name) => /^\d+$/.test(name));
+    pids = readdirSync9("/proc").filter((name) => /^\d+$/.test(name));
   } catch {
     return [];
   }
@@ -9634,7 +9874,7 @@ var DEFAULT_TIMING3 = {
   confirmMs: 8e3,
   pasteMs: 600
 };
-var sleep5 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
+var sleep6 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
 var EXIT_WAIT_MS3 = 5e3;
 var CodexDriver = class {
   constructor(terminals, timing = {}) {
@@ -9657,7 +9897,7 @@ var CodexDriver = class {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
       if (Date.now() > end) return null;
-      await sleep5(this.timing.pollMs);
+      await sleep6(this.timing.pollMs);
     }
   }
   /** Waits for a terminal's output to stop changing, as a shell does once it's ready. */
@@ -9673,7 +9913,7 @@ var CodexDriver = class {
       } else if (Date.now() - stableSince >= this.timing.settleMs) {
         return;
       }
-      await sleep5(this.timing.pollMs);
+      await sleep6(this.timing.pollMs);
     }
   }
   /**
@@ -9739,10 +9979,10 @@ var CodexDriver = class {
         }
       });
     });
-    const confirmed = () => Promise.race([reported, sleep5(this.timing.confirmMs)]);
+    const confirmed = () => Promise.race([reported, sleep6(this.timing.confirmMs)]);
     try {
       if (!leftover) await this.terminals.type(name, text4);
-      await sleep5(this.timing.pasteMs);
+      await sleep6(this.timing.pasteMs);
       const head = sent.slice(0, 40);
       let inBox = true;
       for (let attempt = 0; attempt <= SUBMIT_RETRIES && !taken; attempt++) {
@@ -9772,7 +10012,7 @@ var CodexDriver = class {
   async exit(name) {
     if ((await this.read(name)).program !== "codex") return;
     await this.terminals.type(name, "/exit");
-    await sleep5(this.timing.pasteMs);
+    await sleep6(this.timing.pasteMs);
     await this.terminals.press(name, "enter");
     await this.until(name, (reading) => reading.program !== "codex", EXIT_WAIT_MS3);
   }
@@ -9780,7 +10020,7 @@ var CodexDriver = class {
 
 // src/daemon.ts
 init_define_HERD_PACKAGE();
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 
 // src/dispatch-connection.ts
 init_define_HERD_PACKAGE();
@@ -9895,7 +10135,7 @@ var DispatchConnection = class {
 
 // src/daemon.ts
 var CONFIG_POLL_MS = 2e3;
-var daemonSocketPath = () => join25(herdHome(), "daemon.sock");
+var daemonSocketPath = () => join26(herdHome(), "daemon.sock");
 var Daemon = class {
   constructor(options) {
     this.options = options;
@@ -10108,7 +10348,7 @@ var Daemon = class {
 
 // src/folders.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync18, lstatSync as lstatSync3, readlinkSync as readlinkSync2, rmSync as rmSync14, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync18, lstatSync as lstatSync3, readlinkSync as readlinkSync2, rmSync as rmSync15, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname14, resolve as resolve5 } from "node:path";
 var FOLDER_WAIT_MS = 2 * 60 * 1e3;
 var FOLDER_CHECK_MS = 30 * 1e3;
@@ -10191,7 +10431,7 @@ var FolderWatch = class {
   write() {
     try {
       if (this.current) writeFileSync15(this.options.statusPath, JSON.stringify(this.current));
-      else rmSync14(this.options.statusPath, { force: true });
+      else rmSync15(this.options.statusPath, { force: true });
     } catch {
     }
   }
@@ -10200,7 +10440,7 @@ var FolderWatch = class {
 // src/gh.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { execFile as execFile4, spawn as spawn11 } from "node:child_process";
+import { execFile as execFile4, spawn as spawn12 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 var GH_CHECK_MS = 10 * 60 * 1e3;
 var GH_CODE_WAIT_MS = 30 * 1e3;
@@ -10271,7 +10511,7 @@ function readDeviceCode(output2) {
   return code && url === GITHUB_DEVICE_URL ? { code, url: GITHUB_DEVICE_URL } : null;
 }
 async function signInGh(options) {
-  const spawnGh = options.spawnGh ?? ((args) => spawn11("gh", args, {
+  const spawnGh = options.spawnGh ?? ((args) => spawn12("gh", args, {
     env: options.env?.() ?? process.env,
     stdio: ["ignore", "pipe", "pipe"]
   }));
@@ -10324,20 +10564,20 @@ import { execFileSync as execFileSync6 } from "node:child_process";
 import {
   appendFileSync as appendFileSync2,
   existsSync as existsSync19,
-  mkdirSync as mkdirSync19,
+  mkdirSync as mkdirSync20,
   readFileSync as readFileSync18,
   renameSync as renameSync6,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join26 } from "node:path";
-var LOCAL_SETTINGS = join26(".claude", "settings.local.json");
+import { isAbsolute as isAbsolute5, join as join27 } from "node:path";
+var LOCAL_SETTINGS = join27(".claude", "settings.local.json");
 var git3 = (cwd, ...args) => execFileSync6("git", ["-C", cwd, ...args], {
   encoding: "utf8",
   stdio: ["ignore", "pipe", "pipe"]
 }).trim();
 var shellQuote2 = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 function writeWorktreeSettings(worktree, settings, ownCommand) {
-  const path = join26(worktree, LOCAL_SETTINGS);
+  const path = join27(worktree, LOCAL_SETTINGS);
   let current = {};
   if (existsSync19(path)) {
     try {
@@ -10361,7 +10601,7 @@ function writeWorktreeSettings(worktree, settings, ownCommand) {
     }
     next.hooks = hooks;
   }
-  mkdirSync19(join26(worktree, ".claude"), { recursive: true });
+  mkdirSync20(join27(worktree, ".claude"), { recursive: true });
   const temporary = `${path}.herd-${process.pid}`;
   writeFileSync16(temporary, `${JSON.stringify(next, null, 2)}
 `);
@@ -10381,12 +10621,12 @@ function ignoreLocalSettings(worktree) {
   } catch {
     return;
   }
-  const info = join26(isAbsolute5(common) ? common : join26(worktree, common), "info");
-  const exclude = join26(info, "exclude");
+  const info = join27(isAbsolute5(common) ? common : join27(worktree, common), "info");
+  const exclude = join27(info, "exclude");
   const line2 = "/.claude/settings.local.json";
   const existing = existsSync19(exclude) ? readFileSync18(exclude, "utf8") : "";
   if (existing.split("\n").includes(line2)) return;
-  mkdirSync19(info, { recursive: true });
+  mkdirSync20(info, { recursive: true });
   appendFileSync2(exclude, `${existing && !existing.endsWith("\n") ? "\n" : ""}${line2}
 `);
 }
@@ -10429,7 +10669,7 @@ function loginShellEnv() {
 
 // src/machine-checks.ts
 init_define_HERD_PACKAGE();
-import { existsSync as existsSync20, rmSync as rmSync15 } from "node:fs";
+import { existsSync as existsSync20, rmSync as rmSync16 } from "node:fs";
 var REQUEST_POLL_MS = 2e3;
 var MachineChecks = class {
   constructor(options) {
@@ -10476,7 +10716,7 @@ var MachineChecks = class {
   takeRequest() {
     const path = activationRequestPath(this.options.herdHome);
     if (!existsSync20(path)) return;
-    rmSync15(path, { force: true });
+    rmSync16(path, { force: true });
     this.activateChosen(true);
   }
   start() {
@@ -10522,237 +10762,6 @@ var MachineChecks = class {
   }
 };
 
-// src/terminals.ts
-init_define_HERD_PACKAGE();
-import { spawn as spawn12 } from "node:child_process";
-import { mkdirSync as mkdirSync20, readdirSync as readdirSync9, rmSync as rmSync16 } from "node:fs";
-import { connect as connect2 } from "node:net";
-import { join as join27 } from "node:path";
-init_self();
-import {
-  HOST_PROTOCOL,
-  hostVersion
-} from "./terminal-host.mjs";
-var hostsDir = () => join27(herdHome(), "terminals");
-var legacyHostSocketPath = () => join27(herdHome(), "terminals.sock");
-var currentHostSocketPath = (version = hostVersion()) => join27(hostsDir(), `${version}.sock`);
-var speaksProtocol = (protocol) => protocol === HOST_PROTOCOL || protocol === HOST_PROTOCOL - 1;
-var sleep6 = (ms2) => new Promise((resolve8) => setTimeout(resolve8, ms2));
-function askHost(path, request) {
-  return new Promise((resolve8, reject) => {
-    const socket = connect2(path);
-    let data = "";
-    socket.on("connect", () => socket.write(`${JSON.stringify(request)}
-`));
-    socket.on("data", (chunk) => data += chunk);
-    socket.on("end", () => {
-      try {
-        const reply = JSON.parse(data);
-        if (reply.ok) resolve8(reply);
-        else reject(new HerdError(reply.error ?? "The terminal host refused that."));
-      } catch {
-        reject(new HerdError("The terminal host's answer wasn't readable."));
-      }
-    });
-    socket.on("error", reject);
-  });
-}
-var isDead = (error) => {
-  const code = error?.code;
-  return code === "ECONNREFUSED" || code === "ENOENT";
-};
-var HostTerminals = class {
-  hosts = [];
-  /** Which host each terminal name was last found in. */
-  where = /* @__PURE__ */ new Map();
-  version;
-  log;
-  constructor(options = {}) {
-    this.version = options.version ?? hostVersion();
-    this.log = options.log ?? (() => {
-    });
-  }
-  currentVersion() {
-    return this.version;
-  }
-  unreachable(version) {
-    return this.hosts.some((host) => host.hello.version === version && !host.speaks);
-  }
-  /** Every host that answers, with sockets nothing answers on removed. */
-  async discover() {
-    const dir = hostsDir();
-    let names = [];
-    try {
-      names = readdirSync9(dir).filter((name) => name.endsWith(".sock"));
-    } catch {
-    }
-    const paths = [legacyHostSocketPath(), ...names.map((name) => join27(dir, name))];
-    const found = [];
-    for (const path of paths) {
-      try {
-        const hello = await askHost(path, { op: "hello" });
-        found.push({
-          path,
-          hello,
-          current: hello.version === this.version && speaksProtocol(hello.protocol),
-          speaks: speaksProtocol(hello.protocol)
-        });
-      } catch (error) {
-        if (isDead(error) && path !== legacyHostSocketPath()) rmSync16(path, { force: true });
-      }
-    }
-    this.hosts = found;
-    return found;
-  }
-  current() {
-    return this.hosts.find((host) => host.current);
-  }
-  /** Starts a host of the daemon's own version if none is running, detached so it outlives it. */
-  async ensureHost() {
-    const hosts = await this.discover();
-    for (const host of hosts) {
-      const version = host.hello.version ?? "unversioned";
-      const role = host.current ? "current" : host.speaks ? "older" : "not driveable";
-      this.log(
-        `Terminal host ${version} (protocol ${host.hello.protocol}, pid ${host.hello.pid}): ${role}.`
-      );
-    }
-    if (this.current()) return;
-    const path = currentHostSocketPath(this.version);
-    mkdirSync20(hostsDir(), { recursive: true, mode: 448 });
-    const child = spawn12(process.execPath, [herdBin, "terminal-host", "--socket", path], {
-      detached: true,
-      stdio: "ignore",
-      env: { ...process.env, HERD_HOME: herdHome() }
-    });
-    child.unref();
-    for (let attempt = 0; attempt < 50 && !this.current(); attempt++) {
-      await sleep6(100);
-      const hello = await askHost(path, { op: "hello" }).catch(() => null);
-      if (!hello) continue;
-      if (hello.version !== this.version) {
-        throw new HerdError(
-          `The terminal host started as version ${hello.version}, not ${this.version}, so its files changed as it started. Starting the daemon again picks this up.`
-        );
-      }
-      this.hosts.push({ path, hello, current: true, speaks: speaksProtocol(hello.protocol) });
-    }
-    if (!this.current()) throw new HerdError("The terminal host didn't start.");
-    this.log(`Started terminal host ${this.version}.`);
-  }
-  /**
-   * Every driveable host's terminals. A name in more than one host, as when a session moved, is
-   * the running one, or else the newest.
-   */
-  async list() {
-    if (this.hosts.length === 0) await this.discover();
-    const byName = /* @__PURE__ */ new Map();
-    for (const host of this.hosts.filter((candidate) => candidate.speaks)) {
-      const terminals = await askHost(host.path, { op: "list" }).then((reply) => reply.terminals).catch(() => []);
-      for (const info of terminals) {
-        const seen = byName.get(info.name);
-        const better = !seen || seen.info.exited && !info.exited || seen.info.exited === info.exited && info.createdAt > seen.info.createdAt;
-        if (better) byName.set(info.name, { info, path: host.path });
-      }
-    }
-    this.where = new Map([...byName].map(([name, { path }]) => [name, path]));
-    return [...byName.values()].map(({ info }) => info);
-  }
-  /** The socket of the host holding a terminal. */
-  async pathOf(name) {
-    let path = this.where.get(name);
-    if (!path) {
-      await this.list();
-      path = this.where.get(name);
-    }
-    if (!path) throw new HerdError(`There's no terminal named ${name}.`);
-    return path;
-  }
-  async askFor(name, request) {
-    return askHost(await this.pathOf(name), request);
-  }
-  async create(opts) {
-    const running = (await this.list()).find((t) => t.name === opts.name && !t.exited);
-    if (running) throw new HerdError(`A terminal named ${opts.name} is already running.`);
-    let host = this.current();
-    if (!host) {
-      await this.ensureHost();
-      host = this.current();
-    }
-    if (!host) throw new HerdError("The terminal host didn't start.");
-    const { terminal } = await askHost(host.path, {
-      op: "create",
-      ...opts
-    });
-    this.where.set(opts.name, host.path);
-    return terminal;
-  }
-  async screen(name) {
-    return (await this.askFor(name, { op: "screen", name })).screen;
-  }
-  async snapshot(name) {
-    return (await this.askFor(name, { op: "snapshot", name })).snapshot;
-  }
-  async type(name, text4) {
-    await this.askFor(name, { op: "type", name, text: text4 });
-  }
-  async press(name, key) {
-    await this.askFor(name, { op: "press", name, key });
-  }
-  async exitStatus(name) {
-    const terminal = (await this.list()).find((candidate) => candidate.name === name);
-    if (!terminal) throw new HerdError(`There's no terminal named ${name}.`);
-    return terminal.exited ? terminal.exitCode : null;
-  }
-  async kill(name) {
-    await this.askFor(name, { op: "kill", name });
-  }
-  async retire(canStop) {
-    const stopped2 = [];
-    for (const host of await this.discover()) {
-      if (host.current) continue;
-      const version = host.hello.version ?? "unversioned";
-      if (host.speaks) {
-        const terminals = await askHost(host.path, { op: "list" }).then((reply) => reply.terminals).catch(() => null);
-        if (!terminals) continue;
-        if (terminals.some((t) => !t.exited || (t.viewers ?? 0) > 0)) continue;
-      } else if (!host.hello.version || !canStop(host.hello.version)) {
-        continue;
-      }
-      if (await this.stop(host)) {
-        stopped2.push(version);
-        this.log(`Retired terminal host ${version}, which had nothing left running.`);
-      }
-    }
-    if (stopped2.length > 0) await this.discover();
-    return stopped2;
-  }
-  /** Stops a host: politely where it knows how, and otherwise by its process. */
-  async stop(host) {
-    if (host.speaks && host.hello.ops?.includes("shutdown")) {
-      return askHost(host.path, { op: "shutdown" }).then(
-        () => true,
-        () => false
-      );
-    }
-    const hello = await askHost(host.path, { op: "hello" }).catch(() => null);
-    if (!hello || hello.pid !== host.hello.pid) return false;
-    try {
-      process.kill(hello.pid, "SIGTERM");
-    } catch {
-      return false;
-    }
-    if (host.path === legacyHostSocketPath()) {
-      for (let attempt = 0; attempt < 20; attempt++) {
-        await sleep6(100);
-        if (!await askHost(host.path, { op: "hello" }).catch(() => null)) break;
-      }
-      rmSync16(host.path, { force: true });
-    }
-    return true;
-  }
-};
-
 // src/usage-reporter.ts
 init_define_HERD_PACKAGE();
 var USAGE_REPORT_MS = 5 * 60 * 1e3;
@@ -11962,7 +11971,7 @@ async function watchOne(ws, conversationId, terminals, rows = []) {
   const dialog = listed?.dialog ?? reading?.dialog ?? null;
   await followInvestigation(ws, workspace);
   workspace = ws.get(conversationId) ?? workspace;
-  if (needsInvestigator(ws, workspace, reading)) {
+  if ((lead?.viewers ?? 0) === 0 && needsInvestigator(ws, workspace, reading)) {
     ws.inBackground(
       openInvestigator(ws, workspace).catch(
         (error) => ws.log(`${conversationId}: the investigator didn't start: ${error}`)
@@ -12015,6 +12024,7 @@ async function watchOne(ws, conversationId, terminals, rows = []) {
     const owed = workspace.terminalNotice;
     const retryAt = (workspace.noticeFailedAt ?? 0) + (ws.options.noticeRetryMs ?? NOTICE_RETRY_MS);
     if (!owed && Date.now() < retryAt) return;
+    if (someoneDriving(lead, ws.options.driverQuietMs)) return;
     ws.update(conversationId, { deferred: false, terminalNotice: false });
     const claimed = workspace.deferred && await claim(ws, workspace);
     if (claimed || owed) {
@@ -12033,7 +12043,7 @@ async function watchOne(ws, conversationId, terminals, rows = []) {
     if (idle.idleSince === null && !idle.claimId) {
       idle = ws.update(conversationId, { idleSince: Date.now() });
     }
-    await shutDownIfDone(ws, idle, reading.draft, lead.viewers);
+    await shutDownIfDone(ws, idle, reading.draft, lookingAt(lead));
   }
 }
 function unreachable(ws, workspace) {
@@ -12095,7 +12105,7 @@ async function endTurn(ws, workspace) {
 async function shutDownIfDone(ws, workspace, draft, viewers) {
   if (workspace.idleSince === null || workspace.claimId) return;
   if (!workspace.exitRequested && Date.now() - workspace.idleSince < ws.idleMs) return;
-  if (draft || (viewers ?? 0) > 0) return;
+  if (draft || viewers > 0) return;
   await ws.driverFor(workspace).exit(workspace.lead);
   await ws.options.terminals.kill(workspace.lead);
   await ws.report(workspace.conversationId, "exited");
@@ -12161,9 +12171,13 @@ async function deliver(ws, conversationId, delivery) {
     if (!workspace.startProven) workspace = ws.update(conversationId, { checkInFrom: Date.now() });
     return afterSubmit(ws, workspace, result2);
   }
+  const lead = (await ws.options.terminals.list()).find((t) => t.name === workspace.lead);
+  if (someoneDriving(lead, ws.options.driverQuietMs)) {
+    ws.update(conversationId, { deferred: true });
+    return;
+  }
   let reading = await ws.driverFor(workspace).read(workspace.lead);
   if (reading.knownDialog) {
-    const lead = (await ws.options.terminals.list()).find((t) => t.name === workspace.lead);
     if (await closeKnownDialog(ws, workspace, reading.knownDialog, lead?.viewers ?? 0)) {
       reading = await ws.driverFor(workspace).read(workspace.lead);
     }
@@ -13883,6 +13897,7 @@ async function runDaemon(args) {
     ...timing.agyIdleSettleMs === void 0 ? {} : { agyIdleSettleMs: timing.agyIdleSettleMs },
     ...timing.promptPollMs === void 0 ? {} : { promptPollMs: timing.promptPollMs },
     ...timing.noticeRetryMs === void 0 ? {} : { noticeRetryMs: timing.noticeRetryMs },
+    ...timing.driverQuietMs === void 0 ? {} : { driverQuietMs: timing.driverQuietMs },
     ...timing.investigateAfterMs === void 0 ? {} : { investigateAfterMs: timing.investigateAfterMs },
     config: () => loadConfig(),
     root: () => machineRoot(),
@@ -14580,7 +14595,7 @@ init_define_HERD_PACKAGE();
 init_define_HERD_PACKAGE();
 import { connect as connect4 } from "node:net";
 var DETACH_KEY = "";
-function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: process.stdout }, path = currentHostSocketPath()) {
+function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: process.stdout }, path = currentHostSocketPath(), { watch: watch2 = false } = {}) {
   return new Promise((resolve8, reject) => {
     const socket = connect4(path);
     const size = () => ({ cols: stdout.columns || 120, rows: stdout.rows || 40 });
@@ -14601,7 +14616,7 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
       const data = chunk.toString("utf8");
       const detach = data.indexOf(DETACH_KEY);
       const before = detach >= 0 ? data.slice(0, detach) : data;
-      if (before) socket.write(`${JSON.stringify({ type: "input", data: before })}
+      if (before && !watch2) socket.write(`${JSON.stringify({ type: "input", data: before })}
 `);
       if (detach >= 0) {
         stdout.write("\r\n[detached; it's still running]\r\n");
@@ -14612,8 +14627,10 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
 `);
     socket.on(
       "connect",
-      () => socket.write(`${JSON.stringify({ op: "attach", name, ...size() })}
-`)
+      () => socket.write(
+        `${JSON.stringify(watch2 ? { op: "watch", name } : { op: "attach", name, ...size() })}
+`
+      )
     );
     socket.on("data", (chunk) => {
       buffer += chunk;
@@ -14634,7 +14651,7 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
             if (stdin.isTTY) stdin.setRawMode(true);
             stdin.on("data", onInput);
             stdin.resume();
-            stdout.on("resize", onResize);
+            if (!watch2) stdout.on("resize", onResize);
           }
         } else if (message.type === "data") {
           stdout.write(message.data ?? "");
@@ -14657,7 +14674,8 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
 import { serveHost } from "./terminal-host.mjs";
 async function runAttach(rest) {
   const terminals = new HostTerminals();
-  const name = rest[0];
+  const watch2 = rest.includes("--watch");
+  const name = rest.find((arg) => arg !== "--watch");
   if (!name) {
     const running = (await terminals.list().catch(() => [])).filter((t) => !t.exited);
     console.log(
@@ -14666,7 +14684,7 @@ ${running.map((t) => `  ${t.name}  (${t.cwd})`).join("\n")}` : "No terminals are
     );
     return 0;
   }
-  const result = await attach(name, void 0, await terminals.pathOf(name));
+  const result = await attach(name, void 0, await terminals.pathOf(name), { watch: watch2 });
   return result === "detached" ? 0 : result.exitCode ?? 1;
 }
 async function runTerminalHost(rest) {
@@ -15241,7 +15259,7 @@ On this computer:
   daemon [--repo <path>]...
                         Run this machine's daemon, working from its root folder. Repos given with
                         --repo are only listed as known, since herd works in its own clones
-  attach [<terminal>]   Watch or take over a terminal. Ctrl+\\ detaches. With no name, lists them
+  attach [<terminal>]   Take over a terminal, or only watch it with --watch. Ctrl+\\ detaches. With no name, lists them
   builds [register|speed]
                         Whether this machine is a build runner, register it, with its owner's
                         approval in the browser, or show how long builds take. See builds --help