cruo-agent 0.1.5 → 0.1.7

package/dist/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.7

package/dist/cli.js

@@ -16166,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) {
@@ -16199,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;
               }
@@ -16291,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) {
@@ -17334,8 +17334,8 @@ ${cause.stack}`;
       *
       * ```
       */
-      abortSignal(signal) {
-        this.signal = signal;
+      abortSignal(signal2) {
+        this.signal = signal2;
         return this;
       }
       /**
@@ -23494,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 */
@@ -30517,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({
@@ -30527,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) {
@@ -30631,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,
@@ -30648,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 };
@@ -30689,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,
@@ -30717,7 +30717,7 @@ var require_webauthn = __commonJS({
             factorId: factor.id,
             friendlyName: factor.friendly_name,
             webauthn: { rpId, rpOrigins },
-            signal
+            signal: signal2
           }, {
             create: overrides
           });
@@ -35593,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({
@@ -35641,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({
@@ -36027,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 {
@@ -36036,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) {
@@ -36060,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";
@@ -36121,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) {
@@ -45905,6 +45905,14 @@ function stripTokenFlag(argv2) {
   if (at < 0) return [...argv2];
   return [...argv2.slice(0, at), ...argv2.slice(at + 2)];
 }
+function isKnownCommandWord(first) {
+  if (first === void 0) return true;
+  if (first.startsWith("-")) return true;
+  return CRUO_COMMANDS.includes(first);
+}
+function nearestCommands(first) {
+  return CRUO_COMMANDS.filter((k) => k[0] === first[0]).slice(0, 3);
+}
 function numericIn(argv2, name, spec = {}) {
   const i = argv2.indexOf(`--${name}`);
   if (i < 0) return spec.fallback;
@@ -45939,10 +45947,24 @@ function requiredNumericIn(argv2, name, fallback, spec = {}) {
 function secondsIn(argv2, name, fallbackSeconds) {
   return requiredNumericIn(argv2, name, fallbackSeconds, { unit: "seconds" }) * 1e3;
 }
-var OptionError, flagIn, optIn;
+var CRUO_COMMANDS, OptionError, flagIn, optIn;
 var init_options = __esm({
   "src/options.ts"() {
     "use strict";
+    CRUO_COMMANDS = [
+      "login",
+      "logout",
+      "agents",
+      "whoami",
+      "usage",
+      "help",
+      "start",
+      "ps",
+      "stop",
+      "pause",
+      "resume",
+      "logs"
+    ];
     OptionError = class extends Error {
       constructor(message) {
         super(message);
@@ -45957,6 +45979,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;
@@ -46048,8 +46174,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("-");
@@ -46363,12 +46489,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) {
@@ -46407,16 +46533,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,
@@ -46459,7 +46585,7 @@ Cruo-Wip: ${reason}
     },
     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"]);
     }
@@ -46469,14 +46595,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;
@@ -46485,18 +46611,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);
   }
 });
 
@@ -46504,9 +46630,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();
@@ -46531,7 +46657,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 });
@@ -46679,13 +46805,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(
       {
@@ -46709,7 +46835,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();
@@ -46717,18 +46843,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 {
     }
@@ -46738,7 +46864,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, {
@@ -46874,11 +47000,22 @@ 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 builtinTools = [
+    ...new Set(
+      options.allow.split(",").map((t) => t.trim()).filter((t) => t !== "" && !t.startsWith("mcp__")).map((t) => t.replace(/\(.*$/, ""))
+    )
+  ].join(",");
   const args = [
     "-p",
     userPrompt(hit),
     "--mcp-config",
     mcpConfig,
+    // Both, always. See the note above: without `--restricted` the harness
+    // inherits the operator's settings, and without `--tools` it keeps every
+    // built-in that `--restricted` does not itself remove.
+    "--restricted",
+    "--tools",
+    builtinTools,
     // Only the server we just described. Without this the harness would also
     // load the developer's own .mcp.json — including, on this machine, a Cruo
     // token belonging to a human.
@@ -47010,8 +47147,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;
@@ -47046,11 +47183,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({
@@ -47249,6 +47404,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)"}`
@@ -47262,6 +47446,34 @@ async function main() {
   }
   const ctx = await contextOrExplain();
   const identity = await identify(ctx);
+  installControls();
+  const runName = identityName();
+  if (!options.once && !options.dryRun) {
+    const existing = await liveness(runName, true);
+    if (existing.state === "running") {
+      console.error(
+        `
+${runName} is already running here (pid ${existing.record.pid}, up ${since(existing.record.startedAt)}).
+
+Two supervisors for one agent share a token, a queue and a heartbeat,
+and the second would take over the first one's record \u2014 leaving the
+first with no way to be stopped except by pid.
+
+  stop it     cruo stop ${runName}
+  look at it  cruo ps
+`
+      );
+      process.exit(2);
+    }
+    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) {
@@ -47315,7 +47527,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();
@@ -47342,10 +47554,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, HEAD_STORED, 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";
@@ -47355,6 +47569,7 @@ var init_supervisor = __esm({
     init_auth();
     init_options();
     init_harness_signal();
+    init_process();
     init_pacing();
     init_worktree();
     argv = process.argv.slice(2);
@@ -47526,9 +47741,30 @@ cruo-supervisor: ${error51.message}
       "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);
     });
   }
@@ -47538,11 +47774,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;
@@ -47553,9 +47790,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.
 
@@ -47581,7 +47831,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 };
   }
@@ -47600,8 +47850,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) {
@@ -47661,7 +47911,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.
@@ -47673,7 +47923,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.
@@ -47729,6 +47979,188 @@ 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 positional = argv2[1] && !argv2[1].startsWith("--") ? argv2[1] : null;
+  if (positional && asName && safeName(positional) !== safeName(asName)) {
+    console.error(
+      `
+Two different agents named: \`${positional}\` and \`--as ${asName}\`.
+
+Say one:  cruo start ${positional} \u2026
+      or  cruo start --as ${asName} \u2026
+`
+    );
+    process.exit(2);
+  }
+  const name = await targetName(positional, 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);
+  }
+  const config3 = await readConfig2();
+  const storedKey = Object.keys(config3.agents).find((k) => safeName(k) === name) ?? null;
+  const hasToken = Boolean(process.env.CRUO_TOKEN?.trim()) || argv2.includes("--token") || storedKey !== null;
+  if (!hasToken) {
+    const stored = Object.keys(config3.agents);
+    console.error(
+      `
+Nothing stored for \`${name}\`, so there is no token to run it with.
+
+` + (stored.length > 0 ? `Stored: ${stored.join(", ")}
+Either \`cruo start ${stored[0]}\`, or add this one:
+` : `Nothing is stored at all. Add one:
+`) + `  cruo login <token>
+`
+    );
+    process.exit(2);
+  }
+  await mkdir4(logDir(), { recursive: true });
+  const logPath = join4(logDir(), `${name}.log`);
+  const handle = await open(logPath, "a");
+  const rest = argv2.slice(positional ? 2 : 1).filter((a) => a !== "--all");
+  const chosen = storedKey ?? positional ?? asName;
+  const withoutAs = rest.filter((a, i, all) => a !== "--as" && all[i - 1] !== "--as");
+  const forwarded = chosen ? ["--as", chosen, ...withoutAs] : withoutAs;
+  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;
@@ -47751,12 +48183,39 @@ 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 (!isKnownCommandWord(first)) {
+    const near = nearestCommands(first);
+    console.error(
+      `
+\`${first}\` is not a cruo command.
+
+` + (near.length > 0 ? `Did you mean:  ${near.map((k) => `cruo ${k}`).join("   ")}
+
+` : "") + `To run the agent, give no command:  cruo [options]
+Everything it takes:                cruo --help
+`
+    );
+    process.exit(2);
+  }
+  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.5",
+  "version": "0.1.7",
   "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",