tryharness 0.7.6 → 0.7.7

package/cli.mjs

@@ -5,6 +5,8 @@ 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";
@@ -117,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();
@@ -152,14 +147,10 @@ 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)) {
@@ -312,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");
@@ -527,11 +518,12 @@ async function swarm() {
 
 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")) });
@@ -592,11 +584,21 @@ 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") {
@@ -648,7 +650,7 @@ async function link({ quiet = false } = {}) {
 }
 
 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 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 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`);
+  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 {
@@ -664,6 +666,7 @@ try {
   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();

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;
+  }
+}

package/lib/coordinator.mjs

@@ -1,5 +1,6 @@
 import os from "node:os";
 import { spawn } from "node:child_process";
+import { MACHINE_RUNNERS, nameOf } from "./members.mjs";
 
 // The swarm's coordinator, run from this machine whether or not a Harness window is open. When a thread goes quiet
 // (no run left going) and has new posts the coordinator has not looked at, it runs one round: it gathers the facts
@@ -8,8 +9,7 @@ import { spawn } from "node:child_process";
 // with its tools off. The round's answer is carried out here under the thread's own rules: a brief that wakes an
 // agent, a question for the person, a part left behind, a pause. Every round is recorded with its facts and cost.
 
-const NAMES = { "claude-code": "Claude Code", codex: "Codex", pi: "Pi", opencode: "OpenCode", "grok-bot": "Grok Bot", bankr: "Bankr", quotient: "Quotient", muse: "Muse" };
-const CODING = new Set(["claude-code", "codex", "pi", "opencode"]);
+const CODING = new Set(MACHINE_RUNNERS);
 // The agents with a read-only switch (runner.mjs): only they can be handed a review.
 const REVIEWERS = new Set(["claude-code", "codex"]);
 const TRANSCRIPT_POSTS = 30;
@@ -79,7 +79,7 @@ export function createCoordinator({ store, mode, askHarness, connected, roster,
       const found = await searchContext(thread.id, newest, 6).catch(() => ({ entries: [] }));
       related = found.entries.filter((entry) => !shown.has(entry.text)).slice(0, 4).map((entry) => ({ source: `this thread, ${entry.author}`, text: entry.text.slice(0, 4_000) }));
       for (const hit of store.search({ query: newest.split(/\s+/).slice(0, 12).join(" "), limit: 3 })) {
-        if (hit.excerpt) related.push({ source: `${NAMES[hit.agent] ?? hit.agent} session "${String(hit.title || "").slice(0, 120)}"`, text: String(hit.excerpt).slice(0, 4_000) });
+        if (hit.excerpt) related.push({ source: `${nameOf(hit.agent)} session "${String(hit.title || "").slice(0, 120)}"`, text: String(hit.excerpt).slice(0, 4_000) });
       }
     }
     return {
@@ -114,6 +114,10 @@ export function createCoordinator({ store, mode, askHarness, connected, roster,
     const posts = store.roomPosts(goalId, state.lastSeenSeq, 500).filter((post) => !QUIET_KINDS.has(post.kind) && post.author !== thread.goal.facilitator);
     const active = store.threadRuns(goalId).some((run) => ["open", "claimed", "running"].includes(run.status));
     if (!posts.length || active) return;
+    // A task's own room is coordinated once it becomes a conversation: someone posted in it, not only the task and its result.
+    if (store.meta(`task-room:${goalId}`) && !store.roomPosts(goalId, 0, 500).some((post) => post.kind === "post")) return;
+    // A thread started through Harness by an agent that runs elsewhere gets no rounds until the person sets a spend ceiling.
+    if (store.meta(`hosted-thread:${goalId}`)) return;
     const local = mode() === "local";
     if (!local && !connected()) return;
     const localAgent = local ? localAgents().find((agent) => agent === "claude-code" || agent === "codex") : null;