cruo-agent 0.1.4 → 0.1.6

package/README.md

@@ -93,7 +93,7 @@ given up on work nobody abandoned.
 | `--worktree` | a checkout per card |
 | `--allow <tools>` | what the harness may use |
 | `--push` | publish the branch after a run that commits |
-| `--harness-timeout <seconds>` | kill a run that wedges (default 600) |
+| `--harness-timeout <seconds>` | kill a run that wedges (default 1800) |
 | `--max-attempts <n>` | give up on a card after n unproductive runs (default 3) |
 
 The full list, and what each is for: <https://cruo.space/docs#agents>

package/dist/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.6

package/dist/cli.js

@@ -15247,6 +15247,13 @@ var init_plans = __esm({
   }
 });
 
+// ../../packages/core/dist/reports.js
+var init_reports = __esm({
+  "../../packages/core/dist/reports.js"() {
+    "use strict";
+  }
+});
+
 // ../../packages/core/dist/mcp-connect.js
 var DOCS_URL, AGENT_DOCS_URL, MCP_DOCS_URL, CRUO_CLOUD;
 var init_mcp_connect = __esm({
@@ -15293,6 +15300,7 @@ var init_dist = __esm({
     init_identity();
     init_effort();
     init_plans();
+    init_reports();
     init_mcp_connect();
     init_tree();
     init_place();
@@ -16158,7 +16166,7 @@ var require_FunctionsClient = __commonJS({
           let timeoutId;
           let timeoutController;
           try {
-            const { headers, method, body: functionArgs, signal, timeout } = options2;
+            const { headers, method, body: functionArgs, signal: signal2, timeout } = options2;
             let _headers = {};
             let { region } = options2;
             if (!region) {
@@ -16191,13 +16199,13 @@ var require_FunctionsClient = __commonJS({
                 body = functionArgs;
               }
             }
-            let effectiveSignal = signal;
+            let effectiveSignal = signal2;
             if (timeout) {
               timeoutController = new AbortController();
               timeoutId = setTimeout(() => timeoutController.abort(), timeout);
-              if (signal) {
+              if (signal2) {
                 effectiveSignal = timeoutController.signal;
-                signal.addEventListener("abort", () => timeoutController.abort());
+                signal2.addEventListener("abort", () => timeoutController.abort());
               } else {
                 effectiveSignal = timeoutController.signal;
               }
@@ -16283,21 +16291,21 @@ var require_main = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@supabase+postgrest-js@2.110.7/node_modules/@supabase/postgrest-js/dist/index.mjs
-function sleep(ms2, signal) {
+function sleep(ms2, signal2) {
   return new Promise((resolve2) => {
-    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+    if (signal2 === null || signal2 === void 0 ? void 0 : signal2.aborted) {
       resolve2();
       return;
     }
     const id = setTimeout(() => {
-      signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+      signal2 === null || signal2 === void 0 || signal2.removeEventListener("abort", onAbort);
       resolve2();
     }, ms2);
     function onAbort() {
       clearTimeout(id);
       resolve2();
     }
-    signal === null || signal === void 0 || signal.addEventListener("abort", onAbort);
+    signal2 === null || signal2 === void 0 || signal2.addEventListener("abort", onAbort);
   });
 }
 function shouldRetry(method, status, attemptCount, retryEnabled) {
@@ -17326,8 +17334,8 @@ ${cause.stack}`;
       *
       * ```
       */
-      abortSignal(signal) {
-        this.signal = signal;
+      abortSignal(signal2) {
+        this.signal = signal2;
         return this;
       }
       /**
@@ -23486,8 +23494,8 @@ var require_RealtimeChannel = __commonJS({
       }
       /** @internal */
       _notThisChannelEvent(event, ref) {
-        const { close, error: error51, leave, join: join4 } = constants_1.CHANNEL_EVENTS;
-        const events = [close, error51, leave, join4];
+        const { close, error: error51, leave, join: join5 } = constants_1.CHANNEL_EVENTS;
+        const events = [close, error51, leave, join5];
         return ref && events.includes(event) && ref !== this.joinPush.ref;
       }
       /** @internal */
@@ -30509,7 +30517,7 @@ var require_webauthn = __commonJS({
        * @see {@link https://w3c.github.io/webauthn/#sctn-credential-creation W3C WebAuthn Spec - Credential Creation}
        * @see {@link https://w3c.github.io/webauthn/#sctn-verifying-assertion W3C WebAuthn Spec - Verifying Assertion}
        */
-      async _challenge({ factorId, webauthn, friendlyName, signal }, overrides) {
+      async _challenge({ factorId, webauthn, friendlyName, signal: signal2 }, overrides) {
         var _a3;
         try {
           const { data: challengeResponse, error: challengeError } = await this.client.mfa.challenge({
@@ -30519,7 +30527,7 @@ var require_webauthn = __commonJS({
           if (!challengeResponse) {
             return { data: null, error: challengeError };
           }
-          const abortSignal = signal !== null && signal !== void 0 ? signal : exports.webAuthnAbortService.createNewAbortSignal();
+          const abortSignal = signal2 !== null && signal2 !== void 0 ? signal2 : exports.webAuthnAbortService.createNewAbortSignal();
           if (challengeResponse.webauthn.type === "create") {
             const { user } = challengeResponse.webauthn.credential_options.publicKey;
             if (!user.name) {
@@ -30623,7 +30631,7 @@ var require_webauthn = __commonJS({
        * @see {@link https://w3c.github.io/webauthn/#sctn-authentication W3C WebAuthn Spec - Authentication Ceremony}
        * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialRequestOptions MDN - PublicKeyCredentialRequestOptions}
        */
-      async _authenticate({ factorId, webauthn: { rpId = typeof window !== "undefined" ? window.location.hostname : void 0, rpOrigins = typeof window !== "undefined" ? [window.location.origin] : void 0, signal } = {} }, overrides) {
+      async _authenticate({ factorId, webauthn: { rpId = typeof window !== "undefined" ? window.location.hostname : void 0, rpOrigins = typeof window !== "undefined" ? [window.location.origin] : void 0, signal: signal2 } = {} }, overrides) {
         if (!rpId) {
           return {
             data: null,
@@ -30640,7 +30648,7 @@ var require_webauthn = __commonJS({
           const { data: challengeResponse, error: challengeError } = await this.challenge({
             factorId,
             webauthn: { rpId, rpOrigins },
-            signal
+            signal: signal2
           }, { request: overrides });
           if (!challengeResponse) {
             return { data: null, error: challengeError };
@@ -30681,7 +30689,7 @@ var require_webauthn = __commonJS({
        * @see {@link https://w3c.github.io/webauthn/#sctn-registering-a-new-credential W3C WebAuthn Spec - Registration Ceremony}
        * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions MDN - PublicKeyCredentialCreationOptions}
        */
-      async _register({ friendlyName, webauthn: { rpId = typeof window !== "undefined" ? window.location.hostname : void 0, rpOrigins = typeof window !== "undefined" ? [window.location.origin] : void 0, signal } = {} }, overrides) {
+      async _register({ friendlyName, webauthn: { rpId = typeof window !== "undefined" ? window.location.hostname : void 0, rpOrigins = typeof window !== "undefined" ? [window.location.origin] : void 0, signal: signal2 } = {} }, overrides) {
         if (!rpId) {
           return {
             data: null,
@@ -30709,7 +30717,7 @@ var require_webauthn = __commonJS({
             factorId: factor.id,
             friendlyName: factor.friendly_name,
             webauthn: { rpId, rpOrigins },
-            signal
+            signal: signal2
           }, {
             create: overrides
           });
@@ -35585,10 +35593,10 @@ var require_GoTrueClient = __commonJS({
             return this._returnResult({ data: null, error: optionsError });
           }
           const publicKeyOptions = (0, webauthn_1.deserializeCredentialRequestOptions)(options2.options);
-          const signal = (_c = (_b = credentials === null || credentials === void 0 ? void 0 : credentials.options) === null || _b === void 0 ? void 0 : _b.signal) !== null && _c !== void 0 ? _c : webauthn_1.webAuthnAbortService.createNewAbortSignal();
+          const signal2 = (_c = (_b = credentials === null || credentials === void 0 ? void 0 : credentials.options) === null || _b === void 0 ? void 0 : _b.signal) !== null && _c !== void 0 ? _c : webauthn_1.webAuthnAbortService.createNewAbortSignal();
           const { data: credential, error: credentialError } = await (0, webauthn_1.getCredential)({
             publicKey: publicKeyOptions,
-            signal
+            signal: signal2
           });
           if (credentialError || !credential) {
             return this._returnResult({
@@ -35633,10 +35641,10 @@ var require_GoTrueClient = __commonJS({
             return this._returnResult({ data: null, error: optionsError });
           }
           const publicKeyOptions = (0, webauthn_1.deserializeCredentialCreationOptions)(options2.options);
-          const signal = (_b = (_a3 = credentials === null || credentials === void 0 ? void 0 : credentials.options) === null || _a3 === void 0 ? void 0 : _a3.signal) !== null && _b !== void 0 ? _b : webauthn_1.webAuthnAbortService.createNewAbortSignal();
+          const signal2 = (_b = (_a3 = credentials === null || credentials === void 0 ? void 0 : credentials.options) === null || _a3 === void 0 ? void 0 : _a3.signal) !== null && _b !== void 0 ? _b : webauthn_1.webAuthnAbortService.createNewAbortSignal();
           const { data: credential, error: credentialError } = await (0, webauthn_1.createCredential)({
             publicKey: publicKeyOptions,
-            signal
+            signal: signal2
           });
           if (credentialError || !credential) {
             return this._returnResult({
@@ -36019,8 +36027,8 @@ function parseTraceParent(traceparent) {
     isSampled: (parseInt(traceFlags, 16) & 1) === 1
   };
 }
-function shouldPropagateToTarget(targetUrl, targets) {
-  if (!targetUrl || !targets || targets.length === 0) return false;
+function shouldPropagateToTarget(targetUrl, targets2) {
+  if (!targetUrl || !targets2 || targets2.length === 0) return false;
   let url3;
   if (targetUrl instanceof URL) url3 = targetUrl;
   else try {
@@ -36028,7 +36036,7 @@ function shouldPropagateToTarget(targetUrl, targets) {
   } catch (error51) {
     return false;
   }
-  for (const target of targets) try {
+  for (const target of targets2) try {
     if (typeof target === "string") {
       if (matchStringTarget(url3.hostname, target)) return true;
     } else if (target instanceof RegExp) {
@@ -36052,15 +36060,15 @@ function matchStringTarget(hostname3, target) {
   return false;
 }
 function getDefaultPropagationTargets(supabaseUrl) {
-  const targets = [];
+  const targets2 = [];
   try {
     const url3 = new URL(supabaseUrl);
-    targets.push(url3.hostname);
+    targets2.push(url3.hostname);
   } catch (error51) {
   }
-  targets.push("*.supabase.co", "*.supabase.in");
-  targets.push("localhost", "127.0.0.1", "[::1]");
-  return targets;
+  targets2.push("*.supabase.co", "*.supabase.in");
+  targets2.push("localhost", "127.0.0.1", "[::1]");
+  return targets2;
 }
 function _typeof3(o) {
   "@babel/helpers - typeof";
@@ -36113,8 +36121,8 @@ function _objectSpread23(e) {
   }
   return e;
 }
-async function getTraceHeaders(input, targets, respectSampling) {
-  if (!shouldPropagateToTarget(typeof input === "string" ? input : input instanceof URL ? input : input.url, targets)) return null;
+async function getTraceHeaders(input, targets2, respectSampling) {
+  if (!shouldPropagateToTarget(typeof input === "string" ? input : input instanceof URL ? input : input.url, targets2)) return null;
   const traceContext = await extractTraceContext();
   if (!traceContext || !traceContext.traceparent) return null;
   if (respectSampling) {
@@ -45949,6 +45957,110 @@ var init_options = __esm({
   }
 });
 
+// src/process.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+function safeName(agent) {
+  const cleaned = agent.toLowerCase().replace(/[^a-z0-9._-]/g, "").replace(/^\.+/, "");
+  return cleaned === "" ? "default" : cleaned;
+}
+async function processStartedAt(pid) {
+  try {
+    const { stdout } = await exec("ps", ["-p", String(pid), "-o", "lstart="]);
+    const value = stdout.trim();
+    return value === "" ? null : value;
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error51) {
+    return error51.code === "EPERM";
+  }
+}
+async function writeRecord(record2) {
+  await mkdir(runDir(), { recursive: true });
+  await writeFile(recordPath(record2.agent), JSON.stringify(record2, null, 2) + "\n", {
+    mode: 384
+  });
+}
+async function removeRecord(agent) {
+  await rm(recordPath(agent), { force: true });
+}
+async function readRecord(agent) {
+  try {
+    const parsed = JSON.parse(await readFile(recordPath(agent), "utf8"));
+    return typeof parsed?.pid === "number" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function liveness(agent, tidy = false) {
+  const record2 = await readRecord(agent);
+  if (!record2) return { state: "absent" };
+  if (!isAlive(record2.pid)) {
+    if (tidy) await removeRecord(agent);
+    return { state: "gone", record: record2 };
+  }
+  const now = await processStartedAt(record2.pid);
+  if (record2.procStartedAt !== null && now !== null && now !== record2.procStartedAt) {
+    if (tidy) await removeRecord(agent);
+    return { state: "recycled", record: record2 };
+  }
+  return { state: "running", record: record2 };
+}
+async function listRecords() {
+  let names;
+  try {
+    names = (await readdir(runDir())).filter((n2) => n2.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file2 of names.sort()) {
+    const agent = file2.slice(0, -".json".length);
+    out.push({ agent, live: await liveness(agent) });
+  }
+  return out;
+}
+function signal(pid, which) {
+  try {
+    process.kill(pid, SIGNALS[which]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function since(iso) {
+  const ms2 = Date.now() - Date.parse(iso);
+  if (!Number.isFinite(ms2) || ms2 < 0) return "?";
+  if (ms2 < 6e4) return `${Math.round(ms2 / 1e3)}s`;
+  if (ms2 < 36e5) return `${Math.round(ms2 / 6e4)}m`;
+  if (ms2 < 864e5) return `${Math.round(ms2 / 36e5)}h`;
+  return `${Math.round(ms2 / 864e5)}d`;
+}
+var exec, runDir, logDir, recordPath, SIGNALS;
+var init_process = __esm({
+  "src/process.ts"() {
+    "use strict";
+    exec = promisify(execFile);
+    runDir = () => join(homedir(), ".cruo", "run");
+    logDir = () => join(homedir(), ".cruo", "logs");
+    recordPath = (agent) => join(runDir(), `${safeName(agent)}.json`);
+    SIGNALS = {
+      stop: "SIGTERM",
+      pause: "SIGUSR1",
+      resume: "SIGUSR2"
+    };
+  }
+});
+
 // src/env.ts
 function applyCloudDefaults() {
   const url3 = process.env.SUPABASE_URL ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
@@ -46040,8 +46152,8 @@ function compact(value) {
 }
 async function reportUsage(opts) {
   const ctx = await contextOrExplain();
-  const since = new Date(Date.now() - opts.days * 864e5).toISOString();
-  let query = ctx.client.from("harness_runs").select("*").gte("started_at", since).order("started_at", { ascending: false });
+  const since2 = new Date(Date.now() - opts.days * 864e5).toISOString();
+  let query = ctx.client.from("harness_runs").select("*").gte("started_at", since2).order("started_at", { ascending: false });
   let issueTitle = null;
   if (opts.issue) {
     const [key, num3] = opts.issue.split("-");
@@ -46237,15 +46349,77 @@ function usageIn(text) {
   const measured = Object.values(out).some((v) => v !== void 0);
   return measured ? out : null;
 }
+function renderEvent(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return { text: line, show: line };
+  }
+  if (typeof event !== "object" || event === null) return { text: line, show: line };
+  const e = event;
+  if (e.type === "assistant" || e.type === "user") {
+    const message = e.message;
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const said = [];
+    const shown = [];
+    for (const part of content) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p.type === "text" && typeof p.text === "string") {
+        said.push(p.text);
+        shown.push(p.text);
+      } else if (p.type === "tool_use" && typeof p.name === "string") {
+        shown.push(`  \xB7 ${p.name}`);
+      } else if (p.type === "tool_result") {
+        const failed = p.is_error === true;
+        if (failed) shown.push("  \xB7 tool error");
+      }
+    }
+    return {
+      text: said.length > 0 ? said.join("\n") : null,
+      show: shown.length > 0 ? shown.join("\n") : null
+    };
+  }
+  if (e.type === "result") {
+    const summary = typeof e.result === "string" ? e.result : null;
+    const usage = usageIn(line);
+    const spend = usage ? ` \u2014 ${usage.inputTokens ?? "?"} in / ${usage.outputTokens ?? "?"} out` + (usage.costUsd !== void 0 ? `, $${usage.costUsd.toFixed(4)}` : "") : "";
+    return { text: summary, show: `  [${String(e.subtype ?? "result")}${spend}]` };
+  }
+  if (e.type === "system") return { text: null, show: null };
+  return { text: null, show: null };
+}
 var REFUSALS, num;
 var init_harness_signal = __esm({
   "src/harness-signal.ts"() {
     "use strict";
     REFUSALS = [
-      [/hit your (monthly |weekly |daily )?(spend|usage) limit/i, "the account's spend limit is reached"],
-      [/insufficient credit|out of credit|credit balance is too low/i, "the account is out of credit"],
+      // "hit your" AND "reached your". The original had only the first, and the
+      // harness ships the second — `you have reached your weekly usage limit` is a
+      // literal string in the 2.x binary. That one word cost 8,239 runs (CRA-89):
+      // the refusal went unrecognised, so `neverRan` was false, so the backoff
+      // never engaged and every card was charged for an outage.
+      [
+        /(hit|reached) your (monthly |weekly |daily )?(spend|usage) limit/i,
+        "the account's usage limit is reached"
+      ],
+      // The passive voice of the same thing, which is what the harness prints when
+      // it is reporting rather than addressing you.
+      [/(usage|spend|usage credit) limit reached/i, "the account's usage limit is reached"],
+      // `is` optional: the binary carries BOTH "credit balance is too low" and
+      // "credit balance too low", and the pattern only knew the longer one.
+      [
+        /insufficient credit|out of credit|credit balance (is )?too low/i,
+        "the account is out of credit"
+      ],
       [/upgrade to (a paid plan|claude pro)/i, "the plan does not cover this"],
       [/invalid api key|authentication[_ ]error|please run \/login/i, "the harness is not signed in"],
+      // Still requires the follow-up clause. A bare "rate limited" is left
+      // UNMATCHED on purpose — it is a phrase a model writes about a codebase
+      // ("the endpoint is rate limited"), and the note above is explicit that a
+      // false positive is the worse error: it credits an issue an attempt it
+      // should have been charged.
       [/rate limit(ed| exceeded|s? reached)\b.*\btry again/i, "the account is rate limited"]
     ];
     num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
@@ -46293,12 +46467,12 @@ var init_pacing = __esm({
 });
 
 // src/worktree.ts
-import { execFile } from "node:child_process";
-import { mkdir, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { promisify } from "node:util";
+import { execFile as execFile2 } from "node:child_process";
+import { mkdir as mkdir2, readdir as readdir2, rm as rm2, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
 async function git(repo, args) {
-  const { stdout } = await exec("git", ["-C", repo, ...args], { maxBuffer: 8 * 1024 * 1024 });
+  const { stdout } = await exec2("git", ["-C", repo, ...args], { maxBuffer: 8 * 1024 * 1024 });
   return stdout.trim();
 }
 async function hasRef(repo, ref) {
@@ -46337,16 +46511,16 @@ async function remoteUrl(repo, remote) {
 }
 async function createWorktree(ref, config3) {
   const branch = branchFor(ref);
-  const path = join(config3.root, ref);
-  await mkdir(config3.root, { recursive: true });
-  await rm(path, { recursive: true, force: true });
+  const path = join2(config3.root, ref);
+  await mkdir2(config3.root, { recursive: true });
+  await rm2(path, { recursive: true, force: true });
   await git(config3.repo, ["worktree", "prune"]);
   const existing = await hasRef(config3.repo, branch);
   const startPoint = existing ? [branch] : ["-b", branch, config3.base];
   await git(config3.repo, ["worktree", "add", path, ...startPoint]);
   const startCommit = await git(config3.repo, ["rev-parse", branch]);
   if (config3.prepare) {
-    await exec("/bin/sh", ["-c", config3.prepare], {
+    await exec2("/bin/sh", ["-c", config3.prepare], {
       cwd: path,
       maxBuffer: 32 * 1024 * 1024,
       timeout: config3.prepareTimeoutMs ?? 15 * 6e4,
@@ -46357,10 +46531,28 @@ async function createWorktree(ref, config3) {
     const out = await git(config3.repo, ["rev-list", "--count", `${startCommit}..${branch}`]);
     return Number(out) || 0;
   };
+  const isDirty = async () => (await git(path, ["status", "--porcelain"])).length > 0;
   return {
     path,
     branch,
     commits: countCommits,
+    dirty: isDirty,
+    async saveWip(reason) {
+      if (!await isDirty()) return null;
+      await git(path, ["add", "-A"]);
+      const staged = await git(path, ["diff", "--cached", "--name-only"]);
+      if (staged.length === 0) return null;
+      const message = `wip(${ref}): saved by the supervisor when the run was cut short
+
+The harness was ${reason} with this in the tree. NOT a handoff: the
+agent did not choose to commit it and nothing here has been reviewed.
+The next attempt on this card starts from here rather than from scratch.
+
+Cruo-Wip: ${reason}
+`;
+      await git(path, ["commit", "--no-verify", "-m", message]);
+      return await git(path, ["rev-parse", "HEAD"]);
+    },
     async push(remote) {
       assertPublishable(branch);
       if (await countCommits() === 0 && !await hasRef(config3.repo, `${remote}/${branch}`)) {
@@ -46371,7 +46563,7 @@ async function createWorktree(ref, config3) {
     },
     async remove() {
       await git(config3.repo, ["worktree", "remove", "--force", path]).catch(async () => {
-        await rm(path, { recursive: true, force: true });
+        await rm2(path, { recursive: true, force: true });
       });
       await git(config3.repo, ["worktree", "prune"]);
     }
@@ -46381,14 +46573,14 @@ async function sweep(config3, maxRunMs = 0) {
   await git(config3.repo, ["worktree", "prune"]);
   let entries;
   try {
-    entries = await readdir(config3.root);
+    entries = await readdir2(config3.root);
   } catch {
     return [];
   }
   const cutoff = Date.now() - Math.max(maxRunMs + 5 * 6e4, 60 * 6e4);
   const removed = [];
   for (const name of entries) {
-    const path = join(config3.root, name);
+    const path = join2(config3.root, name);
     let touched;
     try {
       touched = (await stat(path)).mtimeMs;
@@ -46397,18 +46589,18 @@ async function sweep(config3, maxRunMs = 0) {
     }
     if (touched >= cutoff) continue;
     await git(config3.repo, ["worktree", "remove", "--force", path]).catch(async () => {
-      await rm(path, { recursive: true, force: true });
+      await rm2(path, { recursive: true, force: true });
     });
     removed.push(name);
   }
   if (removed.length) await git(config3.repo, ["worktree", "prune"]);
   return removed;
 }
-var exec;
+var exec2;
 var init_worktree = __esm({
   "src/worktree.ts"() {
     "use strict";
-    exec = promisify(execFile);
+    exec2 = promisify2(execFile2);
   }
 });
 
@@ -46416,9 +46608,9 @@ var init_worktree = __esm({
 var supervisor_exports = {};
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
-import { mkdtemp, readdir as readdir2, readFile, rm as rm2, stat as stat2, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join as join2 } from "node:path";
+import { mkdtemp, readdir as readdir3, readFile as readFile2, rm as rm3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function identify(ctx) {
   const { data: member, error: error51 } = await ctx.client.schema("public").from("members").select("kind, job_function, capabilities").eq("workspace_id", ctx.workspaceId).eq("user_id", ctx.userId).maybeSingle();
@@ -46443,7 +46635,7 @@ function resolveWorktreeRoot(identity) {
   if (options.worktreeRoot) return options.worktreeRoot;
   const slug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
   const name = slug(identity.name) || slug(identity.email.split("@")[0] ?? "") || "agent";
-  return join2(homedir(), ".cruo-work", name);
+  return join3(homedir2(), ".cruo-work", name);
 }
 async function pollAssigned(ctx) {
   const { data: issues, error: error51 } = await ctx.client.from("issues").select("*").eq("assignee_id", ctx.userId).order("created_at", { ascending: true });
@@ -46591,13 +46783,13 @@ async function markRead(ctx, notificationIds) {
 }
 async function writeMcpConfig() {
   const session = await childSession();
-  const dir = await mkdtemp(join2(tmpdir(), CONFIG_DIR_PREFIX));
-  const path = join2(dir, "mcp.json");
+  const dir = await mkdtemp(join3(tmpdir(), CONFIG_DIR_PREFIX));
+  const path = join3(dir, "mcp.json");
   const here = fileURLToPath(new URL(".", import.meta.url));
   const bundled = /[/\\]dist[/\\]?$/.test(here);
-  const server = join2(here, bundled ? "index.js" : "index.ts");
+  const server = join3(here, bundled ? "index.js" : "index.ts");
   const loader = bundled ? null : createRequire(import.meta.url).resolve("tsx");
-  await writeFile(
+  await writeFile2(
     path,
     JSON.stringify(
       {
@@ -46621,7 +46813,7 @@ async function writeMcpConfig() {
     ),
     { mode: 384 }
   );
-  return { path, cleanup: () => rm2(dir, { recursive: true, force: true }) };
+  return { path, cleanup: () => rm3(dir, { recursive: true, force: true }) };
 }
 async function sweepStaleConfigs() {
   const dir = tmpdir();
@@ -46629,18 +46821,18 @@ async function sweepStaleConfigs() {
   const cutoff = Date.now() - Math.max(maxRunMs + 5 * 6e4, 60 * 6e4);
   let entries;
   try {
-    entries = await readdir2(dir);
+    entries = await readdir3(dir);
   } catch {
     return 0;
   }
   let removed = 0;
   for (const name of entries) {
     if (!name.startsWith(CONFIG_DIR_PREFIX)) continue;
-    const path = join2(dir, name);
+    const path = join3(dir, name);
     try {
       const info = await stat2(path);
       if (info.mtimeMs >= cutoff) continue;
-      await rm2(path, { recursive: true, force: true });
+      await rm3(path, { recursive: true, force: true });
       removed += 1;
     } catch {
     }
@@ -46650,7 +46842,7 @@ async function sweepStaleConfigs() {
 async function preflight() {
   const { path: mcpConfig, cleanup } = await writeMcpConfig();
   try {
-    const parsed = JSON.parse(await readFile(mcpConfig, "utf8"));
+    const parsed = JSON.parse(await readFile2(mcpConfig, "utf8"));
     const { command, args, env } = parsed.mcpServers.cruo;
     await new Promise((resolve2, reject) => {
       const child = spawn(command, args, {
@@ -46778,9 +46970,14 @@ function userPrompt(hit) {
     `which your function owns. Pick it up and do your part.`
   ].join(" ");
 }
+function headFor(head2) {
+  const flat = head2.replace(/\s+/g, " ").trim();
+  return flat === "" ? null : flat.slice(0, HEAD_STORED);
+}
 async function invokeHarness(ctx, identity, hit, worktree) {
   const cwd = worktree?.path ?? options.cwd;
   const { path: mcpConfig, cleanup } = await writeMcpConfig();
+  const streaming = options.usage === true;
   const args = [
     "-p",
     userPrompt(hit),
@@ -46794,7 +46991,11 @@ async function invokeHarness(ctx, identity, hit, worktree) {
     options.allow,
     "--system-prompt",
     systemPrompt(ctx, identity, worktree),
-    ...options.model ? ["--model", options.model] : []
+    ...options.model ? ["--model", options.model] : [],
+    // `--verbose` is not optional alongside stream-json: without it the harness
+    // emits only the final result and the live view is a blank terminal for the
+    // length of the run.
+    ...streaming ? ["--output-format", "stream-json", "--verbose"] : []
   ];
   try {
     return await new Promise((resolve2) => {
@@ -46810,14 +47011,34 @@ async function invokeHarness(ctx, identity, hit, worktree) {
       let stdoutBytes = 0;
       let tail = "";
       let head2 = "";
+      let pending = "";
+      const addHead = (text) => {
+        if (head2.length < 2048) head2 += text.slice(0, 2048 - head2.length);
+      };
       child.stdout?.on("data", (c) => {
         stdoutBytes += c.length;
-        if (head2.length < 2048) head2 += c.toString("utf8").slice(0, 2048 - head2.length);
-        tail = (tail + c.toString("utf8")).slice(-4096);
-        process.stdout.write(c);
+        const chunk = c.toString("utf8");
+        if (!streaming) {
+          addHead(chunk);
+          tail = (tail + chunk).slice(-4096);
+          process.stdout.write(c);
+          return;
+        }
+        pending += chunk;
+        const lines = pending.split("\n");
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.trim() === "") continue;
+          tail = line;
+          const rendered = renderEvent(line);
+          if (rendered.text) addHead(rendered.text + "\n");
+          if (rendered.show) process.stdout.write(rendered.show + "\n");
+        }
       });
       child.stderr?.on("data", (c) => process.stderr.write(c));
+      let killed = false;
       const timer = setTimeout(() => {
+        killed = true;
         log(`  harness exceeded ${options.harnessTimeoutMs / 1e3}s \u2014 killing it`);
         child.kill("SIGTERM");
         setTimeout(() => child.kill("SIGKILL"), 1e4).unref();
@@ -46830,17 +47051,28 @@ async function invokeHarness(ctx, identity, hit, worktree) {
           stdoutBytes,
           refusal: refusalIn(head2),
           durationMs: Date.now() - startedAtMs,
-          usage: null
+          usage: null,
+          killed,
+          stdoutHead: headFor(head2)
         });
       });
       child.on("close", (code) => {
         clearTimeout(timer);
+        if (streaming && pending.trim() !== "") {
+          tail = pending;
+          const rendered = renderEvent(pending);
+          if (rendered.text) addHead(rendered.text + "\n");
+          if (rendered.show) process.stdout.write(rendered.show + "\n");
+          pending = "";
+        }
         resolve2({
           code: code ?? 1,
           stdoutBytes,
           refusal: refusalIn(head2),
           durationMs: Date.now() - startedAtMs,
-          usage: usageIn(tail)
+          usage: usageIn(tail),
+          killed,
+          stdoutHead: headFor(head2)
         });
       });
     });
@@ -46882,8 +47114,8 @@ async function clearAttempts(ctx, hit) {
   const { error: error51 } = await ctx.client.from("issue_attempts").delete().eq("issue_id", hit.issue.id).eq("agent_id", ctx.userId).eq("reason", hit.reason);
   if (error51) log(`  could not clear attempts on ${hit.ref}: ${error51.message}`);
 }
-async function repliedSince(ctx, hit, since) {
-  const { count, error: error51 } = await ctx.client.from("comments").select("id", { count: "exact", head: true }).eq("issue_id", hit.issue.id).eq("author_id", ctx.userId).gt("created_at", since);
+async function repliedSince(ctx, hit, since2) {
+  const { count, error: error51 } = await ctx.client.from("comments").select("id", { count: "exact", head: true }).eq("issue_id", hit.issue.id).eq("author_id", ctx.userId).gt("created_at", since2);
   if (error51) {
     log(`  could not check for a reply on ${hit.ref}: ${error51.message}`);
     return false;
@@ -46918,11 +47150,29 @@ async function beat(ctx, fields) {
       last_seen_at: (/* @__PURE__ */ new Date()).toISOString(),
       holding: fields.holding,
       dead_ticks: fields.deadTicks,
-      poll_interval_ms: fields.intervalMs
+      poll_interval_ms: fields.intervalMs,
+      // CRA-102. Without this the board cannot tell an agent someone paused
+      // from one that is wading through a backlog, nor one stopped on purpose
+      // from one whose laptop shut its lid — all of them simply went quiet.
+      status: fields.status ?? (paused ? "paused" : "running")
     },
     { onConflict: "user_id,workspace_id" }
   );
   if (error51) log(`  could not record a heartbeat: ${error51.message}`);
+  lastHolding = fields.holding;
+}
+function announce(status) {
+  void (async () => {
+    try {
+      await beat(await getContext(), {
+        holding: lastHolding,
+        deadTicks: 0,
+        intervalMs: options.intervalMs,
+        status
+      });
+    } catch {
+    }
+  })();
 }
 async function recordRun(ctx, hit, run, outcome) {
   const { error: error51 } = await ctx.client.from("harness_runs").insert({
@@ -46933,6 +47183,7 @@ async function recordRun(ctx, hit, run, outcome) {
     duration_ms: run.durationMs,
     exit_code: run.code,
     stdout_bytes: run.stdoutBytes,
+    stdout_head: run.stdoutHead,
     outcome,
     model: run.usage?.model ?? null,
     input_tokens: run.usage?.inputTokens ?? null,
@@ -47029,9 +47280,28 @@ async function tick(ctx, identity, deadTicks, allowance) {
     }
     let run;
     let committed = 0;
+    let salvaged = null;
     try {
       run = await invokeHarness(ctx, identity, hit, worktree);
       if (worktree) committed = await worktree.commits();
+      if (worktree && run.killed) {
+        try {
+          salvaged = await worktree.saveWip("killed at the harness timeout");
+          if (salvaged) {
+            log(
+              `  ${hit.ref} killed with an uncommitted tree \u2014 saved as ${salvaged.slice(0, 8)} on ${worktree.branch}; the next attempt resumes from it`
+            );
+          }
+        } catch (error51) {
+          log(
+            `  ${hit.ref} could not save the killed run's tree: ${error51 instanceof Error ? error51.message.split("\n")[0] : String(error51)}`
+          );
+        }
+      } else if (worktree && committed === 0 && await worktree.dirty()) {
+        log(
+          `  ${hit.ref} exited ${run.code} leaving uncommitted changes \u2014 they go with the worktree${options.keepFailed ? " (kept: --keep-failed)" : "; use --keep-failed to inspect them"}`
+        );
+      }
     } finally {
       await release(ctx, hit);
     }
@@ -47071,7 +47341,8 @@ async function tick(ctx, identity, deadTicks, allowance) {
       }
     } else {
       const what = hit.reason === "mention" ? "no reply written" : "unchanged";
-      const n2 = await recordAttempt(ctx, hit, `${what} (exit ${code})`, attemptsFor(hit));
+      const note = salvaged ? `${what} (exit ${code}); cut short, work saved as ${salvaged.slice(0, 8)}` : `${what} (exit ${code})`;
+      const n2 = await recordAttempt(ctx, hit, note, attemptsFor(hit));
       log(
         `  ${hit.ref} ${what} after the run (exit ${code}) \u2014 attempt ${n2}/${options.maxAttempts}` + (n2 >= options.maxAttempts ? "; setting it aside, a human should look" : "")
       );
@@ -47100,6 +47371,35 @@ async function tick(ctx, identity, deadTicks, allowance) {
   });
   return { invoked, failedToRun, suppressed: false, waiting: actionable.length };
 }
+function installControls() {
+  const requestStop = (why) => {
+    if (stopping && Date.now() - stopRequestedAt < 500) return;
+    if (stopping) {
+      log(`  ${why} again \u2014 leaving now; a harness still running will be orphaned`);
+      process.exit(130);
+    }
+    stopping = true;
+    stopRequestedAt = Date.now();
+    log(`  ${why} \u2014 finishing the current run, then stopping. Again to leave now.`);
+  };
+  process.on("SIGTERM", () => requestStop("stop requested"));
+  process.on("SIGINT", () => requestStop("interrupted"));
+  process.on("SIGUSR1", () => {
+    if (paused) return;
+    paused = true;
+    log(`  paused \u2014 still polling and still reporting, but starting no new runs`);
+    announce("paused");
+  });
+  process.on("SIGUSR2", () => {
+    if (!paused) return;
+    paused = false;
+    log(`  resumed \u2014 taking work again`);
+    announce("running");
+  });
+}
+function identityName() {
+  return safeName(process.env.CRUO_IDENTITY?.trim() || "default");
+}
 async function main() {
   log(
     `board: ${config2.url}${config2.url === CRUO_CLOUD.apiUrl ? " (Cruo cloud)" : " (configured)"}`
@@ -47113,6 +47413,18 @@ async function main() {
   }
   const ctx = await contextOrExplain();
   const identity = await identify(ctx);
+  installControls();
+  const runName = identityName();
+  if (!options.once && !options.dryRun) {
+    await writeRecord({
+      agent: runName,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      procStartedAt: await processStartedAt(process.pid),
+      log: join3(logDir(), `${runName}.log`),
+      argv: process.argv.slice(2)
+    });
+  }
   try {
     await preflight();
   } catch (error51) {
@@ -47166,7 +47478,7 @@ async function main() {
         await getContext(),
         identity,
         pacing.deadTicks,
-        allowanceAt(pacing, Date.now())
+        paused ? "held" : allowanceAt(pacing, Date.now())
       );
       if (result.suppressed) {
         const now = Date.now();
@@ -47193,10 +47505,12 @@ async function main() {
       log(`poll error: ${e instanceof Error ? e.message : String(e)}`);
     }
     if (options.once) return;
+    if (stopping) return;
     await new Promise((r) => setTimeout(r, options.intervalMs));
+    if (stopping) return;
   }
 }
-var argv, flag, opt, num2, ms, readOptions, options, log, worktreeConfig, lastRefusal, PRIORITY_RANK, CONFIG_DIR_PREFIX, CRUO_OWNED_ENV, warnedAboutSpendTable;
+var argv, flag, opt, num2, ms, readOptions, options, log, worktreeConfig, lastRefusal, PRIORITY_RANK, CONFIG_DIR_PREFIX, CRUO_OWNED_ENV, HEAD_STORED, lastHolding, warnedAboutSpendTable, stopping, paused, stopRequestedAt;
 var init_supervisor = __esm({
   "src/supervisor.ts"() {
     "use strict";
@@ -47206,6 +47520,7 @@ var init_supervisor = __esm({
     init_auth();
     init_options();
     init_harness_signal();
+    init_process();
     init_pacing();
     init_worktree();
     argv = process.argv.slice(2);
@@ -47250,14 +47565,40 @@ var init_supervisor = __esm({
        * supervisor down with it. Observed in the first live run: a harness that
        * produced no output and no writes for ten minutes. A killed run counts as
        * unproductive like any other, so the retry/set-aside path handles it.
+       *
+       * THIRTY MINUTES, and the number is a decision rather than a guess — the two
+       * mistakes this sits between are nowhere near the same size (`CRA-105`).
+       * Killing a wedged run late costs wall clock the supervisor was not using
+       * anyway. Killing a WORKING run early costs everything it did: the checkout
+       * is recreated from scratch on the next attempt, so an uncommitted tree is
+       * discarded rather than resumed (`CRA-104`). Ten minutes was tuned on the
+       * cards the loop was first exercised on, and `CRA-83` — four packages and a
+       * test file — was killed at it twice, having written real work both times
+       * and committed neither. Err long: the cheap failure is the slow one.
        */
-      harnessTimeoutMs: ms("harness-timeout", 600),
+      harnessTimeoutMs: ms("harness-timeout", 1800),
       /**
        * Give up on an issue after this many unproductive runs. Persisted in
        * `pm.issue_attempts` since CRA-7 — it was in-memory, which meant a restart
        * forgot every set-aside and nothing outside the process could see one.
        */
       maxAttempts: num2("max-attempts", { fallback: 3, integer: true }),
+      /**
+       * Ask the harness to report what each run spent — `CRA-89`.
+       *
+       * Off by default and that is a real choice, not caution. It appends
+       * `--output-format stream-json --verbose`, which are Claude Code's flags, and
+       * the supervisor's whole design is that `--harness` takes any command that
+       * accepts a prompt and exits. Turning this on says "my harness is Claude Code
+       * shaped"; leaving it off keeps the promise.
+       *
+       * What it costs: the harness's stdout stops being prose and becomes NDJSON,
+       * so the live view is reconstructed by `renderEvent` rather than passed
+       * through. What it buys is the only numbers there are — without it every
+       * token column in `pm.harness_runs` is null, which is what 8,335 rows of it
+       * were.
+       */
+      usage: flag("usage"),
       /**
        * Ceiling on how long invocation is held back after a run of dead ticks.
        * Ten minutes: long enough that a broken harness stops being spawned over and
@@ -47350,9 +47691,31 @@ cruo-supervisor: ${error51.message}
       // stands in for. Cheap to list, and wrong to discover the hard way.
       "CRUO_SESSION"
     ];
+    HEAD_STORED = 200;
+    lastHolding = 0;
     warnedAboutSpendTable = false;
-    main().catch((e) => {
+    stopping = false;
+    paused = false;
+    stopRequestedAt = 0;
+    main().then(async () => {
+      if (!options.once && !options.dryRun) {
+        try {
+          const ctx = await getContext();
+          await beat(ctx, {
+            holding: 0,
+            deadTicks: 0,
+            intervalMs: options.intervalMs,
+            status: "stopped"
+          });
+        } catch {
+        }
+        await removeRecord(identityName()).catch(() => {
+        });
+      }
+    }).catch(async (e) => {
       console.error(e instanceof Error ? e.message : e);
+      await removeRecord(identityName()).catch(() => {
+      });
       process.exit(1);
     });
   }
@@ -47362,11 +47725,12 @@ cruo-supervisor: ${error51.message}
 init_dist();
 init_dist7();
 init_options();
-import { chmod, mkdir as mkdir2, readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
-var CONFIG_DIR = join3(homedir2(), ".cruo");
-var CONFIG_PATH = join3(CONFIG_DIR, "config.json");
+init_process();
+import { chmod, mkdir as mkdir3, readFile as readFile3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+var CONFIG_DIR = join4(homedir3(), ".cruo");
+var CONFIG_PATH = join4(CONFIG_DIR, "config.json");
 function nameFromEmail(email3) {
   const local = email3.split("@")[0]?.toLowerCase().replace(/[^a-z0-9._-]/g, "");
   return local && local.length > 0 ? local : null;
@@ -47377,9 +47741,22 @@ var USAGE = `cruo \u2014 run a Cruo agent
   cruo agents            list what is remembered (never the tokens)
   cruo usage [--days 7]  what the agents have been spending
   cruo logout [name]     forget one, or --all
-  cruo [options]         run the agent's supervisor
+  cruo [options]         run the agent's supervisor, in this terminal
   cruo --as <name> \u2026     run a particular one
 
+Running one in the background
+  cruo start [options]   same, detached \u2014 survives closing the terminal
+  cruo ps                what is running on this machine
+  cruo stop [name]       ask it to finish the run it is on, then exit
+  cruo pause [name]      keep watching the board, start nothing new
+  cruo resume [name]     take work again
+  cruo logs [name] [-f]  what a detached agent has been saying
+  \u2026 --all                stop/pause/resume every one of them
+
+  \`stop\` is a request, not a kill: a harness that is mid-run is allowed to
+  finish, so the work it has done is not thrown away. Say it twice to give up
+  waiting. macOS and Linux only \u2014 these are signals and pid files.
+
 Getting a token
   Cruo \u2192 Settings \u2192 Members \u2192 Add an agent. It is shown once.
 
@@ -47391,6 +47768,7 @@ Common options
   --allow <tools>        what the harness may use; default is the board only
   --push                 publish the branch after a run that commits
   --interval <seconds>   how often to poll (default 20)
+  --usage                record what each run costs (needs a Claude Code harness)
 
   Full list and what each one is for: https://cruo.space/docs#agents
 
@@ -47404,7 +47782,7 @@ var EMPTY = { version: 2, default: null, agents: {} };
 async function readConfig2() {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile2(CONFIG_PATH, "utf8"));
+    parsed = JSON.parse(await readFile3(CONFIG_PATH, "utf8"));
   } catch {
     return { ...EMPTY };
   }
@@ -47423,8 +47801,8 @@ async function readConfig2() {
   return { ...EMPTY };
 }
 async function writeConfig(config3) {
-  await mkdir2(CONFIG_DIR, { recursive: true, mode: 448 });
-  await writeFile2(CONFIG_PATH, JSON.stringify(config3, null, 2) + "\n", { mode: 384 });
+  await mkdir3(CONFIG_DIR, { recursive: true, mode: 448 });
+  await writeFile3(CONFIG_PATH, JSON.stringify(config3, null, 2) + "\n", { mode: 384 });
   await chmod(CONFIG_PATH, 384);
 }
 async function identify2(token) {
@@ -47484,7 +47862,7 @@ async function logout(which, all) {
   const config3 = await readConfig2();
   const names = Object.keys(config3.agents);
   if (all) {
-    await rm3(CONFIG_PATH, { force: true });
+    await rm4(CONFIG_PATH, { force: true });
     console.log(
       names.length === 0 ? `
 Nothing was stored.
@@ -47496,7 +47874,7 @@ Forgot ${names.length} token(s): ${names.join(", ")}. ${CONFIG_PATH} is gone.
   }
   if (!which) {
     if (names.length <= 1) {
-      await rm3(CONFIG_PATH, { force: true });
+      await rm4(CONFIG_PATH, { force: true });
       console.log(
         names.length === 0 ? `
 Nothing was stored.
@@ -47552,6 +47930,156 @@ No tokens stored. \`cruo login <token>\` to add one.
  * is what a bare \`cruo\` runs. Use \`--as <name>\` for another.
 `);
 }
+async function targetName(explicit, asName) {
+  if (explicit) return safeName(explicit);
+  if (asName) return safeName(asName);
+  const config3 = await readConfig2();
+  return safeName(config3.default ?? "default");
+}
+async function targets(explicit, asName, all) {
+  if (all) {
+    const rows = await listRecords();
+    return rows.filter((r) => r.live.state === "running").map((r) => r.live.record);
+  }
+  const name = await targetName(explicit, asName);
+  const live = await liveness(name, true);
+  if (live.state === "running") return [live.record];
+  if (live.state === "gone") {
+    console.error(`
+${name} is not running (it left a record behind; cleared).
+`);
+  } else if (live.state === "recycled") {
+    console.error(`
+${name} is not running \u2014 its pid now belongs to something else. Cleared.
+`);
+  } else {
+    console.error(`
+${name} is not running. Start it with \`cruo start --as ${name}\`.
+`);
+  }
+  return [];
+}
+async function startDetached(argv2, asName) {
+  const { spawn: spawn2 } = await import("node:child_process");
+  const { open, mkdir: mkdir4 } = await import("node:fs/promises");
+  const name = await targetName(null, asName);
+  const already = await liveness(name, true);
+  if (already.state === "running") {
+    console.error(
+      `
+${name} is already running (pid ${already.record.pid}, up ${since(already.record.startedAt)}).
+Stop it first, or use --as <name> to run a different agent.
+`
+    );
+    process.exit(1);
+  }
+  await mkdir4(logDir(), { recursive: true });
+  const logPath = join4(logDir(), `${name}.log`);
+  const handle = await open(logPath, "a");
+  const forwarded = argv2.slice(1).filter((a) => a !== "--all");
+  const child = spawn2(process.execPath, [process.argv[1], ...forwarded], {
+    detached: true,
+    stdio: ["ignore", handle.fd, handle.fd],
+    env: process.env
+  });
+  child.unref();
+  await handle.close();
+  console.log(
+    `
+${name} started (pid ${child.pid}).
+
+  logs   cruo logs ${name} -f
+  check  cruo ps
+  stop   cruo stop ${name}
+
+It survives this terminal closing. It does not survive the machine
+sleeping or shutting down \u2014 for that, see the launchd notes in
+https://cruo.space/docs#agents.
+`
+  );
+}
+async function listProcesses() {
+  const rows = await listRecords();
+  const running = rows.filter((r) => r.live.state === "running");
+  if (rows.length === 0) {
+    console.log(`
+Nothing running. Start one with \`cruo start\`.
+`);
+    return;
+  }
+  console.log("");
+  console.log("  agent           pid      up       started with");
+  for (const { agent, live } of rows) {
+    if (live.state === "running") {
+      const flags = live.record.argv.filter((a) => a.startsWith("--")).join(" ") || "(no flags)";
+      console.log(
+        `  ${agent.padEnd(14)} ${String(live.record.pid).padEnd(8)} ${since(live.record.startedAt).padEnd(8)} ${flags}`
+      );
+    } else if (live.state === "gone") {
+      console.log(`  ${agent.padEnd(14)} \u2014        \u2014        died or was killed (record cleared)`);
+      await removeRecord(agent);
+    } else if (live.state === "recycled") {
+      console.log(`  ${agent.padEnd(14)} \u2014        \u2014        gone; its pid is now someone else's (cleared)`);
+      await removeRecord(agent);
+    }
+  }
+  console.log(
+    `
+  ${running.length} running. Whether each is actually picking up work is on the board, not here \u2014
+  Cruo \u2192 Settings \u2192 Members shows what it is holding and when it last looked.
+`
+  );
+}
+async function control(which, explicit, asName, all) {
+  const records = await targets(explicit, asName, all);
+  if (records.length === 0) {
+    if (all) console.log(`
+Nothing running.
+`);
+    process.exitCode = all ? 0 : 1;
+    return;
+  }
+  for (const record2 of records) {
+    const sent = signal(record2.pid, which);
+    if (!sent) {
+      console.error(`  ${record2.agent}: could not signal pid ${record2.pid} \u2014 it may have just exited`);
+      await removeRecord(record2.agent);
+      continue;
+    }
+    if (which === "stop") {
+      console.log(
+        `  ${record2.agent}: asked to stop. It will finish the run it is on first \u2014
+    a harness mid-run keeps its work, which is the point of asking rather than killing.
+    Watch it leave with: cruo logs ${record2.agent} -f`
+      );
+    } else if (which === "pause") {
+      console.log(`  ${record2.agent}: paused. Still watching the board and still reporting; starts nothing new.`);
+    } else {
+      console.log(`  ${record2.agent}: resumed.`);
+    }
+  }
+  console.log("");
+}
+async function showLogs(explicit, asName, follow) {
+  const { spawn: spawn2 } = await import("node:child_process");
+  const name = await targetName(explicit, asName);
+  const record2 = await readRecord(name);
+  const path = record2?.log ?? join4(logDir(), `${name}.log`);
+  const { access } = await import("node:fs/promises");
+  try {
+    await access(path);
+  } catch {
+    console.error(`
+No log for ${name} at ${path}.
+A detached run writes one; a foreground run prints to its terminal.
+`);
+    process.exit(1);
+  }
+  const child = spawn2("tail", follow ? ["-f", "-n", "40", path] : ["-n", "200", path], {
+    stdio: "inherit"
+  });
+  await new Promise((resolve2) => child.on("close", resolve2));
+}
 async function main2() {
   const argv2 = process.argv.slice(2);
   const [first] = argv2;
@@ -47574,12 +48102,25 @@ Usage: cruo login <token> [--as <name>]
     return logout(named, argv2.includes("--all"));
   }
   if (first === "agents" || first === "whoami") return listAgents();
+  {
+    const named = argv2[1] && !argv2[1].startsWith("--") ? argv2[1] : null;
+    const all = argv2.includes("--all");
+    const asName2 = flagValue("--as");
+    if (first === "ps") return listProcesses();
+    if (first === "stop") return control("stop", named, asName2, all);
+    if (first === "pause") return control("pause", named, asName2, all);
+    if (first === "resume") return control("resume", named, asName2, all);
+    if (first === "logs") {
+      return showLogs(named, asName2, argv2.includes("-f") || argv2.includes("--follow"));
+    }
+  }
   if (first === "usage") {
   }
   if (first === "help" || argv2.includes("--help") || argv2.includes("-h")) {
     console.log(USAGE);
     return;
   }
+  if (first === "start") return startDetached(argv2, flagValue("--as"));
   const flagIndex = argv2.indexOf("--token");
   const fromFlag = flagIndex >= 0 ? argv2[flagIndex + 1] : void 0;
   if (fromFlag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cruo-agent",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Run a Cruo agent: it watches your board, picks up the cards you assign it, and works them.",
   "license": "MIT",
   "homepage": "https://cruo.space/docs#agents",