@herdingchats/friday 0.1.660 → 0.1.666

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.660", gitHead: "21101252ff98a4dc317139a36c286b347f5f5933" };
+    define_HERD_PACKAGE_default = { version: "0.1.666", gitHead: "696b23f94dba08b3cf37c586ef28c4ce29fab715" };
   }
 });
 
@@ -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",
@@ -3213,7 +3300,7 @@ import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node
 import { homedir as homedir5 } from "node:os";
 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.");
     }
@@ -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) {
@@ -4528,23 +4615,23 @@ init_src();
 import { randomBytes as randomBytes4, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname5, join as join8 } from "node:path";
-import { z as z21 } from "zod";
+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;
@@ -5227,9 +5314,9 @@ var activationTerminal = (agent) => `herd-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 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()) {
@@ -6966,7 +7053,7 @@ function defaults() {
     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;
@@ -7607,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",
@@ -8021,12 +8108,12 @@ init_define_HERD_PACKAGE();
 init_src();
 import { chmodSync as chmodSync3, existsSync as existsSync14, mkdirSync as mkdirSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
 import { join as join19 } from "node:path";
-import { z as z24 } from "zod";
+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 = () => join19(herdHome(), "build-runner.json");
 function readRunnerKey() {
@@ -8095,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
     })
@@ -10847,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
@@ -10913,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;
@@ -10943,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}`;
@@ -11123,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
@@ -11137,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);
@@ -11203,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;
@@ -12382,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");
@@ -12464,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()
 });
@@ -13332,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 });
@@ -14598,7 +14685,7 @@ var DETACH_KEY = "";
 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;
@@ -14623,12 +14710,12 @@ function attach(name, { stdin, stdout } = { stdin: process.stdin, stdout: proces
         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(watch2 ? { op: "watch", name } : { op: "attach", name, ...size() })}
+        `${JSON.stringify(watch2 ? { op: "watch", name } : { op: "attach", name, ...size2() })}
 `
       )
     );
@@ -14901,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>
@@ -14993,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}`;
@@ -15011,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") {