@herdingchats/friday 0.1.653 → 0.1.663

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.653", gitHead: "66b195d50009a6d5e3e3f7c256873c5b63fb1271" };
+    define_HERD_PACKAGE_default = { version: "0.1.663", gitHead: "8ba46f6a5262b074559ade9422eb6ff6a3326b3f" };
   }
 });
 
@@ -472,8 +472,69 @@ var init_github = __esm({
   }
 });
 
-// ../common-chat/src/usage.ts
+// ../common-chat/src/terminals.ts
 import { z as z6 } from "zod";
+var terminalAccessSchema, machineTerminalsSchema, terminalModeSchema, terminalTargetSchema, terminalClosedReasonSchema, size, terminalFrameSchema, TERMINAL_DIAL_MS, TERMINAL_IDLE_MS, TERMINAL_MAX_MS, TERMINAL_PROOF_MS;
+var init_terminals = __esm({
+  "../common-chat/src/terminals.ts"() {
+    "use strict";
+    init_define_HERD_PACKAGE();
+    terminalAccessSchema = z6.enum(["drive", "watch", "off"]);
+    machineTerminalsSchema = z6.object({ remote: terminalAccessSchema });
+    terminalModeSchema = z6.enum(["watch", "drive"]);
+    terminalTargetSchema = z6.discriminatedUnion("kind", [
+      z6.object({ kind: z6.literal("conversation"), conversationId: z6.string().min(1) }),
+      z6.object({ kind: z6.literal("activation"), agent: z6.string().min(1) })
+    ]);
+    terminalClosedReasonSchema = z6.enum([
+      // The page closed it, or the person let it go.
+      "closed",
+      // The machine never dialed, or its socket dropped.
+      "expired",
+      "machine_gone",
+      // Its limits: no input for a while, too long in all, or the browser's sign-in is due a check.
+      "idle",
+      "too_long",
+      "reauthorize",
+      // A newer session took its place on the machine.
+      "superseded",
+      // The machine wouldn't open it, saying why in `detail`.
+      "refused",
+      // The terminal itself exited.
+      "exited"
+    ]);
+    size = {
+      cols: z6.number().int().min(10).max(1e3),
+      rows: z6.number().int().min(5).max(1e3)
+    };
+    terminalFrameSchema = z6.discriminatedUnion("type", [
+      z6.object({ type: z6.literal("snapshot"), data: z6.string() }),
+      z6.object({ type: z6.literal("data"), data: z6.string() }),
+      z6.object({ type: z6.literal("exit"), exitCode: z6.number().int().nullable() }),
+      z6.object({ type: z6.literal("mode"), mode: terminalModeSchema }),
+      z6.object({ type: z6.literal("input"), data: z6.string().max(64 * 1024) }),
+      z6.object({ type: z6.literal("resize"), ...size }),
+      z6.object({ type: z6.literal("drive") }),
+      z6.object({ type: z6.literal("watch") }),
+      z6.object({
+        type: z6.literal("closed"),
+        reason: terminalClosedReasonSchema,
+        detail: z6.string().max(500).optional()
+      }),
+      z6.object({
+        type: z6.literal("refused"),
+        code: z6.enum(["confirmation_needed", "watch_only", "not_driving"])
+      })
+    ]);
+    TERMINAL_DIAL_MS = 60 * 1e3;
+    TERMINAL_IDLE_MS = 15 * 60 * 1e3;
+    TERMINAL_MAX_MS = 2 * 60 * 60 * 1e3;
+    TERMINAL_PROOF_MS = 60 * 60 * 1e3;
+  }
+});
+
+// ../common-chat/src/usage.ts
+import { z as z7 } from "zod";
 function currentUsage(usage, now) {
   if (!usage) return void 0;
   const fresh = (window) => window && window.resetsAt > now ? window : void 0;
@@ -491,38 +552,38 @@ var init_usage = __esm({
   "../common-chat/src/usage.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    usageWindowSchema = z6.object({
-      usedPercentage: z6.number().min(0).max(100),
-      resetsAt: z6.number().int().nonnegative()
+    usageWindowSchema = z7.object({
+      usedPercentage: z7.number().min(0).max(100),
+      resetsAt: z7.number().int().nonnegative()
     });
     USAGE_AGENTS = {
       "claude-code": "Claude",
       codex: "Codex",
       agy: "Antigravity"
     };
-    usageSchema = z6.object({
+    usageSchema = z7.object({
       fiveHour: usageWindowSchema.optional(),
       sevenDay: usageWindowSchema.optional(),
-      agent: z6.enum(["claude-code", "codex", "agy"]).optional()
+      agent: z7.enum(["claude-code", "codex", "agy"]).optional()
     }).refine((usage) => usage.fiveHour || usage.sevenDay, "Usage needs at least one window");
     MAX_ACTIVITY_LENGTH = 150;
-    activityTextSchema = z6.string().trim().min(1).max(MAX_ACTIVITY_LENGTH).regex(/^[^\r\n]+$/);
+    activityTextSchema = z7.string().trim().min(1).max(MAX_ACTIVITY_LENGTH).regex(/^[^\r\n]+$/);
     MAX_TITLE_LENGTH = 40;
-    titleSchema = z6.string().trim().min(1).max(MAX_TITLE_LENGTH).regex(/^[^\r\n]+$/);
-    listedWindowSchema = z6.union([
+    titleSchema = z7.string().trim().min(1).max(MAX_TITLE_LENGTH).regex(/^[^\r\n]+$/);
+    listedWindowSchema = z7.union([
       usageWindowSchema,
-      z6.object({ reset: z6.literal(true), resetsAt: z6.number().int().nonnegative() })
+      z7.object({ reset: z7.literal(true), resetsAt: z7.number().int().nonnegative() })
     ]);
-    listedUsageSchema = z6.object({
+    listedUsageSchema = z7.object({
       fiveHour: listedWindowSchema.optional(),
       sevenDay: listedWindowSchema.optional(),
-      agent: z6.enum(["claude-code", "codex", "agy"]).optional()
+      agent: z7.enum(["claude-code", "codex", "agy"]).optional()
     });
   }
 });
 
 // ../common-chat/src/workers.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function agentShortName(cli) {
   return AGENTS[cli]?.short ?? cli;
 }
@@ -558,11 +619,11 @@ var init_workers = __esm({
       "xcode",
       "image_generation"
     ];
-    capabilitySchema = z7.enum(CAPABILITIES);
+    capabilitySchema = z8.enum(CAPABILITIES);
     PLATFORMS = ["macos", "linux", "windows"];
-    platformSchema = z7.enum(PLATFORMS);
+    platformSchema = z8.enum(PLATFORMS);
     TOOLS = ["xcode", "gpu"];
-    toolSchema = z7.enum(TOOLS);
+    toolSchema = z8.enum(TOOLS);
     CAPABILITY_WORDING = {
       macos: "a Mac running macOS",
       linux: "a Linux computer",
@@ -580,51 +641,51 @@ var init_workers = __esm({
     PHRASE_MAX = 100;
     PHRASES_MAX = 10;
     ABOUT_MAX = 500;
-    phrase = z7.string().trim().min(1).max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`);
-    phrases = z7.array(phrase).max(PHRASES_MAX, `at most ${PHRASES_MAX} phrases`);
+    phrase = z8.string().trim().min(1).max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`);
+    phrases = z8.array(phrase).max(PHRASES_MAX, `at most ${PHRASES_MAX} phrases`);
     SHARES = ["off", "little", "some", "lot"];
-    shareSchema = z7.enum(SHARES);
+    shareSchema = z8.enum(SHARES);
     SHARE_LABELS = {
       off: "off",
       little: "a little",
       some: "some",
       lot: "a lot"
     };
-    harnessConfigSchema = z7.object({
+    harnessConfigSchema = z8.object({
       share: shareSchema.optional(),
       /** Read as `share: "off"` when false, from files written before shares. */
-      enabled: z7.boolean().optional(),
+      enabled: z8.boolean().optional(),
       only: phrases.optional(),
       great: phrases.optional(),
       good: phrases.optional(),
       okay: phrases.optional(),
       cant: phrases.optional(),
       /** false starts the harness's profile empty, rather than from herd's defaults. */
-      defaults: z7.boolean().optional(),
+      defaults: z8.boolean().optional(),
       /** Read as `great`, from files written before profiles. */
       prefer: phrases.optional(),
       /** Read as `cant`, from files written before profiles. */
       avoid: phrases.optional(),
-      priority: z7.number().int().min(-100).max(100).optional()
+      priority: z8.number().int().min(-100).max(100).optional()
     }).strict();
     BUILDS_MAX = 4;
-    buildsSettingSchema = z7.union([
-      z7.literal(true),
-      z7.object({ max: z7.number().int().min(1).max(BUILDS_MAX) }).strict()
+    buildsSettingSchema = z8.union([
+      z8.literal(true),
+      z8.object({ max: z8.number().int().min(1).max(BUILDS_MAX) }).strict()
     ]);
     CONFIG_REPOS_MAX = 50;
-    configRepoSchema = z7.object({
-      remote: z7.string().trim().min(1).max(300),
-      about: z7.string().trim().max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`).optional()
+    configRepoSchema = z8.object({
+      remote: z8.string().trim().min(1).max(300),
+      about: z8.string().trim().max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`).optional()
     }).strict();
-    herdConfigSchema = z7.object({
-      about: z7.string().trim().max(ABOUT_MAX, `at most ${ABOUT_MAX} characters`).optional(),
+    herdConfigSchema = z8.object({
+      about: z8.string().trim().max(ABOUT_MAX, `at most ${ABOUT_MAX} characters`).optional(),
       cant: phrases.optional(),
       /** Read as `cant`, from files written before profiles. */
       avoid: phrases.optional(),
-      harnesses: z7.record(z7.string().regex(/^[a-z][a-z0-9-]*$/), harnessConfigSchema).optional(),
+      harnesses: z8.record(z8.string().regex(/^[a-z][a-z0-9-]*$/), harnessConfigSchema).optional(),
       builds: buildsSettingSchema.optional(),
-      repos: z7.array(configRepoSchema).max(CONFIG_REPOS_MAX, `at most ${CONFIG_REPOS_MAX} repos`).optional()
+      repos: z8.array(configRepoSchema).max(CONFIG_REPOS_MAX, `at most ${CONFIG_REPOS_MAX} repos`).optional()
     }).strict();
     HERD_CONFIG_TYPE = `type HerdConfig = {
   /** What this machine is for, in plain words. At most ${ABOUT_MAX} characters. */
@@ -675,54 +736,55 @@ export default {
   harnesses: { claude: { great: ["code review"] }, codex: { cant: ["the billing service"] } },
 } satisfies HerdConfig;`;
     PROFILE_LEVELS = ["great", "good", "okay", "cant"];
-    profileEntrySchema = z7.object({
-      statement: z7.string().min(1),
-      level: z7.enum(PROFILE_LEVELS),
-      source: z7.enum(["default", "owner"])
-    });
-    workerSchema = z7.object({
-      key: z7.string().min(1),
-      name: z7.string().min(1),
-      machineId: z7.string().min(1),
-      machineName: z7.string().min(1),
-      agent: z7.string().min(1),
-      capabilities: z7.array(capabilitySchema),
-      about: z7.string().optional(),
-      only: z7.array(z7.string()),
+    profileEntrySchema = z8.object({
+      statement: z8.string().min(1),
+      level: z8.enum(PROFILE_LEVELS),
+      source: z8.enum(["default", "owner"])
+    });
+    workerSchema = z8.object({
+      key: z8.string().min(1),
+      name: z8.string().min(1),
+      machineId: z8.string().min(1),
+      machineName: z8.string().min(1),
+      agent: z8.string().min(1),
+      capabilities: z8.array(capabilitySchema),
+      about: z8.string().optional(),
+      only: z8.array(z8.string()),
       /** What it's great, good and okay at, and can't do: its agent's defaults with its owner's word. */
-      profile: z7.array(profileEntrySchema),
-      priority: z7.number().int(),
+      profile: z8.array(profileEntrySchema),
+      priority: z8.number().int(),
       /** How much of its agent its owner has. Servers from before shares send none, which is "some". */
       share: shareSchema.default("some"),
-      enabled: z7.boolean(),
+      enabled: z8.boolean(),
       /** Whether its agent checked in from herd's terminal on this version, so it's offered work. */
-      activated: z7.boolean(),
+      activated: z8.boolean(),
       activation: agentActivationSchema.optional(),
-      online: z7.boolean(),
+      online: z8.boolean(),
       /** A folder its machine works in that isn't there, so it's offered no work until it is. */
-      folderUnavailable: z7.object({ path: z7.string().min(1), target: z7.string().min(1).optional() }).optional(),
+      folderUnavailable: z8.object({ path: z8.string().min(1), target: z8.string().min(1).optional() }).optional(),
       // Its machine's repos, each marked whether herd has cloned it there. Older daemons send no `cloned`.
-      repos: z7.array(
-        z7.object({ name: z7.string(), remote: z7.string(), cloned: z7.boolean().optional() })
+      repos: z8.array(
+        z8.object({ name: z8.string(), remote: z8.string(), cloned: z8.boolean().optional() })
       ),
-      machineCreatedAt: z7.number().int().nonnegative()
+      machineCreatedAt: z8.number().int().nonnegative()
     });
   }
 });
 
 // ../common-chat/src/machines.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var nonEmpty4, time2, terminalStateSchema, agentStatusSchema, machineRepoSchema, isCloned, machineCliSchema, folderUnavailableSchema, machineRegistrationSchema, machineSchema, machinePresenceSchema, worktreeSchema, MAX_REPO_HINTS, repoHintSchema, terminalSchema, offerSchema, offerAnswerSchema, dispatchFrameSchema, machineMessageSchema;
 var init_machines = __esm({
   "../common-chat/src/machines.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
     init_activation();
+    init_terminals();
     init_usage();
     init_workers();
-    nonEmpty4 = z8.string().min(1);
-    time2 = z8.number().int().nonnegative();
-    terminalStateSchema = z8.enum([
+    nonEmpty4 = z9.string().min(1);
+    time2 = z9.number().int().nonnegative();
+    terminalStateSchema = z9.enum([
       "working",
       "idle",
       "waiting_on_someone",
@@ -730,64 +792,66 @@ var init_machines = __esm({
       "signed_out",
       "unknown"
     ]);
-    agentStatusSchema = z8.enum(["working", "idle", "waiting_on_someone", "exited"]);
-    machineRepoSchema = z8.object({
+    agentStatusSchema = z9.enum(["working", "idle", "waiting_on_someone", "exited"]);
+    machineRepoSchema = z9.object({
       name: nonEmpty4,
       remote: nonEmpty4,
-      cloned: z8.boolean().optional()
+      cloned: z9.boolean().optional()
     });
     isCloned = (repo) => repo.cloned !== false;
-    machineCliSchema = z8.object({
+    machineCliSchema = z9.object({
       name: nonEmpty4,
       version: nonEmpty4,
-      runnable: z8.boolean().optional(),
-      capabilities: z8.array(capabilitySchema).optional(),
+      runnable: z9.boolean().optional(),
+      capabilities: z9.array(capabilitySchema).optional(),
       activation: agentActivationSchema.optional()
     });
-    folderUnavailableSchema = z8.object({
-      path: z8.string().min(1).max(1e3),
-      target: z8.string().min(1).max(1e3).optional()
+    folderUnavailableSchema = z9.object({
+      path: z9.string().min(1).max(1e3),
+      target: z9.string().min(1).max(1e3).optional()
     });
-    machineRegistrationSchema = z8.object({
+    machineRegistrationSchema = z9.object({
       id: nonEmpty4,
       name: nonEmpty4,
-      repos: z8.array(machineRepoSchema),
-      clis: z8.array(machineCliSchema),
+      repos: z9.array(machineRepoSchema),
+      clis: z9.array(machineCliSchema),
       // The platform the agent actually runs on, and tools from herd's fixed list.
       platform: platformSchema.optional(),
-      tools: z8.array(toolSchema).optional(),
+      tools: z9.array(toolSchema).optional(),
       // The machine's validated `herd.config.ts`, and why the file on disk didn't load if it didn't.
       config: herdConfigSchema.optional(),
-      configError: z8.string().max(1e3).optional(),
+      configError: z9.string().max(1e3).optional(),
       // Whether its GitHub CLI is signed in, and as whom.
       gh: gitHubCliSchema.optional(),
       // A folder it works in that isn't there, while it takes no work.
       folderUnavailable: folderUnavailableSchema.optional(),
       // The daemon's own package version, or `dev` from a checkout. Daemons from before send none,
       // which reads as older than any that does.
-      herdVersion: z8.string().min(1).max(50).optional()
+      herdVersion: z9.string().min(1).max(50).optional(),
+      // What the web may do with its terminals. A daemon from before terminal sessions doesn't say.
+      terminals: machineTerminalsSchema.optional()
     });
     machineSchema = machineRegistrationSchema.extend({
       ownerId: nonEmpty4,
-      online: z8.boolean(),
+      online: z9.boolean(),
       lastSeenAt: time2,
       createdAt: time2
     });
-    machinePresenceSchema = z8.object({ name: nonEmpty4, online: z8.boolean() });
-    worktreeSchema = z8.object({ repo: nonEmpty4, branch: nonEmpty4 });
+    machinePresenceSchema = z9.object({ name: nonEmpty4, online: z9.boolean() });
+    worktreeSchema = z9.object({ repo: nonEmpty4, branch: nonEmpty4 });
     MAX_REPO_HINTS = 10;
-    repoHintSchema = z8.object({
+    repoHintSchema = z9.object({
       remote: nonEmpty4,
       branch: nonEmpty4.optional(),
       folder: nonEmpty4.optional()
     });
-    terminalSchema = z8.object({
+    terminalSchema = z9.object({
       id: nonEmpty4,
       name: nonEmpty4,
       machineId: nonEmpty4,
       conversationId: nonEmpty4,
       // The lead terminal receives the conversation's notices. Others are started with `herd run`.
-      lead: z8.boolean(),
+      lead: z9.boolean(),
       // Only for a conversation from before folders, which works in one repo's worktree.
       worktree: worktreeSchema.optional(),
       // The program the screen reader recognized, such as `claude-code` or `shell`, when it knows.
@@ -795,7 +859,7 @@ var init_machines = __esm({
       state: terminalStateSchema,
       updatedAt: time2
     });
-    offerSchema = z8.object({
+    offerSchema = z9.object({
       id: nonEmpty4,
       conversationId: nonEmpty4,
       machineId: nonEmpty4,
@@ -803,33 +867,41 @@ var init_machines = __esm({
       expiresAt: time2,
       // The repos the work hints, which the machine adds to the conversation's folder before the agent
       // starts. Hints never decide which machines are offered the work.
-      repos: z8.array(repoHintSchema).max(MAX_REPO_HINTS).optional(),
+      repos: z9.array(repoHintSchema).max(MAX_REPO_HINTS).optional(),
       // The first hint's remote, for daemons from before `repos`, which work in that one repo.
       repo: nonEmpty4.optional(),
       // The agent CLI of the worker it's offered to. Without one, it's Claude Code.
       agent: nonEmpty4.optional(),
       // A handed-off conversation restores each of its repos from its branch, if the remote has it.
-      handoff: z8.boolean().optional()
+      handoff: z9.boolean().optional()
     });
-    offerAnswerSchema = z8.discriminatedUnion("answer", [
-      z8.object({ answer: z8.literal("accept") }),
-      z8.object({ answer: z8.literal("refuse"), reason: nonEmpty4 })
+    offerAnswerSchema = z9.discriminatedUnion("answer", [
+      z9.object({ answer: z9.literal("accept") }),
+      z9.object({ answer: z9.literal("refuse"), reason: nonEmpty4 })
     ]);
-    dispatchFrameSchema = z8.discriminatedUnion("type", [
-      z8.object({ type: z8.literal("offer"), offer: offerSchema }),
-      z8.object({
-        type: z8.literal("message"),
+    dispatchFrameSchema = z9.discriminatedUnion("type", [
+      z9.object({ type: z9.literal("offer"), offer: offerSchema }),
+      z9.object({
+        type: z9.literal("message"),
         conversationId: nonEmpty4,
-        delivery: z8.enum(["interrupt", "defer"])
+        delivery: z9.enum(["interrupt", "defer"])
       }),
-      z8.object({ type: z8.literal("reconnect") }),
+      z9.object({ type: z9.literal("reconnect") }),
       // Its owner asked for a sign-in on this machine, which the daemon runs and reports on.
-      z8.object({ type: z8.literal("sign_in"), signInId: nonEmpty4, tool: signInToolSchema })
+      z9.object({ type: z9.literal("sign_in"), signInId: nonEmpty4, tool: signInToolSchema }),
+      // Its owner opened a terminal session from the web, which the daemon dials. An older daemon
+      // ignores it, and the session expires.
+      z9.object({
+        type: z9.literal("terminal_open"),
+        sessionId: nonEmpty4,
+        target: terminalTargetSchema,
+        mode: terminalModeSchema
+      })
     ]);
-    machineMessageSchema = z8.discriminatedUnion("type", [
-      z8.object({ type: z8.literal("ack"), conversationId: nonEmpty4 }),
-      z8.object({
-        type: z8.literal("usage"),
+    machineMessageSchema = z9.discriminatedUnion("type", [
+      z9.object({ type: z9.literal("ack"), conversationId: nonEmpty4 }),
+      z9.object({
+        type: z9.literal("usage"),
         /** The worker's agent on this machine, such as `claude-code`. */
         agent: nonEmpty4,
         usage: usageSchema,
@@ -840,39 +912,39 @@ var init_machines = __esm({
 });
 
 // ../common-chat/src/prompts.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var nonEmpty5, id, promptKindSchema, promptOptionSchema, promptQuestionSchema, promptRequestSchema, promptOutcomeSchema;
 var init_prompts = __esm({
   "../common-chat/src/prompts.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    nonEmpty5 = z9.string().min(1);
-    id = z9.string().regex(/^[A-Za-z0-9_-]{1,40}$/).describe("Short, so it fits in a button's value and action ID");
-    promptKindSchema = z9.enum(["permission", "question", "plan", "automation"]);
-    promptOptionSchema = z9.object({
+    nonEmpty5 = z10.string().min(1);
+    id = z10.string().regex(/^[A-Za-z0-9_-]{1,40}$/).describe("Short, so it fits in a button's value and action ID");
+    promptKindSchema = z10.enum(["permission", "question", "plan", "automation"]);
+    promptOptionSchema = z10.object({
       id,
-      label: z9.string().trim().min(1).max(75),
-      description: z9.string().max(200).optional(),
+      label: z10.string().trim().min(1).max(75),
+      description: z10.string().max(200).optional(),
       // How a button for it is drawn: `primary` to go ahead, `danger` to refuse.
-      style: z9.enum(["primary", "danger"]).optional()
+      style: z10.enum(["primary", "danger"]).optional()
     });
-    promptQuestionSchema = z9.object({
+    promptQuestionSchema = z10.object({
       id,
-      text: z9.string().trim().min(1).max(300),
-      options: z9.array(promptOptionSchema).min(1).max(10)
+      text: z10.string().trim().min(1).max(300),
+      options: z10.array(promptOptionSchema).min(1).max(10)
     });
-    promptRequestSchema = z9.object({
+    promptRequestSchema = z10.object({
       kind: promptKindSchema,
-      title: z9.string().trim().min(1).max(150),
-      detail: z9.string().max(2800).optional(),
-      questions: z9.array(promptQuestionSchema).min(1).max(4)
+      title: z10.string().trim().min(1).max(150),
+      detail: z10.string().max(2800).optional(),
+      questions: z10.array(promptQuestionSchema).min(1).max(4)
     });
-    promptOutcomeSchema = z9.enum(["answered", "cancelled"]);
+    promptOutcomeSchema = z10.enum(["answered", "cancelled"]);
   }
 });
 
 // ../common-chat/src/pull-requests.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function statusOfPhase(phase) {
   return phase === "merged" ? "done" : phase === "closed" ? "closed" : "open";
 }
@@ -911,8 +983,8 @@ var init_pull_requests = __esm({
   "../common-chat/src/pull-requests.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    time3 = z10.number().int().nonnegative();
-    pullRequestPhaseSchema = z10.enum([
+    time3 = z11.number().int().nonnegative();
+    pullRequestPhaseSchema = z11.enum([
       "draft",
       "checks_running",
       "checks_failed",
@@ -923,7 +995,7 @@ var init_pull_requests = __esm({
       "merged",
       "closed"
     ]);
-    pullRequestMoveSchema = z10.enum(["you", "agent", "others", "nobody"]);
+    pullRequestMoveSchema = z11.enum(["you", "agent", "others", "nobody"]);
     PHASE_LABELS = {
       draft: "draft",
       checks_running: "checks running",
@@ -935,22 +1007,22 @@ var init_pull_requests = __esm({
       merged: "merged",
       closed: "closed"
     };
-    leadChangeSchema = z10.object({
+    leadChangeSchema = z11.object({
       /** Its repo and number, such as `api#104`, or "a pull request" when hidden. */
-      label: z10.string().min(1),
+      label: z11.string().min(1),
       phase: pullRequestPhaseSchema,
       move: pullRequestMoveSchema,
       changedAt: time3,
       /** How many of the conversation's other open pull requests are also the person's move. */
-      moreForYou: z10.number().int().nonnegative(),
+      moreForYou: z11.number().int().nonnegative(),
       /** Absent when hidden. */
-      url: z10.string().optional()
+      url: z11.string().optional()
     });
   }
 });
 
 // ../common-chat/src/work-objects.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function workLine(work) {
   const parts = [
     work.phase ? `${work.kind} ${PHASE_LABELS[work.phase]}` : `${work.kind} ${work.status}`
@@ -965,21 +1037,21 @@ var init_work_objects = __esm({
     "use strict";
     init_define_HERD_PACKAGE();
     init_pull_requests();
-    time4 = z11.number().int().nonnegative();
-    workKindSchema = z11.enum(["change", "ticket", "deploy", "document", "other"]);
-    workStatusSchema = z11.enum(["open", "done", "closed"]);
-    workSourceSchema = z11.enum(["agent", "provider"]);
+    time4 = z12.number().int().nonnegative();
+    workKindSchema = z12.enum(["change", "ticket", "deploy", "document", "other"]);
+    workStatusSchema = z12.enum(["open", "done", "closed"]);
+    workSourceSchema = z12.enum(["agent", "provider"]);
     MAX_WORK_TITLE = 200;
     MAX_WORK_DETAIL = 100;
     MAX_WORK_URL = 2048;
-    workObjectSchema = z11.object({
-      url: z11.string().min(1).max(MAX_WORK_URL),
+    workObjectSchema = z12.object({
+      url: z12.string().min(1).max(MAX_WORK_URL),
       kind: workKindSchema,
-      title: z11.string().min(1).max(MAX_WORK_TITLE),
+      title: z12.string().min(1).max(MAX_WORK_TITLE),
       status: workStatusSchema,
-      detail: z11.string().max(MAX_WORK_DETAIL).nullable(),
+      detail: z12.string().max(MAX_WORK_DETAIL).nullable(),
       /** Whether the conversation made it, rather than only being about it. */
-      made: z11.boolean(),
+      made: z12.boolean(),
       changedAt: time4,
       changedBy: workSourceSchema,
       createdAt: time4,
@@ -987,21 +1059,21 @@ var init_work_objects = __esm({
       phase: pullRequestPhaseSchema.nullable().optional(),
       move: pullRequestMoveSchema.nullable().optional(),
       /** The delegate holding it, when it's read from an ancestor. */
-      conversationId: z11.string().min(1).optional()
+      conversationId: z12.string().min(1).optional()
     });
-    workChangeSchema = z11.object({
-      url: z11.string().trim().min(1).max(MAX_WORK_URL),
+    workChangeSchema = z12.object({
+      url: z12.string().trim().min(1).max(MAX_WORK_URL),
       kind: workKindSchema.optional(),
-      title: z11.string().trim().min(1).max(2e3).optional(),
+      title: z12.string().trim().min(1).max(2e3).optional(),
       status: workStatusSchema.optional(),
-      detail: z11.string().trim().max(2e3).nullable().optional(),
-      made: z11.boolean().optional(),
+      detail: z12.string().trim().max(2e3).nullable().optional(),
+      made: z12.boolean().optional(),
       /** Only for a `change`. Its status then follows it. */
       phase: pullRequestPhaseSchema.optional(),
       /** Set by a provider, which knows who was asked to review. Otherwise it follows the phase. */
       move: pullRequestMoveSchema.optional()
     });
-    workFieldSchema = z11.enum([
+    workFieldSchema = z12.enum([
       "kind",
       "title",
       "status",
@@ -1010,27 +1082,27 @@ var init_work_objects = __esm({
       "phase",
       "move"
     ]);
-    workObjectSummarySchema = z11.object({
+    workObjectSummarySchema = z12.object({
       kind: workKindSchema,
       status: workStatusSchema,
-      made: z11.boolean(),
+      made: z12.boolean(),
       changedAt: time4,
       /** A pull request's phase and move, which say nothing of its content, so they're never hidden. */
       phase: pullRequestPhaseSchema.nullable().optional(),
       move: pullRequestMoveSchema.nullable().optional(),
-      url: z11.string().optional(),
-      title: z11.string().optional(),
-      detail: z11.string().nullable().optional(),
+      url: z12.string().optional(),
+      title: z12.string().optional(),
+      detail: z12.string().nullable().optional(),
       /** The delegate holding it, when it isn't the item's own conversation. */
-      conversationId: z11.string().min(1).optional()
+      conversationId: z12.string().min(1).optional()
     });
   }
 });
 
 // ../common-chat/src/events.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function event(type, payload) {
-  return z12.object({ ...eventBase, type: z12.literal(type), payload: z12.object(payload) });
+  return z13.object({ ...eventBase, type: z13.literal(type), payload: z13.object(payload) });
 }
 var routeSchema, deliveryModeSchema, eventSourceSchema, nonEmpty6, actorSchema, eventBase, entryIds, routingRecordSchema, threadChangeSchema, conversationEventSchema, conversationVisibilitySchema, conversationStatusSchema, conversationSummarySchema, placementSchema, treeSummarySchema, conversationSnapshotSchema, liveFrameSchema, adapterCapabilitiesSchema;
 var init_events = __esm({
@@ -1045,141 +1117,141 @@ var init_events = __esm({
     init_usage();
     init_work_objects();
     init_workers();
-    routeSchema = z12.enum(["direct", "mention", "joined"]);
-    deliveryModeSchema = z12.enum(["interrupt", "defer"]);
-    eventSourceSchema = z12.enum(["slack", "discord", "web", "api", "cli", "mcp", "system"]);
-    nonEmpty6 = z12.string().min(1);
-    actorSchema = z12.discriminatedUnion("kind", [
+    routeSchema = z13.enum(["direct", "mention", "joined"]);
+    deliveryModeSchema = z13.enum(["interrupt", "defer"]);
+    eventSourceSchema = z13.enum(["slack", "discord", "web", "api", "cli", "mcp", "system"]);
+    nonEmpty6 = z13.string().min(1);
+    actorSchema = z13.discriminatedUnion("kind", [
       // Someone signed in to this system. `id` is the stable person identifier.
-      z12.object({ kind: z12.literal("person"), id: nonEmpty6, name: nonEmpty6 }),
+      z13.object({ kind: z13.literal("person"), id: nonEmpty6, name: nonEmpty6 }),
       // An account on a platform, which may or may not be linked to a person.
-      z12.object({
-        kind: z12.literal("account"),
+      z13.object({
+        kind: z13.literal("account"),
         provider: nonEmpty6,
         tenant: nonEmpty6,
         subject: nonEmpty6,
-        name: z12.string().optional(),
-        isBot: z12.boolean()
+        name: z13.string().optional(),
+        isBot: z13.boolean()
       }),
-      z12.object({ kind: z12.literal("system") })
+      z13.object({ kind: z13.literal("system") })
     ]);
     eventBase = {
-      seq: z12.number().int().positive(),
+      seq: z13.number().int().positive(),
       source: eventSourceSchema,
       actor: actorSchema,
-      createdAt: z12.number().int().nonnegative()
+      createdAt: z13.number().int().nonnegative()
     };
-    entryIds = z12.array(nonEmpty6);
-    routingRecordSchema = z12.object({
-      eligible: z12.array(z12.object({ key: nonEmpty6, name: nonEmpty6 })),
-      questions: z12.array(
-        z12.object({
+    entryIds = z13.array(nonEmpty6);
+    routingRecordSchema = z13.object({
+      eligible: z13.array(z13.object({ key: nonEmpty6, name: nonEmpty6 })),
+      questions: z13.array(
+        z13.object({
           id: nonEmpty6,
           question: nonEmpty6,
-          probability: z12.number().min(0).max(1).nullable()
+          probability: z13.number().min(0).max(1).nullable()
         })
       ),
       model: nonEmpty6.optional(),
       // Why the model's answers weren't used, when they weren't.
-      fallback: z12.string().optional(),
-      removed: z12.array(z12.object({ key: nonEmpty6, name: nonEmpty6, rule: nonEmpty6 })),
-      order: z12.array(nonEmpty6),
+      fallback: z13.string().optional(),
+      removed: z13.array(z13.object({ key: nonEmpty6, name: nonEmpty6, rule: nonEmpty6 })),
+      order: z13.array(nonEmpty6),
       // Each ordered worker's fit, and the profile statement and level that gave it, when the model
       // answered.
-      fits: z12.array(
-        z12.object({
+      fits: z13.array(
+        z13.object({
           key: nonEmpty6,
-          fit: z12.number().min(0).max(1),
-          statement: z12.string().optional(),
-          level: z12.enum(["great", "good", "okay"]).optional()
+          fit: z13.number().min(0).max(1),
+          statement: z13.string().optional(),
+          level: z13.enum(["great", "good", "okay"]).optional()
         })
       ).optional(),
       // Profile statements left out to keep within the most questions one call asks.
-      dropped: z12.array(z12.string()).optional(),
+      dropped: z13.array(z13.string()).optional(),
       // The repos the work hinted, and the workers whose machine had cloned every one, which go first
       // among workers that tie on fit and priority.
-      hints: z12.array(nonEmpty6).optional(),
-      warm: z12.array(nonEmpty6).optional(),
+      hints: z13.array(nonEmpty6).optional(),
+      warm: z13.array(nonEmpty6).optional(),
       // Each ordered worker's share, how its weekly usage is pacing, and the weight that gives it. The
       // first worker was drawn by weight from those in `drawn`, which suited the work equally.
-      shares: z12.array(
-        z12.object({
+      shares: z13.array(
+        z13.object({
           key: nonEmpty6,
           share: shareSchema,
-          pacing: z12.enum(["ahead", "even", "under", "unknown"]),
-          weight: z12.number().nonnegative()
+          pacing: z13.enum(["ahead", "even", "under", "unknown"]),
+          weight: z13.number().nonnegative()
         })
       ).optional(),
-      drawn: z12.array(nonEmpty6).optional()
+      drawn: z13.array(nonEmpty6).optional()
     });
-    threadChangeSchema = z12.discriminatedUnion("kind", [
-      z12.object({ kind: z12.literal("edited"), messageId: nonEmpty6, previous: z12.string() }),
-      z12.object({
-        kind: z12.literal("reacted"),
+    threadChangeSchema = z13.discriminatedUnion("kind", [
+      z13.object({ kind: z13.literal("edited"), messageId: nonEmpty6, previous: z13.string() }),
+      z13.object({
+        kind: z13.literal("reacted"),
         messageId: nonEmpty6,
         reaction: nonEmpty6,
         /** The words of the message reacted to, cut short. */
-        target: z12.string(),
+        target: z13.string(),
         /** Whether Friday wrote that message. */
-        onBot: z12.boolean()
+        onBot: z13.boolean()
       })
     ]);
-    conversationEventSchema = z12.discriminatedUnion("type", [
+    conversationEventSchema = z13.discriminatedUnion("type", [
       event("message.created", {
         messageId: nonEmpty6,
-        text: z12.string(),
-        direction: z12.enum(["inbound", "outbound"]),
+        text: z13.string(),
+        direction: z13.enum(["inbound", "outbound"]),
         route: routeSchema.optional(),
         // Why the message did or didn't wake the conversation.
-        reason: z12.string().optional(),
+        reason: z13.string().optional(),
         // Loaded from before the conversation joined the thread, so it never waits for a response.
-        isContext: z12.boolean().optional(),
+        isContext: z13.boolean().optional(),
         // Set when the message was deleted on its platform. `text` is then empty.
-        deleted: z12.boolean().optional(),
+        deleted: z13.boolean().optional(),
         // Sent through the API but kept out of the platform, so only clients see it.
-        quiet: z12.boolean().optional(),
+        quiet: z13.boolean().optional(),
         // The client an agent sent it through, such as "Claude Code". Such a message is the agent's.
-        client: z12.string().optional(),
+        client: z13.string().optional(),
         // How to read `text`. Absent means plain text, as every message before this field was.
-        format: z12.enum(["markdown"]).optional(),
+        format: z13.enum(["markdown"]).optional(),
         // Files attached to it, kept with the conversation.
-        files: z12.array(messageFileSchema).optional(),
+        files: z13.array(messageFileSchema).optional(),
         // A platform's own layout, shown there in place of `text`. Every other surface shows `text`.
-        layout: z12.object({ platform: layoutPlatformSchema, blocks: z12.array(z12.unknown()) }).optional(),
+        layout: z13.object({ platform: layoutPlatformSchema, blocks: z13.array(z13.unknown()) }).optional(),
         // Set when this was posted in another channel, starting the conversation named here.
         post: postTargetSchema.optional(),
         // Set on a channel post's own conversation: the conversation that posted it. Its ID is left
         // out for anyone who can't read that conversation.
-        origin: z12.object({ conversationId: nonEmpty6.optional() }).optional(),
+        origin: z13.object({ conversationId: nonEmpty6.optional() }).optional(),
         // Set on Friday's one notice that a firing with no thread can't run yet, saying why.
         threadNotice: nonEmpty6.optional(),
         // Set when this reply answered an open prompt, so it never waits as a message of its own.
         answersPrompt: nonEmpty6.optional(),
         // Set on a child conversation's first message: the brief its parent's agent wrote, from the
         // principal's own account. `by` is the parent's worker.
-        delegation: z12.object({ parent: nonEmpty6, by: nonEmpty6 }).optional(),
+        delegation: z13.object({ parent: nonEmpty6, by: nonEmpty6 }).optional(),
         // Set on a message from another of the principal's conversations' agents, which is that agent's
         // words, not a person's. `posted` means a delegate already posted it in the thread, and
         // `outsideTree` that the sender isn't in this conversation's tree.
-        agentMessage: z12.object({
+        agentMessage: z13.object({
           from: nonEmpty6,
           worker: nonEmpty6,
-          posted: z12.boolean().optional(),
-          overdue: z12.boolean().optional(),
+          posted: z13.boolean().optional(),
+          overdue: z13.boolean().optional(),
           // herd's own note about the delegate, such as that it's waiting for its worker.
-          notice: z12.boolean().optional(),
-          outsideTree: z12.boolean().optional()
+          notice: z13.boolean().optional(),
+          outsideTree: z13.boolean().optional()
         }).optional(),
         // Set on a message a root posted for one of its children, which is labelled as the child's.
-        forChild: z12.object({ id: nonEmpty6, worker: nonEmpty6, for: nonEmpty6 }).optional(),
+        forChild: z13.object({ id: nonEmpty6, worker: nonEmpty6, for: nonEmpty6 }).optional(),
         // Set on an automation's firing, whose `text` is the owner's instructions, and on the opening
         // post that starts a conversation for one. `payload` is what the trigger brought: untrusted.
-        automation: z12.object({
+        automation: z13.object({
           id: nonEmpty6,
           name: nonEmpty6,
           reason: nonEmpty6,
           key: nonEmpty6,
-          payload: z12.string().optional(),
+          payload: z13.string().optional(),
           // The opening post a firing's reactions are shown on, in a conversation it started.
           opener: nonEmpty6.optional()
         }).optional(),
@@ -1190,27 +1262,27 @@ var init_events = __esm({
         // quiet waking work. For an edit `text` is the new words, and for a reaction its emoji.
         threadChange: threadChangeSchema.optional()
       }),
-      event("message.updated", { messageId: nonEmpty6, text: z12.string() }),
+      event("message.updated", { messageId: nonEmpty6, text: z13.string() }),
       // A decision model judged whether a reply in a joined thread was meant for the bot. `for_bot`
       // woke the conversation. `failed` means it couldn't be decided in time, so nothing woke.
       event("message.decided", {
         messageId: nonEmpty6,
-        messageSeq: z12.number().int().positive(),
-        outcome: z12.enum(["for_bot", "not_for_bot", "failed"]),
-        probability: z12.number().min(0).max(1).optional(),
+        messageSeq: z13.number().int().positive(),
+        outcome: z13.enum(["for_bot", "not_for_bot", "failed"]),
+        probability: z13.number().min(0).max(1).optional(),
         model: nonEmpty6,
-        error: z12.string().optional()
+        error: z13.string().optional()
       }),
       // A decision model judged whether the bot's last message of a turn asks a person to answer,
       // decide, provide or confirm something before it can carry on. `asks` keeps the conversation
       // waiting on them. `failed` means it couldn't be judged in time, so nothing changed.
       event("message.asked", {
         messageId: nonEmpty6,
-        messageSeq: z12.number().int().positive(),
-        outcome: z12.enum(["asks", "doesnt_ask", "failed"]),
-        probability: z12.number().min(0).max(1).optional(),
+        messageSeq: z13.number().int().positive(),
+        outcome: z13.enum(["asks", "doesnt_ask", "failed"]),
+        probability: z13.number().min(0).max(1).optional(),
         model: nonEmpty6,
-        error: z12.string().optional()
+        error: z13.string().optional()
       }),
       // One of an incoming message's files arrived, or couldn't. `file` replaces the one with its ID.
       event("message.file_changed", { messageId: nonEmpty6, file: messageFileSchema }),
@@ -1222,21 +1294,21 @@ var init_events = __esm({
       event("context.unavailable", { reason: nonEmpty6 }),
       event("mailbox.queued", {
         entryId: nonEmpty6,
-        messageSeq: z12.number().int().positive(),
+        messageSeq: z13.number().int().positive(),
         delivery: deliveryModeSchema
       }),
       event("mailbox.claimed", {
         claimId: nonEmpty6,
         entryIds,
         holder: nonEmpty6,
-        expiresAt: z12.number().int()
+        expiresAt: z13.number().int()
       }),
-      event("mailbox.renewed", { claimId: nonEmpty6, expiresAt: z12.number().int() }),
+      event("mailbox.renewed", { claimId: nonEmpty6, expiresAt: z13.number().int() }),
       event("mailbox.released", {
         claimId: nonEmpty6,
         entryIds,
         // `delegates` means messages held for delegates are waiting again now that they've settled.
-        reason: z12.enum(["released", "expired", "delegates"])
+        reason: z13.enum(["released", "expired", "delegates"])
       }),
       // A turn ended with delegates still open, so the messages it worked on wait for them, still ⏳.
       event("mailbox.held", { claimId: nonEmpty6, entryIds }),
@@ -1244,7 +1316,7 @@ var init_events = __esm({
       event("mailbox.completed", {
         entryIds,
         claimId: nonEmpty6.optional(),
-        outcome: z12.enum(["passed"]).optional()
+        outcome: z13.enum(["passed"]).optional()
       }),
       event("mailbox.cancelled", { entryIds, reason: nonEmpty6 }),
       // A person asked for what's waiting to be delivered again. The entries stay waiting.
@@ -1261,15 +1333,15 @@ var init_events = __esm({
         // The message it was delivering, when it was one of the conversation's own messages.
         messageId: nonEmpty6.optional(),
         // For `kind: "files"`, which of that message's files didn't arrive.
-        fileIds: z12.array(nonEmpty6).optional()
+        fileIds: z13.array(nonEmpty6).optional()
       }),
       event("status.changed", { status: agentStatusSchema }),
       // A work object was added or changed: the whole of it as it now stands, which fields changed, and
       // whether the agent or a provider changed them. Recording one never wakes the conversation.
       event("work.recorded", {
         work: workObjectSchema.omit({ conversationId: true }),
-        changed: z12.array(workFieldSchema),
-        added: z12.boolean(),
+        changed: z13.array(workFieldSchema),
+        added: z13.boolean(),
         by: workSourceSchema
       }),
       event("work.removed", { url: nonEmpty6, by: workSourceSchema }),
@@ -1282,7 +1354,7 @@ var init_events = __esm({
       event("prompt.opened", {
         promptId: nonEmpty6,
         ...promptRequestSchema.shape,
-        forChild: z12.object({ id: nonEmpty6, worker: nonEmpty6, promptId: nonEmpty6 }).optional()
+        forChild: z13.object({ id: nonEmpty6, worker: nonEmpty6, promptId: nonEmpty6 }).optional()
       }),
       // A reply in the thread answers with its `messageId`, and with `text` when it was taken as the
       // answer in its own words rather than as naming an option.
@@ -1291,12 +1363,12 @@ var init_events = __esm({
         questionId: nonEmpty6,
         optionId: nonEmpty6.optional(),
         messageId: nonEmpty6.optional(),
-        text: z12.string().optional()
+        text: z13.string().optional()
       }),
       event("prompt.closed", {
         promptId: nonEmpty6,
         outcome: promptOutcomeSchema,
-        reason: z12.string().optional()
+        reason: z13.string().optional()
       }),
       // Dispatch: which machine the conversation was offered to, and which one holds it.
       event("dispatch.offered", {
@@ -1320,19 +1392,19 @@ var init_events = __esm({
       // An agent started a child conversation on another worker, and how the child has gone since.
       event("delegation.started", {
         childId: nonEmpty6,
-        workers: z12.array(nonEmpty6),
-        routed: z12.boolean()
+        workers: z13.array(nonEmpty6),
+        routed: z13.boolean()
       }),
       event("delegation.settled", { childId: nonEmpty6 }),
       event("delegation.overdue", { childId: nonEmpty6 }),
-      event("delegation.waiting", { childId: nonEmpty6, waiting: z12.boolean() }),
+      event("delegation.waiting", { childId: nonEmpty6, waiting: z13.boolean() }),
       // An agent asked for its conversation to move to another worker once its turn ends.
       event("dispatch.handoff_requested", { workerKey: nonEmpty6, workerName: nonEmpty6 }),
       // Terminals on the bound machine. Their output never enters the history, only these facts.
       event("terminal.opened", {
         terminalId: nonEmpty6,
         machineId: nonEmpty6,
-        lead: z12.boolean(),
+        lead: z13.boolean(),
         // Only for a conversation from before folders, which works in one repo's worktree.
         worktree: worktreeSchema.optional()
       }),
@@ -1344,9 +1416,9 @@ var init_events = __esm({
         folder: nonEmpty6,
         branch: nonEmpty6,
         base: nonEmpty6.optional(),
-        fetchFailed: z12.string().max(1e3).optional()
+        fetchFailed: z13.string().max(1e3).optional()
       }),
-      event("terminal.exited", { terminalId: nonEmpty6, exitCode: z12.number().int().nullable() }),
+      event("terminal.exited", { terminalId: nonEmpty6, exitCode: z13.number().int().nullable() }),
       event("terminal.notice_failed", { terminalId: nonEmpty6, reason: nonEmpty6 }),
       /**
        * The agent's start didn't check in with `herd inbox` within its window, so it looks like it
@@ -1357,29 +1429,43 @@ var init_events = __esm({
         terminalId: nonEmpty6,
         agent: nonEmpty6,
         machineName: nonEmpty6,
-        detail: z12.string().max(200).optional()
+        detail: z13.string().max(200).optional()
       }),
       /** A start that needed attention checked in after all. */
       event("terminal.checked_in", { terminalId: nonEmpty6 }),
       /** The daemon closed one of Claude Code's own dialogs that it has recorded, named by its title. */
       event("terminal.dialog_closed", { terminalId: nonEmpty6, dialog: nonEmpty6 }),
+      /**
+       * Someone watched the conversation's terminal from the web, or typed into it, from `startedAt`
+       * until `endedAt`, and why it ended. Nothing of what was shown or typed is ever recorded.
+       */
+      event("terminal.watched", {
+        startedAt: z13.number().int(),
+        endedAt: z13.number().int(),
+        reason: nonEmpty6
+      }),
+      event("terminal.driven", {
+        startedAt: z13.number().int(),
+        endedAt: z13.number().int(),
+        reason: nonEmpty6
+      }),
       // A subscribed event that didn't wake the conversation, with the reason. One that woke it is a
       // quiet inbound message carrying `github`, so it waits like any waking work.
       event("github.event", githubEventSummarySchema.shape),
       // A pull request's status card, queued for the conversation's thread.
       event("github.card", {
         resource: nonEmpty6,
-        url: z12.url(),
+        url: z13.url(),
         label: nonEmpty6,
-        title: z12.string(),
+        title: z13.string(),
         phase: pullRequestPhaseSchema,
         move: pullRequestMoveSchema.nullable(),
-        detail: z12.string().nullable()
+        detail: z13.string().nullable()
       }),
       event("subscription.created", {
         resource: nonEmpty6,
         label: nonEmpty6,
-        url: z12.url(),
+        url: z13.url(),
         subscriber: nonEmpty6,
         createdBy: subscriptionOriginSchema
       }),
@@ -1391,72 +1477,72 @@ var init_events = __esm({
       // A subscription reached its hourly limit of wakes, noted once each hour.
       event("subscription.limited", { resource: nonEmpty6 })
     ]);
-    conversationVisibilitySchema = z12.enum(["public", "private"]);
-    conversationStatusSchema = z12.enum(["idle", "waiting", "working"]);
-    conversationSummarySchema = z12.object({
+    conversationVisibilitySchema = z13.enum(["public", "private"]);
+    conversationStatusSchema = z13.enum(["idle", "waiting", "working"]);
+    conversationSummarySchema = z13.object({
       id: nonEmpty6,
       provider: nonEmpty6,
       visibility: conversationVisibilitySchema,
       title: nonEmpty6,
       // Where the conversation lives on its platform, when it has a link.
-      placeUrl: z12.string().nullable(),
+      placeUrl: z13.string().nullable(),
       status: conversationStatusSchema,
-      waitingCount: z12.number().int().nonnegative(),
-      createdAt: z12.number().int(),
-      lastActivityAt: z12.number().int(),
-      expiresAt: z12.number().int()
-    });
-    placementSchema = z12.discriminatedUnion("kind", [
-      z12.object({
-        kind: z12.literal("bound"),
-        machine: z12.object({ name: nonEmpty6, online: z12.boolean() }),
+      waitingCount: z13.number().int().nonnegative(),
+      createdAt: z13.number().int(),
+      lastActivityAt: z13.number().int(),
+      expiresAt: z13.number().int()
+    });
+    placementSchema = z13.discriminatedUnion("kind", [
+      z13.object({
+        kind: z13.literal("bound"),
+        machine: z13.object({ name: nonEmpty6, online: z13.boolean() }),
         // The worker's name, such as `mac-mini/claude`, and never its configuration or capabilities.
         worker: nonEmpty6.optional()
       }),
-      z12.object({ kind: z12.literal("waiting_for_machine") }),
-      z12.object({ kind: z12.literal("author_not_linked") })
+      z13.object({ kind: z13.literal("waiting_for_machine") }),
+      z13.object({ kind: z13.literal("author_not_linked") })
     ]);
-    treeSummarySchema = z12.object({
+    treeSummarySchema = z13.object({
       parent: nonEmpty6.nullable(),
       root: nonEmpty6,
-      children: z12.array(
-        z12.object({
+      children: z13.array(
+        z13.object({
           id: nonEmpty6,
           title: nonEmpty6,
-          state: z12.string().nullable(),
-          createdAt: z12.number()
+          state: z13.string().nullable(),
+          createdAt: z13.number()
         })
       )
     });
-    conversationSnapshotSchema = z12.object({
+    conversationSnapshotSchema = z13.object({
       conversation: conversationSummarySchema,
-      events: z12.array(conversationEventSchema),
+      events: z13.array(conversationEventSchema),
       /**
        * Each person actor's display name, by ID, as it is now. A person is shown by this, never by
        * the name stored with an event, which for older events was their address.
        */
-      people: z12.record(z12.string(), z12.string()).optional(),
+      people: z13.record(z13.string(), z13.string()).optional(),
       placement: placementSchema.nullable().optional(),
       tree: treeSummarySchema.optional()
     });
-    liveFrameSchema = z12.discriminatedUnion("type", [
-      z12.object({ type: z12.literal("event"), event: conversationEventSchema }),
-      z12.object({ type: z12.literal("reconnect") }),
-      z12.object({ type: z12.literal("expired") })
+    liveFrameSchema = z13.discriminatedUnion("type", [
+      z13.object({ type: z13.literal("event"), event: conversationEventSchema }),
+      z13.object({ type: z13.literal("reconnect") }),
+      z13.object({ type: z13.literal("expired") })
     ]);
-    adapterCapabilitiesSchema = z12.object({
-      messages: z12.enum(["push", "window"]),
-      edits: z12.enum(["push", "rescan"]),
-      deletes: z12.enum(["push", "rescan"]),
-      reactions: z12.enum(["push", "counts"]),
-      status: z12.boolean(),
-      search: z12.boolean()
+    adapterCapabilitiesSchema = z13.object({
+      messages: z13.enum(["push", "window"]),
+      edits: z13.enum(["push", "rescan"]),
+      deletes: z13.enum(["push", "rescan"]),
+      reactions: z13.enum(["push", "counts"]),
+      status: z13.boolean(),
+      search: z13.boolean()
     });
   }
 });
 
 // ../common-chat/src/conversation-state.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function openRank(item) {
   if (item.state === "stuck") return 0;
   if (leadOpen(item.lead) && item.lead?.move === "you") return 1;
@@ -1493,8 +1579,8 @@ var init_conversation_state = __esm({
     init_machines();
     init_pull_requests();
     init_work_objects();
-    nonEmpty7 = z13.string().min(1);
-    time5 = z13.number().int().nonnegative();
+    nonEmpty7 = z14.string().min(1);
+    time5 = z14.number().int().nonnegative();
     REACTIONS = {
       waiting: "eyes",
       working: "hourglass_flowing_sand",
@@ -1503,14 +1589,14 @@ var init_conversation_state = __esm({
       // Stuck because it's waiting on a person's answer, approval or decision, rather than on a fault.
       asking: "question"
     };
-    conversationStateSchema = z13.enum([
+    conversationStateSchema = z14.enum([
       "waiting",
       "working",
       "stuck",
       "unanswered",
       "done"
     ]);
-    stuckReasonSchema = z13.enum([
+    stuckReasonSchema = z14.enum([
       "approval",
       "waiting_on_someone",
       // A delegate has an open prompt or is waiting on a person.
@@ -1533,43 +1619,43 @@ var init_conversation_state = __esm({
       "awaiting_answer"
     ]);
     STUCK_REASONS = stuckReasonSchema.options;
-    placeKindSchema = z13.enum(["channel", "direct", "group", "web"]);
-    conversationSourceSchema = z13.object({
+    placeKindSchema = z14.enum(["channel", "direct", "group", "web"]);
+    conversationSourceSchema = z14.object({
       provider: nonEmpty7,
       kind: placeKindSchema,
       /** Such as a Slack channel's name, without its `#`. Left out where it's unknown or hidden. */
-      name: z13.string().optional()
+      name: z14.string().optional()
     });
     LATEST_MESSAGE_LENGTH = 200;
-    latestMessageSchema = z13.object({
-      text: z13.string().max(LATEST_MESSAGE_LENGTH),
+    latestMessageSchema = z14.object({
+      text: z14.string().max(LATEST_MESSAGE_LENGTH),
       /** A person wrote it, or the agent did. */
-      from: z13.enum(["person", "agent"]),
+      from: z14.enum(["person", "agent"]),
       at: time5
     });
     listMachineSchema = machinePresenceSchema.extend({
-      mine: z13.boolean().optional(),
+      mine: z14.boolean().optional(),
       /** The agent holding it on that machine, such as `Claude Code`, when it's known. */
-      agent: z13.string().optional()
+      agent: z14.string().optional()
     });
-    conversationListItemSchema = z13.object({
+    conversationListItemSchema = z14.object({
       id: nonEmpty7,
       title: nonEmpty7,
       visibility: conversationVisibilitySchema,
       /** The conversation's page. */
       url: nonEmpty7,
       /** Its thread on its platform, when it has a link. */
-      placeUrl: z13.string().nullable(),
+      placeUrl: z14.string().nullable(),
       state: conversationStateSchema,
       // A reason this version no longer gives, such as one stored before it, reads as none.
       reason: stuckReasonSchema.nullable().catch(null),
       /** The start of the latest waking message. */
-      latestRequest: z13.string().nullable(),
+      latestRequest: z14.string().nullable(),
       lastRequestAt: time5.nullable(),
       /** When the bot last posted in the thread. */
       lastReplyAt: time5.nullable(),
       /** What the agent says it's doing, while it works. */
-      activity: z13.string().nullable(),
+      activity: z14.string().nullable(),
       /** The machine holding it, by name and presence only, and whether it's the reader's own. */
       machine: listMachineSchema.nullable(),
       lastActivityAt: time5,
@@ -1580,28 +1666,28 @@ var init_conversation_state = __esm({
       /** When its activity last changed, which says how long an agent has been quiet. */
       activityAt: time5.nullable().optional(),
       /** Set when the title, latest request, link and activity were left out because it's private. */
-      hidden: z13.boolean().optional(),
+      hidden: z14.boolean().optional(),
       /**
        * What it's about, its delegates' included: at most 5, open ones first. Missing, from servers
        * older than work objects, means none.
        */
-      work: z13.array(workObjectSummarySchema).optional(),
+      work: z14.array(workObjectSummarySchema).optional(),
       /** How many more work objects it holds than `work` carries. */
-      moreWork: z13.number().int().nonnegative().optional(),
+      moreWork: z14.number().int().nonnegative().optional(),
       /** The pull request it leads with, from all of its tree's, not only those in `work`. */
       lead: leadChangeSchema.nullable().optional()
     });
-    conversationListSchema = z13.object({
-      items: z13.array(conversationListItemSchema),
+    conversationListSchema = z14.object({
+      items: z14.array(conversationListItemSchema),
       /** Present when there's more, to pass back as `next` for the following page. */
-      next: z13.string().optional()
+      next: z14.string().optional()
     });
-    listFrameSchema = z13.discriminatedUnion("type", [
-      z13.object({ type: z13.literal("changed"), conversations: z13.array(nonEmpty7).min(1) }),
+    listFrameSchema = z14.discriminatedUnion("type", [
+      z14.object({ type: z14.literal("changed"), conversations: z14.array(nonEmpty7).min(1) }),
       /** A machine went online or offline, or a worker's usage changed. */
-      z13.object({ type: z13.literal("machines") }),
-      z13.object({ type: z13.literal("reconnect") }),
-      z13.object({ type: z13.literal("expired") })
+      z14.object({ type: z14.literal("machines") }),
+      z14.object({ type: z14.literal("reconnect") }),
+      z14.object({ type: z14.literal("expired") })
     ]);
     STATE_REACTIONS = {
       stuck: REACTIONS.stuck,
@@ -1642,7 +1728,7 @@ var init_conversation_state = __esm({
 });
 
 // ../common-chat/src/board.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var nonEmpty8, time6, BOARD_ITEMS, boardItemSchema, boardWorkerSchema, boardMachineSchema, boardSchema;
 var init_board = __esm({
   "../common-chat/src/board.ts"() {
@@ -1651,27 +1737,27 @@ var init_board = __esm({
     init_conversation_state();
     init_pull_requests();
     init_usage();
-    nonEmpty8 = z14.string().min(1);
-    time6 = z14.number().int().nonnegative();
+    nonEmpty8 = z15.string().min(1);
+    time6 = z15.number().int().nonnegative();
     BOARD_ITEMS = 8;
-    boardItemSchema = z14.object({
+    boardItemSchema = z15.object({
       id: nonEmpty8,
       /** `HIDDEN_TITLE` when the item is private and the board doesn't show private titles. */
       title: nonEmpty8,
       state: conversationStateSchema,
       reason: stuckReasonSchema.nullable().catch(null),
       /** Where the work came from, such as `#herd-dev` or a direct message, when it's known. */
-      source: z14.string().nullable(),
+      source: z15.string().nullable(),
       /** What the agent says it's doing, while it works. */
-      activity: z14.string().nullable(),
+      activity: z15.string().nullable(),
       lastActivityAt: time6,
       /** The machine and agent holding it, such as `mac-mini` and `Claude Code`, once it's bound. */
-      heldBy: z14.object({ machine: nonEmpty8, agent: nonEmpty8 }).nullable().optional(),
+      heldBy: z15.object({ machine: nonEmpty8, agent: nonEmpty8 }).nullable().optional(),
       /** The pull request it leads with, and how many more are the person's move. */
       change: leadChangeSchema.nullable().optional(),
-      hidden: z14.boolean().optional()
+      hidden: z15.boolean().optional()
     });
-    boardWorkerSchema = z14.object({
+    boardWorkerSchema = z15.object({
       /** The worker's short name, such as `claude`, under its machine. */
       name: nonEmpty8,
       /** Its agent CLI, such as `claude-code`, which names it on the board. */
@@ -1680,33 +1766,33 @@ var init_board = __esm({
       usage: usageSchema.nullable(),
       reportedAt: time6.nullable(),
       /** What it's great at, from its profile: its owner's statements, or herd's defaults. */
-      strengths: z14.array(z14.string().min(1).max(100)).max(3).optional()
+      strengths: z15.array(z15.string().min(1).max(100)).max(3).optional()
     });
-    boardMachineSchema = z14.object({
+    boardMachineSchema = z15.object({
       name: nonEmpty8,
-      online: z14.boolean(),
-      workers: z14.array(boardWorkerSchema).max(8)
+      online: z15.boolean(),
+      workers: z15.array(boardWorkerSchema).max(8)
     });
-    boardSchema = z14.object({
+    boardSchema = z15.object({
       /** How many are in each open state: every state but `done`, which is counted for the last day. */
-      counts: z14.object({
-        stuck: z14.number().int().nonnegative(),
-        unanswered: z14.number().int().nonnegative(),
-        waiting: z14.number().int().nonnegative(),
-        working: z14.number().int().nonnegative(),
+      counts: z15.object({
+        stuck: z15.number().int().nonnegative(),
+        unanswered: z15.number().int().nonnegative(),
+        waiting: z15.number().int().nonnegative(),
+        working: z15.number().int().nonnegative(),
         /** Open pull requests the person's conversations made that are their move, each counted. */
-        pullRequests: z14.number().int().nonnegative().optional()
+        pullRequests: z15.number().int().nonnegative().optional()
       }),
       /** How many became `done` in the last 24 hours. */
-      doneToday: z14.number().int().nonnegative(),
+      doneToday: z15.number().int().nonnegative(),
       /**
        * What needs the person (stuck, then pull requests that are their move), then what's working or
        * has a pull request under way, then what's queued, then the latest finished to fill the rest.
        */
-      items: z14.array(boardItemSchema).max(BOARD_ITEMS),
-      machines: z14.array(boardMachineSchema).max(16),
+      items: z15.array(boardItemSchema).max(BOARD_ITEMS),
+      machines: z15.array(boardMachineSchema).max(16),
       /** Changes whenever anything the board shows changes, and only then. */
-      stamp: z14.string().regex(/^[0-9a-f]{12}$/),
+      stamp: z15.string().regex(/^[0-9a-f]{12}$/),
       /** When its content last changed. */
       changedAt: time6
     });
@@ -1728,31 +1814,31 @@ var init_bot = __esm({
 });
 
 // ../common-chat/src/builds.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var nonEmpty9, time7, BUILD_LEASE_MS, BUILD_CLAIM_WINDOW_MS, MAX_LOG_CHUNK_BYTES, MAX_LOG_BYTES, MAX_NODE_MODULES_PART_BYTES, shaSchema, buildOfferSchema, buildCancelReasonSchema, runnerMessageSchema, serviceMessageSchema, runnerRegisterRequestSchema, runnerRegisterResponseSchema, runnerPollRequestSchema, runnerPollResponseSchema, buildStepSchema, buildFinishSchema, sharedPassSchema, passesResponseSchema, deployCredentialsSchema, deployedSchema, healthSchema;
 var init_builds = __esm({
   "../common-chat/src/builds.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
     init_workers();
-    nonEmpty9 = z15.string().min(1);
-    time7 = z15.number().int().nonnegative();
+    nonEmpty9 = z16.string().min(1);
+    time7 = z16.number().int().nonnegative();
     BUILD_LEASE_MS = 5 * 60 * 1e3;
     BUILD_CLAIM_WINDOW_MS = 15 * 1e3;
     MAX_LOG_CHUNK_BYTES = 256 * 1024;
     MAX_LOG_BYTES = 5 * 1024 * 1024;
     MAX_NODE_MODULES_PART_BYTES = 95 * 1024 * 1024;
-    shaSchema = z15.string().regex(/^[0-9a-f]{40}$/);
-    buildOfferSchema = z15.object({
+    shaSchema = z16.string().regex(/^[0-9a-f]{40}$/);
+    buildOfferSchema = z16.object({
       id: nonEmpty9,
       offerId: nonEmpty9,
       repo: nonEmpty9,
       sha: shaSchema,
       ref: nonEmpty9,
-      main: z15.boolean(),
+      main: z16.boolean(),
       expiresAt: time7
     });
-    buildCancelReasonSchema = z15.enum([
+    buildCancelReasonSchema = z16.enum([
       // A newer push to the same branch replaced it.
       "superseded",
       // The branch was deleted.
@@ -1762,7 +1848,7 @@ var init_builds = __esm({
       // Stopped for another reason, such as the repo being removed.
       "cancelled"
     ]);
-    runnerMessageSchema = z15.discriminatedUnion("type", [
+    runnerMessageSchema = z16.discriminatedUnion("type", [
       /**
        * Sent first, and again whenever any of it changes. `capacity` comes from `herd.config.ts`'s
        * `builds` through `runnerCapacity`, `repos` are the normalized remotes of the repos herd has
@@ -1770,82 +1856,82 @@ var init_builds = __esm({
        * any of its owner's repos, cloning one it hasn't got, and `repos` only puts it first for those.
        * A daemon from before herd's root sent its configured checkouts here, which it builds from.
        */
-      z15.object({
-        type: z15.literal("hello"),
+      z16.object({
+        type: z16.literal("hello"),
         /** How many builds at once. 0 when the machine can't sandbox a build, so it takes none. */
-        capacity: z15.number().int().min(0).max(BUILDS_MAX),
-        repos: z15.array(nonEmpty9.max(300)).max(100),
-        running: z15.array(nonEmpty9.max(100)).max(BUILDS_MAX * 2)
+        capacity: z16.number().int().min(0).max(BUILDS_MAX),
+        repos: z16.array(nonEmpty9.max(300)).max(100),
+        running: z16.array(nonEmpty9.max(100)).max(BUILDS_MAX * 2)
       }),
       /** An answer to an offer, before its `expiresAt`. A refusal may say why. */
-      z15.object({
-        type: z15.literal("answer"),
+      z16.object({
+        type: z16.literal("answer"),
         buildId: nonEmpty9,
         offerId: nonEmpty9,
-        answer: z15.enum(["accept", "refuse"]),
-        reason: z15.string().max(500).optional()
+        answer: z16.enum(["accept", "refuse"]),
+        reason: z16.string().max(500).optional()
       })
     ]);
-    serviceMessageSchema = z15.discriminatedUnion("type", [
-      z15.object({ type: z15.literal("build"), build: buildOfferSchema }),
+    serviceMessageSchema = z16.discriminatedUnion("type", [
+      z16.object({ type: z16.literal("build"), build: buildOfferSchema }),
       /** An accepted offer: the build's own secret, and how long its claim lasts between renewals. */
-      z15.object({
-        type: z15.literal("accepted"),
+      z16.object({
+        type: z16.literal("accepted"),
         buildId: nonEmpty9,
         secret: nonEmpty9,
-        leaseMs: z15.number().int().positive()
+        leaseMs: z16.number().int().positive()
       }),
       /**
        * Stop a build this runner holds, within 5 seconds. An accept that came too late, for an offer
        * that had expired or was withdrawn, gets this too, with the reason `cancelled`.
        */
-      z15.object({ type: z15.literal("build-cancel"), buildId: nonEmpty9, reason: buildCancelReasonSchema }),
+      z16.object({ type: z16.literal("build-cancel"), buildId: nonEmpty9, reason: buildCancelReasonSchema }),
       /** Connect again. Sent before the service closes a socket that another replaced. */
-      z15.object({ type: z15.literal("reconnect") })
+      z16.object({ type: z16.literal("reconnect") })
     ]);
-    runnerRegisterRequestSchema = z15.object({ name: z15.string().trim().min(1).max(100) });
-    runnerRegisterResponseSchema = z15.object({
+    runnerRegisterRequestSchema = z16.object({ name: z16.string().trim().min(1).max(100) });
+    runnerRegisterResponseSchema = z16.object({
       /** Shown to the owner, so they can match the approval page to the machine. */
       code: nonEmpty9,
       /** The page the owner opens, signed in, to approve it. */
-      approveUrl: z15.url(),
+      approveUrl: z16.url(),
       /** Sent to `POST /runners/register/poll`. Only this machine has it. */
       pollToken: nonEmpty9,
       expiresAt: time7.optional(),
       /** How often to poll. */
-      pollMs: z15.number().int().positive().optional()
+      pollMs: z16.number().int().positive().optional()
     });
-    runnerPollRequestSchema = z15.object({ pollToken: nonEmpty9.max(200) });
-    runnerPollResponseSchema = z15.discriminatedUnion("status", [
-      z15.object({ status: z15.literal("waiting") }),
+    runnerPollRequestSchema = z16.object({ pollToken: nonEmpty9.max(200) });
+    runnerPollResponseSchema = z16.discriminatedUnion("status", [
+      z16.object({ status: z16.literal("waiting") }),
       /** Approved. The key is returned this once, and the service keeps only its hash. */
-      z15.object({ status: z15.literal("approved"), runnerId: nonEmpty9, key: nonEmpty9 }),
+      z16.object({ status: z16.literal("approved"), runnerId: nonEmpty9, key: nonEmpty9 }),
       /** Expired, or the key was already collected. Start again. */
-      z15.object({ status: z15.literal("expired") })
+      z16.object({ status: z16.literal("expired") })
     ]);
-    buildStepSchema = z15.object({
-      label: z15.string().min(1).max(200),
-      key: z15.string().regex(/^[0-9a-zA-Z_-]{8,128}$/),
-      status: z15.enum(["passed", "failed", "remembered"]),
-      ms: z15.number().int().nonnegative(),
+    buildStepSchema = z16.object({
+      label: z16.string().min(1).max(200),
+      key: z16.string().regex(/^[0-9a-zA-Z_-]{8,128}$/),
+      status: z16.enum(["passed", "failed", "remembered"]),
+      ms: z16.number().int().nonnegative(),
       /** Only some of the step's tests ran, so its pass isn't shared. */
-      partial: z15.boolean().default(false),
-      budgetMs: z15.number().int().positive().nullable().default(null)
+      partial: z16.boolean().default(false),
+      budgetMs: z16.number().int().positive().nullable().default(null)
     });
-    buildFinishSchema = z15.object({
-      status: z15.enum(["success", "failure", "error"]),
-      summary: z15.string().max(2e3).default(""),
-      deployed: z15.boolean().default(false)
+    buildFinishSchema = z16.object({
+      status: z16.enum(["success", "failure", "error"]),
+      summary: z16.string().max(2e3).default(""),
+      deployed: z16.boolean().default(false)
     });
-    sharedPassSchema = z15.object({
+    sharedPassSchema = z16.object({
       step: nonEmpty9,
       passedAt: time7,
       sha: nonEmpty9,
       runner: nonEmpty9,
-      partial: z15.boolean()
+      partial: z16.boolean()
     });
-    passesResponseSchema = z15.object({ passes: z15.record(z15.string(), sharedPassSchema) });
-    deployCredentialsSchema = z15.object({
+    passesResponseSchema = z16.object({ passes: z16.record(z16.string(), sharedPassSchema) });
+    deployCredentialsSchema = z16.object({
       cloudflareToken: nonEmpty9,
       /** Publishes `@herdingchats/friday`. Missing when the build service has none set. */
       npmToken: nonEmpty9.optional(),
@@ -1854,20 +1940,20 @@ var init_builds = __esm({
       /** `owner/name`, for moving `deployed`. */
       repo: nonEmpty9,
       /** The commit being built, which `deployed` moves to. Older services don't send it. */
-      sha: z15.string().regex(/^[0-9a-f]{40}$/).optional(),
+      sha: z16.string().regex(/^[0-9a-f]{40}$/).optional(),
       /** Each Worker's key at its last successful deploy. */
-      lastDeployed: z15.record(z15.string(), z15.string())
+      lastDeployed: z16.record(z16.string(), z16.string())
     });
-    deployedSchema = z15.object({
-      worker: z15.string().regex(/^[a-z][a-z0-9-]{0,62}$/),
-      key: z15.string().regex(/^[0-9a-zA-Z_-]{8,128}$/)
+    deployedSchema = z16.object({
+      worker: z16.string().regex(/^[a-z][a-z0-9-]{0,62}$/),
+      key: z16.string().regex(/^[0-9a-zA-Z_-]{8,128}$/)
     });
-    healthSchema = z15.object({ ok: z15.boolean(), version: z15.string() });
+    healthSchema = z16.object({ ok: z16.boolean(), version: z16.string() });
   }
 });
 
 // ../common-chat/src/setup.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function actionText(action) {
   if (action.kind === "link") return `${action.label}: ${action.url}`;
   if (action.kind === "sign_in") {
@@ -1902,42 +1988,42 @@ var init_setup = __esm({
     init_activation();
     init_bot();
     SETUP_STEP_IDS = ["slack", "machine", "github", "repos"];
-    setupActionSchema = z16.discriminatedUnion("kind", [
+    setupActionSchema = z17.discriminatedUnion("kind", [
       /** A page to open, which signs in to HerdingChats first. */
-      z16.object({ kind: z16.literal("link"), url: z16.string(), label: z16.string() }),
+      z17.object({ kind: z17.literal("link"), url: z17.string(), label: z17.string() }),
       /** A command to run on the computer. */
-      z16.object({ kind: z16.literal("command"), command: z16.string() }),
+      z17.object({ kind: z17.literal("command"), command: z17.string() }),
       /**
        * A sign-in herd starts on one of the person's machines, from Slack or the page, whose code
        * Friday sends to their direct message.
        */
-      z16.object({
-        kind: z16.literal("sign_in"),
-        machineId: z16.string(),
+      z17.object({
+        kind: z17.literal("sign_in"),
+        machineId: z17.string(),
         tool: signInToolSchema,
-        label: z16.string()
+        label: z17.string()
       })
     ]);
-    setupStepSchema = z16.object({
-      id: z16.enum(SETUP_STEP_IDS),
+    setupStepSchema = z17.object({
+      id: z17.enum(SETUP_STEP_IDS),
       /** `unavailable` is a step nobody can take yet, such as GitHub linking before an admin turns it on. */
-      state: z16.enum(["done", "todo", "unavailable"]),
-      optional: z16.boolean(),
-      title: z16.string(),
+      state: z17.enum(["done", "todo", "unavailable"]),
+      optional: z17.boolean(),
+      title: z17.string(),
       /** What was found, such as the machine and whether it's online, or why it can't be done yet. */
-      detail: z16.string().nullable(),
+      detail: z17.string().nullable(),
       /** What to do next. None once it's done, or while it's unavailable. */
       action: setupActionSchema.nullable(),
       /**
        * More that can be done, which doesn't decide whether the step is done, such as signing in a
        * computer's GitHub CLI. Shown whatever the step's state.
        */
-      extra: z16.array(setupActionSchema).optional()
+      extra: z17.array(setupActionSchema).optional()
     });
-    setupStatusSchema = z16.object({
-      steps: z16.array(setupStepSchema),
+    setupStatusSchema = z17.object({
+      steps: z17.array(setupStepSchema),
       /** Whether every step that isn't optional is done, so Friday can take work. */
-      ready: z16.boolean()
+      ready: z17.boolean()
     });
     READY_TEXT = `You're set up: mention @${BOT_NAME} in any channel it's in, or message it directly.`;
     READY_SUGGESTIONS_TITLE = "Some things to try:";
@@ -1979,6 +2065,7 @@ var init_src = __esm({
     init_pull_requests();
     init_setup();
     init_state();
+    init_terminals();
     init_usage();
     init_work_objects();
     init_workers();
@@ -2158,7 +2245,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 function Text({
   theme,
   children,
-  size = "md",
+  size: size2 = "md",
   bold,
   muted,
   faint,
@@ -2171,7 +2258,7 @@ function Text({
     {
       style: {
         display: "flex",
-        fontSize: theme.size[size],
+        fontSize: theme.size[size2],
         fontWeight: bold ? 700 : 400,
         color: faint ? theme.faint : muted ? theme.muted : theme.ink,
         lineHeight: 1.2,
@@ -2183,9 +2270,9 @@ function Text({
     }
   );
 }
-function Icon({ icon: icon2, color, size }) {
+function Icon({ icon: icon2, color, size: size2 }) {
   const { d, label: label3 } = ICON_PATHS[icon2];
-  return /* @__PURE__ */ jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", role: "img", "aria-label": label3, children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx("svg", { width: size2, height: size2, viewBox: "0 0 24 24", role: "img", "aria-label": label3, children: /* @__PURE__ */ jsx(
     "path",
     {
       d,
@@ -2388,7 +2475,7 @@ var init_widget = __esm({
 });
 
 // ../common-board/src/widgets/conversations.tsx
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function badge(item) {
   if (pullRequestBadge(item)) {
@@ -2432,10 +2519,10 @@ var init_conversations = __esm({
     conversations2 = defineWidget({
       kind: "conversations",
       describe: "Blocked, working and queued conversations, then the latest done, with what each is doing, where it came from and who holds it",
-      options: z29.object({
-        states: z29.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
-        limit: z29.number().int().min(1).max(BOARD_ITEMS).default(4),
-        show: z29.array(z29.enum(DETAILS)).default([...DETAILS])
+      options: z30.object({
+        states: z30.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
+        limit: z30.number().int().min(1).max(BOARD_ITEMS).default(4),
+        show: z30.array(z30.enum(DETAILS)).default([...DETAILS])
       }),
       reads: ["items", "machines"],
       Component: ({ board, options, theme, now }) => {
@@ -2479,7 +2566,7 @@ var init_conversations = __esm({
 });
 
 // ../common-board/src/widgets/counts.tsx
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var COUNTS, LABELS2, counts;
 var init_counts = __esm({
@@ -2499,8 +2586,8 @@ var init_counts = __esm({
     counts = defineWidget({
       kind: "counts",
       describe: "How many conversations are stuck, unanswered, waiting and working, and done today",
-      options: z30.object({
-        show: z30.array(z30.enum(COUNTS)).min(1).max(5).default([...COUNTS])
+      options: z31.object({
+        show: z31.array(z31.enum(COUNTS)).min(1).max(5).default([...COUNTS])
       }),
       reads: ["counts", "doneToday"],
       Component: ({ board, options, theme }) => {
@@ -2539,7 +2626,7 @@ var init_counts = __esm({
 });
 
 // ../common-board/src/widgets/header.tsx
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function summary(board) {
   const parts = [
@@ -2564,9 +2651,9 @@ var init_header = __esm({
     header = defineWidget({
       kind: "header",
       describe: "The board's title, a line of how much is open, and when it was drawn",
-      options: z31.object({
-        title: z31.string().min(1).max(40).default(`@${BOT_NAME}`),
-        summary: z31.boolean().default(true)
+      options: z32.object({
+        title: z32.string().min(1).max(40).default(`@${BOT_NAME}`),
+        summary: z32.boolean().default(true)
       }),
       reads: ["counts"],
       Component: ({ board, options, theme, now }) => {
@@ -2584,7 +2671,7 @@ var init_header = __esm({
 });
 
 // ../common-board/src/widgets/machines.tsx
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function usageText(worker) {
   const usage = worker.usage;
@@ -2615,7 +2702,7 @@ var init_machines2 = __esm({
     machines = defineWidget({
       kind: "machines",
       describe: "One bubble per agent on an online machine, with its usage, most recently active first",
-      options: z32.object({ limit: z32.number().int().min(1).max(8).default(3) }),
+      options: z33.object({ limit: z33.number().int().min(1).max(8).default(3) }),
       reads: ["machines"],
       Component: ({ board, options, theme }) => {
         const workers2 = board.machines.filter((machine) => machine.online).flatMap((machine) => machine.workers.map((worker) => ({ ...worker, machine: machine.name }))).sort((a, b) => (b.reportedAt ?? 0) - (a.reportedAt ?? 0));
@@ -2732,9 +2819,9 @@ var init_board2 = __esm({
 });
 
 // ../common-board/src/composition.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 function readComposition(stored) {
-  const shape = z33.object({ widgets: z33.array(placedWidgetSchema) }).safeParse(stored);
+  const shape = z34.object({ widgets: z34.array(placedWidgetSchema) }).safeParse(stored);
   if (!shape.success) return DEFAULT_COMPOSITION;
   const known = shape.data.widgets.filter(
     (widget) => WIDGETS[widget.kind]?.options.safeParse(widget.options).success
@@ -2749,11 +2836,11 @@ var init_composition = __esm({
     init_registry();
     MAX_WIDGETS = 12;
     MAX_COMPOSITION_BYTES = 4096;
-    placedWidgetSchema = z33.object({
-      kind: z33.string().min(1),
-      options: z33.record(z33.string(), z33.unknown()).default({})
+    placedWidgetSchema = z34.object({
+      kind: z34.string().min(1),
+      options: z34.record(z34.string(), z34.unknown()).default({})
     });
-    compositionSchema = z33.object({ widgets: z33.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
+    compositionSchema = z34.object({ widgets: z34.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
       if (JSON.stringify(composition).length > MAX_COMPOSITION_BYTES) {
         context2.addIssue({
           code: "custom",
@@ -3208,12 +3295,12 @@ 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";
+import { z as z23 } from "zod";
 
 // src/auth.ts
 init_define_HERD_PACKAGE();
@@ -3222,21 +3309,21 @@ import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:
 import { createServer } from "node:http";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var herdHome = () => process.env.HERD_HOME ?? join(homedir(), ".herd");
 var apiUrl = () => (process.env.HERD_API_URL ?? "https://api.herdingchats.com").replace(/\/+$/, "");
 var isLocal = (url) => /^http:\/\/localhost:\d+\/?$/.test(url);
 var localSignIn = () => process.env.HERD_LOCAL_SLACK ? { "X-Herd-Local-Slack": process.env.HERD_LOCAL_SLACK } : {};
 var HerdError = class extends Error {
 };
-var credentialsSchema = z17.object({
-  api: z17.string(),
-  tokenEndpoint: z17.string(),
-  revocationEndpoint: z17.string().optional(),
-  clientId: z17.string(),
-  accessToken: z17.string(),
-  accessTokenExpiresAt: z17.number(),
-  refreshToken: z17.string()
+var credentialsSchema = z18.object({
+  api: z18.string(),
+  tokenEndpoint: z18.string(),
+  revocationEndpoint: z18.string().optional(),
+  clientId: z18.string(),
+  accessToken: z18.string(),
+  accessTokenExpiresAt: z18.number(),
+  refreshToken: z18.string()
 });
 var credentialsPath = () => join(herdHome(), "credentials.json");
 function readCredentials() {
@@ -3252,16 +3339,16 @@ function writeCredentials(credentials) {
   writeFileSync(credentialsPath(), JSON.stringify(credentials, null, 2), { mode: 384 });
   chmodSync(credentialsPath(), 384);
 }
-var metadataSchema = z17.object({
-  authorization_endpoint: z17.string(),
-  token_endpoint: z17.string(),
-  registration_endpoint: z17.string(),
-  revocation_endpoint: z17.string().optional()
+var metadataSchema = z18.object({
+  authorization_endpoint: z18.string(),
+  token_endpoint: z18.string(),
+  registration_endpoint: z18.string(),
+  revocation_endpoint: z18.string().optional()
 });
-var tokenSchema = z17.object({
-  access_token: z17.string().min(1),
-  refresh_token: z17.string().min(1),
-  expires_in: z17.number()
+var tokenSchema = z18.object({
+  access_token: z18.string().min(1),
+  refresh_token: z18.string().min(1),
+  expires_in: z18.number()
 });
 var base64url = (bytes) => bytes.toString("base64url");
 async function postForm(url, fields) {
@@ -3293,7 +3380,7 @@ async function login(openBrowser2, { api = apiUrl(), timeoutMs = 10 * 60 * 1e3 }
         token_endpoint_auth_method: "none"
       })
     });
-    const client = z17.object({ client_id: z17.string() }).safeParse(await registration2.json());
+    const client = z18.object({ client_id: z18.string() }).safeParse(await registration2.json());
     if (!registration2.ok || !client.success) {
       throw new HerdError("The sign-in server refused to register this tool.");
     }
@@ -3414,7 +3501,7 @@ var HERD_FLAGS = {
   login: [],
   logout: [],
   daemon: ["--repo"],
-  attach: [],
+  attach: ["--watch"],
   builds: [],
   inbox: [],
   send: ["--json"],
@@ -3527,7 +3614,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3, hostname } from "node:os";
 import { basename, dirname as dirname4, join as join6, resolve } from "node:path";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/login-shell.ts
 init_define_HERD_PACKAGE();
@@ -3653,16 +3740,16 @@ function recordTime(line2) {
   return Number.isNaN(time8) ? 0 : time8;
 }
 function readNew(path, offset) {
-  let size;
+  let size2;
   try {
-    size = statSync(path).size;
+    size2 = statSync(path).size;
   } catch {
     return { events: [], offset };
   }
-  if (size <= offset) return { events: [], offset };
+  if (size2 <= offset) return { events: [], offset };
   const fd = openSync(path, "r");
   try {
-    const buffer = Buffer.alloc(size - offset);
+    const buffer = Buffer.alloc(size2 - offset);
     const read = readSync(fd, buffer, 0, buffer.length, offset);
     const chunk = buffer.subarray(0, read);
     const end = chunk.lastIndexOf(10);
@@ -3763,9 +3850,9 @@ function latestCodexUsage(home = codexHome()) {
   if (!newest) return null;
   let tail3;
   try {
-    const size = statSync(newest).size;
-    const start = Math.max(0, size - USAGE_TAIL_BYTES);
-    const buffer = Buffer.alloc(size - start);
+    const size2 = statSync(newest).size;
+    const start = Math.max(0, size2 - USAGE_TAIL_BYTES);
+    const buffer = Buffer.alloc(size2 - start);
     const fd = openSync(newest, "r");
     try {
       readSync(fd, buffer, 0, buffer.length, start);
@@ -4306,13 +4393,13 @@ function hasUnpushed(path) {
 
 // src/config.ts
 init_self();
-var repoSchema = z18.object({ name: z18.string(), path: z18.string(), remote: z18.string() });
-var configSchema = z18.object({
-  machineId: z18.string(),
-  machineName: z18.string(),
-  repos: z18.array(repoSchema),
+var repoSchema = z19.object({ name: z19.string(), path: z19.string(), remote: z19.string() });
+var configSchema = z19.object({
+  machineId: z19.string(),
+  machineName: z19.string(),
+  repos: z19.array(repoSchema),
   /** The machine's root folder, holding herd's clones and its conversations' folders. */
-  root: z18.string().optional()
+  root: z19.string().optional()
 });
 var configPath = () => join6(herdHome(), "config.json");
 function save(config) {
@@ -4519,32 +4606,32 @@ 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 { z as z21 } from "zod";
+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 z22 } from "zod";
 
 // src/permissions.ts
 init_define_HERD_PACKAGE();
 init_src();
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/local-socket.ts
 init_define_HERD_PACKAGE();
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync4, rmSync as rmSync4 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
-import { z as z19 } from "zod";
-var localRequestSchema = z19.object({
-  secret: z19.string().min(1),
-  op: z19.enum([
+import { z as z20 } from "zod";
+var localRequestSchema = z20.object({
+  secret: z20.string().min(1),
+  op: z20.enum([
     "inbox",
     "send",
     "run",
@@ -4576,32 +4663,32 @@ var localRequestSchema = z19.object({
     "activate"
   ]),
   // The key of the agent's start, from `HERD_START`, which `herd inbox` proves the start with.
-  start: z19.string().min(1).max(100).optional(),
+  start: z20.string().min(1).max(100).optional(),
   // `herd repo`: the repo it added to the conversation's folder, for the daemon to record.
-  repo: z19.object({
-    remote: z19.string().min(1).max(500),
-    folder: z19.string().min(1).max(100),
-    base: z19.string().min(1).max(300).optional(),
-    fetchFailed: z19.string().max(1e3).optional()
+  repo: z20.object({
+    remote: z20.string().min(1).max(500),
+    folder: z20.string().min(1).max(100),
+    base: z20.string().min(1).max(300).optional(),
+    fetchFailed: z20.string().max(1e3).optional()
   }).optional(),
   // `herd repo`: what the agent named and the folder it asked for, for the daemon to add.
-  repoAdd: z19.object({
-    asked: z19.string().min(1).max(500),
-    folder: z19.string().min(1).max(100).optional()
+  repoAdd: z20.object({
+    asked: z20.string().min(1).max(500),
+    folder: z20.string().min(1).max(100).optional()
   }).optional(),
   // `herd delegate --repo`, given once for each repo the delegate works in.
-  repos: z19.array(z19.string().min(1).max(500)).max(10).optional(),
+  repos: z20.array(z20.string().min(1).max(500)).max(10).optional(),
   // `herd watch`, `herd unwatch` and `herd watching`: what to do, and the pull request.
-  watch: z19.object({
-    action: z19.enum(["watch", "unwatch", "list"]),
-    url: z19.string().min(1).max(500).optional()
+  watch: z20.object({
+    action: z20.enum(["watch", "unwatch", "list"]),
+    url: z20.string().min(1).max(500).optional()
   }).optional(),
   // `herd delegate`, `herd tell` and `herd handoff`: the worker or conversation they name.
-  worker: z19.string().min(1).max(200).optional(),
-  to: z19.string().min(1).max(200).optional(),
+  worker: z20.string().min(1).max(200).optional(),
+  to: z20.string().min(1).max(200).optional(),
   // `herd automations`: what to do, to which automation, and the definition or change it sends.
-  automation: z19.object({
-    action: z19.enum([
+  automation: z20.object({
+    action: z20.enum([
       "list",
       "show",
       "create",
@@ -4612,47 +4699,47 @@ var localRequestSchema = z19.object({
       "test",
       "rotate"
     ]),
-    id: z19.string().min(1).max(100).optional(),
-    body: z19.record(z19.string(), z19.unknown()).optional(),
-    waitMs: z19.number().int().min(0).max(6e5).optional()
+    id: z20.string().min(1).max(100).optional(),
+    body: z20.record(z20.string(), z20.unknown()).optional(),
+    waitMs: z20.number().int().min(0).max(6e5).optional()
   }).optional(),
   // `herd work`: list, record or remove one, with the change the daemon checks again.
-  work: z19.object({
-    action: z19.enum(["list", "record", "remove"]),
-    change: z19.unknown().optional(),
-    url: z19.string().min(1).max(2048).optional()
+  work: z20.object({
+    action: z20.enum(["list", "record", "remove"]),
+    change: z20.unknown().optional(),
+    url: z20.string().min(1).max(2048).optional()
   }).optional(),
   // `herd conversations --about <url>`: only the owner's conversations about that URL.
-  about: z19.string().min(1).max(2048).optional(),
+  about: z20.string().min(1).max(2048).optional(),
   // `herd investigate screen` or `herd investigate propose`, with the proposal the daemon checks.
-  action: z19.enum(["screen", "propose"]).optional(),
-  proposal: z19.unknown().optional(),
+  action: z20.enum(["screen", "propose"]).optional(),
+  proposal: z20.unknown().optional(),
   // Commands may name a conversation, but only their own is ever allowed.
-  conversationId: z19.string().optional(),
+  conversationId: z20.string().optional(),
   // Where `conversations` is shown, which decides whether private titles are. Only the terminal's
   // own conversation is ever allowed, so a terminal can't pick one that shows more.
-  for: z19.string().optional(),
-  text: z19.string().optional(),
+  for: z20.string().optional(),
+  text: z20.string().optional(),
   // A whole message, from `herd send --json`, which the daemon checks again.
-  message: z19.unknown().optional(),
-  idempotencyKey: z19.string().optional(),
-  command: z19.array(z19.string()).optional(),
+  message: z20.unknown().optional(),
+  idempotencyKey: z20.string().optional(),
+  command: z20.array(z20.string()).optional(),
   // `status --clear`.
-  clear: z19.boolean().optional(),
+  clear: z20.boolean().optional(),
   // What an agent's status line reported, checked by the daemon.
-  usage: z19.unknown().optional(),
+  usage: z20.unknown().optional(),
   // Which agent and session a status line ran for. Its reports count only from the session herd
   // started in the conversation's lead terminal.
-  agent: z19.enum(["claude-code", "codex", "agy"]).optional(),
-  sessionId: z19.string().min(1).max(200).optional(),
+  agent: z20.enum(["claude-code", "codex", "agy"]).optional(),
+  sessionId: z20.string().min(1).max(200).optional(),
   // What agy's status line says its agent is doing: `working` or `idle`.
-  state: z19.enum(["working", "idle"]).optional(),
+  state: z20.enum(["working", "idle"]).optional(),
   // A permission request from Claude Code's hook, with the key it keeps across reconnects.
-  key: z19.string().min(1).max(200).optional(),
-  request: z19.unknown().optional(),
+  key: z20.string().min(1).max(200).optional(),
+  request: z20.unknown().optional(),
   // For one of Claude Code's other hooks: which event, and the JSON Claude Code gave it.
-  event: z19.string().optional(),
-  input: z19.record(z19.string(), z19.unknown()).optional()
+  event: z20.string().optional(),
+  input: z20.record(z20.string(), z20.unknown()).optional()
 });
 var LocalSocket = class {
   constructor(path, handle) {
@@ -4774,10 +4861,10 @@ function isAnswering(path) {
 }
 
 // src/permissions.ts
-var hookRequestSchema = z20.looseObject({
-  tool_name: z20.string().min(1),
-  tool_input: z20.record(z20.string(), z20.unknown()).default({}),
-  permission_suggestions: z20.array(z20.unknown()).optional()
+var hookRequestSchema = z21.looseObject({
+  tool_name: z21.string().min(1),
+  tool_input: z21.record(z21.string(), z21.unknown()).default({}),
+  permission_suggestions: z21.array(z21.unknown()).optional()
 });
 var DETAIL_LIMIT = 2800;
 var REPLY_MESSAGE_LIMIT = 2e3;
@@ -4930,6 +5017,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 +5267,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 +5311,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()
+  terminal: z22.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 storeSchema = z22.object({ agents: z22.record(z22.string(), recordSchema) });
+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 +5327,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 +5344,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 +5372,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 +5419,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 +5465,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 +5492,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 +5553,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 +5657,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 +5671,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 +5722,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 +5735,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 +5771,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 +5784,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 +5794,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 +5817,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 +5910,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 +6001,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 +6034,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 +6061,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 +6121,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 +6175,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 +6193,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 +6211,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 +6227,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 +6262,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 +6291,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 +6324,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 +6359,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 +6519,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 +6610,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 +6690,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 +6786,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 +6885,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 +6894,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,14 +7046,14 @@ 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,
     print: (line2) => console.log(line2)
   };
 }
-var releaseSchema = z22.object({ version: z22.string().min(1), integrity: z22.string().min(1) });
+var releaseSchema = z23.object({ version: z23.string().min(1), integrity: z23.string().min(1) });
 async function fetchRelease() {
   const response = await apiFetch("/api/daemon/release");
   if (response.status === 404) return null;
@@ -6850,8 +7177,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 +7241,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 +7262,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 +7304,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 +7348,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 +7376,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 +7517,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 +7541,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 +7556,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 +7568,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 +7582,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 +7600,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" }
@@ -7367,11 +7694,11 @@ init_define_HERD_PACKAGE();
 // src/investigator.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var INVESTIGATE_KEYS = ["escape", "up", "down", "enter", "tab"];
-var proposalSchema = z23.object({
-  key: z23.enum([...INVESTIGATE_KEYS, "none"]),
-  reason: z23.string().trim().min(1).max(300)
+var proposalSchema = z24.object({
+  key: z24.enum([...INVESTIGATE_KEYS, "none"]),
+  reason: z24.string().trim().min(1).max(300)
 });
 var KEY_LABELS = {
   escape: "Esc",
@@ -7779,16 +8106,16 @@ 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 { z as z24 } from "zod";
+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 z25 } from "zod";
 var BUILDS_URL = "https://builds.herdingchats.com";
-var runnerKeySchema = z24.object({
-  runnerId: z24.string().min(1),
-  key: z24.string().min(20),
-  url: z24.string().url()
+var runnerKeySchema = z25.object({
+  runnerId: z25.string().min(1),
+  key: z25.string().min(20),
+  url: z25.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 +8128,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);
@@ -7855,33 +8182,33 @@ async function registerRunner({
 
 // src/build-speed.ts
 init_define_HERD_PACKAGE();
-import { z as z25 } from "zod";
-var ms = z25.number().int().nullable();
-var figuresSchema = z25.object({ count: z25.number().int(), median: ms, p90: ms });
-var buildTimesSchema = z25.object({ run: figuresSchema, push: figuresSchema });
-var stepFiguresSchema = z25.object({
-  ran: z25.number().int(),
-  remembered: z25.number().int(),
+import { z as z26 } from "zod";
+var ms = z26.number().int().nullable();
+var figuresSchema = z26.object({ count: z26.number().int(), median: ms, p90: ms });
+var buildTimesSchema = z26.object({ run: figuresSchema, push: figuresSchema });
+var stepFiguresSchema = z26.object({
+  ran: z26.number().int(),
+  remembered: z26.number().int(),
   median: ms,
   p90: ms,
-  overBudget: z25.number().int()
+  overBudget: z26.number().int()
 });
-var kindSchema = z25.object({
-  builds: z25.object({ current: buildTimesSchema, previous: buildTimesSchema }),
-  steps: z25.array(
-    z25.object({ label: z25.string(), current: stepFiguresSchema, previous: stepFiguresSchema })
+var kindSchema = z26.object({
+  builds: z26.object({ current: buildTimesSchema, previous: buildTimesSchema }),
+  steps: z26.array(
+    z26.object({ label: z26.string(), current: stepFiguresSchema, previous: stepFiguresSchema })
   ),
-  overBudget: z25.array(
-    z25.object({ label: z25.string(), current: z25.number().int(), previous: z25.number().int() })
+  overBudget: z26.array(
+    z26.object({ label: z26.string(), current: z26.number().int(), previous: z26.number().int() })
   )
 });
-var range = z25.object({ from: z25.number(), to: z25.number() });
-var speedReportSchema = z25.object({
-  periods: z25.object({ current: range, previous: range }),
-  repos: z25.array(
-    z25.object({
-      repo: z25.string(),
-      capped: z25.boolean(),
+var range = z26.object({ from: z26.number(), to: z26.number() });
+var speedReportSchema = z26.object({
+  periods: z26.object({ current: range, previous: range }),
+  repos: z26.array(
+    z26.object({
+      repo: z26.string(),
+      capped: z26.boolean(),
       pullRequests: kindSchema,
       main: kindSchema
     })
@@ -7969,8 +8296,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 +8305,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 +8585,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 +8637,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 +8665,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 +8681,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 +8721,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 +8799,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 +8903,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 +8922,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 +8934,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 +8949,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 +8972,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 +8988,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 +9054,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 +9101,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 +9120,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 +9135,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 +9145,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 +9328,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 +9361,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 +9378,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 +9391,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 +9425,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 +9437,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 +9449,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 +9461,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 +9473,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 +9492,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 +9517,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 +9532,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 +9557,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 +9591,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 +9603,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 +9614,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 +9625,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 +9640,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 +9649,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 +9669,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 +9690,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 +9702,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 +9746,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 +9754,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 +9783,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 +9961,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 +9984,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 +10000,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 +10066,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 +10099,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 +10107,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 +10222,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 +10435,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 +10518,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 +10527,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 +10598,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 +10651,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 +10688,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 +10708,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 +10756,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 +10803,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 +10849,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;
@@ -10838,7 +10934,7 @@ init_define_HERD_PACKAGE();
 init_src();
 init_self();
 import { join as join28 } from "node:path";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function hasThread(events) {
   return events.some(
     (event2) => event2.type === "prompt.opened" || event2.type === "message.created" && !(event2.payload.direction === "inbound" && event2.payload.automation) && !event2.payload.quiet && !event2.payload.post
@@ -10904,16 +11000,16 @@ var WAITING_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "agent_needs_input",
   "elicitation_dialog"
 ]);
-var agentMessageSchema = z26.object({
-  text: z26.string().trim().min(1).max(12e3),
-  files: z26.array(z26.object({ path: z26.string().min(1), title: z26.string().optional() })).max(10).optional()
+var agentMessageSchema = z27.object({
+  text: z27.string().trim().min(1).max(12e3),
+  files: z27.array(z27.object({ path: z27.string().min(1), title: z27.string().optional() })).max(10).optional()
 });
-var workspaceRepoSchema = z26.object({
-  folder: z26.string(),
-  remote: z26.string(),
-  branch: z26.string(),
+var workspaceRepoSchema = z27.object({
+  folder: z27.string(),
+  remote: z27.string(),
+  branch: z27.string(),
   /** For a conversation from before folders: the name of the repo it was allowed as. */
-  name: z26.string().optional()
+  name: z27.string().optional()
 });
 function fromBeforeFolders(raw) {
   if (!raw || typeof raw !== "object" || "folder" in raw) return raw;
@@ -10934,106 +11030,106 @@ function fromBeforeFolders(raw) {
     legacy: true
   };
 }
-var workspaceFields = z26.object({
-  conversationId: z26.string(),
+var workspaceFields = z27.object({
+  conversationId: z27.string(),
   /** The conversation's own folder, where its terminals start. */
-  folder: z26.string(),
+  folder: z27.string(),
   /** The repos in it, in the order they were added. */
-  worktrees: z26.array(workspaceRepoSchema).default([]),
+  worktrees: z27.array(workspaceRepoSchema).default([]),
   /** A conversation from before folders, which works in its one repo's worktree. */
-  legacy: z26.boolean().default(false),
-  lead: z26.string(),
-  secret: z26.string(),
-  readSeq: z26.number(),
-  claimId: z26.string().nullable(),
-  claimRenewedAt: z26.number(),
-  started: z26.boolean(),
+  legacy: z27.boolean().default(false),
+  lead: z27.string(),
+  secret: z27.string(),
+  readSeq: z27.number(),
+  claimId: z27.string().nullable(),
+  claimRenewedAt: z27.number(),
+  started: z27.boolean(),
   /** Messages to deliver once the current turn ends. */
-  deferred: z26.boolean(),
+  deferred: z27.boolean(),
   /** A `herd run` command finished, which the agent hears about even with nothing to claim. */
-  terminalNotice: z26.boolean().default(false),
-  status: z26.string().nullable(),
+  terminalNotice: z27.boolean().default(false),
+  status: z27.string().nullable(),
   /** Set once the thread has been told the agent is waiting, so it's told once per wait. */
-  toldWaiting: z26.boolean(),
-  runs: z26.array(z26.object({ name: z26.string(), secret: z26.string(), reported: z26.boolean() })),
+  toldWaiting: z27.boolean(),
+  runs: z27.array(z27.object({ name: z27.string(), secret: z27.string(), reported: z27.boolean() })),
   /** The subscription usage Claude Code last reported in this worktree. */
   usage: usageSchema.nullable().default(null),
   /** When that usage was reported, or 0 if it was before this was kept. */
-  usageAt: z26.number().default(0),
+  usageAt: z27.number().default(0),
   /** The lead agent's Claude Code session, as its `SessionStart` hook reported it. */
-  sessionId: z26.string().nullable().default(null),
+  sessionId: z27.string().nullable().default(null),
   /** When the agent's last turn ended with nothing left to do, for shutting it down later. */
-  idleSince: z26.number().nullable().default(null),
+  idleSince: z27.number().nullable().default(null),
   /** The agent ran `herd exit`, so its session ends after this turn. */
-  exitRequested: z26.boolean().default(false),
+  exitRequested: z27.boolean().default(false),
   /** Whether the agent sent anything with `herd send` this turn. */
-  sentThisTurn: z26.boolean().default(false),
+  sentThisTurn: z27.boolean().default(false),
   /** Whether it's been asked this turn to reply. */
-  askedToReply: z26.boolean().default(false),
+  askedToReply: z27.boolean().default(false),
   /** Whether it ran `herd handled` this turn, which handles the turn's messages with no reply. */
-  handledThisTurn: z26.boolean().default(false),
+  handledThisTurn: z27.boolean().default(false),
   /** The newest waiting message it's been pointed at, so one arrival is pointed out once. */
-  nudgedSeq: z26.number().default(0),
+  nudgedSeq: z27.number().default(0),
   /** When a `Stop` hook last ended a turn. */
-  hookIdleAt: z26.number().default(0),
+  hookIdleAt: z27.number().default(0),
   /** When a turn last ended with background work still running, which keeps its messages held. */
-  pausedAt: z26.number().nullable().default(null),
+  pausedAt: z27.number().nullable().default(null),
   /** The version of the terminal host the lead terminal was opened in, if it was recorded. */
-  hostVersion: z26.string().nullable().default(null),
+  hostVersion: z27.string().nullable().default(null),
   /** When a notice last failed for a reason other than someone's draft, to wait before retrying. */
-  noticeFailedAt: z26.number().nullable().default(null),
+  noticeFailedAt: z27.number().nullable().default(null),
   /** Why the last notice failed, so the history records each reason once, not every attempt. */
-  noticeFailure: z26.string().nullable().default(null),
+  noticeFailure: z27.string().nullable().default(null),
   /** A recorded dialog herd pressed its way out of, so a dialog that stays isn't pressed again. */
-  closedDialog: z26.string().nullable().default(null),
+  closedDialog: z27.string().nullable().default(null),
   /**
    * Prompts Claude Code's hooks reported that haven't had their `Stop`. A turn is open while this
    * is above zero. It's a count because a prompt queued mid-turn is reported as it's queued, and
    * runs as a turn of its own, ending with a second `Stop`.
    */
-  promptsOpen: z26.number().default(0),
+  promptsOpen: z27.number().default(0),
   /** The messages the latest claim or addition took, for choosing which notice to type. */
-  claimedSeqs: z26.array(z26.number()).default([]),
+  claimedSeqs: z27.array(z27.number()).default([]),
   /** The investigator looking at a screen herd can't read, from opening to the owner's answer. */
-  investigation: z26.object({
-    terminal: z26.string(),
-    secret: z26.string(),
-    startedAt: z26.number(),
+  investigation: z27.object({
+    terminal: z27.string(),
+    secret: z27.string(),
+    startedAt: z27.number(),
     /** The stuck screen when it opened, saved with the key if the owner approves one. */
-    screen: z26.array(z26.string()),
-    key: z26.string().nullable(),
-    promptId: z26.string().nullable()
+    screen: z27.array(z27.string()),
+    key: z27.string().nullable(),
+    promptId: z27.string().nullable()
   }).nullable().default(null),
   /** The failed notice an investigator was opened for, so each failure gets one. */
-  investigatedFailure: z26.number().nullable().default(null),
+  investigatedFailure: z27.number().nullable().default(null),
   /** The agent CLI this conversation's worker runs, as its offer named it. */
-  agent: z26.string().default("claude-code"),
+  agent: z27.string().default("claude-code"),
   /** Whether what the current claim took needs a reply, which other agents' messages don't. */
-  replyWanted: z26.boolean().default(true),
+  replyWanted: z27.boolean().default(true),
   /** For a delegate: the conversation that started it, which its starting prompt names. */
-  parent: z26.string().nullable().default(null),
+  parent: z27.string().nullable().default(null),
   /** Codex's session file for this worktree, once found, and how far the daemon has read it. */
-  codexFile: z26.string().nullable().default(null),
-  codexOffset: z26.number().default(0),
+  codexFile: z27.string().nullable().default(null),
+  codexOffset: z27.number().default(0),
   /** When the agent was last started, so Codex's new session file is told from older ones. */
-  agentStartedAt: z26.number().default(0),
+  agentStartedAt: z27.number().default(0),
   /**
    * The key the agent was last started with, as `HERD_START`. Its `herd inbox` carrying this key
    * is what proves the start works: never a hook, a prompt being taken, or the screen.
    */
-  startKey: z26.string().nullable().default(null),
+  startKey: z27.string().nullable().default(null),
   /** Whether the current start has checked in. One from before keys counts as proven. */
-  startProven: z26.boolean().default(true),
+  startProven: z27.boolean().default(true),
   /** When the check-in window of an unproven start began, or null once it's proven or for none. */
-  checkInFrom: z26.number().nullable().default(null),
+  checkInFrom: z27.number().nullable().default(null),
   /** Whether this start has been flagged as needing someone at its terminal, so it's said once. */
-  needsAttention: z26.boolean().default(false),
+  needsAttention: z27.boolean().default(false),
   /** What agy's status line last said its agent was doing, and when. */
-  agentState: z26.enum(["working", "idle"]).nullable().default(null),
-  agentStateAt: z26.number().default(0)
+  agentState: z27.enum(["working", "idle"]).nullable().default(null),
+  agentStateAt: z27.number().default(0)
 });
-var workspaceSchema = z26.preprocess(fromBeforeFolders, workspaceFields);
-var stateSchema = z26.object({ workspaces: z26.record(z26.string(), workspaceSchema) });
+var workspaceSchema = z27.preprocess(fromBeforeFolders, workspaceFields);
+var stateSchema = z27.object({ workspaces: z27.record(z27.string(), workspaceSchema) });
 
 // src/workspaces/claims.ts
 var holder = (ws, workspace) => `${ws.options.machineName()}/${workspace.lead}`;
@@ -11114,7 +11210,7 @@ import { join as join29 } from "node:path";
 
 // src/commands/repo.ts
 init_define_HERD_PACKAGE();
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var REPO_HELP = `Usage: herd repo <url or owner/name> [folder]
 
 Checks a repo out in this conversation's folder, on a branch named for the conversation, started
@@ -11128,16 +11224,16 @@ var REPOS_HELP = `Usage: herd repos [--json]
 
 Lists the repos in this conversation's folder, the repos checked out in this machine's root, and
 the repos your owner's herd.config.ts describes, with what each is for. Add one with herd repo.`;
-var repoContextSchema = z27.object({
-  folder: z27.string(),
-  root: z27.string(),
-  branch: z27.string(),
-  legacy: z27.boolean(),
-  legacyReason: z27.string().optional(),
-  recorded: z27.array(z27.object({ folder: z27.string(), remote: z27.string(), branch: z27.string() })),
-  cloned: z27.array(z27.object({ key: z27.string(), remote: z27.string() })),
-  described: z27.array(
-    z27.object({ remote: z27.string(), key: z27.string().nullable(), about: z27.string().optional() })
+var repoContextSchema = z28.object({
+  folder: z28.string(),
+  root: z28.string(),
+  branch: z28.string(),
+  legacy: z28.boolean(),
+  legacyReason: z28.string().optional(),
+  recorded: z28.array(z28.object({ folder: z28.string(), remote: z28.string(), branch: z28.string() })),
+  cloned: z28.array(z28.object({ key: z28.string(), remote: z28.string() })),
+  described: z28.array(
+    z28.object({ remote: z28.string(), key: z28.string().nullable(), about: z28.string().optional() })
   )
 });
 var isUrl = (text4) => /^[a-z][a-z0-9+.-]*:\/\//i.test(text4) || text4.startsWith("/") || /^[^@/\s]+@[^:/\s]+:/.test(text4);
@@ -11194,7 +11290,7 @@ async function runRepo(rest) {
     op: "repo-add",
     repoAdd: { asked, ...folderName !== void 0 ? { folder: folderName } : {} }
   });
-  const lines = z27.array(z27.string()).safeParse(reply.lines);
+  const lines = z28.array(z28.string()).safeParse(reply.lines);
   if (!lines.success) throw new HerdError("The daemon's answer about this repo wasn't readable.");
   console.log(lines.data.join("\n"));
   return 0;
@@ -11962,7 +12058,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 +12111,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 +12130,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 +12192,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 +12258,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);
     }
@@ -12368,21 +12469,21 @@ function resolveAttachments(worktree, files) {
 // src/workers.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z28 } from "zod";
-var workerListingSchema = z28.object({
-  workers: z28.array(workerSchema),
-  machines: z28.array(
-    z28.object({
-      id: z28.string(),
-      name: z28.string(),
-      online: z28.boolean(),
-      missing: z28.array(z28.string()),
-      configError: z28.string().optional(),
+import { z as z29 } from "zod";
+var workerListingSchema = z29.object({
+  workers: z29.array(workerSchema),
+  machines: z29.array(
+    z29.object({
+      id: z29.string(),
+      name: z29.string(),
+      online: z29.boolean(),
+      missing: z29.array(z29.string()),
+      configError: z29.string().optional(),
       // Servers from before versions were reported send none.
-      herdVersion: z28.string().nullable().optional()
+      herdVersion: z29.string().nullable().optional()
     })
   ),
-  configType: z28.string()
+  configType: z29.string()
 });
 async function readWorkers(fetch2) {
   const response = await fetch2("/api/workers");
@@ -12450,20 +12551,20 @@ function formatWorkers(listing, current = null) {
   );
   return lines.join("\n");
 }
-var routingCheckSchema = z28.object({
-  suits: z28.array(z28.object({ key: z28.string(), name: z28.string() })),
-  eligible: z28.array(z28.object({ key: z28.string(), name: z28.string() })),
-  removed: z28.array(z28.object({ key: z28.string(), name: z28.string(), rule: z28.string() })),
-  questions: z28.array(
-    z28.object({ id: z28.string(), question: z28.string(), probability: z28.number().nullable() })
+var routingCheckSchema = z29.object({
+  suits: z29.array(z29.object({ key: z29.string(), name: z29.string() })),
+  eligible: z29.array(z29.object({ key: z29.string(), name: z29.string() })),
+  removed: z29.array(z29.object({ key: z29.string(), name: z29.string(), rule: z29.string() })),
+  questions: z29.array(
+    z29.object({ id: z29.string(), question: z29.string(), probability: z29.number().nullable() })
   ),
-  fallback: z28.string().optional(),
-  fits: z28.array(
-    z28.object({
-      key: z28.string(),
-      fit: z28.number(),
-      statement: z28.string().optional(),
-      level: z28.string().optional()
+  fallback: z29.string().optional(),
+  fits: z29.array(
+    z29.object({
+      key: z29.string(),
+      fit: z29.number(),
+      statement: z29.string().optional(),
+      level: z29.string().optional()
     })
   ).optional()
 });
@@ -13318,8 +13419,8 @@ async function download(ws, workspace, file) {
       Readable.fromWeb(response.body),
       createWriteStream(partial, { flags: "wx" })
     );
-    const { size } = statSync10(partial);
-    if (size !== file.size) throw new Error(`it came to ${size} bytes, not ${file.size}`);
+    const { size: size2 } = statSync10(partial);
+    if (size2 !== file.size) throw new Error(`it came to ${size2} bytes, not ${file.size}`);
     renameSync7(partial, target);
   } finally {
     rmSync17(partial, { force: true });
@@ -13883,6 +13984,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,10 +14682,10 @@ 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 });
+    const size2 = () => ({ cols: stdout.columns || 120, rows: stdout.rows || 40 });
     let buffer = "";
     let started = false;
     let ended = false;
@@ -14601,19 +14703,21 @@ 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");
         finish("detached");
       }
     };
-    const onResize = () => socket.write(`${JSON.stringify({ type: "resize", ...size() })}
+    const onResize = () => socket.write(`${JSON.stringify({ type: "resize", ...size2() })}
 `);
     socket.on(
       "connect",
-      () => socket.write(`${JSON.stringify({ op: "attach", name, ...size() })}
-`)
+      () => socket.write(
+        `${JSON.stringify(watch2 ? { op: "watch", name } : { op: "attach", name, ...size2() })}
+`
+      )
     );
     socket.on("data", (chunk) => {
       buffer += chunk;
@@ -14634,7 +14738,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 +14761,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 +14771,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) {
@@ -14883,7 +14988,7 @@ async function runWatch(command, rest) {
 // src/commands/work.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var WORK_HELP = `Usage: herd work <url> [--kind <kind>] [--title "<title>"] [--status <status>]
                        [--detail "<detail>"] [--made] [--phase <phase>]
        herd work --remove <url>
@@ -14975,9 +15080,9 @@ ${WORK_HELP}`
   };
   return { kind: "record", change, json };
 }
-var followSchema = z34.union([
-  z34.object({ following: z34.literal(true) }),
-  z34.object({ following: z34.literal(false), reason: z34.string() })
+var followSchema = z35.union([
+  z35.object({ following: z35.literal(true) }),
+  z35.object({ following: z35.literal(false), reason: z35.string() })
 ]);
 function formatFollow(follow) {
   return follow.following ? "Following it: its reviews, CI and merge will reach herd inbox." : `Not followed: ${follow.reason}`;
@@ -14993,7 +15098,7 @@ function formatWork(work, own) {
   return `  ${parts.join(" \xB7 ")}${work.made ? "  made here" : ""}
     ${work.url}${whose}`;
 }
-var listSchema = z34.array(workObjectSchema);
+var listSchema = z35.array(workObjectSchema);
 async function runWork(rest) {
   const parsed = parseWork(rest);
   if (parsed.kind === "help") {
@@ -15241,7 +15346,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