tryharness 0.7.4 → 0.7.7

package/cli.mjs

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureAgents, AGENTS, MCP_CLIENTS, detectMcpClients, mcpClientSnippet, removeAgentConfigurations } from "./lib/adapters.mjs";
+import { setupSwarm, testAgent } from "./lib/onboard.mjs";
+import { removeLocalWakes } from "./lib/wakes.mjs";
 import { detectAgents } from "./lib/commands.mjs";
 import { daemonRequest } from "./lib/control-client.mjs";
 import { ensureDir, readJson, writeJsonAtomic } from "./lib/files.mjs";
@@ -116,13 +119,6 @@ async function waitForDaemon(timeoutMs = 12_000) {
   throw new Error(`daemon started but its authenticated Harness bridge did not become ready: ${lastError?.message || lastStatus?.lastError || "timeout"}. Run: npx tryharness doctor`);
 }
 
-function printAgentStates(states) {
-  for (const state of states) {
-    const icon = !state.installed ? "–" : state.configured ? "✓" : "!";
-    console.log(`  ${icon} ${state.agent}: ${state.detail}`);
-  }
-}
-
 async function connect() {
   ensureDir(paths.home);
   const detected = detectAgents();
@@ -151,14 +147,19 @@ async function connect() {
   const stateMap = Object.fromEntries(states.map((state) => [state.agent, state]));
   config = { ...readJson(paths.config, config), version: VERSION, runtimeRoot, agentStates: stateMap };
   writeJsonAtomic(paths.config, config);
-  printAgentStates(states);
-  for (const client of detectMcpClients()) {
-    if (client.path) console.log(`  ! ${client.client}: found; it joins the task board once you paste its MCP snippet (npx tryharness mcp ${client.client})`);
-  }
-
   const service = installService({ runtimeRoot });
   const ready = await waitForDaemon();
   console.log(`daemon: ready via ${service.manager} and connected to Harness`);
+  await setupSwarm({ runtimeRoot, states, daemonRequest });
+  try {
+    const devices = await daemonRequest({ command: "phone.list" });
+    if (devices.ok && !devices.phones.some((device) => device.kind === "browser" && !device.revoked_at)) {
+      console.log("browser: connecting it to this computer end to end");
+      await link({ quiet: true });
+    } else if (devices.ok) console.log("browser: connected end to end");
+  } catch (error) {
+    console.log(`browser: not connected (${error.message}); run npx tryharness link`);
+  }
   if (!has("--no-desktop")) desktop();
   // The context space's embedder lives with the daemon and comes down with setup, so the machine
   // can search a task by meaning before the first task exists. About 110 MB, once.
@@ -263,9 +264,22 @@ async function connectAgent() {
   let brief = "";
   if (file) brief = fs.readFileSync(path.resolve(file), "utf8");
   else if (!process.stdin.isTTY) for await (const chunk of process.stdin) brief += chunk;
-  const response = await daemonRequest({ command: "relay.request", to, fromAgent, about, brief }, 20_000);
+  const response = await daemonRequest({ command: "relay.request", to, fromAgent, about, brief, trustNewKey: has("--trust-new-key") }, 20_000);
   if (!response.ok) throw new Error(response.error || "request failed");
   console.log(`Asked ${to} to work "${about}" with your ${fromAgent}. Thread ${String(response.threadId || "").slice(0, 8)} is ${response.status || "requested"}; once they accept, it appears on your board and your ${fromAgent} is told.`);
+  console.log(response.sealed
+    ? `Sealed end to end to ${to.split("/")[0]}'s computer (key ${response.fingerprint}); Harness carries it and cannot read it. Check the key with them once: npx tryharness peers`
+    : `Not end to end: ${to.split("/")[0]}'s computer runs a Harness without sealed threads yet, so Harness can read this thread.`);
+}
+
+// The keys of other people's computers this one has worked with, pinned the first time, and its own.
+async function peers() {
+  const response = await daemonRequest({ command: "relay.peers" });
+  if (!response.ok) throw new Error(response.error || "the daemon could not list keys");
+  console.log(`This computer: ${response.mine ?? "no key yet"}`);
+  if (!response.peers.length) { console.log("No other computers yet. A key is pinned the first time you connect with someone."); return; }
+  for (const peer of response.peers) console.log(`${peer.handle.padEnd(20)} ${peer.fingerprint}   pinned ${peer.pinned_at.slice(0, 10)}`);
+  console.log("Read a fingerprint to its owner over a channel you trust; if it matches what their npx tryharness peers shows, nobody stands between you.");
 }
 
 async function mcpSnippet() {
@@ -289,7 +303,7 @@ async function board() {
     const targets = String(arg("--for", "")).split(",").map((value) => value.trim()).filter(Boolean);
     const target = targets.length === 1 ? targets[0] : null;
     // Coding agents, Grok Bot and Harness live on this machine's board; Bankr, Quotient and Muse live in Harness and the daemon posts there.
-    const allowed = (name) => AGENTS.includes(name) || ["harness", "grok-bot", "muse", "bankr", "quotient"].includes(name);
+    const allowed = (name) => AGENTS.includes(name) || ["harness", "grok-bot", "openclaw", "hermes", "muse", "bankr", "quotient"].includes(name);
     if (targets.some((name) => !allowed(name))) throw new Error("usage: tryharness board post --for <agent[,agent...]> --objective <text> [--file <brief.md>] [--run --workspace <dir>]");
     const objective = arg("--objective", "");
     const file = arg("--file");
@@ -477,13 +491,39 @@ async function goal() {
   throw new Error("usage: tryharness goal [list | set --objective <text> [--brief <text>] [--team a,b] [--facilitator <agent>] [--workspace <dir>] [--max-posts n] [--max-wakes n] | show <id> | stop <id> | resume <id> [--max-posts n] | folder <id> <dir> | invite <id> <handle/agent>]");
 }
 
+// The swarm's coordinator: who coordinates, and the record of every round it ran.
+async function swarm() {
+  const sub = argv[0] || "rounds";
+  if (sub === "coordinator") {
+    const mode = argv[1];
+    if (mode && mode !== "harness" && mode !== "local") throw new Error("usage: tryharness swarm coordinator [harness|local]");
+    const response = await daemonRequest({ command: "board.swarm.coordinator", agent: "user", ...(mode ? { mode } : {}) });
+    if (!response.ok) throw new Error(response.error || "the coordinator setting was not changed");
+    console.log(response.mode === "local" ? "Threads are coordinated by an agent on this computer with its tools off; nothing in them goes to Harness." : "Threads are coordinated by Harness: each round sends the thread's newest posts and its options to Harness, which decides and words the next step.");
+    return;
+  }
+  if (sub === "rounds") {
+    const response = await daemonRequest({ command: "board.swarm.rounds", agent: "user", ...(argv[1] ? { id: argv[1] } : {}), limit: Number(arg("--limit", "30")) });
+    if (!response.ok) throw new Error(response.error || "rounds unavailable");
+    if (!response.rounds.length) { console.log("No rounds yet."); return; }
+    for (const r of response.rounds) {
+      const cost = r.estimated_micro_usd == null ? "cost unknown" : `$${(r.estimated_micro_usd / 1e6).toFixed(4)} est.`;
+      const progress = `${r.progress.runsFinished} runs done, ${r.progress.newResults} new, ${r.progress.roundsWithoutProgress} rounds idle`;
+      console.log(`${r.at}  ${r.goal_id.slice(0, 8)}  ${r.coordinator.padEnd(11)} ${(r.error ? "error" : r.action ?? "-").padEnd(10)} ${(r.agent ?? "").padEnd(11)} ${(r.loop ?? "").padEnd(13)} ${progress}  ${r.elapsed_ms}ms  ${cost}${r.error ? `  ${r.error}` : ""}`);
+    }
+    return;
+  }
+  throw new Error("usage: tryharness swarm [rounds [<thread>] [--limit n] | coordinator [harness|local]]");
+}
+
 async function room() {
   const agent = arg("--as", "user");
-  const words = argv.filter((value, index, all) => !value.startsWith("--") && all[index - 1] !== "--as" && all[index - 1] !== "--since");
+  const words = argv.filter((value, index, all) => !value.startsWith("--") && !["--as", "--since", "--ask"].includes(all[index - 1]));
   if (words[0] === "post") {
-    const response = await daemonRequest({ command: "board.room.post", agent, id: String(words[1] || ""), text: words.slice(2).join(" "), shareWithGuests: has("--guests") });
+    const ask = String(arg("--ask", "")).split(",").map((name) => name.trim()).filter(Boolean);
+    const response = await daemonRequest({ command: "board.room.post", agent, id: String(words[1] || ""), text: words.slice(2).join(" "), ask, shareWithGuests: has("--guests") });
     if (!response.ok) throw new Error(response.error || "post failed");
-    console.log(response.held ? `Held: it looks like ${response.held}.` : `Posted [${response.post.seq}].`);
+    console.log(response.held ? `Held: it looks like ${response.held}.` : `Posted [${response.post.seq}].${response.note ? ` ${response.note}` : ""}`);
     return;
   }
   const response = await daemonRequest({ command: "board.room.read", agent, id: String(words[0] || ""), since: Number(arg("--since", "0")) });
@@ -544,13 +584,73 @@ async function disconnect() {
   retireDesktop({});
   try { await daemonRequest({ command: "shutdown" }, 2_000); } catch {}
   removeAgentConfigurations();
+  removeLocalWakes();
   try { fs.renameSync(paths.config, paths.config + `.disconnected-${Date.now()}`); } catch {}
   for (const target of [paths.status, paths.socket]) try { fs.unlinkSync(target); } catch {}
   console.log("Harness disconnected. The local history database was preserved.");
 }
 
+// How Harness reaches each agent: `agents` walks the whole swarm, `agents setup <agent>` one agent, `agents test <agent>`
+// posts a check and waits for the agent to answer it.
+async function agents() {
+  const config = readJson(paths.config, {});
+  const [sub, agent] = argv;
+  if (sub === "test" && agent) { process.exitCode = (await testAgent({ agent, daemonRequest })) ? 0 : 1; return; }
+  await setupSwarm({ runtimeRoot: config.runtimeRoot, states: Object.values(config.agentStates || {}), daemonRequest, only: sub === "setup" ? agent || null : null });
+}
+
+async function phone() {
+  const sub = argv[0] || "pair";
+  if (sub === "pair") {
+    const response = await daemonRequest({ command: "phone.offer" });
+    if (!response.ok) throw new Error(response.error || "the daemon could not make a pairing code");
+    const { default: encodeQR } = await import("qr");
+    console.log("Scan this with your phone's camera. The code works once, for 10 minutes.\n");
+    console.log(encodeQR(response.url, "term"));
+    if (has("--link")) console.log(`\n${response.url}\n\nThis link is the pairing secret: open it only on your own phone.`);
+    console.log("\nThe phone talks to this computer through Harness, and Harness only relays sealed messages it cannot read.");
+    return;
+  }
+  if (sub === "list") {
+    const response = await daemonRequest({ command: "phone.list" });
+    if (!response.ok) throw new Error(response.error || "the daemon could not list phones");
+    if (!response.phones.length) { console.log("Nothing paired. Pair a phone: npx tryharness phone pair; connect a browser: npx tryharness link"); return; }
+    for (const p of response.phones) console.log(`${p.id.slice(0, 8)}  ${(p.kind || "phone").padEnd(8)} ${p.label.padEnd(20)} paired ${p.paired_at.slice(0, 10)}  ${p.revoked_at ? `disconnected ${p.revoked_at.slice(0, 10)}` : p.last_seen_at ? `last seen ${p.last_seen_at.slice(0, 16).replace("T", " ")}` : "not used yet"}`);
+    return;
+  }
+  if (sub === "revoke") {
+    const prefix = String(argv[1] || "");
+    if (!prefix) throw new Error("usage: tryharness phone revoke <phone id>");
+    const listed = await daemonRequest({ command: "phone.list" });
+    const matches = (listed.phones || []).filter((p) => p.id.startsWith(prefix));
+    if (matches.length !== 1) throw new Error(matches.length ? "that id matches more than one phone; type more of it" : "no phone with that id (see: tryharness phone list)");
+    const response = await daemonRequest({ command: "phone.revoke", id: matches[0].id });
+    if (!response.ok) throw new Error(response.error);
+    console.log(`${matches[0].label} is disconnected. It can no longer reach this computer.`);
+    return;
+  }
+  throw new Error("usage: tryharness phone [pair [--link] | list | revoke <phone id>]");
+}
+
+// A browser joins the way a phone does, by a one-time link this machine makes: its secret and this
+// machine's key ride in the part of the address no server receives. Once one browser is paired,
+// this machine answers Harness's calls for the person's board, sessions and runs only sealed.
+function openUrl(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try { spawn(command, args, { detached: true, stdio: "ignore" }).on("error", () => {}).unref(); return true; } catch { return false; }
+}
+async function link({ quiet = false } = {}) {
+  const response = await daemonRequest({ command: "phone.offer", kind: "browser" });
+  if (!response.ok) throw new Error(response.error || "the daemon could not make a link");
+  const opened = !has("--print") && openUrl(response.url);
+  if (!quiet || !opened) {
+    console.log(opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes." : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n\n${response.url}`);
+    console.log("Harness then carries what your browser and this computer say to each other sealed, and cannot read it.");
+  }
+}
+
 function help() {
-  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text>\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
+  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text> [--ask agent,agent]\n  tryharness swarm rounds [<thread>]   what the coordinator saw, chose and cost each round\n  tryharness swarm coordinator [harness|local]   who coordinates your threads\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours, sealed to their computer\n  tryharness peers           the keys of other people's computers this one has worked with, to compare\n  tryharness agents          how Harness wakes each of your agents, and set up the rest\n  tryharness agents setup <agent> | agents test <agent>\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness link            connect the browser you use Harness in to this computer, end to end (--print shows the link)\n  tryharness phone pair      show a QR code that pairs your phone with this computer\n  tryharness phone list | revoke <id>\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
 }
 
 try {
@@ -562,8 +662,13 @@ try {
   else if (command === "board") await board();
   else if (command === "goal") await goal();
   else if (command === "room") await room();
+  else if (command === "swarm") await swarm();
   else if (command === "mcp") await mcpSnippet();
   else if (command === "notify") await notify();
+  else if (command === "phone") await phone();
+  else if (command === "agents") await agents();
+  else if (command === "link") await link();
+  else if (command === "peers") await peers();
   else if (command === "connect") await connectAgent();
   else if (command === "desktop") { if (!desktop()) process.exitCode = 1; }
   else if (command === "logs") logs();

package/lib/activity.mjs

@@ -0,0 +1,191 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { listJsonl, readJson } from "./files.mjs";
+import { historyRoots } from "./paths.mjs";
+import { PS } from "./nudge.mjs";
+
+// Is anything on this machine doing agent work right now? Board runs and queued runs come from
+// the daemon. Interactive Claude Code, Codex and pi sessions are read from their live processes
+// and transcripts: a session is busy while its turn is open and a command it started is running
+// (whatever its CPU), or while it wrote within QUIET_MS. A process an agent left running counts
+// only while it uses CPU. An open turn with nothing running and nothing written is waiting,
+// most often at a permission prompt that nobody can answer with the lid closed.
+
+// Measured 2026-10-10 on the owner's transcripts, from a prompt or tool result to the model's next
+// write: p99.9 131 s for Claude Code (n=14,783), 310 s for Codex (n=3,673); 9 of 18,456 exceed 5 min.
+export const QUIET_MS = 5 * 60_000;
+// Measured 2026-10-10 with ps: an idle server with a file watcher reads 0.0-0.1 %, a working process 99.9-100 %.
+export const CPU_BUSY = 5;
+
+const AGENT_NAMES = { claude: "claude-code", codex: "codex", pi: "pi" };
+const RUNTIMES = new Set(["node", "bun", "deno"]);
+// Claude Code runs every tool command in a shell; its other children (MCP servers, caffeinate) are not work.
+const SHELLS = new Set(["sh", "bash", "zsh", "fish", "dash", "ksh"]);
+// Started by Codex or pi during a turn without being a command it ran. A shell may exec the command itself, so any other child counts.
+const HELPERS = new Set(["caffeinate"]);
+const TAIL_BYTES = 256 << 10;
+
+const base = (token) => path.basename(String(token || "")).replace(/^-/, "");
+
+/** The agent a process is, from its command line, or null. */
+export function agentOf(command) {
+  if (/\/@anthropic-ai\/claude-code\//.test(command)) return "claude-code";
+  const [first, second] = String(command).trim().split(/\s+/);
+  const name = RUNTIMES.has(base(first).replace(/\d+$/, "")) ? base(second) : base(first);
+  return AGENT_NAMES[name] || null;
+}
+
+/** ps rows: pid, parent, CPU percent, start time (ms) and command line. */
+export function parsePs(text) {
+  const rows = [];
+  for (const line of String(text).split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/);
+    if (!match) continue;
+    const startedAt = Date.parse(match[4]);
+    if (Number.isFinite(startedAt)) rows.push({ pid: Number(match[1]), ppid: Number(match[2]), cpu: Number(match[3]), startedAt, command: match[5] });
+  }
+  return rows;
+}
+
+const stamp = (value) => (typeof value === "number" ? value : Date.parse(value || "")) || null;
+const textOf = (content) => (typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => part?.text || "").join("") : "");
+
+/** Whether a transcript's last turn is still open, and when it started, from its newest rows. */
+export function turnOf(agent, rows) {
+  for (let index = rows.length - 1; index >= 0; index -= 1) {
+    const row = rows[index];
+    if (agent === "codex") {
+      const kind = row.type === "event_msg" ? row.payload?.type : null;
+      if (kind === "task_started") return { open: true, startedAt: stamp(row.timestamp) };
+      if (kind === "task_complete" || kind === "turn_aborted") return { open: false };
+    } else if (agent === "pi") {
+      const message = row.type === "message" ? row.message : null;
+      if (!message) continue;
+      if (message.role === "user") return { open: true, startedAt: stamp(row.timestamp ?? message.timestamp) };
+      if (message.role === "assistant" && message.stopReason !== "toolUse") return { open: false };
+    } else {
+      if (row.isMeta || (row.type !== "user" && row.type !== "assistant")) continue;
+      const content = row.message?.content;
+      if (row.type === "assistant") {
+        if (row.message?.stop_reason === "end_turn") return { open: false };
+        continue;
+      }
+      if (Array.isArray(content) && content.some((part) => part?.type === "tool_result")) continue;
+      const text = textOf(content);
+      if (text.startsWith("[Request interrupted by user")) return { open: false };
+      if (text.startsWith("<local-command") || text.startsWith("<command-")) continue;
+      return { open: true, startedAt: stamp(row.timestamp) };
+    }
+  }
+  return { open: false };
+}
+
+function tailRows(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, "r");
+    const size = fs.fstatSync(fd).size;
+    const length = Math.min(size, TAIL_BYTES);
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, size - length);
+    const lines = buffer.toString("utf8").split("\n");
+    if (length < size) lines.shift();
+    return lines.flatMap((line) => { try { const row = JSON.parse(line); return row && typeof row === "object" ? [row] : []; } catch { return []; } });
+  } catch {
+    return [];
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+const stat = (file) => { try { return { file, mtime: fs.statSync(file).mtimeMs }; } catch { return null; } };
+
+const exec = (file, args) => new Promise((resolve) => {
+  execFile(file, args, { encoding: "utf8", maxBuffer: 16 << 20, timeout: 10_000, env: { ...process.env, LC_ALL: "C" } }, (error, stdout) => resolve(error && !stdout ? "" : stdout));
+});
+
+// Each process's working directory: Claude Code keeps a session's transcript under it.
+async function workingDirectories(pids) {
+  const found = new Map();
+  if (!pids.length) return found;
+  if (process.platform === "linux") {
+    for (const pid of pids) { try { found.set(pid, fs.readlinkSync(`/proc/${pid}/cwd`)); } catch {} }
+    return found;
+  }
+  const lsof = ["/usr/sbin/lsof", "/usr/bin/lsof"].find((file) => fs.existsSync(file));
+  if (!lsof) return found;
+  let pid = null;
+  for (const line of (await exec(lsof, ["-a", "-d", "cwd", "-p", pids.join(","), "-Fpn"])).split("\n")) {
+    if (line.startsWith("p")) pid = Number(line.slice(1));
+    else if (line.startsWith("n") && pid) found.set(pid, line.slice(1));
+  }
+  return found;
+}
+
+/**
+ * Judges the machine from what was read. `processes` are ps rows, `sessions` are transcripts
+ * ({ agent, file, mtime, turn, owners: pids of the live agent processes it may belong to }).
+ */
+export function judgeActivity({ processes, sessions, runs = [], queued = 0, now = Date.now() }) {
+  const children = new Map();
+  for (const row of processes) children.set(row.ppid, [...(children.get(row.ppid) || []), row]);
+  const descendants = (pid) => {
+    const found = [];
+    const pending = [...(children.get(pid) || [])];
+    while (pending.length) { const row = pending.pop(); found.push(row); pending.push(...(children.get(row.pid) || [])); }
+    return found;
+  };
+  const reasons = runs.map((run) => ({ kind: "run", agent: run.agent, id: run.id }));
+  if (queued) reasons.push({ kind: "queued", count: queued });
+  const waiting = [];
+  for (const session of sessions) {
+    if (!session.turn.open) continue;
+    const started = session.turn.startedAt || 0;
+    const ranCommand = (row) => { const name = base(row.command.split(/\s+/)[0]); return session.agent === "claude-code" ? SHELLS.has(name) : !HELPERS.has(name); };
+    const command = session.owners.flatMap(descendants).find((row) => row.startedAt >= started && ranCommand(row));
+    if (command) reasons.push({ kind: "command", agent: session.agent, file: session.file, command: command.command.slice(0, 120) });
+    else if (now - session.mtime < QUIET_MS) reasons.push({ kind: "turn", agent: session.agent, file: session.file });
+    else waiting.push({ agent: session.agent, file: session.file, since: new Date(session.mtime).toISOString() });
+  }
+  for (const agentRow of processes.filter((row) => agentOf(row.command))) {
+    const hot = descendants(agentRow.pid).find((row) => row.cpu >= CPU_BUSY);
+    if (hot) reasons.push({ kind: "background", agent: agentOf(agentRow.command), pid: agentRow.pid, command: hot.command.slice(0, 120), cpu: hot.cpu });
+  }
+  return { busy: reasons.length > 0, reasons, waiting, sessions: sessions.map((session) => ({ agent: session.agent, file: session.file, open: session.turn.open })), checkedAt: new Date(now).toISOString() };
+}
+
+/** Reads this machine's agent processes and transcripts and judges them. */
+export async function machineActivity({ runs = [], queued = 0, agents = ["claude-code", "codex", "pi"], now = Date.now() } = {}) {
+  const processes = process.platform === "win32" ? [] : parsePs(await exec(PS, ["-axww", "-o", "pid=,ppid=,pcpu=,lstart=,command="]));
+  const live = processes.filter((row) => agents.includes(agentOf(row.command)));
+  const claudeRecords = (pid) => historyRoots("claude-code").some((root) => fs.existsSync(path.join(root, "..", "sessions", `${pid}.json`)));
+  const cwds = await workingDirectories(live.filter((row) => agentOf(row.command) === "claude-code" && !claudeRecords(row.pid)).map((row) => row.pid));
+  const sessions = [];
+  for (const agent of agents) {
+    const owners = live.filter((row) => agentOf(row.command) === agent);
+    if (!owners.length) continue;
+    // A transcript older than every live process of its agent cannot be one of their open turns.
+    const since = Math.min(...owners.map((row) => row.startedAt));
+    for (const root of historyRoots(agent)) {
+      if (agent === "claude-code") {
+        // Claude Code records each process's session beside its projects folder; older versions are matched by folder.
+        const records = path.join(root, "..", "sessions");
+        for (const row of owners) {
+          const record = readJson(path.join(records, `${row.pid}.json`), null);
+          const cwd = record?.cwd || cwds.get(row.pid);
+          if (!cwd) continue;
+          const folder = path.join(root, cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+          const items = record?.sessionId ? [stat(path.join(folder, `${record.sessionId}.jsonl`))].filter(Boolean) : listJsonl(folder).filter((item) => item.mtime >= row.startedAt);
+          for (const item of items) sessions.push({ agent, file: item.file, mtime: item.mtime, turn: turnOf(agent, tailRows(item.file)), owners: [row.pid] });
+        }
+      } else {
+        for (const item of listJsonl(root)) {
+          if (item.mtime >= since) sessions.push({ agent, file: item.file, mtime: item.mtime, turn: turnOf(agent, tailRows(item.file)), owners: owners.map((row) => row.pid) });
+        }
+      }
+    }
+  }
+  // Every agent process, whether or not it is working: the desktop app never pauses the app hosting one.
+  return { ...judgeActivity({ processes, sessions, runs, queued, now }), agentPids: processes.filter((row) => agentOf(row.command)).map((row) => row.pid) };
+}

package/lib/adapters.mjs

@@ -4,8 +4,9 @@ import path from "node:path";
 import { detectAgents, run } from "./commands.mjs";
 import { ensureDir, readJson } from "./files.mjs";
 import { paths } from "./paths.mjs";
+import { MACHINE_RUNNERS } from "./members.mjs";
 
-export const AGENTS = ["claude-code", "codex", "pi", "opencode"];
+export const AGENTS = MACHINE_RUNNERS;
 
 // MCP clients that are not coding agents: no history to index and nothing to run, but they
 // join the machine's task board by launching the same stdio MCP under their own name.

package/lib/claudemem.mjs

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+// claude-mem (github.com/thedotmack/claude-mem), when the person runs it: its local worker
+// remembers what earlier agent sessions did in a project. A board run starts with the same
+// newest notes claude-mem would give an agent starting there. The project is named the way
+// claude-mem names it (git root folder, its origin slug under git-remote naming, or a marker
+// folder) and used only when the worker lists it, so a miss gives no notes, never another
+// project's. Read only; nothing here leaves the machine.
+
+function readSettings(env) {
+  const dir = env.CLAUDE_MEM_DATA_DIR || path.join(os.homedir(), ".claude-mem");
+  try { return JSON.parse(fs.readFileSync(path.join(dir, "settings.json"), "utf8")); } catch { return null; }
+}
+
+const setting = (env, settings, key, fallback) => env[key] || settings[key] || fallback;
+
+function git(cwd, args) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  return result.status === 0 ? result.stdout.trim() || null : null;
+}
+
+// The last two segments of a remote URL (https or scp form), as claude-mem's git-remote naming reads it.
+function remoteSlug(url) {
+  if (!url || /^(file:|[/.~\\]|[a-z]:[\\/])/i.test(url)) return null;
+  const cleaned = url.replace(/\/+$/, "").replace(/\.git$/i, "");
+  const tail = cleaned.match(/^[a-z][a-z0-9+.-]*:\/\/[^/]+\/(.+)$/i)?.[1] ?? cleaned.match(/^(?:[^/@\s]+@)?[^:/\s]+:(?!\/\/)(.+)$/)?.[1];
+  const segments = (tail || "").split("/").filter((segment) => segment && segment !== "_git");
+  return segments.length ? segments.slice(-2).join("/") : null;
+}
+
+function markerRoot(dir) {
+  const stops = new Set([os.homedir(), os.tmpdir(), "/"].map((stop) => path.resolve(stop)));
+  for (let current = path.resolve(dir); !stops.has(current); current = path.dirname(current)) {
+    if ([".claude-mem-project", ".claude-mem.json"].some((marker) => fs.existsSync(path.join(current, marker)))) return current;
+    if (path.dirname(current) === current) break;
+  }
+  return null;
+}
+
+/** The names claude-mem may hold this folder's memory under, most specific first. */
+export function projectNames(cwd, env, settings) {
+  const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!root) return [path.basename(markerRoot(cwd) || cwd)];
+  const names = [];
+  if (String(setting(env, settings, "CLAUDE_MEM_PROJECT_NAME_SOURCE", "path")).toLowerCase() === "git-remote") names.push(remoteSlug(git(root, ["remote", "get-url", "origin"])));
+  names.push(path.basename(root));
+  // A worktree's memory can sit under the main checkout's name.
+  const common = git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (common && path.basename(common) === ".git") names.push(path.basename(path.dirname(common)));
+  return [...new Set(names.filter(Boolean))];
+}
+
+function render(observation) {
+  const heading = `- ${String(observation.created_at).slice(0, 10)} · ${observation.type} · ${observation.title || "untitled"}`;
+  return [heading, observation.subtitle, observation.narrative].filter(Boolean).join("\n  ");
+}
+
+/** claude-mem's newest notes on the project `cwd` belongs to, or null when it has none or is not running. */
+export async function claudeMemNotes(cwd, { env = process.env, timeoutMs, maxChars = 20_000 } = {}) {
+  const settings = cwd && readSettings(env);
+  if (!settings) return null;
+  const host = setting(env, settings, "CLAUDE_MEM_WORKER_HOST", "127.0.0.1");
+  const port = setting(env, settings, "CLAUDE_MEM_WORKER_PORT", String(37700 + ((process.getuid?.() ?? 77) % 100)));
+  const base = `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+  const signal = AbortSignal.timeout(timeoutMs);
+  try {
+    const known = new Set(((await (await fetch(`${base}/api/projects`, { signal })).json()).projects || []).map((name) => String(name).toLowerCase()));
+    const project = projectNames(cwd, env, settings).find((name) => known.has(name.toLowerCase()));
+    if (!project) return null;
+    const limit = Number(setting(env, settings, "CLAUDE_MEM_CONTEXT_OBSERVATIONS", "50")) || 50;
+    const response = await fetch(`${base}/api/search?type=observations&format=json&project=${encodeURIComponent(project)}&limit=${limit}`, { signal });
+    if (!response.ok) return null;
+    // Whole notes, newest first, as many as fit the task context's entry size; a note is never cut.
+    const header = `Project "${project}", newest first:`;
+    const notes = [header];
+    let size = header.length;
+    for (const observation of (await response.json()).observations || []) {
+      const text = render(observation);
+      if (size + text.length + 1 > maxChars) break;
+      notes.push(text);
+      size += text.length + 1;
+    }
+    return notes.length > 1 ? notes.join("\n") : null;
+  } catch {
+    return null;
+  }
+}