@herdingchats/friday 0.1.563 → 0.1.569

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.563", gitHead: "055f38c1feb0ea86dac8b463c249d3f7cd782018" };
+    define_HERD_PACKAGE_default = { version: "0.1.569", gitHead: "ac28f0e97b92fbe2178387595a511d35c3ae4953" };
   }
 });
 
@@ -1319,6 +1319,19 @@ var init_events = __esm({
       }),
       event("terminal.exited", { terminalId: nonEmpty6, exitCode: z12.number().int().nullable() }),
       event("terminal.notice_failed", { terminalId: nonEmpty6, reason: nonEmpty6 }),
+      /**
+       * The agent's start didn't check in with `herd inbox` within its window, so it looks like it
+       * needs someone at its terminal. `agent` is its CLI's name, and `detail` what the screen showed,
+       * when herd recognized it.
+       */
+      event("terminal.needs_attention", {
+        terminalId: nonEmpty6,
+        agent: nonEmpty6,
+        machineName: nonEmpty6,
+        detail: z12.string().max(200).optional()
+      }),
+      /** A start that needed attention checked in after all. */
+      event("terminal.checked_in", { terminalId: nonEmpty6 }),
       /** The daemon closed one of Claude Code's own dialogs that it has recorded, named by its title. */
       event("terminal.dialog_closed", { terminalId: nonEmpty6, dialog: nonEmpty6 }),
       // A subscribed event that didn't wake the conversation, with the reason. One that woke it is a
