@herdingchats/friday 0.1.541 → 0.1.548

package/herd.mjs

@@ -18,12 +18,12 @@ 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.541", gitHead: "ca2d136a1b409a0d993ead45879528bb25fd4ac5" };
+    define_HERD_PACKAGE_default = { version: "0.1.548", gitHead: "9f61cd323e160358d58bbb45c3835f3ae1bc25b3" };
   }
 });
 
 // ../common-chat/src/activation.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function activationText(agent, activation) {
   if (!activation || activation.state === "activated") return "activated";
   if (activation.state === "waiting") {
@@ -45,8 +45,8 @@ var init_activation = __esm({
   "../common-chat/src/activation.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    time = z2.number().int().nonnegative();
-    activationFailureSchema = z2.enum([
+    time = z.number().int().nonnegative();
+    activationFailureSchema = z.enum([
       // The agent showed its own sign-in, and nobody finished it in time.
       "signed_out",
       // A screen herd doesn't know was in the way.
@@ -56,11 +56,11 @@ var init_activation = __esm({
       // It didn't start in its terminal at all.
       "didnt_start"
     ]);
-    agentActivationSchema = z2.object({
-      state: z2.enum(["activated", "waiting", "failed"]),
-      version: z2.string().min(1).max(100),
+    agentActivationSchema = z.object({
+      state: z.enum(["activated", "waiting", "failed"]),
+      version: z.string().min(1).max(100),
       at: time,
-      signingIn: z2.boolean().optional(),
+      signingIn: z.boolean().optional(),
       reason: activationFailureSchema.optional()
     });
     activationSignedOut = (activation) => Boolean(
@@ -71,34 +71,34 @@ var init_activation = __esm({
       codex: "codex",
       agy: "agy"
     };
-    gitHubCliSchema = z2.discriminatedUnion("state", [
-      z2.object({ state: z2.literal("signed_in"), login: z2.string().min(1).max(100), checkedAt: time }),
-      z2.object({ state: z2.literal("signed_out"), checkedAt: time }),
-      z2.object({ state: z2.literal("missing"), checkedAt: time })
+    gitHubCliSchema = z.discriminatedUnion("state", [
+      z.object({ state: z.literal("signed_in"), login: z.string().min(1).max(100), checkedAt: time }),
+      z.object({ state: z.literal("signed_out"), checkedAt: time }),
+      z.object({ state: z.literal("missing"), checkedAt: time })
     ]);
-    signInToolSchema = z2.enum(["gh"]);
+    signInToolSchema = z.enum(["gh"]);
     GITHUB_DEVICE_URL = "https://github.com/login/device";
-    signInUpdateSchema = z2.discriminatedUnion("state", [
-      z2.object({
-        state: z2.literal("code"),
-        code: z2.string().regex(/^[A-Z0-9]{4}-[A-Z0-9]{4}$/),
-        url: z2.literal(GITHUB_DEVICE_URL)
+    signInUpdateSchema = z.discriminatedUnion("state", [
+      z.object({
+        state: z.literal("code"),
+        code: z.string().regex(/^[A-Z0-9]{4}-[A-Z0-9]{4}$/),
+        url: z.literal(GITHUB_DEVICE_URL)
       }),
-      z2.object({ state: z2.literal("signed_in"), login: z2.string().min(1).max(100) }),
+      z.object({ state: z.literal("signed_in"), login: z.string().min(1).max(100) }),
       // `no_code`: it printed nothing herd recognizes. `not_signed_in`: it ended without signing in.
-      z2.object({ state: z2.literal("failed"), reason: z2.enum(["no_code", "not_signed_in"]) })
+      z.object({ state: z.literal("failed"), reason: z.enum(["no_code", "not_signed_in"]) })
     ]);
   }
 });
 
 // ../common-chat/src/github-triggers.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var nonEmpty, GITHUB_TRIGGER_KINDS, githubTriggerKindSchema, GITHUB_TRIGGER_LABELS, githubTriggerEventSchema;
 var init_github_triggers = __esm({
   "../common-chat/src/github-triggers.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    nonEmpty = z3.string().min(1);
+    nonEmpty = z2.string().min(1);
     GITHUB_TRIGGER_KINDS = [
       "opened",
       "review_requested",
@@ -107,7 +107,7 @@ var init_github_triggers = __esm({
       "merged",
       "mention"
     ];
-    githubTriggerKindSchema = z3.enum(GITHUB_TRIGGER_KINDS);
+    githubTriggerKindSchema = z2.enum(GITHUB_TRIGGER_KINDS);
     GITHUB_TRIGGER_LABELS = {
       opened: "Pull requests you open",
       review_requested: "Review requests",
@@ -116,33 +116,33 @@ var init_github_triggers = __esm({
       merged: "Your pull requests merged",
       mention: "Mentions of you"
     };
-    githubTriggerEventSchema = z3.object({
+    githubTriggerEventSchema = z2.object({
       /** The event, so each fires an automation once. */
       key: nonEmpty,
       kind: githubTriggerKindSchema,
-      repoId: z3.number().int(),
+      repoId: z2.number().int(),
       /** `owner/name`. */
       repo: nonEmpty,
-      number: z3.number().int().positive(),
+      number: z2.number().int().positive(),
       /** The pull request's link. */
-      url: z3.url(),
+      url: z2.url(),
       /** Where the event itself is, such as the review or the comment. */
-      eventUrl: z3.url().optional(),
+      eventUrl: z2.url().optional(),
       /** The pull request's title, when the event says it. */
-      title: z3.string().max(300).optional(),
+      title: z2.string().max(300).optional(),
       /** Who caused it. */
       by: nonEmpty,
       /** For a review, its state: `approved`, `changes_requested` or `commented`. */
-      state: z3.string().optional(),
-      private: z3.boolean(),
-      at: z3.number().int().nonnegative()
+      state: z2.string().optional(),
+      private: z2.boolean(),
+      at: z2.number().int().nonnegative()
     });
   }
 });
 
 // ../common-chat/src/automations.ts
 import { Cron } from "croner";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 function isTimeZone(timeZone) {
   try {
     new Intl.DateTimeFormat("en-US", { timeZone }).format(0);
@@ -212,56 +212,56 @@ var init_automations = __esm({
     MIN_SCHEDULE_INTERVAL_MS = 15 * 60 * 1e3;
     MAX_WEBHOOK_BODY = 64 * 1024;
     MAX_ONCE_AHEAD_MS = 366 * 24 * 60 * 60 * 1e3;
-    nonEmpty2 = z4.string().trim().min(1);
+    nonEmpty2 = z3.string().trim().min(1);
     timeZoneSchema = nonEmpty2.max(64).refine(isTimeZone, "That isn't a time zone. Use an IANA name, such as America/Los_Angeles.");
-    triggerSchema = z4.discriminatedUnion("kind", [
+    triggerSchema = z3.discriminatedUnion("kind", [
       // A five-field cron expression, read in its time zone.
-      z4.object({ kind: z4.literal("cron"), cron: nonEmpty2.max(100), timeZone: timeZoneSchema }),
+      z3.object({ kind: z3.literal("cron"), cron: nonEmpty2.max(100), timeZone: timeZoneSchema }),
       // A single instant, with the time zone it's described in.
-      z4.object({ kind: z4.literal("once"), at: z4.number().int().positive(), timeZone: timeZoneSchema }),
+      z3.object({ kind: z3.literal("once"), at: z3.number().int().positive(), timeZone: timeZoneSchema }),
       // A secret URL on the hooks hostname, which anything can post to.
-      z4.object({ kind: z4.literal("webhook") }),
+      z3.object({ kind: z3.literal("webhook") }),
       // The owner's own GitHub events, of these kinds, and only in these repos when it names any.
       // `unfollowed` keeps only pull requests none of the owner's conversations follow or made.
-      z4.object({
-        kind: z4.literal("github"),
-        events: z4.array(githubTriggerKindSchema).min(1).max(GITHUB_TRIGGER_KINDS.length),
-        unfollowed: z4.boolean().optional(),
-        repos: z4.array(
-          z4.string().trim().regex(/^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/, "Name each repo as owner/name.")
+      z3.object({
+        kind: z3.literal("github"),
+        events: z3.array(githubTriggerKindSchema).min(1).max(GITHUB_TRIGGER_KINDS.length),
+        unfollowed: z3.boolean().optional(),
+        repos: z3.array(
+          z3.string().trim().regex(/^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/, "Name each repo as owner/name.")
         ).max(10).optional()
       })
     ]);
     triggerTimeZone = (trigger) => trigger.kind === "cron" || trigger.kind === "once" ? trigger.timeZone : "UTC";
-    targetInputSchema = z4.discriminatedUnion("kind", [
-      z4.object({ kind: z4.literal("direct") }),
-      z4.object({ kind: z4.literal("channel"), channel: nonEmpty2.max(100) }),
-      z4.object({ kind: z4.literal("conversation"), conversationId: nonEmpty2.max(100) })
+    targetInputSchema = z3.discriminatedUnion("kind", [
+      z3.object({ kind: z3.literal("direct") }),
+      z3.object({ kind: z3.literal("channel"), channel: nonEmpty2.max(100) }),
+      z3.object({ kind: z3.literal("conversation"), conversationId: nonEmpty2.max(100) })
     ]);
-    targetSchema = z4.discriminatedUnion("kind", [
-      z4.object({ kind: z4.literal("direct") }),
-      z4.object({
-        kind: z4.literal("channel"),
+    targetSchema = z3.discriminatedUnion("kind", [
+      z3.object({ kind: z3.literal("direct") }),
+      z3.object({
+        kind: z3.literal("channel"),
         channel: nonEmpty2,
         name: nonEmpty2,
-        isPrivate: z4.boolean()
+        isPrivate: z3.boolean()
       }),
-      z4.object({ kind: z4.literal("conversation"), conversationId: nonEmpty2 })
+      z3.object({ kind: z3.literal("conversation"), conversationId: nonEmpty2 })
     ]);
     MAX_AUTOMATION_REPOS = 10;
-    automationInputSchema = z4.object({
+    automationInputSchema = z3.object({
       name: nonEmpty2.max(80),
       trigger: triggerSchema,
       target: targetInputSchema,
       instructions: nonEmpty2.max(MAX_INSTRUCTIONS),
       // The repos each firing's conversation starts with, as hints. `repo` is the one-repo form from
       // before automations could name several, read as a list of one.
-      repos: z4.array(nonEmpty2.max(300)).max(MAX_AUTOMATION_REPOS).optional(),
+      repos: z3.array(nonEmpty2.max(300)).max(MAX_AUTOMATION_REPOS).optional(),
       repo: nonEmpty2.max(300).nullable().optional()
     });
     automationChangeSchema = automationInputSchema.partial();
-    automationStateSchema = z4.enum(["pending_approval", "active", "paused", "finished"]);
-    firingOutcomeSchema = z4.enum([
+    automationStateSchema = z3.enum(["pending_approval", "active", "paused", "finished"]);
+    firingOutcomeSchema = z3.enum([
       // Waiting to reach its conversation.
       "pending",
       "delivered",
@@ -275,7 +275,7 @@ var init_automations = __esm({
 });
 
 // ../common-chat/src/content.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 function exactlyOneBody(message, ctx) {
   if (message.text === void 0 === (message.markdown === void 0)) {
     ctx.addIssue({
@@ -306,80 +306,80 @@ var init_content = __esm({
     MAX_FILES_PER_MESSAGE = 10;
     MAX_FILE_BYTES = 100 * 1024 * 1024;
     MAX_CONVERSATION_FILE_BYTES = 1024 * 1024 * 1024;
-    layoutPlatformSchema = z5.enum(["slack"]);
-    blockSchema = z5.looseObject({ type: z5.string().min(1) });
-    blocksSchema = z5.array(blockSchema).min(1).max(MAX_LAYOUT_BLOCKS, `A message can have at most ${MAX_LAYOUT_BLOCKS} blocks.`).refine(
+    layoutPlatformSchema = z4.enum(["slack"]);
+    blockSchema = z4.looseObject({ type: z4.string().min(1) });
+    blocksSchema = z4.array(blockSchema).min(1).max(MAX_LAYOUT_BLOCKS, `A message can have at most ${MAX_LAYOUT_BLOCKS} blocks.`).refine(
       (blocks) => new TextEncoder().encode(JSON.stringify(blocks)).length <= MAX_LAYOUT_BYTES,
       `Blocks can be at most ${MAX_LAYOUT_BYTES / 1e3} KB as JSON.`
     );
-    layoutSchema = z5.strictObject({
+    layoutSchema = z4.strictObject({
       platform: layoutPlatformSchema,
       blocks: blocksSchema
     });
-    textBody = z5.string().max(
+    textBody = z4.string().max(
       MAX_TEXT_LENGTH,
       `Text can be at most ${MAX_TEXT_LENGTH.toLocaleString("en-US")} characters.`
     ).refine((text4) => text4.trim().length > 0, "The message is empty.");
-    markdownBody = z5.string().max(
+    markdownBody = z4.string().max(
       MAX_MARKDOWN_LENGTH,
       `Markdown can be at most ${MAX_MARKDOWN_LENGTH.toLocaleString("en-US")} characters.`
     ).refine((text4) => text4.trim().length > 0, "The message is empty.");
-    title = z5.string().trim().min(1).max(255);
-    alt = z5.string().trim().min(1).max(1e3);
-    channelTargetSchema = z5.string().trim().regex(/^(#[a-z0-9][a-z0-9._-]{0,79}|[CG][A-Z0-9]{2,})$/, {
+    title = z4.string().trim().min(1).max(255);
+    alt = z4.string().trim().min(1).max(1e3);
+    channelTargetSchema = z4.string().trim().regex(/^(#[a-z0-9][a-z0-9._-]{0,79}|[CG][A-Z0-9]{2,})$/, {
       message: "A channel is an ID such as C0123ABCD, or a name such as #eng."
     });
-    herdMessageSchema = z5.strictObject({
+    herdMessageSchema = z4.strictObject({
       text: textBody.optional(),
       markdown: markdownBody.optional(),
       blocks: blocksSchema.optional(),
-      files: z5.array(
-        z5.strictObject({ path: z5.string().min(1), title: title.optional(), alt: alt.optional() })
+      files: z4.array(
+        z4.strictObject({ path: z4.string().min(1), title: title.optional(), alt: alt.optional() })
       ).min(1).max(MAX_FILES_PER_MESSAGE, `A message can have at most ${MAX_FILES_PER_MESSAGE} files.`).optional(),
       channel: channelTargetSchema.optional()
     }).superRefine(exactlyOneBody);
-    sendMessageSchema = z5.strictObject({
+    sendMessageSchema = z4.strictObject({
       text: textBody.optional(),
       markdown: markdownBody.optional(),
       layout: layoutSchema.optional(),
-      files: z5.array(
-        z5.strictObject({
-          id: z5.string().min(1).max(100),
+      files: z4.array(
+        z4.strictObject({
+          id: z4.string().min(1).max(100),
           title: title.optional(),
           alt: alt.optional()
         })
       ).min(1).max(MAX_FILES_PER_MESSAGE, `A message can have at most ${MAX_FILES_PER_MESSAGE} files.`).optional(),
       channel: channelTargetSchema.optional(),
-      quiet: z5.boolean().optional(),
+      quiet: z4.boolean().optional(),
       // Which client an agent sent it through, such as "Claude Code", recorded on the message.
-      client: z5.string().trim().min(1).max(40).regex(/^[^\r\n]+$/).optional()
+      client: z4.string().trim().min(1).max(40).regex(/^[^\r\n]+$/).optional()
     }).superRefine(exactlyOneBody).superRefine((message, ctx) => {
       if (message.quiet && message.channel) {
         ctx.addIssue({ code: "custom", message: "A channel post can't be quiet.", path: ["quiet"] });
       }
     });
-    messageFileStateSchema = z5.enum(["pending", "ready", "unavailable"]);
-    messageFileSchema = z5.object({
-      id: z5.string().min(1),
-      name: z5.string().min(1),
-      type: z5.string().min(1),
-      size: z5.number().int().nonnegative(),
-      title: z5.string().optional(),
-      alt: z5.string().optional(),
+    messageFileStateSchema = z4.enum(["pending", "ready", "unavailable"]);
+    messageFileSchema = z4.object({
+      id: z4.string().min(1),
+      name: z4.string().min(1),
+      type: z4.string().min(1),
+      size: z4.number().int().nonnegative(),
+      title: z4.string().optional(),
+      alt: z4.string().optional(),
       state: messageFileStateSchema.optional(),
       // Why an `unavailable` file couldn't come in, for a person to read.
-      reason: z5.string().optional()
+      reason: z4.string().optional()
     });
-    postTargetSchema = z5.object({
-      place: z5.string().min(1),
-      placeName: z5.string().min(1),
-      conversationId: z5.string().min(1)
+    postTargetSchema = z4.object({
+      place: z4.string().min(1),
+      placeName: z4.string().min(1),
+      conversationId: z4.string().min(1)
     });
   }
 });
 
 // ../common-chat/src/github.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 function parsePullRequestRef(text4) {
   const trimmed = text4.trim();
   const short = trimmed.match(new RegExp(`^(${NAME})/(${REPO})#(\\d{1,10})$`));
@@ -397,16 +397,16 @@ var init_github = __esm({
   "../common-chat/src/github.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    nonEmpty3 = z6.string().min(1);
+    nonEmpty3 = z5.string().min(1);
     MAX_EXTERNAL_TEXT = 4e3;
-    subscriptionOriginSchema = z6.enum(["watch", "branch", "work"]);
-    subscriptionEndSchema = z6.enum([
+    subscriptionOriginSchema = z5.enum(["watch", "branch", "work"]);
+    subscriptionEndSchema = z5.enum([
       "resource_closed",
       "unsubscribed",
       "uninstalled",
       "conversation_deleted"
     ]);
-    githubEventKindSchema = z6.enum([
+    githubEventKindSchema = z5.enum([
       "pull_request",
       "review",
       "review_comment",
@@ -414,48 +414,48 @@ var init_github = __esm({
       "comment",
       "ci"
     ]);
-    githubSenderSchema = z6.object({
-      id: z6.number().int(),
+    githubSenderSchema = z5.object({
+      id: z5.number().int(),
       login: nonEmpty3,
-      association: z6.string().optional(),
-      bot: z6.boolean()
+      association: z5.string().optional(),
+      bot: z5.boolean()
     });
-    githubEventSummarySchema = z6.object({
+    githubEventSummarySchema = z5.object({
       resource: nonEmpty3,
       /** `owner/name#number`, for people. */
       label: nonEmpty3,
       kind: githubEventKindSchema,
       action: nonEmpty3,
       /** What it reports, such as `merged`, `changes_requested` or `failed`. */
-      state: z6.string().optional(),
-      url: z6.url(),
+      state: z5.string().optional(),
+      url: z5.url(),
       sender: githubSenderSchema,
       /** A person's words, cut to `MAX_EXTERNAL_TEXT`. */
-      text: z6.string().max(MAX_EXTERNAL_TEXT).optional(),
-      sha: z6.string().optional(),
+      text: z5.string().max(MAX_EXTERNAL_TEXT).optional(),
+      sha: z5.string().optional(),
       /** For CI: the check or status that settled it, or failed first. */
-      check: z6.object({ name: nonEmpty3, conclusion: z6.string().optional() }).optional(),
-      wakes: z6.boolean(),
+      check: z5.object({ name: nonEmpty3, conclusion: z5.string().optional() }).optional(),
+      wakes: z5.boolean(),
       reason: nonEmpty3,
       /** Set when its author isn't an owner, member or collaborator of the repo. */
-      outsider: z6.boolean().optional(),
+      outsider: z5.boolean().optional(),
       /** Set when its author is a GitHub account linked to the subscriber. */
-      own: z6.boolean().optional(),
+      own: z5.boolean().optional(),
       /**
        * Whether its repo is private, and GitHub's numeric ID for the repo, so its words are shown only
        * to people who can read it. A summary stored without `private` is treated as private.
        */
-      private: z6.boolean().optional(),
-      repoId: z6.number().int().optional(),
+      private: z5.boolean().optional(),
+      repoId: z5.number().int().optional(),
       /** Set where a reader can't see the words of a private repo, which were taken out. */
-      withheld: z6.boolean().optional()
+      withheld: z5.boolean().optional()
     });
-    subscriptionSchema = z6.object({
+    subscriptionSchema = z5.object({
       resource: nonEmpty3,
       label: nonEmpty3,
-      url: z6.url(),
+      url: z5.url(),
       createdBy: subscriptionOriginSchema,
-      createdAt: z6.number().int().nonnegative()
+      createdAt: z5.number().int().nonnegative()
     });
     NAME = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})";
     REPO = "[A-Za-z0-9._-]{1,100}";
@@ -463,7 +463,7 @@ var init_github = __esm({
 });
 
 // ../common-chat/src/usage.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 function currentUsage(usage, now) {
   if (!usage) return void 0;
   const fresh = (window) => window && window.resetsAt > now ? window : void 0;
@@ -481,38 +481,38 @@ var init_usage = __esm({
   "../common-chat/src/usage.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    usageWindowSchema = z7.object({
-      usedPercentage: z7.number().min(0).max(100),
-      resetsAt: z7.number().int().nonnegative()
+    usageWindowSchema = z6.object({
+      usedPercentage: z6.number().min(0).max(100),
+      resetsAt: z6.number().int().nonnegative()
     });
     USAGE_AGENTS = {
       "claude-code": "Claude",
       codex: "Codex",
       agy: "Antigravity"
     };
-    usageSchema = z7.object({
+    usageSchema = z6.object({
       fiveHour: usageWindowSchema.optional(),
       sevenDay: usageWindowSchema.optional(),
-      agent: z7.enum(["claude-code", "codex", "agy"]).optional()
+      agent: z6.enum(["claude-code", "codex", "agy"]).optional()
     }).refine((usage) => usage.fiveHour || usage.sevenDay, "Usage needs at least one window");
     MAX_ACTIVITY_LENGTH = 150;
-    activityTextSchema = z7.string().trim().min(1).max(MAX_ACTIVITY_LENGTH).regex(/^[^\r\n]+$/);
+    activityTextSchema = z6.string().trim().min(1).max(MAX_ACTIVITY_LENGTH).regex(/^[^\r\n]+$/);
     MAX_TITLE_LENGTH = 40;
-    titleSchema = z7.string().trim().min(1).max(MAX_TITLE_LENGTH).regex(/^[^\r\n]+$/);
-    listedWindowSchema = z7.union([
+    titleSchema = z6.string().trim().min(1).max(MAX_TITLE_LENGTH).regex(/^[^\r\n]+$/);
+    listedWindowSchema = z6.union([
       usageWindowSchema,
-      z7.object({ reset: z7.literal(true), resetsAt: z7.number().int().nonnegative() })
+      z6.object({ reset: z6.literal(true), resetsAt: z6.number().int().nonnegative() })
     ]);
-    listedUsageSchema = z7.object({
+    listedUsageSchema = z6.object({
       fiveHour: listedWindowSchema.optional(),
       sevenDay: listedWindowSchema.optional(),
-      agent: z7.enum(["claude-code", "codex", "agy"]).optional()
+      agent: z6.enum(["claude-code", "codex", "agy"]).optional()
     });
   }
 });
 
 // ../common-chat/src/workers.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 function agentShortName(cli) {
   return AGENTS[cli]?.short ?? cli;
 }
@@ -548,11 +548,11 @@ var init_workers = __esm({
       "xcode",
       "image_generation"
     ];
-    capabilitySchema = z8.enum(CAPABILITIES);
+    capabilitySchema = z7.enum(CAPABILITIES);
     PLATFORMS = ["macos", "linux", "windows"];
-    platformSchema = z8.enum(PLATFORMS);
+    platformSchema = z7.enum(PLATFORMS);
     TOOLS = ["xcode", "gpu"];
-    toolSchema = z8.enum(TOOLS);
+    toolSchema = z7.enum(TOOLS);
     CAPABILITY_WORDING = {
       macos: "a Mac running macOS",
       linux: "a Linux computer",
@@ -570,51 +570,51 @@ var init_workers = __esm({
     PHRASE_MAX = 100;
     PHRASES_MAX = 10;
     ABOUT_MAX = 500;
-    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`);
+    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`);
     SHARES = ["off", "little", "some", "lot"];
-    shareSchema = z8.enum(SHARES);
+    shareSchema = z7.enum(SHARES);
     SHARE_LABELS = {
       off: "off",
       little: "a little",
       some: "some",
       lot: "a lot"
     };
-    harnessConfigSchema = z8.object({
+    harnessConfigSchema = z7.object({
       share: shareSchema.optional(),
       /** Read as `share: "off"` when false, from files written before shares. */
-      enabled: z8.boolean().optional(),
+      enabled: z7.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: z8.boolean().optional(),
+      defaults: z7.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: z8.number().int().min(-100).max(100).optional()
+      priority: z7.number().int().min(-100).max(100).optional()
     }).strict();
     BUILDS_MAX = 4;
-    buildsSettingSchema = z8.union([
-      z8.literal(true),
-      z8.object({ max: z8.number().int().min(1).max(BUILDS_MAX) }).strict()
+    buildsSettingSchema = z7.union([
+      z7.literal(true),
+      z7.object({ max: z7.number().int().min(1).max(BUILDS_MAX) }).strict()
     ]);
     CONFIG_REPOS_MAX = 50;
-    configRepoSchema = z8.object({
-      remote: z8.string().trim().min(1).max(300),
-      about: z8.string().trim().max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`).optional()
+    configRepoSchema = z7.object({
+      remote: z7.string().trim().min(1).max(300),
+      about: z7.string().trim().max(PHRASE_MAX, `at most ${PHRASE_MAX} characters`).optional()
     }).strict();
-    herdConfigSchema = z8.object({
-      about: z8.string().trim().max(ABOUT_MAX, `at most ${ABOUT_MAX} characters`).optional(),
+    herdConfigSchema = z7.object({
+      about: z7.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: z8.record(z8.string().regex(/^[a-z][a-z0-9-]*$/), harnessConfigSchema).optional(),
+      harnesses: z7.record(z7.string().regex(/^[a-z][a-z0-9-]*$/), harnessConfigSchema).optional(),
       builds: buildsSettingSchema.optional(),
-      repos: z8.array(configRepoSchema).max(CONFIG_REPOS_MAX, `at most ${CONFIG_REPOS_MAX} repos`).optional()
+      repos: z7.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. */
@@ -665,41 +665,41 @@ export default {
   harnesses: { claude: { great: ["code review"] }, codex: { cant: ["the billing service"] } },
 } satisfies HerdConfig;`;
     PROFILE_LEVELS = ["great", "good", "okay", "cant"];
-    profileEntrySchema = z8.object({
-      statement: z8.string().min(1),
-      level: z8.enum(PROFILE_LEVELS),
-      source: z8.enum(["default", "owner"])
+    profileEntrySchema = z7.object({
+      statement: z7.string().min(1),
+      level: z7.enum(PROFILE_LEVELS),
+      source: z7.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()),
+    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()),
       /** What it's great, good and okay at, and can't do: its agent's defaults with its owner's word. */
-      profile: z8.array(profileEntrySchema),
-      priority: z8.number().int(),
+      profile: z7.array(profileEntrySchema),
+      priority: z7.number().int(),
       /** How much of its agent its owner has. Servers from before shares send none, which is "some". */
       share: shareSchema.default("some"),
-      enabled: z8.boolean(),
+      enabled: z7.boolean(),
       /** Whether its agent checked in from herd's terminal on this version, so it's offered work. */
-      activated: z8.boolean(),
+      activated: z7.boolean(),
       activation: agentActivationSchema.optional(),
-      online: z8.boolean(),
+      online: z7.boolean(),
       // Its machine's repos, each marked whether herd has cloned it there. Older daemons send no `cloned`.
-      repos: z8.array(
-        z8.object({ name: z8.string(), remote: z8.string(), cloned: z8.boolean().optional() })
+      repos: z7.array(
+        z7.object({ name: z7.string(), remote: z7.string(), cloned: z7.boolean().optional() })
       ),
-      machineCreatedAt: z8.number().int().nonnegative()
+      machineCreatedAt: z7.number().int().nonnegative()
     });
   }
 });
 
 // ../common-chat/src/machines.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var nonEmpty4, time2, terminalStateSchema, agentStatusSchema, machineRepoSchema, isCloned, machineCliSchema, machineRegistrationSchema, machineSchema, machinePresenceSchema, worktreeSchema, MAX_REPO_HINTS, repoHintSchema, terminalSchema, offerSchema, offerAnswerSchema, dispatchFrameSchema, machineMessageSchema;
 var init_machines = __esm({
   "../common-chat/src/machines.ts"() {
@@ -708,9 +708,9 @@ var init_machines = __esm({
     init_activation();
     init_usage();
     init_workers();
-    nonEmpty4 = z9.string().min(1);
-    time2 = z9.number().int().nonnegative();
-    terminalStateSchema = z9.enum([
+    nonEmpty4 = z8.string().min(1);
+    time2 = z8.number().int().nonnegative();
+    terminalStateSchema = z8.enum([
       "working",
       "idle",
       "waiting_on_someone",
@@ -718,55 +718,55 @@ var init_machines = __esm({
       "signed_out",
       "unknown"
     ]);
-    agentStatusSchema = z9.enum(["working", "idle", "waiting_on_someone", "exited"]);
-    machineRepoSchema = z9.object({
+    agentStatusSchema = z8.enum(["working", "idle", "waiting_on_someone", "exited"]);
+    machineRepoSchema = z8.object({
       name: nonEmpty4,
       remote: nonEmpty4,
-      cloned: z9.boolean().optional()
+      cloned: z8.boolean().optional()
     });
     isCloned = (repo) => repo.cloned !== false;
-    machineCliSchema = z9.object({
+    machineCliSchema = z8.object({
       name: nonEmpty4,
       version: nonEmpty4,
-      runnable: z9.boolean().optional(),
-      capabilities: z9.array(capabilitySchema).optional(),
+      runnable: z8.boolean().optional(),
+      capabilities: z8.array(capabilitySchema).optional(),
       activation: agentActivationSchema.optional()
     });
-    machineRegistrationSchema = z9.object({
+    machineRegistrationSchema = z8.object({
       id: nonEmpty4,
       name: nonEmpty4,
-      repos: z9.array(machineRepoSchema),
-      clis: z9.array(machineCliSchema),
+      repos: z8.array(machineRepoSchema),
+      clis: z8.array(machineCliSchema),
       // The platform the agent actually runs on, and tools from herd's fixed list.
       platform: platformSchema.optional(),
-      tools: z9.array(toolSchema).optional(),
+      tools: z8.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: z9.string().max(1e3).optional(),
+      configError: z8.string().max(1e3).optional(),
       // Whether its GitHub CLI is signed in, and as whom.
       gh: gitHubCliSchema.optional()
     });
     machineSchema = machineRegistrationSchema.extend({
       ownerId: nonEmpty4,
-      online: z9.boolean(),
+      online: z8.boolean(),
       lastSeenAt: time2,
       createdAt: time2
     });
-    machinePresenceSchema = z9.object({ name: nonEmpty4, online: z9.boolean() });
-    worktreeSchema = z9.object({ repo: nonEmpty4, branch: nonEmpty4 });
+    machinePresenceSchema = z8.object({ name: nonEmpty4, online: z8.boolean() });
+    worktreeSchema = z8.object({ repo: nonEmpty4, branch: nonEmpty4 });
     MAX_REPO_HINTS = 10;
-    repoHintSchema = z9.object({
+    repoHintSchema = z8.object({
       remote: nonEmpty4,
       branch: nonEmpty4.optional(),
       folder: nonEmpty4.optional()
     });
-    terminalSchema = z9.object({
+    terminalSchema = z8.object({
       id: nonEmpty4,
       name: nonEmpty4,
       machineId: nonEmpty4,
       conversationId: nonEmpty4,
       // The lead terminal receives the conversation's notices. Others are started with `herd run`.
-      lead: z9.boolean(),
+      lead: z8.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.
@@ -774,7 +774,7 @@ var init_machines = __esm({
       state: terminalStateSchema,
       updatedAt: time2
     });
-    offerSchema = z9.object({
+    offerSchema = z8.object({
       id: nonEmpty4,
       conversationId: nonEmpty4,
       machineId: nonEmpty4,
@@ -782,33 +782,33 @@ 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: z9.array(repoHintSchema).max(MAX_REPO_HINTS).optional(),
+      repos: z8.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: z9.boolean().optional()
+      handoff: z8.boolean().optional()
     });
-    offerAnswerSchema = z9.discriminatedUnion("answer", [
-      z9.object({ answer: z9.literal("accept") }),
-      z9.object({ answer: z9.literal("refuse"), reason: nonEmpty4 })
+    offerAnswerSchema = z8.discriminatedUnion("answer", [
+      z8.object({ answer: z8.literal("accept") }),
+      z8.object({ answer: z8.literal("refuse"), reason: nonEmpty4 })
     ]);
-    dispatchFrameSchema = z9.discriminatedUnion("type", [
-      z9.object({ type: z9.literal("offer"), offer: offerSchema }),
-      z9.object({
-        type: z9.literal("message"),
+    dispatchFrameSchema = z8.discriminatedUnion("type", [
+      z8.object({ type: z8.literal("offer"), offer: offerSchema }),
+      z8.object({
+        type: z8.literal("message"),
         conversationId: nonEmpty4,
-        delivery: z9.enum(["interrupt", "defer"])
+        delivery: z8.enum(["interrupt", "defer"])
       }),
-      z9.object({ type: z9.literal("reconnect") }),
+      z8.object({ type: z8.literal("reconnect") }),
       // Its owner asked for a sign-in on this machine, which the daemon runs and reports on.
-      z9.object({ type: z9.literal("sign_in"), signInId: nonEmpty4, tool: signInToolSchema })
+      z8.object({ type: z8.literal("sign_in"), signInId: nonEmpty4, tool: signInToolSchema })
     ]);
-    machineMessageSchema = z9.discriminatedUnion("type", [
-      z9.object({ type: z9.literal("ack"), conversationId: nonEmpty4 }),
-      z9.object({
-        type: z9.literal("usage"),
+    machineMessageSchema = z8.discriminatedUnion("type", [
+      z8.object({ type: z8.literal("ack"), conversationId: nonEmpty4 }),
+      z8.object({
+        type: z8.literal("usage"),
         /** The worker's agent on this machine, such as `claude-code`. */
         agent: nonEmpty4,
         usage: usageSchema,
@@ -819,39 +819,39 @@ var init_machines = __esm({
 });
 
 // ../common-chat/src/prompts.ts
-import { z as z10 } from "zod";
+import { z as z9 } 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 = 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({
+    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({
       id,
-      label: z10.string().trim().min(1).max(75),
-      description: z10.string().max(200).optional(),
+      label: z9.string().trim().min(1).max(75),
+      description: z9.string().max(200).optional(),
       // How a button for it is drawn: `primary` to go ahead, `danger` to refuse.
-      style: z10.enum(["primary", "danger"]).optional()
+      style: z9.enum(["primary", "danger"]).optional()
     });
-    promptQuestionSchema = z10.object({
+    promptQuestionSchema = z9.object({
       id,
-      text: z10.string().trim().min(1).max(300),
-      options: z10.array(promptOptionSchema).min(1).max(10)
+      text: z9.string().trim().min(1).max(300),
+      options: z9.array(promptOptionSchema).min(1).max(10)
     });
-    promptRequestSchema = z10.object({
+    promptRequestSchema = z9.object({
       kind: promptKindSchema,
-      title: z10.string().trim().min(1).max(150),
-      detail: z10.string().max(2800).optional(),
-      questions: z10.array(promptQuestionSchema).min(1).max(4)
+      title: z9.string().trim().min(1).max(150),
+      detail: z9.string().max(2800).optional(),
+      questions: z9.array(promptQuestionSchema).min(1).max(4)
     });
-    promptOutcomeSchema = z10.enum(["answered", "cancelled"]);
+    promptOutcomeSchema = z9.enum(["answered", "cancelled"]);
   }
 });
 
 // ../common-chat/src/pull-requests.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function statusOfPhase(phase) {
   return phase === "merged" ? "done" : phase === "closed" ? "closed" : "open";
 }
@@ -890,8 +890,8 @@ var init_pull_requests = __esm({
   "../common-chat/src/pull-requests.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
-    time3 = z11.number().int().nonnegative();
-    pullRequestPhaseSchema = z11.enum([
+    time3 = z10.number().int().nonnegative();
+    pullRequestPhaseSchema = z10.enum([
       "draft",
       "checks_running",
       "checks_failed",
@@ -902,7 +902,7 @@ var init_pull_requests = __esm({
       "merged",
       "closed"
     ]);
-    pullRequestMoveSchema = z11.enum(["you", "agent", "others", "nobody"]);
+    pullRequestMoveSchema = z10.enum(["you", "agent", "others", "nobody"]);
     PHASE_LABELS = {
       draft: "draft",
       checks_running: "checks running",
@@ -914,22 +914,22 @@ var init_pull_requests = __esm({
       merged: "merged",
       closed: "closed"
     };
-    leadChangeSchema = z11.object({
+    leadChangeSchema = z10.object({
       /** Its repo and number, such as `api#104`, or "a pull request" when hidden. */
-      label: z11.string().min(1),
+      label: z10.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: z11.number().int().nonnegative(),
+      moreForYou: z10.number().int().nonnegative(),
       /** Absent when hidden. */
-      url: z11.string().optional()
+      url: z10.string().optional()
     });
   }
 });
 
 // ../common-chat/src/work-objects.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 function workLine(work) {
   const parts = [
     work.phase ? `${work.kind} ${PHASE_LABELS[work.phase]}` : `${work.kind} ${work.status}`
@@ -944,21 +944,21 @@ var init_work_objects = __esm({
     "use strict";
     init_define_HERD_PACKAGE();
     init_pull_requests();
-    time4 = z12.number().int().nonnegative();
-    workKindSchema = z12.enum(["change", "ticket", "deploy", "document", "other"]);
-    workStatusSchema = z12.enum(["open", "done", "closed"]);
-    workSourceSchema = z12.enum(["agent", "provider"]);
+    time4 = z11.number().int().nonnegative();
+    workKindSchema = z11.enum(["change", "ticket", "deploy", "document", "other"]);
+    workStatusSchema = z11.enum(["open", "done", "closed"]);
+    workSourceSchema = z11.enum(["agent", "provider"]);
     MAX_WORK_TITLE = 200;
     MAX_WORK_DETAIL = 100;
     MAX_WORK_URL = 2048;
-    workObjectSchema = z12.object({
-      url: z12.string().min(1).max(MAX_WORK_URL),
+    workObjectSchema = z11.object({
+      url: z11.string().min(1).max(MAX_WORK_URL),
       kind: workKindSchema,
-      title: z12.string().min(1).max(MAX_WORK_TITLE),
+      title: z11.string().min(1).max(MAX_WORK_TITLE),
       status: workStatusSchema,
-      detail: z12.string().max(MAX_WORK_DETAIL).nullable(),
+      detail: z11.string().max(MAX_WORK_DETAIL).nullable(),
       /** Whether the conversation made it, rather than only being about it. */
-      made: z12.boolean(),
+      made: z11.boolean(),
       changedAt: time4,
       changedBy: workSourceSchema,
       createdAt: time4,
@@ -966,21 +966,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: z12.string().min(1).optional()
+      conversationId: z11.string().min(1).optional()
     });
-    workChangeSchema = z12.object({
-      url: z12.string().trim().min(1).max(MAX_WORK_URL),
+    workChangeSchema = z11.object({
+      url: z11.string().trim().min(1).max(MAX_WORK_URL),
       kind: workKindSchema.optional(),
-      title: z12.string().trim().min(1).max(2e3).optional(),
+      title: z11.string().trim().min(1).max(2e3).optional(),
       status: workStatusSchema.optional(),
-      detail: z12.string().trim().max(2e3).nullable().optional(),
-      made: z12.boolean().optional(),
+      detail: z11.string().trim().max(2e3).nullable().optional(),
+      made: z11.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 = z12.enum([
+    workFieldSchema = z11.enum([
       "kind",
       "title",
       "status",
@@ -989,27 +989,27 @@ var init_work_objects = __esm({
       "phase",
       "move"
     ]);
-    workObjectSummarySchema = z12.object({
+    workObjectSummarySchema = z11.object({
       kind: workKindSchema,
       status: workStatusSchema,
-      made: z12.boolean(),
+      made: z11.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: z12.string().optional(),
-      title: z12.string().optional(),
-      detail: z12.string().nullable().optional(),
+      url: z11.string().optional(),
+      title: z11.string().optional(),
+      detail: z11.string().nullable().optional(),
       /** The delegate holding it, when it isn't the item's own conversation. */
-      conversationId: z12.string().min(1).optional()
+      conversationId: z11.string().min(1).optional()
     });
   }
 });
 
 // ../common-chat/src/events.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function event(type, payload) {
-  return z13.object({ ...eventBase, type: z13.literal(type), payload: z13.object(payload) });
+  return z12.object({ ...eventBase, type: z12.literal(type), payload: z12.object(payload) });
 }
 var routeSchema, deliveryModeSchema, eventSourceSchema, nonEmpty6, actorSchema, eventBase, entryIds, routingRecordSchema, conversationEventSchema, conversationVisibilitySchema, conversationStatusSchema, conversationSummarySchema, placementSchema, treeSummarySchema, conversationSnapshotSchema, liveFrameSchema, adapterCapabilitiesSchema;
 var init_events = __esm({
@@ -1023,129 +1023,129 @@ var init_events = __esm({
     init_usage();
     init_work_objects();
     init_workers();
-    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", [
+    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", [
       // Someone signed in to this system. `id` is the stable person identifier.
-      z13.object({ kind: z13.literal("person"), id: nonEmpty6, name: nonEmpty6 }),
+      z12.object({ kind: z12.literal("person"), id: nonEmpty6, name: nonEmpty6 }),
       // An account on a platform, which may or may not be linked to a person.
-      z13.object({
-        kind: z13.literal("account"),
+      z12.object({
+        kind: z12.literal("account"),
         provider: nonEmpty6,
         tenant: nonEmpty6,
         subject: nonEmpty6,
-        name: z13.string().optional(),
-        isBot: z13.boolean()
+        name: z12.string().optional(),
+        isBot: z12.boolean()
       }),
-      z13.object({ kind: z13.literal("system") })
+      z12.object({ kind: z12.literal("system") })
     ]);
     eventBase = {
-      seq: z13.number().int().positive(),
+      seq: z12.number().int().positive(),
       source: eventSourceSchema,
       actor: actorSchema,
-      createdAt: z13.number().int().nonnegative()
+      createdAt: z12.number().int().nonnegative()
     };
-    entryIds = z13.array(nonEmpty6);
-    routingRecordSchema = z13.object({
-      eligible: z13.array(z13.object({ key: nonEmpty6, name: nonEmpty6 })),
-      questions: z13.array(
-        z13.object({
+    entryIds = z12.array(nonEmpty6);
+    routingRecordSchema = z12.object({
+      eligible: z12.array(z12.object({ key: nonEmpty6, name: nonEmpty6 })),
+      questions: z12.array(
+        z12.object({
           id: nonEmpty6,
           question: nonEmpty6,
-          probability: z13.number().min(0).max(1).nullable()
+          probability: z12.number().min(0).max(1).nullable()
         })
       ),
       model: nonEmpty6.optional(),
       // Why the model's answers weren't used, when they weren't.
-      fallback: z13.string().optional(),
-      removed: z13.array(z13.object({ key: nonEmpty6, name: nonEmpty6, rule: nonEmpty6 })),
-      order: z13.array(nonEmpty6),
+      fallback: z12.string().optional(),
+      removed: z12.array(z12.object({ key: nonEmpty6, name: nonEmpty6, rule: nonEmpty6 })),
+      order: z12.array(nonEmpty6),
       // Each ordered worker's fit, and the profile statement and level that gave it, when the model
       // answered.
-      fits: z13.array(
-        z13.object({
+      fits: z12.array(
+        z12.object({
           key: nonEmpty6,
-          fit: z13.number().min(0).max(1),
-          statement: z13.string().optional(),
-          level: z13.enum(["great", "good", "okay"]).optional()
+          fit: z12.number().min(0).max(1),
+          statement: z12.string().optional(),
+          level: z12.enum(["great", "good", "okay"]).optional()
         })
       ).optional(),
       // Profile statements left out to keep within the most questions one call asks.
-      dropped: z13.array(z13.string()).optional(),
+      dropped: z12.array(z12.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: z13.array(nonEmpty6).optional(),
-      warm: z13.array(nonEmpty6).optional(),
+      hints: z12.array(nonEmpty6).optional(),
+      warm: z12.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: z13.array(
-        z13.object({
+      shares: z12.array(
+        z12.object({
           key: nonEmpty6,
           share: shareSchema,
-          pacing: z13.enum(["ahead", "even", "under", "unknown"]),
-          weight: z13.number().nonnegative()
+          pacing: z12.enum(["ahead", "even", "under", "unknown"]),
+          weight: z12.number().nonnegative()
         })
       ).optional(),
-      drawn: z13.array(nonEmpty6).optional()
+      drawn: z12.array(nonEmpty6).optional()
     });
-    conversationEventSchema = z13.discriminatedUnion("type", [
+    conversationEventSchema = z12.discriminatedUnion("type", [
       event("message.created", {
         messageId: nonEmpty6,
-        text: z13.string(),
-        direction: z13.enum(["inbound", "outbound"]),
+        text: z12.string(),
+        direction: z12.enum(["inbound", "outbound"]),
         route: routeSchema.optional(),
         // Why the message did or didn't wake the conversation.
-        reason: z13.string().optional(),
+        reason: z12.string().optional(),
         // Loaded from before the conversation joined the thread, so it never waits for a response.
-        isContext: z13.boolean().optional(),
+        isContext: z12.boolean().optional(),
         // Set when the message was deleted on its platform. `text` is then empty.
-        deleted: z13.boolean().optional(),
+        deleted: z12.boolean().optional(),
         // Sent through the API but kept out of the platform, so only clients see it.
-        quiet: z13.boolean().optional(),
+        quiet: z12.boolean().optional(),
         // The client an agent sent it through, such as "Claude Code". Such a message is the agent's.
-        client: z13.string().optional(),
+        client: z12.string().optional(),
         // How to read `text`. Absent means plain text, as every message before this field was.
-        format: z13.enum(["markdown"]).optional(),
+        format: z12.enum(["markdown"]).optional(),
         // Files attached to it, kept with the conversation.
-        files: z13.array(messageFileSchema).optional(),
+        files: z12.array(messageFileSchema).optional(),
         // A platform's own layout, shown there in place of `text`. Every other surface shows `text`.
-        layout: z13.object({ platform: layoutPlatformSchema, blocks: z13.array(z13.unknown()) }).optional(),
+        layout: z12.object({ platform: layoutPlatformSchema, blocks: z12.array(z12.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: z13.object({ conversationId: nonEmpty6.optional() }).optional(),
+        origin: z12.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: z13.object({ parent: nonEmpty6, by: nonEmpty6 }).optional(),
+        delegation: z12.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: z13.object({
+        agentMessage: z12.object({
           from: nonEmpty6,
           worker: nonEmpty6,
-          posted: z13.boolean().optional(),
-          overdue: z13.boolean().optional(),
+          posted: z12.boolean().optional(),
+          overdue: z12.boolean().optional(),
           // herd's own note about the delegate, such as that it's waiting for its worker.
-          notice: z13.boolean().optional(),
-          outsideTree: z13.boolean().optional()
+          notice: z12.boolean().optional(),
+          outsideTree: z12.boolean().optional()
         }).optional(),
         // Set on a message a root posted for one of its children, which is labelled as the child's.
-        forChild: z13.object({ id: nonEmpty6, worker: nonEmpty6, for: nonEmpty6 }).optional(),
+        forChild: z12.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: z13.object({
+        automation: z12.object({
           id: nonEmpty6,
           name: nonEmpty6,
           reason: nonEmpty6,
           key: nonEmpty6,
-          payload: z13.string().optional(),
+          payload: z12.string().optional(),
           // The opening post a firing's reactions are shown on, in a conversation it started.
           opener: nonEmpty6.optional()
         }).optional(),
@@ -1153,27 +1153,27 @@ var init_events = __esm({
         // follows. `text` is a short line about it, and anyone's words in it are untrusted.
         github: githubEventSummarySchema.optional()
       }),
-      event("message.updated", { messageId: nonEmpty6, text: z13.string() }),
+      event("message.updated", { messageId: nonEmpty6, text: z12.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: z13.number().int().positive(),
-        outcome: z13.enum(["for_bot", "not_for_bot", "failed"]),
-        probability: z13.number().min(0).max(1).optional(),
+        messageSeq: z12.number().int().positive(),
+        outcome: z12.enum(["for_bot", "not_for_bot", "failed"]),
+        probability: z12.number().min(0).max(1).optional(),
         model: nonEmpty6,
-        error: z13.string().optional()
+        error: z12.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: z13.number().int().positive(),
-        outcome: z13.enum(["asks", "doesnt_ask", "failed"]),
-        probability: z13.number().min(0).max(1).optional(),
+        messageSeq: z12.number().int().positive(),
+        outcome: z12.enum(["asks", "doesnt_ask", "failed"]),
+        probability: z12.number().min(0).max(1).optional(),
         model: nonEmpty6,
-        error: z13.string().optional()
+        error: z12.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 }),
@@ -1185,21 +1185,21 @@ var init_events = __esm({
       event("context.unavailable", { reason: nonEmpty6 }),
       event("mailbox.queued", {
         entryId: nonEmpty6,
-        messageSeq: z13.number().int().positive(),
+        messageSeq: z12.number().int().positive(),
         delivery: deliveryModeSchema
       }),
       event("mailbox.claimed", {
         claimId: nonEmpty6,
         entryIds,
         holder: nonEmpty6,
-        expiresAt: z13.number().int()
+        expiresAt: z12.number().int()
       }),
-      event("mailbox.renewed", { claimId: nonEmpty6, expiresAt: z13.number().int() }),
+      event("mailbox.renewed", { claimId: nonEmpty6, expiresAt: z12.number().int() }),
       event("mailbox.released", {
         claimId: nonEmpty6,
         entryIds,
         // `delegates` means messages held for delegates are waiting again now that they've settled.
-        reason: z13.enum(["released", "expired", "delegates"])
+        reason: z12.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 }),
@@ -1207,7 +1207,7 @@ var init_events = __esm({
       event("mailbox.completed", {
         entryIds,
         claimId: nonEmpty6.optional(),
-        outcome: z13.enum(["passed"]).optional()
+        outcome: z12.enum(["passed"]).optional()
       }),
       event("mailbox.cancelled", { entryIds, reason: nonEmpty6 }),
       // A person asked for what's waiting to be delivered again. The entries stay waiting.
@@ -1224,15 +1224,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: z13.array(nonEmpty6).optional()
+        fileIds: z12.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: z13.array(workFieldSchema),
-        added: z13.boolean(),
+        changed: z12.array(workFieldSchema),
+        added: z12.boolean(),
         by: workSourceSchema
       }),
       event("work.removed", { url: nonEmpty6, by: workSourceSchema }),
@@ -1245,7 +1245,7 @@ var init_events = __esm({
       event("prompt.opened", {
         promptId: nonEmpty6,
         ...promptRequestSchema.shape,
-        forChild: z13.object({ id: nonEmpty6, worker: nonEmpty6, promptId: nonEmpty6 }).optional()
+        forChild: z12.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.
@@ -1254,12 +1254,12 @@ var init_events = __esm({
         questionId: nonEmpty6,
         optionId: nonEmpty6.optional(),
         messageId: nonEmpty6.optional(),
-        text: z13.string().optional()
+        text: z12.string().optional()
       }),
       event("prompt.closed", {
         promptId: nonEmpty6,
         outcome: promptOutcomeSchema,
-        reason: z13.string().optional()
+        reason: z12.string().optional()
       }),
       // Dispatch: which machine the conversation was offered to, and which one holds it.
       event("dispatch.offered", {
@@ -1283,19 +1283,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: z13.array(nonEmpty6),
-        routed: z13.boolean()
+        workers: z12.array(nonEmpty6),
+        routed: z12.boolean()
       }),
       event("delegation.settled", { childId: nonEmpty6 }),
       event("delegation.overdue", { childId: nonEmpty6 }),
-      event("delegation.waiting", { childId: nonEmpty6, waiting: z13.boolean() }),
+      event("delegation.waiting", { childId: nonEmpty6, waiting: z12.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: z13.boolean(),
+        lead: z12.boolean(),
         // Only for a conversation from before folders, which works in one repo's worktree.
         worktree: worktreeSchema.optional()
       }),
@@ -1307,9 +1307,9 @@ var init_events = __esm({
         folder: nonEmpty6,
         branch: nonEmpty6,
         base: nonEmpty6.optional(),
-        fetchFailed: z13.string().max(1e3).optional()
+        fetchFailed: z12.string().max(1e3).optional()
       }),
-      event("terminal.exited", { terminalId: nonEmpty6, exitCode: z13.number().int().nullable() }),
+      event("terminal.exited", { terminalId: nonEmpty6, exitCode: z12.number().int().nullable() }),
       event("terminal.notice_failed", { terminalId: nonEmpty6, reason: 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 }),
@@ -1319,7 +1319,7 @@ var init_events = __esm({
       event("subscription.created", {
         resource: nonEmpty6,
         label: nonEmpty6,
-        url: z13.url(),
+        url: z12.url(),
         subscriber: nonEmpty6,
         createdBy: subscriptionOriginSchema
       }),
@@ -1331,72 +1331,72 @@ var init_events = __esm({
       // A subscription reached its hourly limit of wakes, noted once each hour.
       event("subscription.limited", { resource: nonEmpty6 })
     ]);
-    conversationVisibilitySchema = z13.enum(["public", "private"]);
-    conversationStatusSchema = z13.enum(["idle", "waiting", "working"]);
-    conversationSummarySchema = z13.object({
+    conversationVisibilitySchema = z12.enum(["public", "private"]);
+    conversationStatusSchema = z12.enum(["idle", "waiting", "working"]);
+    conversationSummarySchema = z12.object({
       id: nonEmpty6,
       provider: nonEmpty6,
       visibility: conversationVisibilitySchema,
       title: nonEmpty6,
       // Where the conversation lives on its platform, when it has a link.
-      placeUrl: z13.string().nullable(),
+      placeUrl: z12.string().nullable(),
       status: conversationStatusSchema,
-      waitingCount: z13.number().int().nonnegative(),
-      createdAt: z13.number().int(),
-      lastActivityAt: z13.number().int(),
-      expiresAt: z13.number().int()
+      waitingCount: z12.number().int().nonnegative(),
+      createdAt: z12.number().int(),
+      lastActivityAt: z12.number().int(),
+      expiresAt: z12.number().int()
     });
-    placementSchema = z13.discriminatedUnion("kind", [
-      z13.object({
-        kind: z13.literal("bound"),
-        machine: z13.object({ name: nonEmpty6, online: z13.boolean() }),
+    placementSchema = z12.discriminatedUnion("kind", [
+      z12.object({
+        kind: z12.literal("bound"),
+        machine: z12.object({ name: nonEmpty6, online: z12.boolean() }),
         // The worker's name, such as `mac-mini/claude`, and never its configuration or capabilities.
         worker: nonEmpty6.optional()
       }),
-      z13.object({ kind: z13.literal("waiting_for_machine") }),
-      z13.object({ kind: z13.literal("author_not_linked") })
+      z12.object({ kind: z12.literal("waiting_for_machine") }),
+      z12.object({ kind: z12.literal("author_not_linked") })
     ]);
-    treeSummarySchema = z13.object({
+    treeSummarySchema = z12.object({
       parent: nonEmpty6.nullable(),
       root: nonEmpty6,
-      children: z13.array(
-        z13.object({
+      children: z12.array(
+        z12.object({
           id: nonEmpty6,
           title: nonEmpty6,
-          state: z13.string().nullable(),
-          createdAt: z13.number()
+          state: z12.string().nullable(),
+          createdAt: z12.number()
         })
       )
     });
-    conversationSnapshotSchema = z13.object({
+    conversationSnapshotSchema = z12.object({
       conversation: conversationSummarySchema,
-      events: z13.array(conversationEventSchema),
+      events: z12.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: z13.record(z13.string(), z13.string()).optional(),
+      people: z12.record(z12.string(), z12.string()).optional(),
       placement: placementSchema.nullable().optional(),
       tree: treeSummarySchema.optional()
     });
-    liveFrameSchema = z13.discriminatedUnion("type", [
-      z13.object({ type: z13.literal("event"), event: conversationEventSchema }),
-      z13.object({ type: z13.literal("reconnect") }),
-      z13.object({ type: z13.literal("expired") })
+    liveFrameSchema = z12.discriminatedUnion("type", [
+      z12.object({ type: z12.literal("event"), event: conversationEventSchema }),
+      z12.object({ type: z12.literal("reconnect") }),
+      z12.object({ type: z12.literal("expired") })
     ]);
-    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()
+    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()
     });
   }
 });
 
 // ../common-chat/src/conversation-state.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function openRank(item) {
   if (item.state === "stuck") return 0;
   if (leadOpen(item.lead) && item.lead?.move === "you") return 1;
@@ -1433,8 +1433,8 @@ var init_conversation_state = __esm({
     init_machines();
     init_pull_requests();
     init_work_objects();
-    nonEmpty7 = z14.string().min(1);
-    time5 = z14.number().int().nonnegative();
+    nonEmpty7 = z13.string().min(1);
+    time5 = z13.number().int().nonnegative();
     REACTIONS = {
       waiting: "eyes",
       working: "hourglass_flowing_sand",
@@ -1443,14 +1443,14 @@ var init_conversation_state = __esm({
       passed: "ok_hand",
       stuck: "warning"
     };
-    conversationStateSchema = z14.enum([
+    conversationStateSchema = z13.enum([
       "waiting",
       "working",
       "stuck",
       "unanswered",
       "done"
     ]);
-    stuckReasonSchema = z14.enum([
+    stuckReasonSchema = z13.enum([
       "approval",
       "waiting_on_someone",
       // A delegate has an open prompt or is waiting on a person.
@@ -1467,43 +1467,43 @@ var init_conversation_state = __esm({
       "awaiting_answer"
     ]);
     STUCK_REASONS = stuckReasonSchema.options;
-    placeKindSchema = z14.enum(["channel", "direct", "group", "web"]);
-    conversationSourceSchema = z14.object({
+    placeKindSchema = z13.enum(["channel", "direct", "group", "web"]);
+    conversationSourceSchema = z13.object({
       provider: nonEmpty7,
       kind: placeKindSchema,
       /** Such as a Slack channel's name, without its `#`. Left out where it's unknown or hidden. */
-      name: z14.string().optional()
+      name: z13.string().optional()
     });
     LATEST_MESSAGE_LENGTH = 200;
-    latestMessageSchema = z14.object({
-      text: z14.string().max(LATEST_MESSAGE_LENGTH),
+    latestMessageSchema = z13.object({
+      text: z13.string().max(LATEST_MESSAGE_LENGTH),
       /** A person wrote it, or the agent did. */
-      from: z14.enum(["person", "agent"]),
+      from: z13.enum(["person", "agent"]),
       at: time5
     });
     listMachineSchema = machinePresenceSchema.extend({
-      mine: z14.boolean().optional(),
+      mine: z13.boolean().optional(),
       /** The agent holding it on that machine, such as `Claude Code`, when it's known. */
-      agent: z14.string().optional()
+      agent: z13.string().optional()
     });
-    conversationListItemSchema = z14.object({
+    conversationListItemSchema = z13.object({
       id: nonEmpty7,
       title: nonEmpty7,
       visibility: conversationVisibilitySchema,
       /** The conversation's page. */
       url: nonEmpty7,
       /** Its thread on its platform, when it has a link. */
-      placeUrl: z14.string().nullable(),
+      placeUrl: z13.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: z14.string().nullable(),
+      latestRequest: z13.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: z14.string().nullable(),
+      activity: z13.string().nullable(),
       /** The machine holding it, by name and presence only, and whether it's the reader's own. */
       machine: listMachineSchema.nullable(),
       lastActivityAt: time5,
@@ -1514,28 +1514,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: z14.boolean().optional(),
+      hidden: z13.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: z14.array(workObjectSummarySchema).optional(),
+      work: z13.array(workObjectSummarySchema).optional(),
       /** How many more work objects it holds than `work` carries. */
-      moreWork: z14.number().int().nonnegative().optional(),
+      moreWork: z13.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 = z14.object({
-      items: z14.array(conversationListItemSchema),
+    conversationListSchema = z13.object({
+      items: z13.array(conversationListItemSchema),
       /** Present when there's more, to pass back as `next` for the following page. */
-      next: z14.string().optional()
+      next: z13.string().optional()
     });
-    listFrameSchema = z14.discriminatedUnion("type", [
-      z14.object({ type: z14.literal("changed"), conversations: z14.array(nonEmpty7).min(1) }),
+    listFrameSchema = z13.discriminatedUnion("type", [
+      z13.object({ type: z13.literal("changed"), conversations: z13.array(nonEmpty7).min(1) }),
       /** A machine went online or offline, or a worker's usage changed. */
-      z14.object({ type: z14.literal("machines") }),
-      z14.object({ type: z14.literal("reconnect") }),
-      z14.object({ type: z14.literal("expired") })
+      z13.object({ type: z13.literal("machines") }),
+      z13.object({ type: z13.literal("reconnect") }),
+      z13.object({ type: z13.literal("expired") })
     ]);
     STATE_REACTIONS = {
       stuck: REACTIONS.stuck,
@@ -1574,7 +1574,7 @@ var init_conversation_state = __esm({
 });
 
 // ../common-chat/src/board.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 var nonEmpty8, time6, BOARD_ITEMS, boardItemSchema, boardWorkerSchema, boardMachineSchema, boardSchema;
 var init_board = __esm({
   "../common-chat/src/board.ts"() {
@@ -1583,27 +1583,27 @@ var init_board = __esm({
     init_conversation_state();
     init_pull_requests();
     init_usage();
-    nonEmpty8 = z15.string().min(1);
-    time6 = z15.number().int().nonnegative();
+    nonEmpty8 = z14.string().min(1);
+    time6 = z14.number().int().nonnegative();
     BOARD_ITEMS = 8;
-    boardItemSchema = z15.object({
+    boardItemSchema = z14.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: z15.string().nullable(),
+      source: z14.string().nullable(),
       /** What the agent says it's doing, while it works. */
-      activity: z15.string().nullable(),
+      activity: z14.string().nullable(),
       lastActivityAt: time6,
       /** The machine and agent holding it, such as `mac-mini` and `Claude Code`, once it's bound. */
-      heldBy: z15.object({ machine: nonEmpty8, agent: nonEmpty8 }).nullable().optional(),
+      heldBy: z14.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: z15.boolean().optional()
+      hidden: z14.boolean().optional()
     });
-    boardWorkerSchema = z15.object({
+    boardWorkerSchema = z14.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. */
@@ -1612,33 +1612,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: z15.array(z15.string().min(1).max(100)).max(3).optional()
+      strengths: z14.array(z14.string().min(1).max(100)).max(3).optional()
     });
-    boardMachineSchema = z15.object({
+    boardMachineSchema = z14.object({
       name: nonEmpty8,
-      online: z15.boolean(),
-      workers: z15.array(boardWorkerSchema).max(8)
+      online: z14.boolean(),
+      workers: z14.array(boardWorkerSchema).max(8)
     });
-    boardSchema = z15.object({
+    boardSchema = z14.object({
       /** How many are in each open state: every state but `done`, which is counted for the last day. */
-      counts: z15.object({
-        stuck: z15.number().int().nonnegative(),
-        unanswered: z15.number().int().nonnegative(),
-        waiting: z15.number().int().nonnegative(),
-        working: z15.number().int().nonnegative(),
+      counts: z14.object({
+        stuck: z14.number().int().nonnegative(),
+        unanswered: z14.number().int().nonnegative(),
+        waiting: z14.number().int().nonnegative(),
+        working: z14.number().int().nonnegative(),
         /** Open pull requests the person's conversations made that are their move, each counted. */
-        pullRequests: z15.number().int().nonnegative().optional()
+        pullRequests: z14.number().int().nonnegative().optional()
       }),
       /** How many became `done` in the last 24 hours. */
-      doneToday: z15.number().int().nonnegative(),
+      doneToday: z14.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: z15.array(boardItemSchema).max(BOARD_ITEMS),
-      machines: z15.array(boardMachineSchema).max(16),
+      items: z14.array(boardItemSchema).max(BOARD_ITEMS),
+      machines: z14.array(boardMachineSchema).max(16),
       /** Changes whenever anything the board shows changes, and only then. */
-      stamp: z15.string().regex(/^[0-9a-f]{12}$/),
+      stamp: z14.string().regex(/^[0-9a-f]{12}$/),
       /** When its content last changed. */
       changedAt: time6
     });
@@ -1646,41 +1646,45 @@ var init_board = __esm({
 });
 
 // ../common-chat/src/bot.ts
-var BOT_NAME;
+var BOT_NAME, NPM_SCOPE, FRIDAY_PACKAGE, FRIDAY_COMMAND, START_COMMAND;
 var init_bot = __esm({
   "../common-chat/src/bot.ts"() {
     "use strict";
     init_define_HERD_PACKAGE();
     BOT_NAME = "Friday";
+    NPM_SCOPE = "@herdingchats";
+    FRIDAY_PACKAGE = `${NPM_SCOPE}/friday`;
+    FRIDAY_COMMAND = `npx ${FRIDAY_PACKAGE}`;
+    START_COMMAND = `${FRIDAY_COMMAND} start`;
   }
 });
 
 // ../common-chat/src/builds.ts
-import { z as z16 } from "zod";
+import { z as z15 } 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 = z16.string().min(1);
-    time7 = z16.number().int().nonnegative();
+    nonEmpty9 = z15.string().min(1);
+    time7 = z15.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 = z16.string().regex(/^[0-9a-f]{40}$/);
-    buildOfferSchema = z16.object({
+    shaSchema = z15.string().regex(/^[0-9a-f]{40}$/);
+    buildOfferSchema = z15.object({
       id: nonEmpty9,
       offerId: nonEmpty9,
       repo: nonEmpty9,
       sha: shaSchema,
       ref: nonEmpty9,
-      main: z16.boolean(),
+      main: z15.boolean(),
       expiresAt: time7
     });
-    buildCancelReasonSchema = z16.enum([
+    buildCancelReasonSchema = z15.enum([
       // A newer push to the same branch replaced it.
       "superseded",
       // The branch was deleted.
@@ -1690,7 +1694,7 @@ var init_builds = __esm({
       // Stopped for another reason, such as the repo being removed.
       "cancelled"
     ]);
-    runnerMessageSchema = z16.discriminatedUnion("type", [
+    runnerMessageSchema = z15.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
@@ -1698,82 +1702,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.
        */
-      z16.object({
-        type: z16.literal("hello"),
+      z15.object({
+        type: z15.literal("hello"),
         /** How many builds at once. 0 when the machine can't sandbox a build, so it takes none. */
-        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)
+        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)
       }),
       /** An answer to an offer, before its `expiresAt`. A refusal may say why. */
-      z16.object({
-        type: z16.literal("answer"),
+      z15.object({
+        type: z15.literal("answer"),
         buildId: nonEmpty9,
         offerId: nonEmpty9,
-        answer: z16.enum(["accept", "refuse"]),
-        reason: z16.string().max(500).optional()
+        answer: z15.enum(["accept", "refuse"]),
+        reason: z15.string().max(500).optional()
       })
     ]);
-    serviceMessageSchema = z16.discriminatedUnion("type", [
-      z16.object({ type: z16.literal("build"), build: buildOfferSchema }),
+    serviceMessageSchema = z15.discriminatedUnion("type", [
+      z15.object({ type: z15.literal("build"), build: buildOfferSchema }),
       /** An accepted offer: the build's own secret, and how long its claim lasts between renewals. */
-      z16.object({
-        type: z16.literal("accepted"),
+      z15.object({
+        type: z15.literal("accepted"),
         buildId: nonEmpty9,
         secret: nonEmpty9,
-        leaseMs: z16.number().int().positive()
+        leaseMs: z15.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`.
        */
-      z16.object({ type: z16.literal("build-cancel"), buildId: nonEmpty9, reason: buildCancelReasonSchema }),
+      z15.object({ type: z15.literal("build-cancel"), buildId: nonEmpty9, reason: buildCancelReasonSchema }),
       /** Connect again. Sent before the service closes a socket that another replaced. */
-      z16.object({ type: z16.literal("reconnect") })
+      z15.object({ type: z15.literal("reconnect") })
     ]);
-    runnerRegisterRequestSchema = z16.object({ name: z16.string().trim().min(1).max(100) });
-    runnerRegisterResponseSchema = z16.object({
+    runnerRegisterRequestSchema = z15.object({ name: z15.string().trim().min(1).max(100) });
+    runnerRegisterResponseSchema = z15.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: z16.url(),
+      approveUrl: z15.url(),
       /** Sent to `POST /runners/register/poll`. Only this machine has it. */
       pollToken: nonEmpty9,
       expiresAt: time7.optional(),
       /** How often to poll. */
-      pollMs: z16.number().int().positive().optional()
+      pollMs: z15.number().int().positive().optional()
     });
-    runnerPollRequestSchema = z16.object({ pollToken: nonEmpty9.max(200) });
-    runnerPollResponseSchema = z16.discriminatedUnion("status", [
-      z16.object({ status: z16.literal("waiting") }),
+    runnerPollRequestSchema = z15.object({ pollToken: nonEmpty9.max(200) });
+    runnerPollResponseSchema = z15.discriminatedUnion("status", [
+      z15.object({ status: z15.literal("waiting") }),
       /** Approved. The key is returned this once, and the service keeps only its hash. */
-      z16.object({ status: z16.literal("approved"), runnerId: nonEmpty9, key: nonEmpty9 }),
+      z15.object({ status: z15.literal("approved"), runnerId: nonEmpty9, key: nonEmpty9 }),
       /** Expired, or the key was already collected. Start again. */
-      z16.object({ status: z16.literal("expired") })
+      z15.object({ status: z15.literal("expired") })
     ]);
-    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(),
+    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(),
       /** Only some of the step's tests ran, so its pass isn't shared. */
-      partial: z16.boolean().default(false),
-      budgetMs: z16.number().int().positive().nullable().default(null)
+      partial: z15.boolean().default(false),
+      budgetMs: z15.number().int().positive().nullable().default(null)
     });
-    buildFinishSchema = z16.object({
-      status: z16.enum(["success", "failure", "error"]),
-      summary: z16.string().max(2e3).default(""),
-      deployed: z16.boolean().default(false)
+    buildFinishSchema = z15.object({
+      status: z15.enum(["success", "failure", "error"]),
+      summary: z15.string().max(2e3).default(""),
+      deployed: z15.boolean().default(false)
     });
-    sharedPassSchema = z16.object({
+    sharedPassSchema = z15.object({
       step: nonEmpty9,
       passedAt: time7,
       sha: nonEmpty9,
       runner: nonEmpty9,
-      partial: z16.boolean()
+      partial: z15.boolean()
     });
-    passesResponseSchema = z16.object({ passes: z16.record(z16.string(), sharedPassSchema) });
-    deployCredentialsSchema = z16.object({
+    passesResponseSchema = z15.object({ passes: z15.record(z15.string(), sharedPassSchema) });
+    deployCredentialsSchema = z15.object({
       cloudflareToken: nonEmpty9,
       /** Publishes `@herdingchats/friday`. Missing when the build service has none set. */
       npmToken: nonEmpty9.optional(),
@@ -1782,20 +1786,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: z16.string().regex(/^[0-9a-f]{40}$/).optional(),
+      sha: z15.string().regex(/^[0-9a-f]{40}$/).optional(),
       /** Each Worker's key at its last successful deploy. */
-      lastDeployed: z16.record(z16.string(), z16.string())
+      lastDeployed: z15.record(z15.string(), z15.string())
     });
-    deployedSchema = z16.object({
-      worker: z16.string().regex(/^[a-z][a-z0-9-]{0,62}$/),
-      key: z16.string().regex(/^[0-9a-zA-Z_-]{8,128}$/)
+    deployedSchema = z15.object({
+      worker: z15.string().regex(/^[a-z][a-z0-9-]{0,62}$/),
+      key: z15.string().regex(/^[0-9a-zA-Z_-]{8,128}$/)
     });
-    healthSchema = z16.object({ ok: z16.boolean(), version: z16.string() });
+    healthSchema = z15.object({ ok: z15.boolean(), version: z15.string() });
   }
 });
 
 // ../common-chat/src/setup.ts
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 function actionText(action) {
   if (action.kind === "link") return `${action.label}: ${action.url}`;
   if (action.kind === "sign_in") {
@@ -1830,42 +1834,42 @@ var init_setup = __esm({
     init_activation();
     init_bot();
     SETUP_STEP_IDS = ["slack", "machine", "github", "repos"];
-    setupActionSchema = z17.discriminatedUnion("kind", [
+    setupActionSchema = z16.discriminatedUnion("kind", [
       /** A page to open, which signs in to HerdingChats first. */
-      z17.object({ kind: z17.literal("link"), url: z17.string(), label: z17.string() }),
+      z16.object({ kind: z16.literal("link"), url: z16.string(), label: z16.string() }),
       /** A command to run on the computer. */
-      z17.object({ kind: z17.literal("command"), command: z17.string() }),
+      z16.object({ kind: z16.literal("command"), command: z16.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.
        */
-      z17.object({
-        kind: z17.literal("sign_in"),
-        machineId: z17.string(),
+      z16.object({
+        kind: z16.literal("sign_in"),
+        machineId: z16.string(),
         tool: signInToolSchema,
-        label: z17.string()
+        label: z16.string()
       })
     ]);
-    setupStepSchema = z17.object({
-      id: z17.enum(SETUP_STEP_IDS),
+    setupStepSchema = z16.object({
+      id: z16.enum(SETUP_STEP_IDS),
       /** `unavailable` is a step nobody can take yet, such as GitHub linking before an admin turns it on. */
-      state: z17.enum(["done", "todo", "unavailable"]),
-      optional: z17.boolean(),
-      title: z17.string(),
+      state: z16.enum(["done", "todo", "unavailable"]),
+      optional: z16.boolean(),
+      title: z16.string(),
       /** What was found, such as the machine and whether it's online, or why it can't be done yet. */
-      detail: z17.string().nullable(),
+      detail: z16.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: z17.array(setupActionSchema).optional()
+      extra: z16.array(setupActionSchema).optional()
     });
-    setupStatusSchema = z17.object({
-      steps: z17.array(setupStepSchema),
+    setupStatusSchema = z16.object({
+      steps: z16.array(setupStepSchema),
       /** Whether every step that isn't optional is done, so Friday can take work. */
-      ready: z17.boolean()
+      ready: z16.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:";
@@ -3135,6 +3139,7 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/friday/main.ts
 init_define_HERD_PACKAGE();
+init_src();
 import { spawn as spawn5 } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
@@ -3148,21 +3153,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 } from "zod";
+import { z as z17 } 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 = z.object({
-  api: z.string(),
-  tokenEndpoint: z.string(),
-  revocationEndpoint: z.string().optional(),
-  clientId: z.string(),
-  accessToken: z.string(),
-  accessTokenExpiresAt: z.number(),
-  refreshToken: z.string()
+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 credentialsPath = () => join(herdHome(), "credentials.json");
 function readCredentials() {
@@ -3178,16 +3183,16 @@ function writeCredentials(credentials) {
   writeFileSync(credentialsPath(), JSON.stringify(credentials, null, 2), { mode: 384 });
   chmodSync(credentialsPath(), 384);
 }
-var metadataSchema = z.object({
-  authorization_endpoint: z.string(),
-  token_endpoint: z.string(),
-  registration_endpoint: z.string(),
-  revocation_endpoint: z.string().optional()
+var metadataSchema = z17.object({
+  authorization_endpoint: z17.string(),
+  token_endpoint: z17.string(),
+  registration_endpoint: z17.string(),
+  revocation_endpoint: z17.string().optional()
 });
-var tokenSchema = z.object({
-  access_token: z.string().min(1),
-  refresh_token: z.string().min(1),
-  expires_in: z.number()
+var tokenSchema = z17.object({
+  access_token: z17.string().min(1),
+  refresh_token: z17.string().min(1),
+  expires_in: z17.number()
 });
 var base64url = (bytes) => bytes.toString("base64url");
 async function postForm(url, fields) {
@@ -3219,7 +3224,7 @@ async function login(openBrowser2, { api = apiUrl(), timeoutMs = 10 * 60 * 1e3 }
         token_endpoint_auth_method: "none"
       })
     });
-    const client = z.object({ client_id: z.string() }).safeParse(await registration2.json());
+    const client = z17.object({ client_id: z17.string() }).safeParse(await registration2.json());
     if (!registration2.ok || !client.success) {
       throw new HerdError("The sign-in server refused to register this tool.");
     }
@@ -5142,7 +5147,9 @@ async function awaitActivations(options, chosen, since, print) {
       }
     }
     if (!started && said.size === 0 && Date.now() > startBy) {
-      print("Friday hasn't started activating your agents yet. friday status says how it's doing.");
+      print(
+        `Friday hasn't started activating your agents yet. ${FRIDAY_COMMAND} logs shows what it's doing.`
+      );
       break;
     }
     await sleep2(pollMs);
@@ -5153,6 +5160,7 @@ var herdConfigIn = (herdHome2) => join7(herdHome2, "herd.config.ts");
 
 // src/friday/home.ts
 init_define_HERD_PACKAGE();
+init_src();
 import { spawnSync } from "node:child_process";
 import {
   closeSync as closeSync2,
@@ -5165,7 +5173,7 @@ import {
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { dirname as dirname6, join as join8, resolve as resolve2 } from "node:path";
-var PACKAGE_NAME = "@herdingchats/friday";
+var PACKAGE_NAME = FRIDAY_PACKAGE;
 function fridayPaths(herdHome2) {
   const logs = join8(herdHome2, "logs");
   return {
@@ -5800,7 +5808,7 @@ async function runStart(options) {
   const repo = insideWorkTree(root);
   if (repo) {
     throw new StartError(
-      `${root} is inside the git repo ${repo}, so it can't be the machine's root: every conversation would load that repo's settings. Run friday start in an empty folder outside any repo, such as ~/friday.`
+      `${root} is inside the git repo ${repo}, so it can't be the machine's root: every conversation would load that repo's settings. Run ${START_COMMAND} in an empty folder outside any repo, such as ~/friday.`
     );
   }
   if ((options.platform ?? process.platform) === "linux") {
@@ -5830,10 +5838,13 @@ async function runStart(options) {
   const changed = await service.install();
   await service.start(changed);
   print(
-    `Friday is running from ${root}, version ${currentVersion(paths)}, ${service.kind === "launchd" ? "and starts whenever you log in" : service.kind === "systemd" ? "and starts whenever you log in, as a systemd user service" : "in the background"}. friday status says how it's doing, and friday logs shows what it's done.`
+    `Friday is running from ${root}, version ${currentVersion(paths)}, ${service.kind === "launchd" ? "and starts whenever you log in" : service.kind === "systemd" ? "and starts whenever you log in, as a systemd user service" : "in the background"}.`
   );
   await waitForAgents(options, asked, print);
   await printSetup(options, print, { waitForMachine: true });
+  print(
+    `${FRIDAY_COMMAND} status says how it's doing, and ${FRIDAY_COMMAND} logs shows what it's done.`
+  );
   return 0;
 }
 async function chooseAndAsk(options, print) {
@@ -5884,7 +5895,7 @@ async function ensureInstalled(options, print) {
   if (current && !await versionRuns(paths.current, current, options.run)) return;
   if (version === "dev" && !options.install?.spec) {
     throw new StartError(
-      "This friday runs from the repo, which has no version to install. Run npx @herdingchats/friday start, or npx herd daemon to watch a daemon in the foreground."
+      `This friday runs from the repo, which has no version to install. Run ${START_COMMAND}, or npx herd daemon to watch a daemon in the foreground.`
     );
   }
   print(`Installing Friday ${version}.`);
@@ -5896,6 +5907,7 @@ async function ensureInstalled(options, print) {
 
 // src/friday/supervisor.ts
 init_define_HERD_PACKAGE();
+init_src();
 import { spawn as spawn4 } from "node:child_process";
 import {
   closeSync as closeSync3,
@@ -5975,7 +5987,7 @@ var Supervisor = class {
     try {
       dir = realpathSync4(this.options.paths.current);
     } catch {
-      throw new Error("Nothing is installed in ~/.herd/current. Run friday start.");
+      throw new Error(`Nothing is installed in ~/.herd/current. Run ${START_COMMAND}.`);
     }
     return [process.execPath, binOf(dir, "herd"), "daemon"];
   }
@@ -6120,7 +6132,7 @@ var Supervisor = class {
 // src/friday/main.ts
 var HELP = `friday: run HerdingChats' agent daemon on this computer.
 
-Usage: friday <command>
+Usage: ${FRIDAY_COMMAND} <command>
 
   start       Make this computer a machine, with the folder this runs in as its root, where
               Friday keeps its repos and conversations. Signs in through your browser when
@@ -6128,7 +6140,7 @@ Usage: friday <command>
               you log in, waits for each agent to check in, then shows what's left to set up.
               Safe to run again. --agents claude=lot,codex=little sets the shares without
               asking: off, little, some or lot, where a bare name is some and one left out off
-  stop        Stop the daemon until you log in again, or run friday start
+  stop        Stop the daemon until you log in again, or run start again
   status      Whether the daemon is running, which version, and its root
   logs [-f]   Show the daemon's latest log lines. -f keeps following them
   --version   Print this version
@@ -6267,7 +6279,7 @@ async function runStop(deps) {
   });
   await service.stop();
   deps.print(
-    running ? "Stopped Friday. Its terminals keep running. friday start starts it again, and so does logging in." : "Friday wasn't running."
+    running ? `Stopped Friday. Its terminals keep running. ${START_COMMAND} starts it again, and so does logging in.` : "Friday wasn't running."
   );
   return 0;
 }
@@ -6288,12 +6300,12 @@ function runStatus(deps) {
     pin = "";
   }
   if (!version && !running) {
-    print("Friday isn't set up on this computer. Run npx @herdingchats/friday start in its root.");
+    print(`Friday isn't set up on this computer. Run ${START_COMMAND} in its root.`);
     return 1;
   }
   const daemon = running && status2.daemonPid && alive2(status2.daemonPid);
   print(
-    running ? `Friday is running, version ${status2.version}${daemon ? `, with the daemon at pid ${status2.daemonPid}` : ", restarting the daemon"}.` : "Friday isn't running. friday start starts it."
+    running ? `Friday is running, version ${status2.version}${daemon ? `, with the daemon at pid ${status2.daemonPid}` : ", restarting the daemon"}.` : `Friday isn't running. ${START_COMMAND} starts it.`
   );
   if (version) print(`Installed: ${version}${pin ? `, pinned to ${pin} in ${paths.pin}` : ""}.`);
   if (root) print(`Root: ${root}`);