@herdingchats/friday 0.1.581 → 0.1.598

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.581", gitHead: "44cd77d45198d74bbfb12b60b241e35dc7adfdeb" };
+    define_HERD_PACKAGE_default = { version: "0.1.598", gitHead: "7d8c736673ed8d8010c9b9915d30f42b5733edf9" };
   }
 });
 
@@ -2115,21 +2115,21 @@ var init_usb = __esm({
 // ../common-board/src/time.ts
 function when(at, now, theme) {
   if (theme.mode === "live") return ago2(now - at);
-  const day = (time8) => new Intl.DateTimeFormat("en-CA", { timeZone: theme.timeZone }).format(time8);
+  const day2 = (time8) => new Intl.DateTimeFormat("en-CA", { timeZone: theme.timeZone }).format(time8);
   const clock = new Intl.DateTimeFormat("en-US", {
     timeZone: theme.timeZone,
     hour: "numeric",
     minute: "2-digit"
   }).format(at);
-  if (day(at) === day(now)) return clock;
+  if (day2(at) === day2(now)) return clock;
   const weekday = new Intl.DateTimeFormat("en-US", {
     timeZone: theme.timeZone,
     weekday: "short"
   }).format(at);
   return `${weekday} ${clock}`;
 }
-function ago2(ms) {
-  const minutes = Math.floor(Math.max(0, ms) / 6e4);
+function ago2(ms2) {
+  const minutes = Math.floor(Math.max(0, ms2) / 6e4);
   if (minutes < 1) return "just now";
   if (minutes < 60) return `${minutes}m ago`;
   const hours = Math.floor(minutes / 60);
@@ -2385,7 +2385,7 @@ var init_widget = __esm({
 });
 
 // ../common-board/src/widgets/conversations.tsx
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function badge(item) {
   if (pullRequestBadge(item)) {
@@ -2429,10 +2429,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: z27.object({
-        states: z27.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
-        limit: z27.number().int().min(1).max(BOARD_ITEMS).default(4),
-        show: z27.array(z27.enum(DETAILS)).default([...DETAILS])
+      options: z28.object({
+        states: z28.array(conversationStateSchema).min(1).default(["stuck", "working", "waiting", "done"]),
+        limit: z28.number().int().min(1).max(BOARD_ITEMS).default(4),
+        show: z28.array(z28.enum(DETAILS)).default([...DETAILS])
       }),
       reads: ["items", "machines"],
       Component: ({ board, options, theme, now }) => {
@@ -2476,7 +2476,7 @@ var init_conversations = __esm({
 });
 
 // ../common-board/src/widgets/counts.tsx
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var COUNTS, LABELS2, counts;
 var init_counts = __esm({
@@ -2496,8 +2496,8 @@ var init_counts = __esm({
     counts = defineWidget({
       kind: "counts",
       describe: "How many conversations are stuck, unanswered, waiting and working, and done today",
-      options: z28.object({
-        show: z28.array(z28.enum(COUNTS)).min(1).max(5).default([...COUNTS])
+      options: z29.object({
+        show: z29.array(z29.enum(COUNTS)).min(1).max(5).default([...COUNTS])
       }),
       reads: ["counts", "doneToday"],
       Component: ({ board, options, theme }) => {
@@ -2536,7 +2536,7 @@ var init_counts = __esm({
 });
 
 // ../common-board/src/widgets/header.tsx
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function summary(board) {
   const parts = [
@@ -2561,9 +2561,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: z29.object({
-        title: z29.string().min(1).max(40).default(`@${BOT_NAME}`),
-        summary: z29.boolean().default(true)
+      options: z30.object({
+        title: z30.string().min(1).max(40).default(`@${BOT_NAME}`),
+        summary: z30.boolean().default(true)
       }),
       reads: ["counts"],
       Component: ({ board, options, theme, now }) => {
@@ -2581,7 +2581,7 @@ var init_header = __esm({
 });
 
 // ../common-board/src/widgets/machines.tsx
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function usageText(worker) {
   const usage = worker.usage;
@@ -2612,7 +2612,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: z30.object({ limit: z30.number().int().min(1).max(8).default(3) }),
+      options: z31.object({ limit: z31.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));
@@ -2729,9 +2729,9 @@ var init_board2 = __esm({
 });
 
 // ../common-board/src/composition.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function readComposition(stored) {
-  const shape = z31.object({ widgets: z31.array(placedWidgetSchema) }).safeParse(stored);
+  const shape = z32.object({ widgets: z32.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
@@ -2746,11 +2746,11 @@ var init_composition = __esm({
     init_registry();
     MAX_WIDGETS = 12;
     MAX_COMPOSITION_BYTES = 4096;
-    placedWidgetSchema = z31.object({
-      kind: z31.string().min(1),
-      options: z31.record(z31.string(), z31.unknown()).default({})
+    placedWidgetSchema = z32.object({
+      kind: z32.string().min(1),
+      options: z32.record(z32.string(), z32.unknown()).default({})
     });
-    compositionSchema = z31.object({ widgets: z31.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
+    compositionSchema = z32.object({ widgets: z32.array(placedWidgetSchema).max(MAX_WIDGETS) }).superRefine((composition, context2) => {
       if (JSON.stringify(composition).length > MAX_COMPOSITION_BYTES) {
         context2.addIssue({
           code: "custom",
@@ -3031,13 +3031,13 @@ var init_png = __esm({
     "use strict";
     init_define_HERD_PACKAGE();
     CRC_TABLE = (() => {
-      const table = new Uint32Array(256);
+      const table2 = new Uint32Array(256);
       for (let n = 0; n < 256; n++) {
         let c = n;
         for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-        table[n] = c >>> 0;
+        table2[n] = c >>> 0;
       }
-      return table;
+      return table2;
     })();
   }
 });
@@ -3636,7 +3636,7 @@ function dayFolders(home) {
   const days = [];
   for (const year of list(root)) {
     for (const month of list(join2(root, year))) {
-      for (const day of list(join2(root, year, month))) days.push(join2(root, year, month, day));
+      for (const day2 of list(join2(root, year, month))) days.push(join2(root, year, month, day2));
     }
   }
   return days;
@@ -3672,14 +3672,14 @@ var realpath = (path) => {
 };
 function findSessionByCwd(cwd, since, home = codexHome()) {
   const wanted = realpath(cwd);
-  for (const day of dayFolders(home).slice(0, 2)) {
+  for (const day2 of dayFolders(home).slice(0, 2)) {
     let names;
     try {
-      names = readdirSync(day).filter((name) => /^rollout-.*\.jsonl$/.test(name));
+      names = readdirSync(day2).filter((name) => /^rollout-.*\.jsonl$/.test(name));
     } catch {
       continue;
     }
-    const found = names.map((name) => join2(day, name)).filter((path) => {
+    const found = names.map((name) => join2(day2, name)).filter((path) => {
       try {
         return statSync(path).mtimeMs >= since - 2e3;
       } catch {
@@ -3696,10 +3696,10 @@ function findSessionByCwd(cwd, since, home = codexHome()) {
 }
 function findSessionById(id2, home = codexHome()) {
   const suffix = `-${id2}.jsonl`;
-  for (const day of dayFolders(home)) {
+  for (const day2 of dayFolders(home)) {
     try {
-      const name = readdirSync(day).find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
-      if (name) return join2(day, name);
+      const name = readdirSync(day2).find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
+      if (name) return join2(day2, name);
     } catch {
     }
   }
@@ -4965,7 +4965,7 @@ function activateDecision(request, code) {
     }
   };
 }
-var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 var label = (agent) => AGENTS[agent]?.label ?? agent;
 var Activator = class {
   constructor(options) {
@@ -5290,7 +5290,7 @@ function askToActivate(herdHome2, now = Date.now()) {
   requestActivation(herdHome2, now);
   return now;
 }
-var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep2 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 function settledLine(cli, activation) {
   if (activation.state === "activated") return `${label2(cli)} is activated.`;
   return `${label2(cli)} ${activationText(cli, activation).replace(" there", " on this computer")}.`;
@@ -6178,11 +6178,11 @@ var Supervisor = class {
     await this.stopLeftoverDaemon();
     this.save();
     this.spawnDaemon();
-    const schedule = (ms) => {
+    const schedule = (ms2) => {
       this.checkTimer = setTimeout(async () => {
         await this.check().catch((error) => this.log(`The release check failed: ${error}`));
         if (!this.stopping) schedule(this.options.checkMs ?? 12e4);
-      }, ms);
+      }, ms2);
     };
     schedule(this.options.firstCheckMs ?? 5e3);
   }
@@ -7196,7 +7196,7 @@ async function registerRunner({
   url = buildsUrl(),
   fetchImpl = fetch,
   say = (line2) => console.log(line2),
-  sleep: sleep8 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms)),
+  sleep: sleep8 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2)),
   pollMs = 2e3,
   waitMs = 15 * 60 * 1e3
 }) {
@@ -7233,6 +7233,120 @@ async function registerRunner({
   );
 }
 
+// src/build-speed.ts
+init_define_HERD_PACKAGE();
+import { z as z25 } from "zod";
+var ms = z25.number().int().nullable();
+var figuresSchema = z25.object({ count: z25.number().int(), median: ms, p90: ms });
+var buildTimesSchema = z25.object({ run: figuresSchema, push: figuresSchema });
+var stepFiguresSchema = z25.object({
+  ran: z25.number().int(),
+  remembered: z25.number().int(),
+  median: ms,
+  p90: ms,
+  overBudget: z25.number().int()
+});
+var kindSchema = z25.object({
+  builds: z25.object({ current: buildTimesSchema, previous: buildTimesSchema }),
+  steps: z25.array(
+    z25.object({ label: z25.string(), current: stepFiguresSchema, previous: stepFiguresSchema })
+  ),
+  overBudget: z25.array(
+    z25.object({ label: z25.string(), current: z25.number().int(), previous: z25.number().int() })
+  )
+});
+var range = z25.object({ from: z25.number(), to: z25.number() });
+var speedReportSchema = z25.object({
+  periods: z25.object({ current: range, previous: range }),
+  repos: z25.array(
+    z25.object({
+      repo: z25.string(),
+      capped: z25.boolean(),
+      pullRequests: kindSchema,
+      main: kindSchema
+    })
+  )
+});
+async function fetchSpeed(key, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchImpl(`${key.url}/speed`, {
+      headers: { Authorization: `Bearer ${key.key}` }
+    });
+  } catch (error) {
+    throw new HerdError(`Couldn't reach the build service at ${key.url}: ${String(error)}`);
+  }
+  if (response.status === 404)
+    throw new HerdError(
+      "The build service doesn't accept this machine's runner key, as after it was revoked. Register it again with herd builds register."
+    );
+  if (!response.ok)
+    throw new HerdError(`The build service couldn't give build speed (${response.status}).`);
+  return speedReportSchema.parse(await response.json());
+}
+function duration(value) {
+  if (value === null) return "-";
+  if (value < 1e3) return `${value}ms`;
+  if (value < 6e4) return `${(value / 1e3).toFixed(1)}s`;
+  const seconds = Math.round(value / 1e3);
+  return `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+function table(rows) {
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, i) => {
+      widths[i] = Math.max(widths[i] ?? 0, cell.length);
+    });
+  }
+  return rows.map(
+    (row) => row.map((cell, i) => i === 0 ? cell.padEnd(widths[i] ?? 0) : cell.padStart(widths[i] ?? 0)).join("  ").trimEnd()
+  );
+}
+var day = (time8) => new Date(time8).toISOString().slice(0, 10);
+function kindLines(name, kind) {
+  const { current, previous } = kind.builds;
+  const rows = [
+    [name, "median", "p90", "builds", "|", "median", "p90", "builds"],
+    ...["run", "push"].map((which) => [
+      which === "run" ? "  start to finish" : "  push to finish",
+      duration(current[which].median),
+      duration(current[which].p90),
+      String(current[which].count),
+      "|",
+      duration(previous[which].median),
+      duration(previous[which].p90),
+      String(previous[which].count)
+    ]),
+    ["  steps, slowest first", "", "", "ran/rem", "|", "", "", "ran/rem"],
+    ...kind.steps.map((step) => [
+      `  ${step.label}`,
+      duration(step.current.median),
+      duration(step.current.p90),
+      `${step.current.ran}/${step.current.remembered}`,
+      "|",
+      duration(step.previous.median),
+      duration(step.previous.p90),
+      `${step.previous.ran}/${step.previous.remembered}`
+    ])
+  ];
+  const over = kind.overBudget.map((s) => `${s.label} ${s.current}x (${s.previous}x before)`);
+  return [...table(rows), ...over.length ? [`  over budget most often: ${over.join(", ")}`] : []];
+}
+function formatSpeed(report) {
+  const { current, previous } = report.periods;
+  const lines = [
+    `Last 14 days (${day(current.from)} to ${day(current.to)}) | 14 days before (${day(previous.from)} to ${day(previous.to)}).`,
+    "Builds that passed or failed; steps only when they ran, not when remembered."
+  ];
+  if (report.repos.length === 0) lines.push("", "No repos are built for this machine's owner yet.");
+  for (const repo of report.repos) {
+    lines.push("", `${repo.repo}${repo.capped ? " (only the newest builds count)" : ""}`);
+    lines.push(...kindLines("pull requests", repo.pullRequests), "");
+    lines.push(...kindLines("main", repo.main));
+  }
+  return lines.join("\n");
+}
+
 // src/builds-admin.ts
 init_define_HERD_PACKAGE();
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
@@ -7270,6 +7384,14 @@ Usage:
   herd builds register     Register it: prints a link its owner opens to approve it, then waits
                            and keeps the runner key. Only registered runners are offered builds,
                            and only the workspace's admin can register one.
+  herd builds speed [--json]
+                           How long builds take: the median and 90th percentile of build time,
+                           start to finish and push to finish, for pull requests and main apart,
+                           over the last 14 days against the 14 before, and each step's when it
+                           ran, slowest first, with how often it was remembered or over budget.
+                           Read with this machine's runner key, so only a registered runner can.
+                           --json prints the figures as JSON. People see them on
+                           /manage/speed of the build service.
 
 How many builds a runner takes at once is "builds" in ~/.herd/herd.config.ts: true for one, or
 { max: <n> } for up to 4.`;
@@ -7295,6 +7417,16 @@ async function runBuilds(args) {
     console.log("The daemon connects as a runner once it restarts.");
     return 0;
   }
+  if (sub === "speed") {
+    const key2 = readRunnerKey();
+    if (!key2)
+      throw new HerdError(
+        "Build speed is read with a runner key, and this machine isn't a build runner. herd builds register makes it one."
+      );
+    const report = await fetchSpeed(key2);
+    console.log(args.includes("--json") ? JSON.stringify(report, null, 2) : formatSpeed(report));
+    return 0;
+  }
   if (sub !== void 0) throw new HerdError(`herd builds doesn't understand "${sub}".
 
 ${HELP3}`);
@@ -7556,7 +7688,7 @@ function withStartKey(command, startKey) {
   return startKey ? `HERD_START=${startKey} ${command}` : command;
 }
 var DEFAULT_TIMING = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep3 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep3 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 var EXIT_WAIT_MS = 5e3;
 var AgentDriver = class {
   constructor(terminals, timing = {}) {
@@ -7578,8 +7710,8 @@ var AgentDriver = class {
   async read(name) {
     return readClaudeScreen(await this.terminals.screen(name));
   }
-  async until(name, check2, ms) {
-    const end = Date.now() + ms;
+  async until(name, check2, ms2) {
+    const end = Date.now() + ms2;
     for (; ; ) {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
@@ -7862,7 +7994,7 @@ function writeAgyFiles(worktree, herd) {
 // src/agy-driver.ts
 var AGY_FLAGS = `--dangerously-skip-permissions --settings ${AGY_SETTINGS_FILE}`;
 var DEFAULT_TIMING2 = { settleMs: 800, pollMs: 150, startMs: 6e4, confirmMs: 3e3 };
-var sleep4 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep4 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 var EXIT_WAIT_MS2 = 5e3;
 var AgyDriver = class {
   constructor(terminals, timing = {}) {
@@ -7879,8 +8011,8 @@ var AgyDriver = class {
   async read(name) {
     return readAgyScreen(await this.terminals.screen(name));
   }
-  async until(name, check2, ms) {
-    const end = Date.now() + ms;
+  async until(name, check2, ms2) {
+    const end = Date.now() + ms2;
     for (; ; ) {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
@@ -8854,7 +8986,7 @@ var DEFAULT_TIMING3 = {
   confirmMs: 8e3,
   pasteMs: 600
 };
-var sleep5 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep5 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 var EXIT_WAIT_MS3 = 5e3;
 var CodexDriver = class {
   constructor(terminals, timing = {}) {
@@ -8871,8 +9003,8 @@ var CodexDriver = class {
   async read(name) {
     return readCodexScreen(await this.terminals.screen(name));
   }
-  async until(name, check2, ms) {
-    const end = Date.now() + ms;
+  async until(name, check2, ms2) {
+    const end = Date.now() + ms2;
     for (; ; ) {
       const reading = await this.read(name);
       if (check2(reading)) return reading;
@@ -9334,7 +9466,7 @@ function machineFolderProblem(root, convos, checks = {}) {
 async function waitForFolders(problem, {
   timeoutMs = FOLDER_WAIT_MS,
   pollMs = 2e3,
-  sleep: sleep8 = (ms) => new Promise((done) => setTimeout(done, ms)),
+  sleep: sleep8 = (ms2) => new Promise((done) => setTimeout(done, ms2)),
   now = Date.now,
   log = (line2) => console.log(line2)
 } = {}) {
@@ -9744,7 +9876,7 @@ var hostsDir = () => join25(herdHome(), "terminals");
 var legacyHostSocketPath = () => join25(herdHome(), "terminals.sock");
 var currentHostSocketPath = (version = hostVersion()) => join25(hostsDir(), `${version}.sock`);
 var speaksProtocol = (protocol) => protocol === HOST_PROTOCOL || protocol === HOST_PROTOCOL - 1;
-var sleep6 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep6 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
 function askHost(path, request) {
   return new Promise((resolve7, reject) => {
     const socket = connect2(path);
@@ -10045,7 +10177,7 @@ init_define_HERD_PACKAGE();
 init_src();
 init_self();
 import { join as join26 } from "node:path";
-import { z as z25 } from "zod";
+import { z as z26 } 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
@@ -10111,16 +10243,16 @@ var WAITING_NOTIFICATIONS = /* @__PURE__ */ new Set([
   "agent_needs_input",
   "elicitation_dialog"
 ]);
-var agentMessageSchema = z25.object({
-  text: z25.string().trim().min(1).max(12e3),
-  files: z25.array(z25.object({ path: z25.string().min(1), title: z25.string().optional() })).max(10).optional()
+var agentMessageSchema = z26.object({
+  text: z26.string().trim().min(1).max(12e3),
+  files: z26.array(z26.object({ path: z26.string().min(1), title: z26.string().optional() })).max(10).optional()
 });
-var workspaceRepoSchema = z25.object({
-  folder: z25.string(),
-  remote: z25.string(),
-  branch: z25.string(),
+var workspaceRepoSchema = z26.object({
+  folder: z26.string(),
+  remote: z26.string(),
+  branch: z26.string(),
   /** For a conversation from before folders: the name of the repo it was allowed as. */
-  name: z25.string().optional()
+  name: z26.string().optional()
 });
 function fromBeforeFolders(raw) {
   if (!raw || typeof raw !== "object" || "folder" in raw) return raw;
@@ -10141,106 +10273,106 @@ function fromBeforeFolders(raw) {
     legacy: true
   };
 }
-var workspaceFields = z25.object({
-  conversationId: z25.string(),
+var workspaceFields = z26.object({
+  conversationId: z26.string(),
   /** The conversation's own folder, where its terminals start. */
-  folder: z25.string(),
+  folder: z26.string(),
   /** The repos in it, in the order they were added. */
-  worktrees: z25.array(workspaceRepoSchema).default([]),
+  worktrees: z26.array(workspaceRepoSchema).default([]),
   /** A conversation from before folders, which works in its one repo's worktree. */
-  legacy: z25.boolean().default(false),
-  lead: z25.string(),
-  secret: z25.string(),
-  readSeq: z25.number(),
-  claimId: z25.string().nullable(),
-  claimRenewedAt: z25.number(),
-  started: z25.boolean(),
+  legacy: z26.boolean().default(false),
+  lead: z26.string(),
+  secret: z26.string(),
+  readSeq: z26.number(),
+  claimId: z26.string().nullable(),
+  claimRenewedAt: z26.number(),
+  started: z26.boolean(),
   /** Messages to deliver once the current turn ends. */
-  deferred: z25.boolean(),
+  deferred: z26.boolean(),
   /** A `herd run` command finished, which the agent hears about even with nothing to claim. */
-  terminalNotice: z25.boolean().default(false),
-  status: z25.string().nullable(),
+  terminalNotice: z26.boolean().default(false),
+  status: z26.string().nullable(),
   /** Set once the thread has been told the agent is waiting, so it's told once per wait. */
-  toldWaiting: z25.boolean(),
-  runs: z25.array(z25.object({ name: z25.string(), secret: z25.string(), reported: z25.boolean() })),
+  toldWaiting: z26.boolean(),
+  runs: z26.array(z26.object({ name: z26.string(), secret: z26.string(), reported: z26.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: z25.number().default(0),
+  usageAt: z26.number().default(0),
   /** The lead agent's Claude Code session, as its `SessionStart` hook reported it. */
-  sessionId: z25.string().nullable().default(null),
+  sessionId: z26.string().nullable().default(null),
   /** When the agent's last turn ended with nothing left to do, for shutting it down later. */
-  idleSince: z25.number().nullable().default(null),
+  idleSince: z26.number().nullable().default(null),
   /** The agent ran `herd exit`, so its session ends after this turn. */
-  exitRequested: z25.boolean().default(false),
+  exitRequested: z26.boolean().default(false),
   /** Whether the agent sent anything with `herd send` this turn. */
-  sentThisTurn: z25.boolean().default(false),
+  sentThisTurn: z26.boolean().default(false),
   /** Whether it's been asked this turn to reply. */
-  askedToReply: z25.boolean().default(false),
+  askedToReply: z26.boolean().default(false),
   /** Whether it ran `herd handled` this turn, which handles the turn's messages with no reply. */
-  handledThisTurn: z25.boolean().default(false),
+  handledThisTurn: z26.boolean().default(false),
   /** The newest waiting message it's been pointed at, so one arrival is pointed out once. */
-  nudgedSeq: z25.number().default(0),
+  nudgedSeq: z26.number().default(0),
   /** When a `Stop` hook last ended a turn. */
-  hookIdleAt: z25.number().default(0),
+  hookIdleAt: z26.number().default(0),
   /** When a turn last ended with background work still running, which keeps its messages held. */
-  pausedAt: z25.number().nullable().default(null),
+  pausedAt: z26.number().nullable().default(null),
   /** The version of the terminal host the lead terminal was opened in, if it was recorded. */
-  hostVersion: z25.string().nullable().default(null),
+  hostVersion: z26.string().nullable().default(null),
   /** When a notice last failed for a reason other than someone's draft, to wait before retrying. */
-  noticeFailedAt: z25.number().nullable().default(null),
+  noticeFailedAt: z26.number().nullable().default(null),
   /** Why the last notice failed, so the history records each reason once, not every attempt. */
-  noticeFailure: z25.string().nullable().default(null),
+  noticeFailure: z26.string().nullable().default(null),
   /** A recorded dialog herd pressed its way out of, so a dialog that stays isn't pressed again. */
-  closedDialog: z25.string().nullable().default(null),
+  closedDialog: z26.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: z25.number().default(0),
+  promptsOpen: z26.number().default(0),
   /** The messages the latest claim or addition took, for choosing which notice to type. */
-  claimedSeqs: z25.array(z25.number()).default([]),
+  claimedSeqs: z26.array(z26.number()).default([]),
   /** The investigator looking at a screen herd can't read, from opening to the owner's answer. */
-  investigation: z25.object({
-    terminal: z25.string(),
-    secret: z25.string(),
-    startedAt: z25.number(),
+  investigation: z26.object({
+    terminal: z26.string(),
+    secret: z26.string(),
+    startedAt: z26.number(),
     /** The stuck screen when it opened, saved with the key if the owner approves one. */
-    screen: z25.array(z25.string()),
-    key: z25.string().nullable(),
-    promptId: z25.string().nullable()
+    screen: z26.array(z26.string()),
+    key: z26.string().nullable(),
+    promptId: z26.string().nullable()
   }).nullable().default(null),
   /** The failed notice an investigator was opened for, so each failure gets one. */
-  investigatedFailure: z25.number().nullable().default(null),
+  investigatedFailure: z26.number().nullable().default(null),
   /** The agent CLI this conversation's worker runs, as its offer named it. */
-  agent: z25.string().default("claude-code"),
+  agent: z26.string().default("claude-code"),
   /** Whether what the current claim took needs a reply, which other agents' messages don't. */
-  replyWanted: z25.boolean().default(true),
+  replyWanted: z26.boolean().default(true),
   /** For a delegate: the conversation that started it, which its starting prompt names. */
-  parent: z25.string().nullable().default(null),
+  parent: z26.string().nullable().default(null),
   /** Codex's session file for this worktree, once found, and how far the daemon has read it. */
-  codexFile: z25.string().nullable().default(null),
-  codexOffset: z25.number().default(0),
+  codexFile: z26.string().nullable().default(null),
+  codexOffset: z26.number().default(0),
   /** When the agent was last started, so Codex's new session file is told from older ones. */
-  agentStartedAt: z25.number().default(0),
+  agentStartedAt: z26.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: z25.string().nullable().default(null),
+  startKey: z26.string().nullable().default(null),
   /** Whether the current start has checked in. One from before keys counts as proven. */
-  startProven: z25.boolean().default(true),
+  startProven: z26.boolean().default(true),
   /** When the check-in window of an unproven start began, or null once it's proven or for none. */
-  checkInFrom: z25.number().nullable().default(null),
+  checkInFrom: z26.number().nullable().default(null),
   /** Whether this start has been flagged as needing someone at its terminal, so it's said once. */
-  needsAttention: z25.boolean().default(false),
+  needsAttention: z26.boolean().default(false),
   /** What agy's status line last said its agent was doing, and when. */
-  agentState: z25.enum(["working", "idle"]).nullable().default(null),
-  agentStateAt: z25.number().default(0)
+  agentState: z26.enum(["working", "idle"]).nullable().default(null),
+  agentStateAt: z26.number().default(0)
 });
-var workspaceSchema = z25.preprocess(fromBeforeFolders, workspaceFields);
-var stateSchema = z25.object({ workspaces: z25.record(z25.string(), workspaceSchema) });
+var workspaceSchema = z26.preprocess(fromBeforeFolders, workspaceFields);
+var stateSchema = z26.object({ workspaces: z26.record(z26.string(), workspaceSchema) });
 
 // src/workspaces/claims.ts
 var holder = (ws, workspace) => `${ws.options.machineName()}/${workspace.lead}`;
@@ -11335,19 +11467,19 @@ function resolveAttachments(worktree, files) {
 // src/workers.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z26 } from "zod";
-var workerListingSchema = z26.object({
-  workers: z26.array(workerSchema),
-  machines: z26.array(
-    z26.object({
-      id: z26.string(),
-      name: z26.string(),
-      online: z26.boolean(),
-      missing: z26.array(z26.string()),
-      configError: z26.string().optional()
+import { z as z27 } from "zod";
+var workerListingSchema = z27.object({
+  workers: z27.array(workerSchema),
+  machines: z27.array(
+    z27.object({
+      id: z27.string(),
+      name: z27.string(),
+      online: z27.boolean(),
+      missing: z27.array(z27.string()),
+      configError: z27.string().optional()
     })
   ),
-  configType: z26.string()
+  configType: z27.string()
 });
 async function readWorkers(fetch2) {
   const response = await fetch2("/api/workers");
@@ -11411,20 +11543,20 @@ function formatWorkers(listing, current = null) {
   );
   return lines.join("\n");
 }
-var routingCheckSchema = z26.object({
-  suits: z26.array(z26.object({ key: z26.string(), name: z26.string() })),
-  eligible: z26.array(z26.object({ key: z26.string(), name: z26.string() })),
-  removed: z26.array(z26.object({ key: z26.string(), name: z26.string(), rule: z26.string() })),
-  questions: z26.array(
-    z26.object({ id: z26.string(), question: z26.string(), probability: z26.number().nullable() })
+var routingCheckSchema = z27.object({
+  suits: z27.array(z27.object({ key: z27.string(), name: z27.string() })),
+  eligible: z27.array(z27.object({ key: z27.string(), name: z27.string() })),
+  removed: z27.array(z27.object({ key: z27.string(), name: z27.string(), rule: z27.string() })),
+  questions: z27.array(
+    z27.object({ id: z27.string(), question: z27.string(), probability: z27.number().nullable() })
   ),
-  fallback: z26.string().optional(),
-  fits: z26.array(
-    z26.object({
-      key: z26.string(),
-      fit: z26.number(),
-      statement: z26.string().optional(),
-      level: z26.string().optional()
+  fallback: z27.string().optional(),
+  fits: z27.array(
+    z27.object({
+      key: z27.string(),
+      fit: z27.number(),
+      statement: z27.string().optional(),
+      level: z27.string().optional()
     })
   ).optional()
 });
@@ -13088,11 +13220,11 @@ function agyAnswer(event2, output2) {
 }
 
 // src/hook-client.ts
-var sleep7 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
-function within2(promise, ms) {
+var sleep7 = (ms2) => new Promise((resolve7) => setTimeout(resolve7, ms2));
+function within2(promise, ms2) {
   let timer;
   const timeout = new Promise((resolve7) => {
-    timer = setTimeout(() => resolve7(null), ms);
+    timer = setTimeout(() => resolve7(null), ms2);
   });
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
@@ -13625,7 +13757,7 @@ async function runTerminalHost(rest) {
 // src/commands/repo.ts
 init_define_HERD_PACKAGE();
 import { join as join35 } from "node:path";
-import { z as z32 } from "zod";
+import { z as z33 } 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
@@ -13639,16 +13771,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 = z32.object({
-  folder: z32.string(),
-  root: z32.string(),
-  branch: z32.string(),
-  legacy: z32.boolean(),
-  legacyReason: z32.string().optional(),
-  recorded: z32.array(z32.object({ folder: z32.string(), remote: z32.string(), branch: z32.string() })),
-  cloned: z32.array(z32.object({ key: z32.string(), remote: z32.string() })),
-  described: z32.array(
-    z32.object({ remote: z32.string(), key: z32.string().nullable(), about: z32.string().optional() })
+var repoContextSchema = z33.object({
+  folder: z33.string(),
+  root: z33.string(),
+  branch: z33.string(),
+  legacy: z33.boolean(),
+  legacyReason: z33.string().optional(),
+  recorded: z33.array(z33.object({ folder: z33.string(), remote: z33.string(), branch: z33.string() })),
+  cloned: z33.array(z33.object({ key: z33.string(), remote: z33.string() })),
+  described: z33.array(
+    z33.object({ remote: z33.string(), key: z33.string().nullable(), about: z33.string().optional() })
   )
 });
 var isUrl = (text4) => /^[a-z][a-z0-9+.-]*:\/\//i.test(text4) || text4.startsWith("/") || /^[^@/\s]+@[^:/\s]+:/.test(text4);
@@ -14018,7 +14150,7 @@ async function runWatch(command, rest) {
 // src/commands/work.ts
 init_define_HERD_PACKAGE();
 init_src();
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var WORK_HELP = `Usage: herd work <url> [--kind <kind>] [--title "<title>"] [--status <status>]
                        [--detail "<detail>"] [--made] [--phase <phase>]
        herd work --remove <url>
@@ -14110,9 +14242,9 @@ ${WORK_HELP}`
   };
   return { kind: "record", change, json };
 }
-var followSchema = z33.union([
-  z33.object({ following: z33.literal(true) }),
-  z33.object({ following: z33.literal(false), reason: z33.string() })
+var followSchema = z34.union([
+  z34.object({ following: z34.literal(true) }),
+  z34.object({ following: z34.literal(false), reason: z34.string() })
 ]);
 function formatFollow(follow) {
   return follow.following ? "Following it: its reviews, CI and merge will reach herd inbox." : `Not followed: ${follow.reason}`;
@@ -14128,7 +14260,7 @@ function formatWork(work, own) {
   return `  ${parts.join(" \xB7 ")}${work.made ? "  made here" : ""}
     ${work.url}${whose}`;
 }
-var listSchema = z33.array(workObjectSchema);
+var listSchema = z34.array(workObjectSchema);
 async function runWork(rest) {
   const parsed = parseWork(rest);
   if (parsed.kind === "help") {
@@ -14377,8 +14509,9 @@ On this computer:
                         Run this machine's daemon, working from its root folder. Repos given with
                         --repo are only listed as known, since herd works in its own clones
   attach [<terminal>]   Watch or take over a terminal. Ctrl+\\ detaches. With no name, lists them
-  builds [register]     Whether this machine is a build runner, or register it, with its owner's
-                        approval in the browser. See builds --help
+  builds [register|speed]
+                        Whether this machine is a build runner, register it, with its owner's
+                        approval in the browser, or show how long builds take. See builds --help
   setup                 Show what's set up for Friday and what's left, with how to do each step.
                         --json prints it as JSON. Inside a terminal, it's your owner's
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herdingchats/friday",
-  "version": "0.1.581",
+  "version": "0.1.598",
   "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": "44cd77d45198d74bbfb12b60b241e35dc7adfdeb"
+  "gitHead": "7d8c736673ed8d8010c9b9915d30f42b5733edf9"
 }