@@ -1466,6 +1479,9 @@ var init_conversation_state = __esm({
       "author_not_linked",
       // The only agents that could take it showed their own sign-in, so a person has to sign in.
       "agent_signed_out",
+      // Its agent started and never checked in with `herd inbox`, so it looks like it needs someone
+      // at its terminal.
+      "agent_needs_attention",
       // The only machines that could take it have a folder that isn't there, such as a drive not
       // yet mounted.
       "folder_unavailable",
@@ -1568,6 +1584,7 @@ var init_conversation_state = __esm({
       author_not_linked: "the author's account isn't linked",
       delegate_waiting: "a delegate is waiting on someone",
       agent_signed_out: "its agent isn't signed in on its machine",
+      agent_needs_attention: "its agent looks like it needs someone at its terminal",
       folder_unavailable: "its machine's folder isn't there",
       no_suitable_worker: "no worker may take it under its configuration",
       notice_failed: "a notice didn't reach the agent's terminal",
@@ -3156,6 +3173,7 @@ import { spawn as spawn6 } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname10, join as join14 } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { z as z22 } from "zod";
 
 // src/auth.ts
@@ -3384,7 +3402,7 @@ var HERD_FLAGS = {
   persona: []
 };
 var FRIDAY_FLAGS = {
-  start: ["--agents"],
+  start: ["--agents", "--config"],
   stop: [],
   status: [],
   logs: ["--follow", "-f", "-n"]
@@ -4472,6 +4490,8 @@ var localRequestSchema = z19.object({
     "repo",
     "activate"
   ]),
+  // The key of the agent's start, from `HERD_START`, which `herd inbox` proves the start with.
+  start: z19.string().min(1).max(100).optional(),
   // `herd repo`: the repo it added to the conversation's folder, for the daemon to record.
   repo: z19.object({
     remote: z19.string().min(1).max(500),
@@ -4820,6 +4840,50 @@ async function permissionHook(raw, options = {}) {
   }
 }
 
+// src/timing.ts
+init_define_HERD_PACKAGE();
+var CHECK_IN_MS = 15e3;
+var VARIABLES = {
+  settleMs: "HERD_SETTLE_MS",
+  pollMs: "HERD_POLL_MS",
+  confirmMs: "HERD_CONFIRM_MS",
+  pasteMs: "HERD_PASTE_MS",
+  renewMs: "HERD_RENEW_MS",
+  hookSettleMs: "HERD_HOOK_SETTLE_MS",
+  agyIdleSettleMs: "HERD_AGY_IDLE_SETTLE_MS",
+  promptPollMs: "HERD_PROMPT_POLL_MS",
+  noticeRetryMs: "HERD_NOTICE_RETRY_MS",
+  investigateAfterMs: "HERD_INVESTIGATE_AFTER_MS",
+  idleMs: "HERD_IDLE_MS",
+  watchMs: "HERD_WATCH_MS",
+  usageReportMs: "HERD_USAGE_REPORT_MS",
+  usageStaleMs: "HERD_USAGE_STALE_MS",
+  activationMs: "HERD_ACTIVATION_MS",
+  activationPollMs: "HERD_ACTIVATION_POLL_MS",
+  signInRestartMs: "HERD_SIGN_IN_RESTART_MS",
+  checkInMs: "HERD_CHECK_IN_MS",
+  machineCheckMs: "HERD_MACHINE_CHECK_MS"
+};
+function timingFromEnv(env) {
+  const timing = {};
+  for (const [key, name] of Object.entries(VARIABLES)) {
+    const raw = env[name];
+    if (raw === void 0 || raw === "") continue;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new HerdError(`${name} must be a number of milliseconds, not "${raw}".`);
+    }
+    timing[key] = value;
+  }
+  return timing;
+}
+function driverTiming(timing) {
+  const { settleMs, pollMs, confirmMs } = timing;
+  return Object.fromEntries(
+    Object.entries({ settleMs, pollMs, confirmMs }).filter(([, value]) => value !== void 0)
+  );
+}
+
 // src/activation.ts
 var ACTIVATION_DEADLINE_MS = 3 * 60 * 1e3;
 var ACTIVATION_POLL_MS = 500;
@@ -5026,6 +5090,7 @@ var Activator = class {
     const { agent } = current;
     const deadline = Date.now() + (this.options.deadlineMs ?? ACTIVATION_DEADLINE_MS);
     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;
     let seen = "didnt_start";
     let startedAt = 0;
@@ -5060,7 +5125,7 @@ var Activator = class {
     await start();
     while (!current.checkedIn && Date.now() < deadline && !this.stopped) {
       const reading = await driver.read(current.terminal).catch(() => null);
-      if (reading?.state === "signed_out") {
+      if (reading?.state === "signed_out" && Date.now() - startedAt >= checkInMs) {
         seen = "signed_out";
         if (!signingIn) {
           signingIn = true;
@@ -5170,16 +5235,18 @@ async function chooseAgents(options, print) {
   }
   const saved = loaded.status === "ok" ? loaded.config : void 0;
   const choices = agentChoices(installed, saved);
-  const asked = options.given ? null : await (options.pick?.(choices) ?? Promise.resolve(null));
+  const asked = options.given || !options.ask ? null : await (options.pick?.(choices) ?? Promise.resolve(null));
   const shares = options.given ?? asked ?? // No terminal: what was chosen before, or what's installed.
   Object.fromEntries(choices.map((choice) => [choice.cli, choice.share]));
-  if (!sameChoice(saved, shares) || !existsSync5(options.configPath)) {
+  const choosing = options.ask || options.given !== void 0;
+  if (choosing && (!sameChoice(saved, shares) || !existsSync5(options.configPath))) {
     mkdirSync6(dirname6(options.configPath), { recursive: true, mode: 448 });
     writeFileSync5(options.configPath, configSource(withChoice(saved, shares)), { mode: 384 });
   }
   const chosen = ADAPTERS.map(({ cli }) => cli).filter((cli) => (shares[cli] ?? "off") !== "off");
+  const change = options.ask ? "" : ` ${START_COMMAND} --config changes that.`;
   print(
-    chosen.length > 0 ? `This machine runs ${chosen.map((cli) => `${label2(cli)} (${SHARE_LABELS[shares[cli]]})`).join(", ")}.` : "This machine runs no agents, so it takes no work. Run this again to choose some."
+    chosen.length > 0 ? `This machine runs ${chosen.map((cli) => `${label2(cli)} (${SHARE_LABELS[shares[cli]]})`).join(", ")}.${change}` : `This machine runs no agents, so it takes no work. ${START_COMMAND} --config chooses some.`
   );
   return chosen;
 }
@@ -5888,16 +5955,25 @@ async function runStart(options) {
   const existing = readRoot2(paths);
   const wanted = chooseRoot(options.cwd, options.home);
   const running = runningSupervisor(paths);
+  let moving = false;
   if (existing && real(existing) !== real(wanted)) {
     print(`This machine's root is ${existing}, which holds the repos Friday works on.`);
-    if (running) {
-      print(`Friday is running there, version ${running.version}, so nothing changed.`);
-      await waitForAgents(options, await chooseAndAsk(options, print), print);
-      await printSetup(options, print);
-      return 0;
+    moving = await options.confirm?.(
+      `Make ${wanted} the root instead? Conversations already going carry on where they are.`
+    ) ?? false;
+    if (!moving) {
+      print(
+        options.confirm ? "The root stays where it is." : `Run this in a terminal to move the root to ${wanted}.`
+      );
+      if (running) {
+        print(`Friday is running there, version ${running.version}, so nothing changed.`);
+        await waitForAgents(options, await chooseAndAsk(options, print), print);
+        await printSetup(options, print);
+        return 0;
+      }
     }
   }
-  const root = existing ?? wanted;
+  const root = moving ? wanted : existing ?? wanted;
   if (running && root === existing) {
     print(`Friday is running from ${root}, version ${running.version}. Nothing changed.`);
     await waitForAgents(options, await chooseAndAsk(options, print), print);
@@ -5906,6 +5982,7 @@ async function runStart(options) {
   }
   const repo = insideWorkTree(root);
   if (repo) {
+    if (moving) print("The root stays where it is.");
     throw new StartError(
       `${root} is inside the git repo ${repo}, so it can't be the machine's root: every conversation would load that repo's settings. Run ${START_COMMAND} in a folder outside any repo, such as the one that holds your checkouts, like ~/code.`
     );
@@ -5929,13 +6006,18 @@ async function runStart(options) {
       `Stopped the old daemon: removed ${retired.join(" and ")}. Its checkout is left as it was.`
     );
   await ensureInstalled(options, print);
-  mkdirSync10(root, { recursive: true });
-  writeRoot(paths, root);
   const command = [process.execPath, binOf(paths.current, "friday"), "supervise"];
   const env = { HERD_HOME: paths.herdHome, ...options.env };
   const service = (options.service ?? defaultService(options))(command, env);
+  if (moving && running) {
+    print(`Stopping Friday at ${existing} to start it again from ${root}.`);
+    await service.stop();
+    await stopped(options);
+  }
+  mkdirSync10(root, { recursive: true });
+  writeRoot(paths, root);
   const changed = await service.install();
-  await service.start(changed);
+  await service.start(changed || moving);
   print(
     `Friday is running from ${root}, version ${currentVersion(paths)}, ${service.kind === "launchd" ? "and starts whenever you log in" : service.kind === "systemd" ? "and starts whenever you log in, as a systemd user service" : "in the background"}.`
   );
@@ -5946,10 +6028,22 @@ async function runStart(options) {
   );
   return 0;
 }
+async function stopped(options) {
+  const deadline = Date.now() + (options.stopWaitMs ?? 15e3);
+  while (runningSupervisor(options.paths)) {
+    if (Date.now() > deadline) {
+      throw new StartError(
+        `Friday didn't stop within ${Math.round((options.stopWaitMs ?? 15e3) / 1e3)} seconds, so the root wasn't moved. Run ${FRIDAY_COMMAND} stop, then this again.`
+      );
+    }
+    await new Promise((done) => setTimeout(done, options.stopPollMs ?? 250));
+  }
+}
 async function chooseAndAsk(options, print) {
   if (!options.agents) return null;
   const chosen = await chooseAgents(options.agents, print);
   if (!chosen) return null;
+  if (!options.agents.ask && !options.agents.given) return null;
   return { chosen, since: askToActivate(options.paths.herdHome) };
 }
 async function waitForAgents(options, asked, print) {
@@ -6235,10 +6329,12 @@ Usage: ${FRIDAY_COMMAND} <command>
 
   start       Make this computer a machine, with the folder this runs in as its root, which
               holds your repos, such as ~/code. Signs in through your browser when
-              needed, asks how much of each agent you have, starts the daemon now and whenever
-              you log in, waits for each agent to check in, then shows what's left to set up.
-              Safe to run again. --agents claude=lot,codex=little sets the shares without
-              asking: off, little, some or lot, where a bare name is some and one left out off
+              needed, asks how much of each agent you have the first time, starts the daemon
+              now and whenever you log in, then shows what's left to set up. Safe to run
+              again. Run in another folder, it offers to move the root there. --config asks
+              about the agents again, and --agents claude=lot,codex=little sets their shares
+              without asking: off, little, some or lot, where a bare name is some and one
+              left out off
   stop        Stop the daemon until you log in again, or run start again
   status      Whether the daemon is running, which version, and its root
   logs [-f]   Show the daemon's latest log lines. -f keeps following them
@@ -6312,7 +6408,11 @@ async function friday(args, deps = defaults()) {
           print: deps.print,
           setup: fetchSetup,
           ...process.env.HERD_PACKAGE_SPEC ? { install: { spec: process.env.HERD_PACKAGE_SPEC } } : {},
+          ...process.stdin.isTTY && process.stdout.isTTY ? { confirm: confirmInTerminal } : {},
           agents: {
+            // The choice lives in herd.config.ts, so it's asked for only before there is one, or
+            // with --config.
+            ask: rest.includes("--config") || !existsSync11(herdConfigIn(deps.paths.herdHome)),
             installed: async () => installedAgents(),
             load: () => loadHerdConfig(herdConfigIn(deps.paths.herdHome)),
             configPath: herdConfigIn(deps.paths.herdHome),
@@ -6345,6 +6445,14 @@ ${HELP}`);
     throw error;
   }
 }
+async function confirmInTerminal(question) {
+  const lines = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return /^y(es)?$/i.test((await lines.question(`${question} [y/N] `)).trim());
+  } finally {
+    lines.close();
+  }
+}
 function agentsFlag(args) {
   const at = args.findIndex((arg) => arg === "--agents" || arg.startsWith("--agents="));
   if (at < 0) return void 0;
@@ -6572,6 +6680,10 @@ init_define_HERD_PACKAGE();
 // src/commands/terminal.ts
 init_define_HERD_PACKAGE();
 var DAEMON_WAIT_MS = Number(process.env.HERD_DAEMON_WAIT_MS ?? 3e4);
+function withStart(request) {
+  const start = process.env.HERD_START;
+  return start ? { start, ...request } : request;
+}
 async function fromTerminal(request) {
   const socket = process.env.HERD_SOCKET;
   const secret = process.env.HERD_TERMINAL;
@@ -6581,7 +6693,7 @@ async function fromTerminal(request) {
   let reply = null;
   const deadline = Date.now() + DAEMON_WAIT_MS;
   while (!reply) {
-    reply = await askDaemon(socket, { secret, ...request }).catch(() => null);
+    reply = await askDaemon(socket, { secret, ...withStart(request) }).catch(() => null);
     if (reply) break;
     if (Date.now() > deadline) throw new HerdError("Couldn't reach herd's daemon. Is it running?");
     await new Promise((resolve7) => setTimeout(resolve7, 500));
@@ -7404,6 +7516,9 @@ var ownPrompt = (draft) => OWN_PROMPTS.find(
 ) ?? (draft.startsWith(DELEGATE_START) || draft.length >= 40 && DELEGATE_START.startsWith(draft) ? draft : null);
 var SESSION_ID = /^[A-Za-z0-9-]{1,100}$/;
 var SUBMIT_RETRIES = 3;
+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 EXIT_WAIT_MS = 5e3;
@@ -7460,12 +7575,12 @@ var AgentDriver = class {
    * `claude --resume <id>`. Resuming without an ID types `/resume` and picks the newest
    * conversation, which is this worktree's only agent.
    */
-  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2 } = {}) {
+  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2, startKey = null } = {}) {
     const known = sessionId !== null && SESSION_ID.test(sessionId);
     const byId = resume && known;
     const command = byId ? `claude --resume ${sessionId}` : !resume && known ? `claude --session-id ${sessionId}` : "claude";
     await this.settle(name);
-    await this.terminals.type(name, command);
+    await this.terminals.type(name, withStartKey(command, startKey));
     await this.terminals.press(name, "enter");
     const first = await this.until(
       name,
@@ -7758,11 +7873,11 @@ var AgyDriver = class {
    * waits for its prompt box. It trusts the folder only in a worktree the daemon made. agy chooses
    * a session's ID itself, and its `SessionStart` hook reports it.
    */
-  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2 } = {}) {
+  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2, startKey = null } = {}) {
     const byId = resume && sessionId !== null && SESSION_ID.test(sessionId);
     const command = byId ? `agy --conversation=${sessionId} ${AGY_FLAGS}` : `agy ${AGY_FLAGS}`;
     await this.settle(name);
-    await this.terminals.type(name, command);
+    await this.terminals.type(name, withStartKey(command, startKey));
     await this.terminals.press(name, "enter");
     const first = await this.until(
       name,
@@ -8749,11 +8864,11 @@ var CodexDriver = class {
    * Types `codex` into the settled shell, or `codex resume <id>` to continue a session, and waits
    * for its composer. Codex chooses a session's ID itself, when it takes the first prompt.
    */
-  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2 } = {}) {
+  async start(name, cwd, { resume = false, sessionId = null, ownFolder: ownFolder2, startKey = null } = {}) {
     const byId = resume && sessionId !== null && SESSION_ID.test(sessionId);
     const command = byId ? `codex resume ${sessionId} ${CODEX_FLAGS}` : `codex ${CODEX_FLAGS}`;
     await this.settle(name);
-    await this.terminals.type(name, command);
+    await this.terminals.type(name, withStartKey(command, startKey));
     await this.terminals.press(name, "enter");
     const first = await this.until(
       name,
@@ -9764,7 +9879,7 @@ var HostTerminals = class {
     await this.askFor(name, { op: "kill", name });
   }
   async retire(canStop) {
-    const stopped = [];
+    const stopped2 = [];
     for (const host of await this.discover()) {
       if (host.current) continue;
       const version = host.hello.version ?? "unversioned";
@@ -9776,12 +9891,12 @@ var HostTerminals = class {
         continue;
       }
       if (await this.stop(host)) {
-        stopped.push(version);
+        stopped2.push(version);
         this.log(`Retired terminal host ${version}, which had nothing left running.`);
       }
     }
-    if (stopped.length > 0) await this.discover();
-    return stopped;
+    if (stopped2.length > 0) await this.discover();
+    return stopped2;
   }
   /** Stops a host: politely where it knows how, and otherwise by its process. */
   async stop(host) {
@@ -9809,48 +9924,6 @@ var HostTerminals = class {
   }
 };
 
-// src/timing.ts
-init_define_HERD_PACKAGE();
-var VARIABLES = {
-  settleMs: "HERD_SETTLE_MS",
-  pollMs: "HERD_POLL_MS",
-  confirmMs: "HERD_CONFIRM_MS",
-  pasteMs: "HERD_PASTE_MS",
-  renewMs: "HERD_RENEW_MS",
-  hookSettleMs: "HERD_HOOK_SETTLE_MS",
-  agyIdleSettleMs: "HERD_AGY_IDLE_SETTLE_MS",
-  promptPollMs: "HERD_PROMPT_POLL_MS",
-  noticeRetryMs: "HERD_NOTICE_RETRY_MS",
-  investigateAfterMs: "HERD_INVESTIGATE_AFTER_MS",
-  idleMs: "HERD_IDLE_MS",
-  watchMs: "HERD_WATCH_MS",
-  usageReportMs: "HERD_USAGE_REPORT_MS",
-  usageStaleMs: "HERD_USAGE_STALE_MS",
-  activationMs: "HERD_ACTIVATION_MS",
-  activationPollMs: "HERD_ACTIVATION_POLL_MS",
-  signInRestartMs: "HERD_SIGN_IN_RESTART_MS",
-  machineCheckMs: "HERD_MACHINE_CHECK_MS"
-};
-function timingFromEnv(env) {
-  const timing = {};
-  for (const [key, name] of Object.entries(VARIABLES)) {
-    const raw = env[name];
-    if (raw === void 0 || raw === "") continue;
-    const value = Number(raw);
-    if (!Number.isFinite(value) || value < 0) {
-      throw new HerdError(`${name} must be a number of milliseconds, not "${raw}".`);
-    }
-    timing[key] = value;
-  }
-  return timing;
-}
-function driverTiming(timing) {
-  const { settleMs, pollMs, confirmMs } = timing;
-  return Object.fromEntries(
-    Object.entries({ settleMs, pollMs, confirmMs }).filter(([, value]) => value !== void 0)
-  );
-}
-
 // src/usage-reporter.ts
 init_define_HERD_PACKAGE();
 var USAGE_REPORT_MS = 5 * 60 * 1e3;
@@ -10115,6 +10188,17 @@ var workspaceFields = z25.object({
   codexOffset: z25.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),
+  /**
+   * 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),
+  /** Whether the current start has checked in. One from before keys counts as proven. */
+  startProven: z25.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),
+  /** Whether this start has been flagged as needing someone at its terminal, so it's said once. */
+  needsAttention: z25.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)
@@ -10191,7 +10275,7 @@ async function claimChange(ws, workspace, change) {
 
 // src/workspaces/delivery.ts
 init_define_HERD_PACKAGE();
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomBytes as randomBytes6, randomUUID as randomUUID6 } from "node:crypto";
 import { join as join30 } from "node:path";
 
 // src/workspaces/repos.ts
@@ -10491,6 +10575,10 @@ async function setUp(ws, conversationId) {
     codexFile: null,
     codexOffset: 0,
     agentStartedAt: 0,
+    startKey: null,
+    startProven: true,
+    checkInFrom: null,
+    needsAttention: false,
     agentState: null,
     agentStateAt: 0
   };
@@ -10534,6 +10622,12 @@ async function openLead(ws, workspace) {
   });
 }
 
+// src/workspaces/watch.ts
+init_define_HERD_PACKAGE();
+
+// src/workspaces/check-in.ts
+init_define_HERD_PACKAGE();
+
 // src/workspaces/signed-out.ts
 init_define_HERD_PACKAGE();
 init_src();
@@ -10554,14 +10648,50 @@ async function releaseSignedOut(ws, workspace) {
     terminalNotice: false,
     idleSince: null,
     noticeFailedAt: null,
-    noticeFailure: null
+    noticeFailure: null,
+    checkInFrom: null,
+    needsAttention: false
   });
   if (workspace.status !== "exited") await ws.report(id2, "exited");
   await ws.post(`${ws.conversationPath(id2)}/release`, { reason: "agent_signed_out" });
 }
 
-// src/workspaces/watch.ts
-init_define_HERD_PACKAGE();
+// src/workspaces/check-in.ts
+async function checkIn(ws, workspace, grant, start) {
+  if (workspace.startProven || !start || start !== workspace.startKey) return;
+  if (grant.terminalId !== workspace.lead) return;
+  const id2 = workspace.conversationId;
+  ws.update(id2, { startProven: true, checkInFrom: null, needsAttention: false });
+  if (!workspace.needsAttention) return;
+  ws.log(`${id2}: the agent checked in after all.`);
+  await ws.terminalEvent(id2, {
+    type: "terminal.checked_in",
+    payload: { terminalId: workspace.lead }
+  });
+}
+function checkInOverdue(ws, workspace, now = Date.now()) {
+  return !workspace.startProven && workspace.checkInFrom !== null && now - workspace.checkInFrom >= (ws.options.checkInMs ?? CHECK_IN_MS);
+}
+async function followCheckIn(ws, workspace, reading) {
+  if (!checkInOverdue(ws, workspace)) return false;
+  if (reading?.state === "signed_out") {
+    await releaseSignedOut(ws, workspace);
+    return true;
+  }
+  if (workspace.needsAttention) return false;
+  const id2 = workspace.conversationId;
+  ws.update(id2, { needsAttention: true });
+  ws.log(`${id2}: ${workspace.agent} started but didn't check in, so it needs someone.`);
+  await ws.terminalEvent(id2, {
+    type: "terminal.needs_attention",
+    payload: {
+      terminalId: workspace.lead,
+      agent: workspace.agent,
+      machineName: ws.options.machineName()
+    }
+  });
+  return false;
+}
 
 // src/workspaces/investigation.ts
 init_define_HERD_PACKAGE();
@@ -10569,11 +10699,19 @@ import { randomUUID as randomUUID5 } from "node:crypto";
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync21 } from "node:fs";
 import { join as join29 } from "node:path";
 function needsInvestigator(ws, workspace, reading) {
+  const allowed = ws.options.canInvestigate ? ws.options.canInvestigate() : workspace.agent === "claude-code";
+  if (!allowed || !reading || workspace.investigation) return false;
+  if (reading.state !== "unknown" || reading.knownDialog || reading.program === "shell") {
+    return false;
+  }
+  const trigger = investigationTrigger(ws, workspace);
+  return trigger !== null && workspace.investigatedFailure !== trigger;
+}
+function investigationTrigger(ws, workspace) {
+  if (workspace.needsAttention && checkInOverdue(ws, workspace)) return workspace.checkInFrom;
   const failedAt = workspace.noticeFailedAt;
-  if (workspace.agent === "codex" || workspace.agent === "agy") return false;
-  return Boolean(
-    reading && failedAt !== null && workspace.deferred && !workspace.investigation && workspace.investigatedFailure !== failedAt && Date.now() - failedAt >= (ws.options.investigateAfterMs ?? INVESTIGATE_AFTER_MS) && reading.state === "unknown" && !reading.knownDialog && reading.program !== "shell"
-  );
+  const after = ws.options.investigateAfterMs ?? INVESTIGATE_AFTER_MS;
+  return failedAt !== null && workspace.deferred && Date.now() - failedAt >= after ? failedAt : null;
 }
 async function openInvestigator(ws, workspace) {
   const id2 = workspace.conversationId;
@@ -10583,10 +10721,11 @@ async function openInvestigator(ws, workspace) {
   );
   const secret = ws.options.local().grant({ terminalId: terminal, conversationId: id2, investigates: workspace.lead });
   ws.update(id2, {
-    investigatedFailure: workspace.noticeFailedAt,
+    investigatedFailure: investigationTrigger(ws, workspace),
     investigation: { terminal, secret, startedAt: Date.now(), screen, key: null, promptId: null }
   });
   ws.log(`${id2}: opened an investigator for a screen herd can't read.`);
+  if (workspace.agent !== "claude-code") configureClaude(ws, workspace);
   const shell = ws.options.shell ?? process.env.SHELL ?? "/bin/sh";
   try {
     await ws.options.terminals.create({
@@ -10757,7 +10896,8 @@ async function watchOne(ws, conversationId, terminals, rows = []) {
     lead = (await ws.options.terminals.list()).find((t) => t.name === workspace?.lead);
   }
   let reading = lead && !lead.exited ? await ws.driverFor(workspace).read(workspace.lead) : null;
-  if (reading?.state === "signed_out") return releaseSignedOut(ws, workspace);
+  if (await followCheckIn(ws, workspace, reading)) return;
+  workspace = ws.get(conversationId) ?? workspace;
   if (reading && !reading.knownDialog && workspace.closedDialog) {
     workspace = ws.update(conversationId, { closedDialog: null });
   }
@@ -10856,12 +10996,12 @@ async function retireHosts(ws) {
   if (!terminals.retire || Date.now() - ws.retiredAt < every) return;
   ws.retiredAt = Date.now();
   const inHost = (version) => Object.values(ws.load()).filter((workspace) => workspace.hostVersion === version);
-  const stopped = await terminals.retire(
+  const stopped2 = await terminals.retire(
     (version) => inHost(version).every(
       (workspace) => !workspace.claimId && (workspace.status === "idle" || workspace.status === "exited")
     )
   );
-  for (const version of stopped) {
+  for (const version of stopped2) {
     for (const workspace of inHost(version)) {
       const id2 = workspace.conversationId;
       await ws.serially(id2, async () => {
@@ -10939,11 +11079,18 @@ async function deliver(ws, conversationId, delivery) {
       });
     }
     const resume = workspace.started && (!ownId || workspace.sessionId !== null);
-    workspace = ws.update(conversationId, { agentStartedAt: Date.now() });
+    workspace = ws.update(conversationId, {
+      agentStartedAt: Date.now(),
+      startKey: randomBytes6(12).toString("hex"),
+      startProven: false,
+      checkInFrom: null,
+      needsAttention: false
+    });
     await ws.driverFor(workspace).start(workspace.lead, workspace.folder, {
       resume,
       sessionId: workspace.sessionId,
-      ownFolder: isHerdFolder(workspace.folder, rootOf(ws))
+      ownFolder: isHerdFolder(workspace.folder, rootOf(ws)),
+      startKey: workspace.startKey
     });
     workspace = ws.update(conversationId, {
       started: true,
@@ -10952,16 +11099,15 @@ async function deliver(ws, conversationId, delivery) {
       askedToReply: false,
       handledThisTurn: false
     });
-    if ((await ws.driverFor(workspace).read(workspace.lead)).state === "signed_out") {
-      return releaseSignedOut(ws, workspace);
-    }
     if (!await claim(ws, workspace)) return;
     const result2 = await submitKeepingClaim(
       ws,
       conversationId,
       workspace.readSeq === 0 ? workspace.parent ? delegatePrompt(workspace.parent) : STARTING_PROMPT : NOTICE
     );
-    return afterSubmit(ws, ws.get(conversationId) ?? workspace, result2);
+    workspace = ws.get(conversationId) ?? workspace;
+    if (!workspace.startProven) workspace = ws.update(conversationId, { checkInFrom: Date.now() });
+    return afterSubmit(ws, workspace, result2);
   }
   let reading = await ws.driverFor(workspace).read(workspace.lead);
   if (reading.knownDialog) {
@@ -11352,7 +11498,10 @@ async function answer(ws, grant, request, gone = new AbortController().signal) {
   if (request.op === "activate") {
     return { ok: false, error: "Only an agent's activation terminal can check in." };
   }
-  if (request.op === "inbox") return inbox(ws, workspace);
+  if (request.op === "inbox") {
+    await checkIn(ws, workspace, grant, request.start);
+    return inbox(ws, ws.get(grant.conversationId) ?? workspace);
+  }
   if (request.op === "send") return send(ws, workspace, request);
   if (request.op === "channels") return channels(ws, workspace);
   if (request.op === "watch") return watch(ws, workspace, request);
@@ -12643,6 +12792,11 @@ async function runDaemon(args) {
     activations: {
       fromTerminal: async (grant, request) => activator?.fromTerminal(grant, request) ?? { ok: false, error: "This activation is over." }
     },
+    // The investigator is Claude Code, so any agent's stuck screen gets one where it's activated.
+    canInvestigate: () => Boolean(
+      daemon?.chosenClis().some((cli) => cli.name === "claude-code") && activator?.states()["claude-code"]?.state === "activated"
+    ),
+    ...timing.checkInMs === void 0 ? {} : { checkInMs: timing.checkInMs },
     // The agent stops being offered before its conversation goes back, then activates again.
     agentSignedOut: async (agent) => {
       const version = daemon?.chosenClis().find((cli) => cli.name === agent)?.version ?? "unknown";
@@ -12680,6 +12834,7 @@ async function runDaemon(args) {
     ...timing.activationMs === void 0 ? {} : { deadlineMs: timing.activationMs },
     ...timing.activationPollMs === void 0 ? {} : { pollMs: timing.activationPollMs },
     ...timing.signInRestartMs === void 0 ? {} : { signInRestartMs: timing.signInRestartMs },
+    ...timing.checkInMs === void 0 ? {} : { checkInMs: timing.checkInMs },
     log
   });
   checks = new MachineChecks({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herdingchats/friday",
-  "version": "0.1.563",
+  "version": "0.1.569",
   "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": "055f38c1feb0ea86dac8b463c249d3f7cd782018"
+  "gitHead": "ac28f0e97b92fbe2178387595a511d35c3ae4953"
 }