@herdingchats/friday 0.1.688 → 0.1.707

package/herd.mjs

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_HERD_PACKAGE_default;
 var init_define_HERD_PACKAGE = __esm({
   "<define:HERD_PACKAGE>"() {
-    define_HERD_PACKAGE_default = { version: "0.1.688", gitHead: "a284c931b34fdaa76115c8d2c91da8b2903d19ff" };
+    define_HERD_PACKAGE_default = { version: "0.1.707", gitHead: "092263ddfd4398fa1093a095995b57b617e624d3" };
   }
 });
 
@@ -508,7 +508,13 @@ var init_terminals = __esm({
       rows: z6.number().int().min(5).max(1e3)
     };
     terminalFrameSchema = z6.discriminatedUnion("type", [
-      z6.object({ type: z6.literal("snapshot"), data: z6.string() }),
+      // The screen, and its size, which a watcher draws it at. Hosts from before sizes don't say.
+      z6.object({
+        type: z6.literal("snapshot"),
+        data: z6.string(),
+        cols: size.cols.optional(),
+        rows: size.rows.optional()
+      }),
       z6.object({ type: z6.literal("data"), data: z6.string() }),
       z6.object({ type: z6.literal("exit"), exitCode: z6.number().int().nullable() }),
       z6.object({ type: z6.literal("mode"), mode: terminalModeSchema }),
@@ -1507,7 +1513,10 @@ var init_events = __esm({
         kind: z13.literal("bound"),
         machine: z13.object({ name: nonEmpty6, online: z13.boolean() }),
         // The worker's name, such as `mac-mini/claude`, and never its configuration or capabilities.
-        worker: nonEmpty6.optional()
+        worker: nonEmpty6.optional(),
+        // Only for the machine's owner, while it's online: what they may do with its terminal from
+        // the web. Absent for anyone else, and where the machine allows nothing or can't.
+        terminal: z13.enum(["drive", "watch"]).optional()
       }),
       z13.object({ kind: z13.literal("waiting_for_machine") }),
       z13.object({ kind: z13.literal("author_not_linked") })
@@ -1962,8 +1971,138 @@ var init_builds = __esm({
   }
 });
 
-// ../common-chat/src/setup.ts
+// ../common-chat/src/gateway-spend.ts
 import { z as z17 } from "zod";
+var spendLimitDimensionSchema, spendLimitRuleSchema, gatewaySettingsSchema, accountCreditsSchema, gatewayAnalyticsGroupSchema, gatewayAnalyticsResponseSchema, GATEWAY_SPEND_CACHE_MS, GATEWAY_SPEND_KEEP_MS, usd, modelSpendSchema, spendPeriodSchema, spendLimitScopeSchema, spendLimitSchema, creditBalanceSchema, gatewaySpendFiguresSchema, gatewaySpendResponseSchema;
+var init_gateway_spend = __esm({
+  "../common-chat/src/gateway-spend.ts"() {
+    "use strict";
+    init_define_HERD_PACKAGE();
+    spendLimitDimensionSchema = z17.discriminatedUnion("mode", [
+      z17.object({ mode: z17.literal("partition") }),
+      z17.object({ mode: z17.literal("filter"), values: z17.array(z17.string()) })
+    ]);
+    spendLimitRuleSchema = z17.object({
+      id: z17.string().min(1).optional(),
+      enabled: z17.boolean().optional(),
+      limit: z17.number().positive(),
+      limitType: z17.string(),
+      window: z17.number().positive(),
+      technique: z17.enum(["fixed", "sliding"]).optional(),
+      metadata: z17.record(z17.string(), spendLimitDimensionSchema).nullish(),
+      model: spendLimitDimensionSchema.nullish(),
+      provider: spendLimitDimensionSchema.nullish()
+    });
+    gatewaySettingsSchema = z17.object({
+      id: z17.string(),
+      spend_limits: z17.object({
+        enabled: z17.boolean().optional(),
+        rules: z17.array(spendLimitRuleSchema).nullish()
+      }).nullish()
+    });
+    accountCreditsSchema = z17.object({
+      confirmed_balance_cents: z17.number().nullish(),
+      currency: z17.string().nullish(),
+      days_remaining: z17.number().nullish(),
+      eligible: z17.boolean().nullish(),
+      has_record: z17.boolean().nullish(),
+      original_amount_cents: z17.number().nullish(),
+      percent_consumed: z17.number().nullish(),
+      projected_depletion_date: z17.string().nullish(),
+      valid_from: z17.string().nullish(),
+      valid_to: z17.string().nullish()
+    });
+    gatewayAnalyticsGroupSchema = z17.object({
+      count: z17.number().int().nonnegative(),
+      sum: z17.object({ cost: z17.number().nullish() }).nullish(),
+      dimensions: z17.object({ model: z17.string().nullish(), provider: z17.string().nullish() }).nullish()
+    });
+    gatewayAnalyticsResponseSchema = z17.object({
+      data: z17.object({
+        viewer: z17.object({
+          accounts: z17.array(z17.record(z17.string(), z17.array(gatewayAnalyticsGroupSchema)))
+        })
+      }).nullish(),
+      errors: z17.array(z17.object({ message: z17.string() })).nullish()
+    });
+    GATEWAY_SPEND_CACHE_MS = 5 * 60 * 1e3;
+    GATEWAY_SPEND_KEEP_MS = 24 * 60 * 60 * 1e3;
+    usd = z17.number().nonnegative();
+    modelSpendSchema = z17.object({
+      model: z17.string(),
+      provider: z17.string().nullable(),
+      costUsd: usd,
+      requests: z17.number().int().nonnegative()
+    });
+    spendPeriodSchema = z17.object({
+      since: z17.number().int(),
+      costUsd: usd,
+      requests: z17.number().int().nonnegative(),
+      byModel: z17.array(modelSpendSchema)
+    });
+    spendLimitScopeSchema = z17.object({
+      /** Only these models, or any model. */
+      models: z17.array(z17.string()),
+      /** Only these providers, or any provider. */
+      providers: z17.array(z17.string()),
+      /** Dimensions that give each value its own budget, such as `model` or `metadata:cf.user_id`. */
+      splitBy: z17.array(z17.string()),
+      /** Custom metadata keys the rule filters or splits by, such as `cf.user_id`. */
+      metadata: z17.array(z17.string())
+    });
+    spendLimitSchema = z17.object({
+      id: z17.string().nullable(),
+      enabled: z17.boolean(),
+      limitUsd: z17.number().positive(),
+      windowSeconds: z17.number().positive(),
+      /** `fixed` counts from the window's start, and `rolling` over its length up to now. */
+      windowKind: z17.enum(["fixed", "rolling"]),
+      scope: spendLimitScopeSchema,
+      /** When the counted window started, in ms. */
+      windowStart: z17.number().int(),
+      /** When a fixed window starts again, in ms, or null for a rolling one. */
+      resetsAt: z17.number().int().nullable(),
+      /**
+       * The estimated spend counted against it, and that as a share of the limit, which can pass 1.
+       * For a rule split by model or provider, that's its fullest bucket, which `bucket` names. Null
+       * when analytics can't attribute spend to its buckets, as for a rule on custom metadata.
+       */
+      consumed: z17.object({ costUsd: usd, share: z17.number().nonnegative(), bucket: z17.string().nullable() }).nullable()
+    });
+    creditBalanceSchema = z17.object({ amount: z17.number(), currency: z17.string() });
+    gatewaySpendFiguresSchema = z17.object({
+      gateway: z17.string(),
+      /** When Cloudflare was read, in ms. */
+      readAt: z17.number().int(),
+      today: spendPeriodSchema,
+      month: spendPeriodSchema,
+      /** Whether the gateway enforces its spend limits at all. */
+      limitsEnabled: z17.boolean(),
+      limits: z17.array(spendLimitSchema),
+      credits: creditBalanceSchema.nullable(),
+      /** Why the balance is missing, when it is. */
+      creditsError: z17.string().nullable()
+    });
+    gatewaySpendResponseSchema = z17.discriminatedUnion("configured", [
+      /** Before the read-only token is uploaded: what's missing, by binding name. */
+      z17.object({ configured: z17.literal(false), missing: z17.array(z17.string()).min(1) }),
+      z17.object({
+        configured: z17.literal(true),
+        /** Stand-in figures from `npm run dev`, never Cloudflare's. */
+        local: z17.boolean(),
+        /** Spend is Cloudflare's estimate from token counts and model pricing, not the bill. */
+        estimated: z17.literal(true),
+        /** The latest good figures, or null if no read has succeeded in the last day. */
+        figures: gatewaySpendFiguresSchema.nullable(),
+        /** Why the latest read failed, when it did. The figures are then the last good ones. */
+        error: z17.string().nullable()
+      })
+    ]);
+  }
+});
+
+// ../common-chat/src/setup.ts
+import { z as z18 } from "zod";
 function actionText(action) {
   if (action.kind === "link") return `${action.label}: ${action.url}`;
   if (action.kind === "sign_in") {
@@ -1998,42 +2137,42 @@ var init_setup = __esm({
     init_activation();
     init_bot();
     SETUP_STEP_IDS = ["slack", "machine", "github", "repos"];
-    setupActionSchema = z17.discriminatedUnion("kind", [
+    setupActionSchema = z18.discriminatedUnion("kind", [
       /** A page to open, which signs in to HerdingChats first. */
-      z17.object({ kind: z17.literal("link"), url: z17.string(), label: z17.string() }),
+      z18.object({ kind: z18.literal("link"), url: z18.string(), label: z18.string() }),
       /** A command to run on the computer. */
-      z17.object({ kind: z17.literal("command"), command: z17.string() }),
+      z18.object({ kind: z18.literal("command"), command: z18.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(),
+      z18.object({
+        kind: z18.literal("sign_in"),
+        machineId: z18.string(),
         tool: signInToolSchema,
-        label: z17.string()
+        label: z18.string()
       })
     ]);
-    setupStepSchema = z17.object({
-      id: z17.enum(SETUP_STEP_IDS),
+    setupStepSchema = z18.object({
+      id: z18.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: z18.enum(["done", "todo", "unavailable"]),
+      optional: z18.boolean(),
+      title: z18.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: z18.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: z18.array(setupActionSchema).optional()
     });
-    setupStatusSchema = z17.object({
-      steps: z17.array(setupStepSchema),
+    setupStatusSchema = z18.object({
+      steps: z18.array(setupStepSchema),
       /** Whether every step that isn't optional is done, so Friday can take work. */
-      ready: z17.boolean()
+      ready: z18.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:";
@@ -2068,6 +2207,7 @@ var init_src = __esm({
     init_content();
     init_conversation_state();
     init_events();
+    init_gateway_spend();
     init_github();
     init_github_triggers();
     init_machines();
@@ -2485,7 +2625,7 @@ var init_widget = __esm({
 });
 
 // ../common-board/src/widgets/conversations.tsx
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function badge(item) {
   if (pullRequestBadge(item)) {
@@ -2529,10 +2669,10 @@ var init_conversations = __esm({
     conversations2 = defineWidget({
       kind: "conversations",
       describe: "Blocked, working and queued conversations, then the latest done, with what each is doing, where it came from and who holds it",
-      options: z30.object({
-        states: z30.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
-        limit: z30.number().int().min(1).max(BOARD_ITEMS).default(4),
-        show: z30.array(z30.enum(DETAILS)).default([...DETAILS])
+      options: z31.object({
+        states: z31.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
+        limit: z31.number().int().min(1).max(BOARD_ITEMS).default(4),
+        show: z31.array(z31.enum(DETAILS)).default([...DETAILS])
       }),
       reads: ["items", "machines"],
       Component: ({ board, options, theme, now }) => {
@@ -2576,7 +2716,7 @@ var init_conversations = __esm({
 });
 
 // ../common-board/src/widgets/counts.tsx
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var COUNTS, LABELS2, counts;
 var init_counts = __esm({
@@ -2596,8 +2736,8 @@ var init_counts = __esm({
     counts = defineWidget({
       kind: "counts",
       describe: "How many conversations are stuck, unanswered, waiting and working, and done today",
-      options: z31.object({
-        show: z31.array(z31.enum(COUNTS)).min(1).max(5).default([...COUNTS])
+      options: z32.object({
+        show: z32.array(z32.enum(COUNTS)).min(1).max(5).default([...COUNTS])
       }),
       reads: ["counts", "doneToday"],
       Component: ({ board, options, theme }) => {
@@ -2636,7 +2776,7 @@ var init_counts = __esm({
 });
 
 // ../common-board/src/widgets/header.tsx
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function summary(board) {
   const parts = [
@@ -2661,9 +2801,9 @@ var init_header = __esm({
     header = defineWidget({
       kind: "header",
       describe: "The board's title, a line of how much is open, and when it was drawn",
-      options: z32.object({
-        title: z32.string().min(1).max(40).default(`@${BOT_NAME}`),
-        summary: z32.boolean().default(true)
+      options: z33.object({
+        title: z33.string().min(1).max(40).default(`@${BOT_NAME}`),
+        summary: z33.boolean().default(true)
       }),
       reads: ["counts"],
       Component: ({ board, options, theme, now }) => {
@@ -2681,7 +2821,7 @@ var init_header = __esm({
 });
 
 // ../common-board/src/widgets/machines.tsx
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function usageText(worker) {
   const usage = worker.usage;
@@ -2712,7 +2852,7 @@ var init_machines2 = __esm({
     machines = defineWidget({
       kind: "machines",
       describe: "One bubble per agent on an online machine, with its usage, most recently active first",
-      options: z33.object({ limit: z33.number().int().min(1).max(8).default(3) }),
+      options: z34.object({ limit: z34.number().int().min(1).max(8).default(3) }),
       reads: ["machines"],
       Component: ({ board, options, theme }) => {
         const workers2 = board.machines.filter((machine) => machine.online).flatMap((machine) => machine.workers.map((worker) => ({ ...worker, machine: machine.name }))).sort((a, b) => (b.reportedAt ?? 0) - (a.reportedAt ?? 0));
@@ -2829,9 +2969,9 @@ var init_board2 = __esm({
 });
 
 // ../common-board/src/composition.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 function readComposition(stored) {
-  const shape = z34.object({ widgets: z34.array(placedWidgetSchema) }).safeParse(stored);
+  const shape = z35.object({ widgets: z35.array(placedWidgetSchema) }).safeParse(stored);
   if (!shape.success) return DEFAULT_COMPOSITION;
   const known = shape.data.widgets.filter(
     (widget) => WIDGETS[widget.kind]?.options.safeParse(widget.options).success
@@ -2846,11 +2986,11 @@ var init_composition = __esm({
     init_registry();
     MAX_WIDGETS = 12;
     MAX_COMPOSITION_BYTES = 4096;
-    placedWidgetSchema = z34.object({
-      kind: z34.string().min(1),
-      options: z34.record(z34.string(), z34.unknown()).default({})
+    placedWidgetSchema = z35.object({
+      kind: z35.string().min(1),
+      options: z35.record(z35.string(), z35.unknown()).default({})
     });
-    compositionSchema = z34.object({ widgets: z34.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
+    compositionSchema = z35.object({ widgets: z35.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
       if (JSON.stringify(composition).length > MAX_COMPOSITION_BYTES) {
         context2.addIssue({
           code: "custom",
@@ -3310,7 +3450,7 @@ import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname10, join as join16 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/auth.ts
 init_define_HERD_PACKAGE();
@@ -3319,21 +3459,21 @@ import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:
 import { createServer } from "node:http";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { z as z18 } from "zod";
+import { z as z19 } 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 = z18.object({
-  api: z18.string(),
-  tokenEndpoint: z18.string(),
-  revocationEndpoint: z18.string().optional(),
-  clientId: z18.string(),
-  accessToken: z18.string(),
-  accessTokenExpiresAt: z18.number(),
-  refreshToken: z18.string()
+var credentialsSchema = z19.object({
+  api: z19.string(),
+  tokenEndpoint: z19.string(),
+  revocationEndpoint: z19.string().optional(),
+  clientId: z19.string(),
+  accessToken: z19.string(),
+  accessTokenExpiresAt: z19.number(),
+  refreshToken: z19.string()
 });
 var credentialsPath = () => join(herdHome(), "credentials.json");
 function readCredentials() {
@@ -3349,16 +3489,16 @@ function writeCredentials(credentials) {
   writeFileSync(credentialsPath(), JSON.stringify(credentials, null, 2), { mode: 384 });
   chmodSync(credentialsPath(), 384);
 }
-var metadataSchema = z18.object({
-  authorization_endpoint: z18.string(),
-  token_endpoint: z18.string(),
-  registration_endpoint: z18.string(),
-  revocation_endpoint: z18.string().optional()
+var metadataSchema = z19.object({
+  authorization_endpoint: z19.string(),
+  token_endpoint: z19.string(),
+  registration_endpoint: z19.string(),
+  revocation_endpoint: z19.string().optional()
 });
-var tokenSchema = z18.object({
-  access_token: z18.string().min(1),
-  refresh_token: z18.string().min(1),
-  expires_in: z18.number()
+var tokenSchema = z19.object({
+  access_token: z19.string().min(1),
+  refresh_token: z19.string().min(1),
+  expires_in: z19.number()
 });
 var base64url = (bytes) => bytes.toString("base64url");
 async function postForm(url, fields) {
@@ -3467,7 +3607,7 @@ async function login(how, {
         token_endpoint_auth_method: "none"
       })
     });
-    const client = z18.object({ client_id: z18.string() }).safeParse(await registration2.json());
+    const client = z19.object({ client_id: z19.string() }).safeParse(await registration2.json());
     if (!registration2.ok || !client.success) {
       throw new HerdError("The sign-in server refused to register this tool.");
     }
@@ -3705,7 +3845,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3, hostname } from "node:os";
 import { basename, dirname as dirname4, join as join6, resolve } from "node:path";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/login-shell.ts
 init_define_HERD_PACKAGE();
@@ -4484,13 +4624,13 @@ function hasUnpushed(path) {
 
 // src/config.ts
 init_self();
-var repoSchema = z19.object({ name: z19.string(), path: z19.string(), remote: z19.string() });
-var configSchema = z19.object({
-  machineId: z19.string(),
-  machineName: z19.string(),
-  repos: z19.array(repoSchema),
+var repoSchema = z20.object({ name: z20.string(), path: z20.string(), remote: z20.string() });
+var configSchema = z20.object({
+  machineId: z20.string(),
+  machineName: z20.string(),
+  repos: z20.array(repoSchema),
   /** The machine's root folder, holding herd's clones and its conversations' folders. */
-  root: z19.string().optional()
+  root: z20.string().optional()
 });
 var configPath = () => join6(herdHome(), "config.json");
 function save(config) {
@@ -4708,23 +4848,23 @@ init_src();
 import { randomBytes as randomBytes4, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname5, join as join8 } from "node:path";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // src/permissions.ts
 init_define_HERD_PACKAGE();
 init_src();
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/local-socket.ts
 init_define_HERD_PACKAGE();
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync4, rmSync as rmSync4 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
-import { z as z20 } from "zod";
-var localRequestSchema = z20.object({
-  secret: z20.string().min(1),
-  op: z20.enum([
+import { z as z21 } from "zod";
+var localRequestSchema = z21.object({
+  secret: z21.string().min(1),
+  op: z21.enum([
     "inbox",
     "send",
     "run",
@@ -4756,32 +4896,32 @@ var localRequestSchema = z20.object({
     "activate"
   ]),
   // The key of the agent's start, from `HERD_START`, which `herd inbox` proves the start with.
-  start: z20.string().min(1).max(100).optional(),
+  start: z21.string().min(1).max(100).optional(),
   // `herd repo`: the repo it added to the conversation's folder, for the daemon to record.
-  repo: z20.object({
-    remote: z20.string().min(1).max(500),
-    folder: z20.string().min(1).max(100),
-    base: z20.string().min(1).max(300).optional(),
-    fetchFailed: z20.string().max(1e3).optional()
+  repo: z21.object({
+    remote: z21.string().min(1).max(500),
+    folder: z21.string().min(1).max(100),
+    base: z21.string().min(1).max(300).optional(),
+    fetchFailed: z21.string().max(1e3).optional()
   }).optional(),
   // `herd repo`: what the agent named and the folder it asked for, for the daemon to add.
-  repoAdd: z20.object({
-    asked: z20.string().min(1).max(500),
-    folder: z20.string().min(1).max(100).optional()
+  repoAdd: z21.object({
+    asked: z21.string().min(1).max(500),
+    folder: z21.string().min(1).max(100).optional()
   }).optional(),
   // `herd delegate --repo`, given once for each repo the delegate works in.
-  repos: z20.array(z20.string().min(1).max(500)).max(10).optional(),
+  repos: z21.array(z21.string().min(1).max(500)).max(10).optional(),
   // `herd watch`, `herd unwatch` and `herd watching`: what to do, and the pull request.
-  watch: z20.object({
-    action: z20.enum(["watch", "unwatch", "list"]),
-    url: z20.string().min(1).max(500).optional()
+  watch: z21.object({
+    action: z21.enum(["watch", "unwatch", "list"]),
+    url: z21.string().min(1).max(500).optional()
   }).optional(),
   // `herd delegate`, `herd tell` and `herd handoff`: the worker or conversation they name.
-  worker: z20.string().min(1).max(200).optional(),
-  to: z20.string().min(1).max(200).optional(),
+  worker: z21.string().min(1).max(200).optional(),
+  to: z21.string().min(1).max(200).optional(),
   // `herd automations`: what to do, to which automation, and the definition or change it sends.
-  automation: z20.object({
-    action: z20.enum([
+  automation: z21.object({
+    action: z21.enum([
       "list",
       "show",
       "create",
@@ -4792,47 +4932,47 @@ var localRequestSchema = z20.object({
       "test",
       "rotate"
     ]),
-    id: z20.string().min(1).max(100).optional(),
-    body: z20.record(z20.string(), z20.unknown()).optional(),
-    waitMs: z20.number().int().min(0).max(6e5).optional()
+    id: z21.string().min(1).max(100).optional(),
+    body: z21.record(z21.string(), z21.unknown()).optional(),
+    waitMs: z21.number().int().min(0).max(6e5).optional()
   }).optional(),
   // `herd work`: list, record or remove one, with the change the daemon checks again.
-  work: z20.object({
-    action: z20.enum(["list", "record", "remove"]),
-    change: z20.unknown().optional(),
-    url: z20.string().min(1).max(2048).optional()
+  work: z21.object({
+    action: z21.enum(["list", "record", "remove"]),
+    change: z21.unknown().optional(),
+    url: z21.string().min(1).max(2048).optional()
   }).optional(),
   // `herd conversations --about <url>`: only the owner's conversations about that URL.
-  about: z20.string().min(1).max(2048).optional(),
+  about: z21.string().min(1).max(2048).optional(),
   // `herd investigate screen` or `herd investigate propose`, with the proposal the daemon checks.
-  action: z20.enum(["screen", "propose"]).optional(),
-  proposal: z20.unknown().optional(),
+  action: z21.enum(["screen", "propose"]).optional(),
+  proposal: z21.unknown().optional(),
   // Commands may name a conversation, but only their own is ever allowed.
-  conversationId: z20.string().optional(),
+  conversationId: z21.string().optional(),
   // Where `conversations` is shown, which decides whether private titles are. Only the terminal's
   // own conversation is ever allowed, so a terminal can't pick one that shows more.
-  for: z20.string().optional(),
-  text: z20.string().optional(),
+  for: z21.string().optional(),
+  text: z21.string().optional(),
   // A whole message, from `herd send --json`, which the daemon checks again.
-  message: z20.unknown().optional(),
-  idempotencyKey: z20.string().optional(),
-  command: z20.array(z20.string()).optional(),
+  message: z21.unknown().optional(),
+  idempotencyKey: z21.string().optional(),
+  command: z21.array(z21.string()).optional(),
   // `status --clear`.
-  clear: z20.boolean().optional(),
+  clear: z21.boolean().optional(),
   // What an agent's status line reported, checked by the daemon.
-  usage: z20.unknown().optional(),
+  usage: z21.unknown().optional(),
   // Which agent and session a status line ran for. Its reports count only from the session herd
   // started in the conversation's lead terminal.
-  agent: z20.enum(["claude-code", "codex", "agy"]).optional(),
-  sessionId: z20.string().min(1).max(200).optional(),
+  agent: z21.enum(["claude-code", "codex", "agy"]).optional(),
+  sessionId: z21.string().min(1).max(200).optional(),
   // What agy's status line says its agent is doing: `working` or `idle`.
-  state: z20.enum(["working", "idle"]).optional(),
+  state: z21.enum(["working", "idle"]).optional(),
   // A permission request from Claude Code's hook, with the key it keeps across reconnects.
-  key: z20.string().min(1).max(200).optional(),
-  request: z20.unknown().optional(),
+  key: z21.string().min(1).max(200).optional(),
+  request: z21.unknown().optional(),
   // For one of Claude Code's other hooks: which event, and the JSON Claude Code gave it.
-  event: z20.string().optional(),
-  input: z20.record(z20.string(), z20.unknown()).optional()
+  event: z21.string().optional(),
+  input: z21.record(z21.string(), z21.unknown()).optional()
 });
 var LocalSocket = class {
   constructor(path, handle) {
@@ -4954,10 +5094,10 @@ function isAnswering(path) {
 }
 
 // src/permissions.ts
-var hookRequestSchema = z21.looseObject({
-  tool_name: z21.string().min(1),
-  tool_input: z21.record(z21.string(), z21.unknown()).default({}),
-  permission_suggestions: z21.array(z21.unknown()).optional()
+var hookRequestSchema = z22.looseObject({
+  tool_name: z22.string().min(1),
+  tool_input: z22.record(z22.string(), z22.unknown()).default({}),
+  permission_suggestions: z22.array(z22.unknown()).optional()
 });
 var DETAIL_LIMIT = 2800;
 var REPLY_MESSAGE_LIMIT = 2e3;
@@ -5407,9 +5547,9 @@ var activationTerminal = (agent) => `herd-activate-${agentShortName(agent)}`;
 var activationFolder = (root, agent) => join8(convosHome(root), ".activate", agentShortName(agent));
 var recordSchema = agentActivationSchema.extend({
   /** While it's waiting: the terminal it runs in, which `friday start` can attach to. */
-  terminal: z22.string().optional()
+  terminal: z23.string().optional()
 });
-var storeSchema = z22.object({ agents: z22.record(z22.string(), recordSchema) });
+var storeSchema = z23.object({ agents: z23.record(z23.string(), recordSchema) });
 var activationsPath = (home = herdHome()) => join8(home, "activations.json");
 var activationRequestPath = (home = herdHome()) => join8(home, "activate-request");
 function readActivations(path = activationsPath()) {
@@ -5496,6 +5636,25 @@ var Activator = class {
     }
     this.request([{ name: agent, version }]);
   }
+  /**
+   * The terminal an agent's activation runs in, for its owner to sign in from the web. One that
+   * isn't running is started, and its terminal named once it's open. Null if it didn't open.
+   */
+  async terminalFor(agent, version, { waitMs = 6e4, pollMs = 200 } = {}) {
+    if (this.current?.agent !== agent) this.request([{ name: agent, version }], { force: true });
+    const until = Date.now() + waitMs;
+    while (Date.now() < until && !this.stopped) {
+      const current = this.current;
+      if (current?.agent === agent) {
+        const open = (await this.options.terminals.list().catch(() => [])).some(
+          (t) => t.name === current.terminal && !t.exited
+        );
+        if (open) return current.terminal;
+      }
+      await new Promise((resolve8) => setTimeout(resolve8, pollMs));
+    }
+    return null;
+  }
   /** Resolves once nothing is queued or running, as tests wait for. */
   async settled() {
     while (this.running) await this.running;
@@ -5596,7 +5755,8 @@ var Activator = class {
   async waitForCheckIn(version, driver, current, folder, wasSignedOut) {
     const { terminals } = this.options;
     const { agent } = current;
-    const deadline = Date.now() + (this.options.deadlineMs ?? ACTIVATION_DEADLINE_MS);
+    const deadlineMs = this.options.deadlineMs ?? ACTIVATION_DEADLINE_MS;
+    let deadline = Date.now() + deadlineMs;
     const restartMs = this.options.signInRestartMs ?? SIGN_IN_RESTART_MS;
     const checkInMs = this.options.checkInMs ?? CHECK_IN_MS;
     const pollMs = this.options.pollMs ?? ACTIVATION_POLL_MS;
@@ -5632,6 +5792,8 @@ var Activator = class {
     };
     await start();
     while (!current.checkedIn && Date.now() < deadline && !this.stopped) {
+      const lookers = lookingAt((await terminals.list()).find((t) => t.name === current.terminal));
+      if (lookers > 0) deadline = Math.max(deadline, Date.now() + deadlineMs);
       const reading = await driver.read(current.terminal).catch(() => null);
       if (reading?.state === "signed_out" && Date.now() - startedAt >= checkInMs) {
         seen = "signed_out";
@@ -7147,7 +7309,7 @@ function defaults() {
     print: (line2) => console.log(line2)
   };
 }
-var releaseSchema = z23.object({ version: z23.string().min(1), integrity: z23.string().min(1) });
+var releaseSchema = z24.object({ version: z24.string().min(1), integrity: z24.string().min(1) });
 async function fetchRelease() {
   const response = await apiFetch("/api/daemon/release");
   if (response.status === 404) return null;
@@ -7788,11 +7950,11 @@ init_define_HERD_PACKAGE();
 // src/investigator.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var INVESTIGATE_KEYS = ["escape", "up", "down", "enter", "tab"];
-var proposalSchema = z24.object({
-  key: z24.enum([...INVESTIGATE_KEYS, "none"]),
-  reason: z24.string().trim().min(1).max(300)
+var proposalSchema = z25.object({
+  key: z25.enum([...INVESTIGATE_KEYS, "none"]),
+  reason: z25.string().trim().min(1).max(300)
 });
 var KEY_LABELS = {
   escape: "Esc",
@@ -8202,12 +8364,12 @@ init_define_HERD_PACKAGE();
 init_src();
 import { chmodSync as chmodSync3, existsSync as existsSync14, mkdirSync as mkdirSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
 import { join as join19 } from "node:path";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var BUILDS_URL = "https://builds.herdingchats.com";
-var runnerKeySchema = z25.object({
-  runnerId: z25.string().min(1),
-  key: z25.string().min(20),
-  url: z25.string().url()
+var runnerKeySchema = z26.object({
+  runnerId: z26.string().min(1),
+  key: z26.string().min(20),
+  url: z26.string().url()
 });
 var runnerKeyPath = () => join19(herdHome(), "build-runner.json");
 function readRunnerKey() {
@@ -8276,33 +8438,33 @@ async function registerRunner({
 
 // src/build-speed.ts
 init_define_HERD_PACKAGE();
-import { z as z26 } from "zod";
-var ms = z26.number().int().nullable();
-var figuresSchema = z26.object({ count: z26.number().int(), median: ms, p90: ms });
-var buildTimesSchema = z26.object({ run: figuresSchema, push: figuresSchema });
-var stepFiguresSchema = z26.object({
-  ran: z26.number().int(),
-  remembered: z26.number().int(),
+import { z as z27 } from "zod";
+var ms = z27.number().int().nullable();
+var figuresSchema = z27.object({ count: z27.number().int(), median: ms, p90: ms });
+var buildTimesSchema = z27.object({ run: figuresSchema, push: figuresSchema });
+var stepFiguresSchema = z27.object({
+  ran: z27.number().int(),
+  remembered: z27.number().int(),
   median: ms,
   p90: ms,
-  overBudget: z26.number().int()
+  overBudget: z27.number().int()
 });
-var kindSchema = z26.object({
-  builds: z26.object({ current: buildTimesSchema, previous: buildTimesSchema }),
-  steps: z26.array(
-    z26.object({ label: z26.string(), current: stepFiguresSchema, previous: stepFiguresSchema })
+var kindSchema = z27.object({
+  builds: z27.object({ current: buildTimesSchema, previous: buildTimesSchema }),
+  steps: z27.array(
+    z27.object({ label: z27.string(), current: stepFiguresSchema, previous: stepFiguresSchema })
   ),
-  overBudget: z26.array(
-    z26.object({ label: z26.string(), current: z26.number().int(), previous: z26.number().int() })
+  overBudget: z27.array(
+    z27.object({ label: z27.string(), current: z27.number().int(), previous: z27.number().int() })
   )
 });
-var range = z26.object({ from: z26.number(), to: z26.number() });
-var speedReportSchema = z26.object({
-  periods: z26.object({ current: range, previous: range }),
-  repos: z26.array(
-    z26.object({
-      repo: z26.string(),
-      capped: z26.boolean(),
+var range = z27.object({ from: z27.number(), to: z27.number() });
+var speedReportSchema = z27.object({
+  periods: z27.object({ current: range, previous: range }),
+  repos: z27.array(
+    z27.object({
+      repo: z27.string(),
+      capped: z27.boolean(),
       pullRequests: kindSchema,
       main: kindSchema
     })
@@ -11068,9 +11230,13 @@ var Session = class {
     });
   }
   fromHost(message) {
-    if (message.type === "snapshot") {
+    const size2 = typeof message.cols === "number" && typeof message.rows === "number" ? { cols: message.cols, rows: message.rows } : null;
+    if (message.type === "resize" && size2) {
+      this.flush();
+      this.send({ type: "resize", ...size2 });
+    } else if (message.type === "snapshot") {
       this.pending = "";
-      this.send({ type: "snapshot", data: message.data ?? "" });
+      this.send({ type: "snapshot", data: message.data ?? "", ...size2 ?? {} });
     } else if (message.type === "data") {
       if (this.behind) return;
       this.pending += message.data ?? "";
@@ -11240,7 +11406,7 @@ init_define_HERD_PACKAGE();
 init_src();
 init_self();
 import { join as join28 } from "node:path";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 function hasThread(events) {
   return events.some(
     (event2) => event2.type === "prompt.opened" || event2.type === "message.created" && !(event2.payload.direction === "inbound" && event2.payload.automation) && !event2.payload.quiet && !event2.payload.post
@@ -11306,16 +11472,16 @@ var WAITING_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "agent_needs_input",
   "elicitation_dialog"
 ]);
-var agentMessageSchema = z27.object({
-  text: z27.string().trim().min(1).max(12e3),
-  files: z27.array(z27.object({ path: z27.string().min(1), title: z27.string().optional() })).max(10).optional()
+var agentMessageSchema = z28.object({
+  text: z28.string().trim().min(1).max(12e3),
+  files: z28.array(z28.object({ path: z28.string().min(1), title: z28.string().optional() })).max(10).optional()
 });
-var workspaceRepoSchema = z27.object({
-  folder: z27.string(),
-  remote: z27.string(),
-  branch: z27.string(),
+var workspaceRepoSchema = z28.object({
+  folder: z28.string(),
+  remote: z28.string(),
+  branch: z28.string(),
   /** For a conversation from before folders: the name of the repo it was allowed as. */
-  name: z27.string().optional()
+  name: z28.string().optional()
 });
 function fromBeforeFolders(raw) {
   if (!raw || typeof raw !== "object" || "folder" in raw) return raw;
@@ -11336,106 +11502,106 @@ function fromBeforeFolders(raw) {
     legacy: true
   };
 }
-var workspaceFields = z27.object({
-  conversationId: z27.string(),
+var workspaceFields = z28.object({
+  conversationId: z28.string(),
   /** The conversation's own folder, where its terminals start. */
-  folder: z27.string(),
+  folder: z28.string(),
   /** The repos in it, in the order they were added. */
-  worktrees: z27.array(workspaceRepoSchema).default([]),
+  worktrees: z28.array(workspaceRepoSchema).default([]),
   /** A conversation from before folders, which works in its one repo's worktree. */
-  legacy: z27.boolean().default(false),
-  lead: z27.string(),
-  secret: z27.string(),
-  readSeq: z27.number(),
-  claimId: z27.string().nullable(),
-  claimRenewedAt: z27.number(),
-  started: z27.boolean(),
+  legacy: z28.boolean().default(false),
+  lead: z28.string(),
+  secret: z28.string(),
+  readSeq: z28.number(),
+  claimId: z28.string().nullable(),
+  claimRenewedAt: z28.number(),
+  started: z28.boolean(),
   /** Messages to deliver once the current turn ends. */
-  deferred: z27.boolean(),
+  deferred: z28.boolean(),
   /** A `herd run` command finished, which the agent hears about even with nothing to claim. */
-  terminalNotice: z27.boolean().default(false),
-  status: z27.string().nullable(),
+  terminalNotice: z28.boolean().default(false),
+  status: z28.string().nullable(),
   /** Set once the thread has been told the agent is waiting, so it's told once per wait. */
-  toldWaiting: z27.boolean(),
-  runs: z27.array(z27.object({ name: z27.string(), secret: z27.string(), reported: z27.boolean() })),
+  toldWaiting: z28.boolean(),
+  runs: z28.array(z28.object({ name: z28.string(), secret: z28.string(), reported: z28.boolean() })),
   /** The subscription usage Claude Code last reported in this worktree. */
   usage: usageSchema.nullable().default(null),
   /** When that usage was reported, or 0 if it was before this was kept. */
-  usageAt: z27.number().default(0),
+  usageAt: z28.number().default(0),
   /** The lead agent's Claude Code session, as its `SessionStart` hook reported it. */
-  sessionId: z27.string().nullable().default(null),
+  sessionId: z28.string().nullable().default(null),
   /** When the agent's last turn ended with nothing left to do, for shutting it down later. */
-  idleSince: z27.number().nullable().default(null),
+  idleSince: z28.number().nullable().default(null),
   /** The agent ran `herd exit`, so its session ends after this turn. */
-  exitRequested: z27.boolean().default(false),
+  exitRequested: z28.boolean().default(false),
   /** Whether the agent sent anything with `herd send` this turn. */
-  sentThisTurn: z27.boolean().default(false),
+  sentThisTurn: z28.boolean().default(false),
   /** Whether it's been asked this turn to reply. */
-  askedToReply: z27.boolean().default(false),
+  askedToReply: z28.boolean().default(false),
   /** Whether it ran `herd handled` this turn, which handles the turn's messages with no reply. */
-  handledThisTurn: z27.boolean().default(false),
+  handledThisTurn: z28.boolean().default(false),
   /** The newest waiting message it's been pointed at, so one arrival is pointed out once. */
-  nudgedSeq: z27.number().default(0),
+  nudgedSeq: z28.number().default(0),
   /** When a `Stop` hook last ended a turn. */
-  hookIdleAt: z27.number().default(0),
+  hookIdleAt: z28.number().default(0),
   /** When a turn last ended with background work still running, which keeps its messages held. */
-  pausedAt: z27.number().nullable().default(null),
+  pausedAt: z28.number().nullable().default(null),
   /** The version of the terminal host the lead terminal was opened in, if it was recorded. */
-  hostVersion: z27.string().nullable().default(null),
+  hostVersion: z28.string().nullable().default(null),
   /** When a notice last failed for a reason other than someone's draft, to wait before retrying. */
-  noticeFailedAt: z27.number().nullable().default(null),
+  noticeFailedAt: z28.number().nullable().default(null),
   /** Why the last notice failed, so the history records each reason once, not every attempt. */
-  noticeFailure: z27.string().nullable().default(null),
+  noticeFailure: z28.string().nullable().default(null),
   /** A recorded dialog herd pressed its way out of, so a dialog that stays isn't pressed again. */
-  closedDialog: z27.string().nullable().default(null),
+  closedDialog: z28.string().nullable().default(null),
   /**
    * Prompts Claude Code's hooks reported that haven't had their `Stop`. A turn is open while this
    * is above zero. It's a count because a prompt queued mid-turn is reported as it's queued, and
    * runs as a turn of its own, ending with a second `Stop`.
    */
-  promptsOpen: z27.number().default(0),
+  promptsOpen: z28.number().default(0),
   /** The messages the latest claim or addition took, for choosing which notice to type. */
-  claimedSeqs: z27.array(z27.number()).default([]),
+  claimedSeqs: z28.array(z28.number()).default([]),
   /** The investigator looking at a screen herd can't read, from opening to the owner's answer. */
-  investigation: z27.object({
-    terminal: z27.string(),
-    secret: z27.string(),
-    startedAt: z27.number(),
+  investigation: z28.object({
+    terminal: z28.string(),
+    secret: z28.string(),
+    startedAt: z28.number(),
     /** The stuck screen when it opened, saved with the key if the owner approves one. */
-    screen: z27.array(z27.string()),
-    key: z27.string().nullable(),
-    promptId: z27.string().nullable()
+    screen: z28.array(z28.string()),
+    key: z28.string().nullable(),
+    promptId: z28.string().nullable()
   }).nullable().default(null),
   /** The failed notice an investigator was opened for, so each failure gets one. */
-  investigatedFailure: z27.number().nullable().default(null),
+  investigatedFailure: z28.number().nullable().default(null),
   /** The agent CLI this conversation's worker runs, as its offer named it. */
-  agent: z27.string().default("claude-code"),
+  agent: z28.string().default("claude-code"),
   /** Whether what the current claim took needs a reply, which other agents' messages don't. */
-  replyWanted: z27.boolean().default(true),
+  replyWanted: z28.boolean().default(true),
   /** For a delegate: the conversation that started it, which its starting prompt names. */
-  parent: z27.string().nullable().default(null),
+  parent: z28.string().nullable().default(null),
   /** Codex's session file for this worktree, once found, and how far the daemon has read it. */
-  codexFile: z27.string().nullable().default(null),
-  codexOffset: z27.number().default(0),
+  codexFile: z28.string().nullable().default(null),
+  codexOffset: z28.number().default(0),
   /** When the agent was last started, so Codex's new session file is told from older ones. */
-  agentStartedAt: z27.number().default(0),
+  agentStartedAt: z28.number().default(0),
   /**
    * The key the agent was last started with, as `HERD_START`. Its `herd inbox` carrying this key
    * is what proves the start works: never a hook, a prompt being taken, or the screen.
    */
-  startKey: z27.string().nullable().default(null),
+  startKey: z28.string().nullable().default(null),
   /** Whether the current start has checked in. One from before keys counts as proven. */
-  startProven: z27.boolean().default(true),
+  startProven: z28.boolean().default(true),
   /** When the check-in window of an unproven start began, or null once it's proven or for none. */
-  checkInFrom: z27.number().nullable().default(null),
+  checkInFrom: z28.number().nullable().default(null),
   /** Whether this start has been flagged as needing someone at its terminal, so it's said once. */
-  needsAttention: z27.boolean().default(false),
+  needsAttention: z28.boolean().default(false),
   /** What agy's status line last said its agent was doing, and when. */
-  agentState: z27.enum(["working", "idle"]).nullable().default(null),
-  agentStateAt: z27.number().default(0)
+  agentState: z28.enum(["working", "idle"]).nullable().default(null),
+  agentStateAt: z28.number().default(0)
 });
-var workspaceSchema = z27.preprocess(fromBeforeFolders, workspaceFields);
-var stateSchema = z27.object({ workspaces: z27.record(z27.string(), workspaceSchema) });
+var workspaceSchema = z28.preprocess(fromBeforeFolders, workspaceFields);
+var stateSchema = z28.object({ workspaces: z28.record(z28.string(), workspaceSchema) });
 
 // src/workspaces/claims.ts
 var holder = (ws, workspace) => `${ws.options.machineName()}/${workspace.lead}`;
@@ -11516,7 +11682,7 @@ import { join as join29 } from "node:path";
 
 // src/commands/repo.ts
 init_define_HERD_PACKAGE();
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var REPO_HELP = `Usage: herd repo <url or owner/name> [folder]
 
 Checks a repo out in this conversation's folder, on a branch named for the conversation, started
@@ -11530,16 +11696,16 @@ var REPOS_HELP = `Usage: herd repos [--json]
 
 Lists the repos in this conversation's folder, the repos checked out in this machine's root, and
 the repos your owner's herd.config.ts describes, with what each is for. Add one with herd repo.`;
-var repoContextSchema = z28.object({
-  folder: z28.string(),
-  root: z28.string(),
-  branch: z28.string(),
-  legacy: z28.boolean(),
-  legacyReason: z28.string().optional(),
-  recorded: z28.array(z28.object({ folder: z28.string(), remote: z28.string(), branch: z28.string() })),
-  cloned: z28.array(z28.object({ key: z28.string(), remote: z28.string() })),
-  described: z28.array(
-    z28.object({ remote: z28.string(), key: z28.string().nullable(), about: z28.string().optional() })
+var repoContextSchema = z29.object({
+  folder: z29.string(),
+  root: z29.string(),
+  branch: z29.string(),
+  legacy: z29.boolean(),
+  legacyReason: z29.string().optional(),
+  recorded: z29.array(z29.object({ folder: z29.string(), remote: z29.string(), branch: z29.string() })),
+  cloned: z29.array(z29.object({ key: z29.string(), remote: z29.string() })),
+  described: z29.array(
+    z29.object({ remote: z29.string(), key: z29.string().nullable(), about: z29.string().optional() })
   )
 });
 var isUrl = (text4) => /^[a-z][a-z0-9+.-]*:\/\//i.test(text4) || text4.startsWith("/") || /^[^@/\s]+@[^:/\s]+:/.test(text4);
@@ -11596,7 +11762,7 @@ async function runRepo(rest) {
     op: "repo-add",
     repoAdd: { asked, ...folderName !== void 0 ? { folder: folderName } : {} }
   });
-  const lines = z28.array(z28.string()).safeParse(reply.lines);
+  const lines = z29.array(z29.string()).safeParse(reply.lines);
   if (!lines.success) throw new HerdError("The daemon's answer about this repo wasn't readable.");
   console.log(lines.data.join("\n"));
   return 0;
@@ -12775,21 +12941,21 @@ function resolveAttachments(worktree, files) {
 // src/workers.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z29 } from "zod";
-var workerListingSchema = z29.object({
-  workers: z29.array(workerSchema),
-  machines: z29.array(
-    z29.object({
-      id: z29.string(),
-      name: z29.string(),
-      online: z29.boolean(),
-      missing: z29.array(z29.string()),
-      configError: z29.string().optional(),
+import { z as z30 } from "zod";
+var workerListingSchema = z30.object({
+  workers: z30.array(workerSchema),
+  machines: z30.array(
+    z30.object({
+      id: z30.string(),
+      name: z30.string(),
+      online: z30.boolean(),
+      missing: z30.array(z30.string()),
+      configError: z30.string().optional(),
       // Servers from before versions were reported send none.
-      herdVersion: z29.string().nullable().optional()
+      herdVersion: z30.string().nullable().optional()
     })
   ),
-  configType: z29.string()
+  configType: z30.string()
 });
 async function readWorkers(fetch2) {
   const response = await fetch2("/api/workers");
@@ -12857,20 +13023,20 @@ function formatWorkers(listing, current = null) {
   );
   return lines.join("\n");
 }
-var routingCheckSchema = z29.object({
-  suits: z29.array(z29.object({ key: z29.string(), name: z29.string() })),
-  eligible: z29.array(z29.object({ key: z29.string(), name: z29.string() })),
-  removed: z29.array(z29.object({ key: z29.string(), name: z29.string(), rule: z29.string() })),
-  questions: z29.array(
-    z29.object({ id: z29.string(), question: z29.string(), probability: z29.number().nullable() })
+var routingCheckSchema = z30.object({
+  suits: z30.array(z30.object({ key: z30.string(), name: z30.string() })),
+  eligible: z30.array(z30.object({ key: z30.string(), name: z30.string() })),
+  removed: z30.array(z30.object({ key: z30.string(), name: z30.string(), rule: z30.string() })),
+  questions: z30.array(
+    z30.object({ id: z30.string(), question: z30.string(), probability: z30.number().nullable() })
   ),
-  fallback: z29.string().optional(),
-  fits: z29.array(
-    z29.object({
-      key: z29.string(),
-      fit: z29.number(),
-      statement: z29.string().optional(),
-      level: z29.string().optional()
+  fallback: z30.string().optional(),
+  fits: z30.array(
+    z30.object({
+      key: z30.string(),
+      fit: z30.number(),
+      statement: z30.string().optional(),
+      level: z30.string().optional()
     })
   ).optional()
 });
@@ -14254,8 +14420,12 @@ async function runDaemon(args) {
     }),
     access: () => daemon?.configuration().config?.terminals?.remote ?? "drive",
     resolve: async (target) => {
-      if (target.kind !== "conversation") {
-        return { refused: "This machine can't open an agent's sign-in terminal from the web yet." };
+      if (target.kind === "activation") {
+        const cli = clis.find((candidate) => candidate.name === target.agent);
+        if (!cli || !activator) return { refused: "This machine doesn't run that agent." };
+        const terminal = await activator.terminalFor(cli.name, cli.version);
+        if (!terminal) return { refused: "The agent's sign-in didn't start on this machine." };
+        return { terminal, socketPath: await terminals.pathOf(terminal) };
       }
       const workspace = workspaces.get(target.conversationId);
       if (!workspace) return { refused: "This machine doesn't hold that conversation." };
@@ -15321,7 +15491,7 @@ async function runWatch(command, rest) {
 // src/commands/work.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var WORK_HELP = `Usage: herd work <url> [--kind <kind>] [--title "<title>"] [--status <status>]
                        [--detail "<detail>"] [--made] [--phase <phase>]
        herd work --remove <url>
@@ -15413,9 +15583,9 @@ ${WORK_HELP}`
   };
   return { kind: "record", change, json };
 }
-var followSchema = z35.union([
-  z35.object({ following: z35.literal(true) }),
-  z35.object({ following: z35.literal(false), reason: z35.string() })
+var followSchema = z36.union([
+  z36.object({ following: z36.literal(true) }),
+  z36.object({ following: z36.literal(false), reason: z36.string() })
 ]);
 function formatFollow(follow) {
   return follow.following ? "Following it: its reviews, CI and merge will reach herd inbox." : `Not followed: ${follow.reason}`;
@@ -15431,7 +15601,7 @@ function formatWork(work, own) {
   return `  ${parts.join(" \xB7 ")}${work.made ? "  made here" : ""}
     ${work.url}${whose}`;
 }
-var listSchema = z35.array(workObjectSchema);
+var listSchema = z36.array(workObjectSchema);
 async function runWork(rest) {
   const parsed = parseWork(rest);
   if (parsed.kind === "help") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herdingchats/friday",
-  "version": "0.1.688",
+  "version": "0.1.707",
   "description": "Friday, HerdingChats' agent daemon, and the herd command it runs agents with.",
   "license": "MIT",
   "type": "module",
@@ -22,5 +22,5 @@
     "satori": "0.32.0",
     "zod": "4.6.7"
   },
-  "gitHead": "a284c931b34fdaa76115c8d2c91da8b2903d19ff"
+  "gitHead": "092263ddfd4398fa1093a095995b57b617e624d3"
 }

package/terminal-host.mjs

@@ -230,6 +230,16 @@ var TerminalHost = class {
     if (held.info.exited) return;
     held.pty.resize(cols, rows);
     held.term.resize(cols, rows);
+    for (const socket of held.watchers) {
+      socket.write(`${JSON.stringify({ type: "resize", cols, rows })}
+`);
+    }
+  }
+  /** The screen as `attach` and `watch` send it first: its contents, and its size. */
+  async sized(name) {
+    const held = this.get(name);
+    const data = await this.snapshot(name);
+    return { type: "snapshot", data, cols: held.term.cols, rows: held.term.rows };
   }
   subscribe(name, socket) {
     const held = this.get(name);
@@ -253,7 +263,7 @@ var TerminalHost = class {
       return;
     }
     if (size.cols && size.rows) this.resize(name, size.cols, size.rows);
-    socket.write(`${JSON.stringify({ type: "snapshot", data: await this.snapshot(name) })}
+    socket.write(`${JSON.stringify(await this.sized(name))}
 `);
     held.viewers.add(socket);
     held.drivenAt = Date.now();
@@ -294,7 +304,7 @@ var TerminalHost = class {
 `);
       return;
     }
-    socket.write(`${JSON.stringify({ type: "snapshot", data: await this.snapshot(name) })}
+    socket.write(`${JSON.stringify(await this.sized(name))}
 `);
     held.watchers.add(socket);
     held.subscribers.add(socket);