cruo-agent 0.1.8 → 0.1.10

package/dist/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.10

package/dist/cli.js

@@ -45913,6 +45913,36 @@ function isKnownCommandWord(first) {
 function nearestCommands(first) {
   return CRUO_COMMANDS.filter((k) => k[0] === first[0]).slice(0, 3);
 }
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return row[b.length];
+}
+function unknownFlags(argv2, valued = [...SUPERVISOR_VALUED, ...CLI_VALUED], switches = SUPERVISOR_SWITCHES) {
+  const known = [...valued, ...switches];
+  const found = [];
+  for (let i = 0; i < argv2.length; i++) {
+    const arg = argv2[i];
+    if (!arg.startsWith("-")) continue;
+    const name = arg.replace(/^-+/, "");
+    if (valued.includes(name)) {
+      i++;
+      continue;
+    }
+    if (switches.includes(name)) continue;
+    const ranked = known.map((k) => ({ k, d: editDistance(name.split("=")[0], k) })).sort((x, y) => x.d - y.d)[0];
+    found.push({ flag: arg, nearest: ranked && ranked.d <= 2 ? `--${ranked.k}` : null });
+  }
+  return found;
+}
 function numericIn(argv2, name, spec = {}) {
   const i = argv2.indexOf(`--${name}`);
   if (i < 0) return spec.fallback;
@@ -45947,7 +45977,7 @@ function requiredNumericIn(argv2, name, fallback, spec = {}) {
 function secondsIn(argv2, name, fallbackSeconds) {
   return requiredNumericIn(argv2, name, fallbackSeconds, { unit: "seconds" }) * 1e3;
 }
-var CRUO_COMMANDS, OptionError, flagIn, optIn;
+var CRUO_COMMANDS, SUPERVISOR_SWITCHES, SUPERVISOR_VALUED, CLI_VALUED, OptionError, flagIn, optIn;
 var init_options = __esm({
   "src/options.ts"() {
     "use strict";
@@ -45963,8 +45993,32 @@ var init_options = __esm({
       "stop",
       "pause",
       "resume",
-      "logs"
+      "logs",
+      "run",
+      "version",
+      "?"
     ];
+    SUPERVISOR_SWITCHES = ["once", "dry-run", "worktree", "keep-failed", "push", "usage"];
+    SUPERVISOR_VALUED = [
+      "allow",
+      "base",
+      "cwd",
+      "function",
+      "harness",
+      "harness-timeout",
+      "interval",
+      "limit",
+      "max-attempts",
+      "max-interval",
+      "model",
+      "prepare",
+      "prepare-timeout",
+      "project",
+      "push-remote",
+      "repo",
+      "worktree-root"
+    ];
+    CLI_VALUED = ["as", "token"];
     OptionError = class extends Error {
       constructor(message) {
         super(message);
@@ -46051,6 +46105,83 @@ async function listRecords() {
   }
   return out;
 }
+function entryKindOf(token) {
+  const normalised = token.replace(/\\/g, "/");
+  const basename = normalised.slice(normalised.lastIndexOf("/") + 1);
+  if (CLI_BIN_NAMES.has(basename)) return "cli";
+  if (SUPERVISOR_BIN_NAMES.has(basename)) return "supervisor";
+  const isCliFile = /^cli\.(?:js|ts)$/.test(basename);
+  const isSupervisorFile = /^supervisor\.(?:js|ts)$/.test(basename);
+  if (!isCliFile && !isSupervisorFile) return null;
+  if (!OWN_PACKAGE_MARKERS.some((marker) => normalised.includes(marker))) return null;
+  return isCliFile ? "cli" : "supervisor";
+}
+function parsePsLine(line) {
+  const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+  return m ? { pid: Number(m[1]), uid: Number(m[2]), args: m[3] } : null;
+}
+function asNameFrom(tokens) {
+  const i = tokens.indexOf("--as");
+  const value = i >= 0 ? tokens[i + 1] : void 0;
+  return value && !value.startsWith("-") ? safeName(value) : null;
+}
+async function processArgv(pid) {
+  try {
+    const { stdout } = await exec("ps", ["-p", String(pid), "-o", "args="]);
+    const value = stdout.trim();
+    return value === "" ? null : value.split(/\s+/).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+async function findSupervisorProcesses() {
+  const uid = process.getuid?.();
+  if (uid === void 0) return [];
+  let stdout;
+  try {
+    ({ stdout } = await exec("ps", ["-axwwo", "pid=,uid=,args="]));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of stdout.split("\n")) {
+    const parsed = parsePsLine(line);
+    if (!parsed || parsed.uid !== uid || parsed.pid === process.pid) continue;
+    const tokens = parsed.args.trim().split(/\s+/).filter(Boolean);
+    let scriptAt = -1;
+    let kind = null;
+    for (let i = 0; i < tokens.length; i++) {
+      kind = entryKindOf(tokens[i]);
+      if (kind) {
+        scriptAt = i;
+        break;
+      }
+    }
+    if (!kind) continue;
+    if (kind === "cli") {
+      const next = tokens[scriptAt + 1];
+      const isSubcommand = next !== void 0 && !next.startsWith("-") && NON_LOOPING_CLI_COMMANDS.includes(next);
+      if (isSubcommand) continue;
+    }
+    out.push({
+      pid: parsed.pid,
+      asName: asNameFrom(tokens),
+      procStartedAt: await processStartedAt(parsed.pid),
+      argv: tokens
+    });
+  }
+  return out;
+}
+async function untrackedSupervisors() {
+  const found = await findSupervisorProcesses();
+  if (found.length === 0) return found;
+  const tracked = await listRecords();
+  const trackedPids = /* @__PURE__ */ new Set();
+  for (const { live } of tracked) {
+    if (live.state === "running") trackedPids.add(live.record.pid);
+  }
+  return found.filter((p) => !trackedPids.has(p.pid));
+}
 function signal(pid, which) {
   try {
     process.kill(pid, SIGNALS[which]);
@@ -46067,14 +46198,19 @@ function since(iso) {
   if (ms2 < 864e5) return `${Math.round(ms2 / 36e5)}h`;
   return `${Math.round(ms2 / 864e5)}d`;
 }
-var exec, runDir, logDir, recordPath, SIGNALS;
+var exec, runDir, logDir, recordPath, CLI_BIN_NAMES, SUPERVISOR_BIN_NAMES, OWN_PACKAGE_MARKERS, NON_LOOPING_CLI_COMMANDS, SIGNALS;
 var init_process = __esm({
   "src/process.ts"() {
     "use strict";
+    init_options();
     exec = promisify(execFile);
     runDir = () => join(homedir(), ".cruo", "run");
     logDir = () => join(homedir(), ".cruo", "logs");
     recordPath = (agent) => join(runDir(), `${safeName(agent)}.json`);
+    CLI_BIN_NAMES = /* @__PURE__ */ new Set(["cruo", "cruo-agent"]);
+    SUPERVISOR_BIN_NAMES = /* @__PURE__ */ new Set(["cruo-supervisor"]);
+    OWN_PACKAGE_MARKERS = ["@cruo/mcp", "cruo-agent", "apps/mcp", "packages/cli"];
+    NON_LOOPING_CLI_COMMANDS = CRUO_COMMANDS.filter((c) => c !== "run");
     SIGNALS = {
       stop: "SIGTERM",
       pause: "SIGUSR1",
@@ -47057,6 +47193,14 @@ function systemPrompt(ctx, identity, worktree) {
     `- If you cannot do the work \u2014 missing information, ambiguous brief, outside`,
     `  your capabilities \u2014 say so in a comment and assign it to someone who can,`,
     `  or leave it for a human. Do not guess, and do not silently do nothing.`,
+    `- Claim the work before you do it: move the issue to the state your workflow`,
+    `  uses for work in progress, and do that BEFORE you start, not when you`,
+    `  finish. However short the work looks \u2014 a run of a few minutes is exactly`,
+    `  the case nobody sees. A board that only changes at the end shows an idle`,
+    `  queue while the work is happening, and neither a colleague nor another`,
+    `  agent choosing what to pick up can tell a card nobody has touched from one`,
+    `  being worked right now. If the workflow has no such state, leave it where`,
+    `  it is. A mention is the exception \u2014 see below.`,
     `- You may be given an issue because someone MENTIONED you on it rather than`,
     `  because your function owns its state. The prompt says which. A mention is`,
     `  a question from a colleague: read the comments with list_comments, answer`,
@@ -47077,14 +47221,16 @@ function userPrompt(hit) {
   if (hit.reason === "assigned") {
     return [
       `${hit.ref} \u2014 "${hit.issue.title}" \u2014 is assigned to you, in the "${hit.state.name}"`,
-      `state. Do it. When you are finished, hand it on: move it to the state that`,
+      `state. Claim it first \u2014 move it to the state your workflow uses for work in`,
+      `progress \u2014 then do it. When you are finished, hand it on: move it to the state that`,
       `comes next and assign it to whoever owns that step. Leaving it assigned to`,
       `you, in this state, means it comes back to you.`
     ].join(" ");
   }
   return [
     `${hit.ref} \u2014 "${hit.issue.title}" \u2014 is in the "${hit.state.name}" state,`,
-    `which your function owns. Pick it up and do your part.`
+    `which your function owns. Claim it first \u2014 move it to the state your workflow`,
+    `uses for work in progress \u2014 then do your part.`
   ].join(" ");
 }
 function headFor(head2) {
@@ -47436,6 +47582,7 @@ async function tick(ctx, identity, deadTicks, allowance) {
     let committed = 0;
     let salvaged = null;
     const stopBusyBeat = beatWhileBusy(ctx, deadTicks);
+    currentRun = { ref: hit.ref, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
     try {
       run = await invokeHarness(ctx, identity, hit, worktree);
       if (worktree) committed = await worktree.commits();
@@ -47459,6 +47606,7 @@ async function tick(ctx, identity, deadTicks, allowance) {
       }
     } finally {
       stopBusyBeat();
+      currentRun = null;
       await release(ctx, hit);
     }
     const code = run.code;
@@ -47527,6 +47675,22 @@ async function tick(ctx, identity, deadTicks, allowance) {
   });
   return { invoked, failedToRun, suppressed: false, waiting: actionable.length };
 }
+function interruptibleWait(ms2) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      pendingWait = null;
+      resolve2();
+    }, ms2);
+    pendingWait = { timer, resolve: resolve2 };
+  });
+}
+function interruptWait() {
+  if (!pendingWait) return;
+  clearTimeout(pendingWait.timer);
+  const { resolve: resolve2 } = pendingWait;
+  pendingWait = null;
+  resolve2();
+}
 function installControls() {
   const requestStop = (why) => {
     if (stopping && Date.now() - stopRequestedAt < 500) return;
@@ -47536,7 +47700,14 @@ function installControls() {
     }
     stopping = true;
     stopRequestedAt = Date.now();
-    log(`  ${why} \u2014 finishing the current run, then stopping. Again to leave now.`);
+    if (currentRun) {
+      log(
+        `  ${why} \u2014 finishing the current run (${currentRun.ref}), running ${since(currentRun.startedAt)} so far, up to ${Math.round(options.harnessTimeoutMs / 1e3)}s before it is killed. Again to leave now.`
+      );
+    } else {
+      log(`  ${why} \u2014 idle, nothing to finish, leaving now.`);
+    }
+    interruptWait();
   };
   process.on("SIGTERM", () => requestStop("stop requested"));
   process.on("SIGINT", () => requestStop("interrupted"));
@@ -47584,6 +47755,27 @@ first with no way to be stopped except by pid.
 
   stop it     cruo stop ${runName}
   look at it  cruo ps
+`
+      );
+      process.exit(2);
+    }
+    const ownArgv = await processArgv(process.pid);
+    const implicit = !ownArgv || asNameFrom(ownArgv) === null;
+    const runningUntracked = (await untrackedSupervisors()).filter(
+      (p) => p.asName === runName || implicit && p.asName === null
+    );
+    if (runningUntracked.length > 0) {
+      const pids = runningUntracked.map((p) => p.pid).join(", ");
+      console.error(
+        `
+${runName} looks like it is already running here \u2014 untracked, pid ${pids} (found in the process table, no run record).
+
+Two supervisors for one agent share a token, a queue and a heartbeat,
+and starting this one anyway repeats the exact incident this check exists
+to catch: a second supervisor nothing could see or stop.
+
+  look at it  cruo ps
+  stop it     cruo stop ${runName}
 `
       );
       process.exit(2);
@@ -47678,11 +47870,11 @@ first with no way to be stopped except by pid.
     }
     if (options.once) return;
     if (stopping) return;
-    await new Promise((r) => setTimeout(r, options.intervalMs));
+    await interruptibleWait(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, lastHolding, warnedAboutSpendTable, stopping, paused, stopRequestedAt;
+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, currentRun, pendingWait;
 var init_supervisor = __esm({
   "src/supervisor.ts"() {
     "use strict";
@@ -47829,6 +48021,12 @@ var init_supervisor = __esm({
     });
     options = (() => {
       try {
+        const [unknown2] = unknownFlags(argv, SUPERVISOR_VALUED);
+        if (unknown2) {
+          throw new OptionError(
+            `${unknown2.flag} is not a flag the supervisor reads` + (unknown2.nearest ? ` \u2014 did you mean ${unknown2.nearest}?` : ".") + ` Nothing was started.`
+          );
+        }
         return readOptions();
       } catch (error51) {
         if (error51 instanceof OptionError) {
@@ -47870,6 +48068,8 @@ cruo-supervisor: ${error51.message}
     stopping = false;
     paused = false;
     stopRequestedAt = 0;
+    currentRun = null;
+    pendingWait = null;
     main().then(async () => {
       if (!options.once && !options.dryRun) {
         try {
@@ -47914,8 +48114,10 @@ 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, in this terminal
-  cruo --as <name> \u2026     run a particular one
+  cruo run [options]     run the agent's supervisor, in this terminal
+  cruo --as <name> \u2026     run a particular one (flags alone also run it)
+  cruo version           which build this is
+  cruo help              this list (also: cruo, cruo -h, cruo ?)
 
 Running one in the background
   cruo start [options]   same, detached \u2014 survives closing the terminal
@@ -48027,7 +48229,7 @@ ${CONFIG_PATH} is readable only by you.
 
 ` + (config3.default === name ? `Run \`cruo --dry-run\` to see what it would pick up.
 ` : `Run \`cruo --as ${name} --dry-run\` to see what it would pick up.
-A bare \`cruo\` still runs \`${config3.default}\`.
+\`cruo run\` still runs \`${config3.default}\`.
 `)
   );
 }
@@ -48078,7 +48280,7 @@ Nothing stored for \`${which}\`. Stored: ${names.join(", ") || "(none)"}
   await writeConfig(config3);
   console.log(
     `
-Forgot the token for \`${which}\`.` + (config3.default ? ` A bare \`cruo\` now runs \`${config3.default}\`.
+Forgot the token for \`${which}\`.` + (config3.default ? ` \`cruo run\` now runs \`${config3.default}\`.
 ` : ` Nothing is stored now.
 `)
   );
@@ -48100,7 +48302,7 @@ No tokens stored. \`cruo login <token>\` to add one.
     console.log(` ${mark} ${name}${who}`);
   }
   console.log(`
- * is what a bare \`cruo\` runs. Use \`--as <name>\` for another.
+ * is what \`cruo run\` runs. Use \`--as <name>\` for another.
 `);
 }
 async function targetName(explicit, asName) {
@@ -48109,28 +48311,72 @@ async function targetName(explicit, asName) {
   const config3 = await readConfig2();
   return safeName(config3.default ?? "default");
 }
+async function untrackedMatchingForRefusal(name, implicit) {
+  return (await untrackedSupervisors()).filter((p) => p.asName === name || implicit && p.asName === null);
+}
+function reportUnidentified(procs) {
+  if (procs.length === 0) return false;
+  const pids = procs.map((p) => p.pid).join(", ");
+  console.error(
+    `
+${procs.length} more untracked ${procs.length === 1 ? "process" : "processes"} found with no \`--as\` of its own to confirm identity: pid ${pids}.
+Not signalled \u2014 a wrong \`stop\` is far more costly than a missed one. Look at it yourself:
+
+  cruo ps
+  kill -TERM <pid>   (if you are sure)
+`
+  );
+  return true;
+}
 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 tracked = rows.filter((r) => r.live.state === "running").map((r) => ({ agent: r.agent, pid: r.live.record.pid, untracked: false }));
+    const discovered = await untrackedSupervisors();
+    const untracked = discovered.filter((p) => p.asName !== null).map((p) => ({ agent: p.asName, pid: p.pid, untracked: true }));
+    const reported = reportUnidentified(discovered.filter((p) => p.asName === null));
+    if (!reported && tracked.length === 0 && untracked.length === 0) console.log(`
+Nothing running.
+`);
+    return [...tracked, ...untracked];
   }
   const name = await targetName(explicit, asName);
+  const implicit = explicit === null && asName === null;
   const live = await liveness(name, true);
-  if (live.state === "running") return [live.record];
-  if (live.state === "gone") {
-    console.error(`
+  const out = [];
+  if (live.state === "running") out.push({ agent: name, pid: live.record.pid, untracked: false });
+  const matches = (await untrackedSupervisors()).filter((p) => p.asName === name);
+  out.push(...matches.map((p) => ({ agent: name, pid: p.pid, untracked: true })));
+  if (out.length === 0) {
+    const unidentified = implicit ? (await untrackedSupervisors()).filter((p) => p.asName === null) : [];
+    if (unidentified.length > 0) {
+      const pids = unidentified.map((p) => p.pid).join(", ");
+      console.error(
+        `
+${name} \u2014 can't confirm. ${unidentified.length} untracked ${unidentified.length === 1 ? "process" : "processes"} found with no \`--as\` of its own (pid ${pids}) \u2014 exactly how ${name} would look if it is running as this machine's default identity, but nothing here can tell that apart from an
+unrelated process sharing this account.
+
+Not signalled. Look at it yourself, then act if you are sure:
+
+  cruo ps
+  kill -TERM <pid>
+`
+      );
+    } else if (live.state === "gone") {
+      console.error(`
 ${name} is not running (it left a record behind; cleared).
 `);
-  } else if (live.state === "recycled") {
-    console.error(`
+    } else if (live.state === "recycled") {
+      console.error(`
 ${name} is not running \u2014 its pid now belongs to something else. Cleared.
 `);
-  } else {
-    console.error(`
+    } else {
+      console.error(`
 ${name} is not running. Start it with \`cruo start --as ${name}\`.
 `);
+    }
   }
-  return [];
+  return out;
 }
 async function startDetached(argv2, asName) {
   const { spawn: spawn2 } = await import("node:child_process");
@@ -48158,6 +48404,22 @@ Stop it first, or use --as <name> to run a different agent.
     );
     process.exit(1);
   }
+  const runningUntracked = await untrackedMatchingForRefusal(name, !positional && !asName);
+  if (runningUntracked.length > 0) {
+    const pids = runningUntracked.map((p) => p.pid).join(", ");
+    console.error(
+      `
+${name} looks like it is already running here \u2014 untracked, pid ${pids} (found in the process table, no run record).
+
+Two supervisors for one agent share a token, a queue and a heartbeat.
+Look at it, then stop it if it should not be there:
+
+  cruo ps
+  cruo stop ${name}
+`
+    );
+    process.exit(2);
+  }
   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;
@@ -48175,13 +48437,14 @@ Either \`cruo start ${stored[0]}\`, or add this one:
     );
     process.exit(2);
   }
+  refuseUnknownFlags(argv2.slice(positional ? 2 : 1).filter((a) => a !== "--all"));
   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 forwarded = ["run", ...chosen ? ["--as", chosen] : [], ...withoutAs];
   const child = spawn2(process.execPath, [process.argv[1], ...forwarded], {
     detached: true,
     stdio: ["ignore", handle.fd, handle.fd],
@@ -48206,7 +48469,8 @@ 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) {
+  const untracked = await untrackedSupervisors();
+  if (rows.length === 0 && untracked.length === 0) {
     console.log(`
 Nothing running. Start one with \`cruo start\`.
 `);
@@ -48228,9 +48492,25 @@ Nothing running. Start one with \`cruo start\`.
       await removeRecord(agent);
     }
   }
+  for (const proc of untracked) {
+    const name = proc.asName ?? "(unknown identity)";
+    const flags = proc.argv.filter((a) => a.startsWith("--")).join(" ") || "(no flags)";
+    const up = proc.procStartedAt ? since(proc.procStartedAt) : "?";
+    console.log(
+      `  ${name.padEnd(14)} ${String(proc.pid).padEnd(8)} ${up.padEnd(8)} ${flags}  \u2014 UNTRACKED (no run record; found in the process table)`
+    );
+  }
+  if (untracked.length > 0) {
+    const named = untracked.filter((p) => p.asName !== null).length;
+    const unnamed = untracked.length - named;
+    console.log(
+      `
+  ${untracked.length} untracked ${untracked.length === 1 ? "process" : "processes"} found with no run record.` + (named > 0 ? ` \`cruo stop <name>\` can reach ${named === 1 ? "the one" : `${named}`} whose own argv named it with --as.` : "") + (unnamed > 0 ? ` ${unnamed} ${unnamed === 1 ? "has" : "have"} no \`--as\` of its own \u2014 \`cruo stop\` will report ${unnamed === 1 ? "its" : "their"} pid but never signal ${unnamed === 1 ? "it" : "them"} without one.` : "")
+    );
+  }
   console.log(
     `
-  ${running.length} running. Whether each is actually picking up work is on the board, not here \u2014
+  ${running.length + untracked.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.
 `
   );
@@ -48238,29 +48518,27 @@ Nothing running. Start one with \`cruo start\`.
 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 tag = record2.untracked ? ` (untracked, pid ${record2.pid})` : "";
     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);
+      console.error(`  ${record2.agent}${tag}: could not signal pid ${record2.pid} \u2014 it may have just exited`);
+      if (!record2.untracked) 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
+        `  ${record2.agent}${tag}: 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.`);
+      console.log(`  ${record2.agent}${tag}: paused. Still watching the board and still reporting; starts nothing new.`);
     } else {
-      console.log(`  ${record2.agent}: resumed.`);
+      console.log(`  ${record2.agent}${tag}: resumed.`);
     }
   }
   console.log("");
@@ -48285,6 +48563,26 @@ A detached run writes one; a foreground run prints to its terminal.
   });
   await new Promise((resolve2) => child.on("close", resolve2));
 }
+async function printVersion() {
+  try {
+    const pkg = JSON.parse(await readFile3(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(`${pkg.name} ${pkg.version}`);
+  } catch {
+    console.log("unknown \u2014 no package.json beside this build");
+  }
+}
+function refuseUnknownFlags(argv2) {
+  const unknown2 = unknownFlags(argv2);
+  if (unknown2.length === 0) return;
+  console.error(
+    `
+${unknown2.map((u) => `\`${u.flag}\` is not a cruo flag.` + (u.nearest ? ` Did you mean ${u.nearest}?` : "")).join("\n")}
+
+Nothing was started. Everything it takes:  cruo help
+`
+  );
+  process.exit(2);
+}
 async function main2() {
   const argv2 = process.argv.slice(2);
   const [first] = argv2;
@@ -48321,10 +48619,11 @@ Usage: cruo login <token> [--as <name>]
   }
   if (first === "usage") {
   }
-  if (first === "help" || argv2.includes("--help") || argv2.includes("-h")) {
+  if (first === void 0 || first === "help" || first === "?" || argv2.includes("--help") || argv2.includes("-h")) {
     console.log(USAGE);
     return;
   }
+  if (first === "version" || first === "--version" || first === "-v") return printVersion();
   if (!isKnownCommandWord(first)) {
     const near = nearestCommands(first);
     console.error(
@@ -48333,13 +48632,15 @@ Usage: cruo login <token> [--as <name>]
 
 ` + (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
+` : "") + `To run the agent:     cruo run [options]
+Everything it takes:  cruo help
 `
     );
     process.exit(2);
   }
   if (first === "start") return startDetached(argv2, flagValue("--as"));
+  const runArgv = first === "run" ? argv2.slice(1) : argv2;
+  if (first !== "usage") refuseUnknownFlags(runArgv);
   const flagIndex = argv2.indexOf("--token");
   const fromFlag = flagIndex >= 0 ? argv2[flagIndex + 1] : void 0;
   if (fromFlag) {
@@ -48379,7 +48680,7 @@ Get one from Cruo \u2192 Settings \u2192 Members \u2192 Add an agent.
     process.env.CRUO_IDENTITY = asName ?? config3.default ?? "";
   }
   process.env.CRUO_TOKEN = token;
-  const passthrough = stripTokenFlag(argv2).filter((a, i, all) => a !== "--as" && all[i - 1] !== "--as");
+  const passthrough = stripTokenFlag(runArgv).filter((a, i, all) => a !== "--as" && all[i - 1] !== "--as");
   process.argv = [process.argv[0], process.argv[1], ...passthrough];
   if (first === "usage") {
     const { reportUsage: reportUsage2 } = await Promise.resolve().then(() => (init_usage(), usage_exports));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cruo-agent",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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",