tryharness 0.7.6 → 0.7.7

package/lib/mcp-stdio.mjs

@@ -13,7 +13,7 @@ let chain = Promise.resolve();
 const LOCAL_TOOLS = [
   {
     name: "list_tasks",
-    description: "List open work on this machine's Harness task board: tasks posted by the user or by other agents (Harness, Claude Code, Codex, Pi, OpenCode, Grok Bot) for this agent or for anyone. Tasks you posted for Bankr, Quotient or Muse live in Harness, not here: read one with get_task and its id. A task for a coding agent with a folder may run on its own (the user's standing permission or a goal); otherwise claim a task before working on it.",
+    description: "List open work on this machine's Harness task board: tasks posted by the user or by other agents (Harness, Claude Code, Codex, Pi, OpenCode, Grok Bot) for this agent or for anyone. Tasks you posted for Bankr, Quotient or Muse live in Harness, not here: read one with get_task and its id. A task for a coding agent with a folder may run on its own (the user's standing permission or a goal); otherwise claim a task before working on it. When work you asked for has finished, failed or come back with a question since your last call, it comes back under finished: read it with get_task and tell the user.",
     inputSchema: {
       type: "object",
       properties: { status: { type: "string", enum: ["open", "claimed", "needs_input", "done", "failed"] }, all: { type: "boolean", description: "include every task on the board, finished ones too" } },
@@ -33,7 +33,7 @@ const LOCAL_TOOLS = [
       properties: {
         objective: { type: "string", description: "one line, in the user's words" },
         brief: { type: "string" },
-        target_agent: { type: "string", description: "claude-code, codex, pi, opencode, grok-bot or harness on this machine; bankr, quotient or muse in Harness; omit for any agent" },
+        target_agent: { type: "string", description: "claude-code, codex, pi, opencode, grok-bot, openclaw, hermes or harness on this machine; bankr, quotient or muse in Harness; omit for any agent" },
         target_agents: { type: "array", items: { type: "string" }, description: "several agents at once: one task with a part for each, closed with every result when the last part finishes" },
         parent_id: { type: "string", description: "the board task this one continues" },
         run_workspace: { type: "string", description: "the absolute directory a coding agent runs this task in, non-interactively, once the user authorizes it; the run's result and session come back on the task. Left out, a task for a coding agent runs in the folder you are working in" },
@@ -91,8 +91,8 @@ const LOCAL_TOOLS = [
   },
   {
     name: "post_to_room",
-    description: "Post in a goal's room for the whole team: a finding, partial work, a question or what you did. Mention @agent to bring that agent in and wake it: @claude-code, @codex, @pi, @opencode, @grok-bot, @bankr, @quotient, @muse, or @harness to have the thread coordinated. To ask another agent for help, name it, say exactly what you need, then stop: you are woken again when someone answers you by name. Post results and sources, not secrets: anything that looks like a key is held. For work someone else should do, post_task with parent_id set to the goal id.",
-    inputSchema: { type: "object", properties: { id: { type: "string", description: "the goal id" }, text: { type: "string" }, share_with_guests: { type: "boolean", description: "also send it to the goal's invited guests (other people's agents); only what is fine for them to see" } }, required: ["id", "text"], additionalProperties: false },
+    description: "Post in a goal's room for the whole team: a finding, partial work, a question or what you did. To ask another agent for help, put its name in ask (claude-code, codex, pi, opencode, grok-bot, openclaw, hermes, bankr, quotient, muse, or harness to have the thread coordinated), say exactly what you need, then stop: you are woken again when it answers you by name. When you answer someone who asked you, name them (@codex) and they are woken. Any other @name, like a thanks, wakes no one. Post results and sources, not secrets: anything that looks like a key is held. For work someone else should do, post_task with parent_id set to the goal id.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "the goal id" }, text: { type: "string" }, ask: { type: "array", items: { type: "string" }, description: "the agents you are asking for something; each is woken" }, share_with_guests: { type: "boolean", description: "also send it to the goal's invited guests (other people's agents); only what is fine for them to see" } }, required: ["id", "text"], additionalProperties: false },
   },
   {
     name: "search_room",
@@ -103,11 +103,29 @@ const LOCAL_TOOLS = [
     description: "Search the shared memory of the user's agents: everything any agent wrote in any thread (findings, answers, questions, results) and the user's coding sessions on this computer. Use it before starting work to build on what another agent already did, and when you need to know how something was done before.",
     inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"], additionalProperties: false },
   },
+  {
+    name: "list_agents",
+    description: "The user's other agents you can ask, what each is for, and how each answers (some start at once, some are woken, some only pick work up later). Use it to pick a name before post_task or start_thread instead of guessing one.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "start_thread",
+    description: "Start a shared thread with one or more of the user's agents, named with @ in the message (for example \"@codex @grok-bot compare the two parsers\"). The thread carries your words, not the user's: nothing in it runs until the user starts it. Answers arrive in the thread; read it with read_room and add to it with post_to_room. Give a folder only when the work concerns one.",
+    inputSchema: { type: "object", properties: { text: { type: "string" }, folder: { type: "string", description: "absolute folder the coding agents work in; never guessed" } }, required: ["text"], additionalProperties: false },
+  },
+  {
+    name: "stop_thread",
+    description: "Stop the runs in a thread you started. The user can resume it.",
+    inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false },
+  },
 ];
 
 const BOARD_CALLS = {
+  list_agents: () => ({ command: "board.swarm.agents" }),
+  start_thread: (args) => ({ command: "board.swarm.start", text: args.text, folder: args.folder }),
+  stop_thread: (args) => ({ command: "board.swarm.stop", id: String(args.id || "") }),
   read_room: (args) => ({ command: "board.room.read", id: String(args.id || ""), since: args.since }),
-  post_to_room: (args) => ({ command: "board.room.post", id: String(args.id || ""), text: args.text, shareWithGuests: args.share_with_guests === true }),
+  post_to_room: (args) => ({ command: "board.room.post", id: String(args.id || ""), text: args.text, ask: Array.isArray(args.ask) ? args.ask : [], shareWithGuests: args.share_with_guests === true }),
   search_room: (args) => ({ command: "board.room.search", id: String(args.id || ""), query: args.query }),
   search_swarm: (args) => ({ command: "board.swarm.search", query: args.query }),
   search_task_context: (args) => ({ command: "board.context.search", id: String(args.id || ""), query: args.query, limit: args.limit }),

package/lib/members.json

@@ -0,0 +1,31 @@
+{
+  "version": 1,
+  "members": [
+    { "id": "harness", "name": "Harness", "aliases": [], "road": "server", "home": "cloud", "runs": "server", "target": true, "wake": "run",
+      "about": "coordinates the thread and asks the person when only they can decide" },
+    { "id": "claude-code", "name": "Claude Code", "aliases": ["claude code"], "road": "local", "home": "machine", "runs": "machine", "target": true, "wake": "run",
+      "about": "reads and changes code in the thread's folder, runs commands and tests" },
+    { "id": "codex", "name": "Codex", "aliases": [], "road": "local", "home": "machine", "runs": "machine", "target": true, "wake": "run",
+      "about": "reads and changes code in the thread's folder, runs commands and tests" },
+    { "id": "pi", "name": "Pi", "aliases": [], "road": "local", "home": "machine", "runs": "machine", "target": true, "wake": "run",
+      "about": "reads and changes code in the thread's folder and runs commands" },
+    { "id": "opencode", "name": "OpenCode", "aliases": ["open code"], "road": "local", "home": "machine", "runs": "machine", "target": true, "wake": "run",
+      "about": "reads and changes code in the thread's folder and runs commands" },
+    { "id": "grok-bot", "name": "Grok Bot", "aliases": ["grok", "grok bot"], "road": "hosted", "home": "machine", "runs": "self", "target": true, "wake": "email",
+      "about": "research on X and the web" },
+    { "id": "bankr", "name": "Bankr", "aliases": [], "road": "server", "home": "cloud", "runs": "server", "target": true, "wake": "run",
+      "about": "the person's crypto wallet and trading, always under the person's own approval and limits" },
+    { "id": "quotient", "name": "Quotient", "aliases": [], "road": "server", "home": "cloud", "runs": "server", "target": true, "wake": "run",
+      "about": "prediction markets research and positions, under the person's own approval and limits" },
+    { "id": "muse", "name": "Muse", "aliases": [], "road": "hosted", "home": "cloud", "runs": "self", "target": true, "wake": "schedule",
+      "about": "writing and creative drafts" },
+    { "id": "openclaw", "name": "OpenClaw", "aliases": ["open claw"], "road": "local", "home": "machine", "runs": "self", "target": true, "wake": "local-webhook",
+      "about": "the person's own assistant on this computer, with their chat apps and tools" },
+    { "id": "hermes", "name": "Hermes", "aliases": [], "road": "local", "home": "machine", "runs": "self", "target": true, "wake": "local-webhook",
+      "about": "the person's own assistant on this computer, with their chat apps and tools" },
+    { "id": "claude-app", "name": "Claude app", "aliases": ["claude ai"], "road": "hosted", "home": "cloud", "runs": "self", "target": false, "wake": "none",
+      "about": "the Claude chat app; can ask, cannot be woken" },
+    { "id": "chatgpt", "name": "ChatGPT", "aliases": ["chat gpt"], "road": "hosted", "home": "cloud", "runs": "self", "target": false, "wake": "none",
+      "about": "the ChatGPT app; can ask, cannot be woken" }
+  ]
+}

package/lib/members.mjs

@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+
+// The swarm's members, one entry each (members.json): who they are, which road they call in on, where their tasks
+// live (home), who runs their work (runs), whether others may hand them work (target) and how they are told work is
+// waiting (wake). The server reads the same file (src/shared/members.ts). A caller on this machine names itself
+// (--agent) and is taken at its word: anything running as the person could read a token kept for it, so none is
+// kept (owner, October 10). A call through Harness is never taken for a member on this machine (hostedCaller).
+const ROSTER = JSON.parse(readFileSync(new URL("./members.json", import.meta.url), "utf8"));
+
+export const ROSTER_VERSION = ROSTER.version;
+export const MEMBERS = ROSTER.members;
+const byId = new Map(MEMBERS.map((entry) => [entry.id, entry]));
+
+export const member = (id) => byId.get(String(id)) ?? null;
+export const ids = (keep = () => true) => MEMBERS.filter(keep).map((entry) => entry.id);
+/** Members others may hand work to, Harness included. */
+export const TARGETS = ids((entry) => entry.target);
+/** Coding agents the daemon runs on this machine. */
+export const MACHINE_RUNNERS = ids((entry) => entry.runs === "machine");
+/** Targets whose tasks live on Harness's server, not the machine (Harness itself excluded). */
+export const CLOUD_HOMED = ids((entry) => entry.target && entry.home === "cloud" && entry.id !== "harness");
+/** Targets asked by a task rather than started here: they run themselves or on the server. */
+export const ASKED_BY_TASK = ids((entry) => entry.target && entry.runs !== "machine" && entry.id !== "harness");
+export const nameOf = (id) => member(id)?.name ?? String(id);
+export const aboutOf = (id) => {
+  const entry = member(id);
+  return entry ? `${entry.name}: ${entry.about}` : String(id);
+};
+
+const plain = (value) => String(value || "").trim().toLowerCase().replace(/^@/, "").replace(/[\s_]+/g, " ");
+/**
+ * A name as people and agents write it, resolved to one member: an id, a display name or an alias, else the one
+ * member whose name it starts. A start shared by several ("claude": Claude Code and the Claude app) comes back
+ * ambiguous with the candidates, so the caller asks its person or picks. `extra` admits board names the roster does
+ * not list (a connector named by its person), matched exactly.
+ */
+export function resolveMember(name, { extra = [] } = {}) {
+  const wanted = plain(name);
+  if (!wanted) return { ok: false, candidates: [] };
+  const exact = MEMBERS.find((entry) => entry.id === wanted || plain(entry.name) === wanted || entry.aliases.some((alias) => plain(alias) === wanted));
+  if (exact) return { ok: true, id: exact.id };
+  if (extra.map(String).includes(wanted)) return { ok: true, id: wanted };
+  const words = wanted.split(" ");
+  const candidates = MEMBERS.filter((entry) => [entry.id.replace(/-/g, " "), plain(entry.name), ...entry.aliases.map(plain)]
+    .some((label) => words.every((word, index) => label.split(" ")[index]?.startsWith(word)))).map((entry) => entry.id);
+  return candidates.length === 1 ? { ok: true, id: candidates[0] } : { ok: false, candidates };
+}

package/lib/onboard.mjs

@@ -0,0 +1,131 @@
+import { spawnSync } from "node:child_process";
+import readline from "node:readline";
+import { detectLocalAgents, setupHermes, setupOpenClaw, localWakes } from "./wakes.mjs";
+
+// "Your swarm" in setup: every agent class with how Harness reaches it, the recommended way already chosen, the steps
+// numbered, and a real test at the end that passes only when the agent claims and reports a task. Also reachable on its
+// own as `npx tryharness agents`. Without a terminal to answer in, it only says what is set up and how to finish.
+
+const SETUP = { openclaw: setupOpenClaw, hermes: setupHermes };
+const LABEL = { openclaw: "OpenClaw", hermes: "Hermes", "grok-bot": "Grok Bot" };
+const MEASURED = "measured on a real Grok: about 23s by email, 17s by webhook";
+
+export function createPrompter({ input = process.stdin, output = process.stdout } = {}) {
+  const ask = (question, { hidden = false } = {}) => new Promise((resolve) => {
+    const rl = readline.createInterface({ input, output, terminal: true });
+    if (hidden) rl._writeToOutput = (text) => { if (text.includes(question)) output.write(text); };
+    rl.question(question, (answer) => { rl.close(); if (hidden) output.write("\n"); resolve(answer.trim()); });
+  });
+  return { ask };
+}
+
+const copy = (text) => {
+  const tool = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
+  const result = spawnSync(tool, tool === "xclip" ? ["-selection", "clipboard"] : [], { input: text });
+  return result.status === 0;
+};
+
+/** Post a setup check for the agent and wait for its report: the same path real work takes. */
+export async function testAgent({ agent, daemonRequest, out = console.log, waitMs = 10 * 60_000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  const posted = await daemonRequest({ command: "board.post", agent: "user", objective: "Setup check from Harness: reply ready", brief: "Harness is checking that it can wake you. Claim this task and report it done with the single word: ready. Do nothing else.", targetAgent: agent });
+  if (!posted?.ok) { out(`    ! the test task could not be posted: ${posted?.error || "no answer"}`); return false; }
+  const started = Date.now();
+  out(`    Test sent. Waiting for ${LABEL[agent] || agent} to answer (Ctrl-C stops waiting; the test task stays on your board).`);
+  while (Date.now() - started < waitMs) {
+    await sleep(2_000);
+    const task = (await daemonRequest({ command: "board.get", agent: "user", id: posted.task.id }).catch(() => null))?.task;
+    if (task?.status === "done") { out(`    ✓ ${LABEL[agent] || agent} answered in ${Math.round((Date.now() - started) / 1000)}s. Ready.`); return true; }
+    if (task && ["failed", "needs_input"].includes(task.status)) { out(`    ! ${LABEL[agent] || agent} answered but the task is ${task.status}: ${task.result || ""}`); return false; }
+  }
+  out(`    ! No answer after ${Math.round(waitMs / 60_000)} minutes. Check that the agent is running, then: npx tryharness agents test ${agent}`);
+  return false;
+}
+
+async function setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out }) {
+  const name = LABEL[entry.agent];
+  if (localWakes()[entry.agent]) {
+    const health = (await daemonRequest({ command: "wake.local" }).catch(() => null))?.agents?.[entry.agent];
+    if (!health || health.answering) { out(`  ✓ ${name}: woken on this computer by its own webhook`); return; }
+    out(`  ! ${name}: not answering wakes (${health.lastFailure}). Check that it is running.`);
+    if (!prompter || /^n/i.test(await prompter.ask(`    Set ${name} up again? [Y/n] `))) { out(`    Later: npx tryharness agents setup ${entry.agent}`); return; }
+    const result = SETUP[entry.agent]({ runtimeRoot });
+    out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
+    if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+    return;
+  }
+  if (!prompter) { out(`  ! ${name}: found. Set it up with: npx tryharness agents setup ${entry.agent}`); return; }
+  out(`  ${name} found. Harness wakes it with a webhook on this computer (recommended, nothing to copy).`);
+  out(`    This adds Harness to ${name}'s MCP servers and turns on its webhook with a key made here${entry.agent === "openclaw" ? ", then restarts its gateway" : ""}.`);
+  if (/^n/i.test(await prompter.ask(`    Set up ${name} now? [Y/n] `))) { out(`    Skipped. Later: npx tryharness agents setup ${entry.agent}`); return; }
+  const result = SETUP[entry.agent]({ runtimeRoot });
+  out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
+  if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+}
+
+async function setupGrok({ prompter, daemonRequest, out, clipboard }) {
+  const listed = await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch((error) => ({ ok: false, error: error.message }));
+  if (!listed.ok) { out(`  ! Grok Bot: Harness could not be reached (${listed.error}). Later: npx tryharness agents setup grok-bot`); return; }
+  const current = (listed.wakes || []).find((wake) => wake.agent === "grok-bot");
+  if (current) {
+    const how = current.channel === "email" ? `email at ${current.address}` : "its webhook";
+    if (current.answering) { out(`  ✓ Grok Bot: woken by ${how}`); return; }
+    out(`  ! Grok Bot: not answering wakes by ${how} (${current.last_failure}).`);
+    if (!prompter || /^n/i.test(await prompter.ask("    Set it up again? [Y/n] "))) { out("    Later: npx tryharness agents setup grok-bot"); return; }
+  }
+  if (!prompter) { out("  Grok Bot: not set up. Set it up with: npx tryharness agents setup grok-bot"); return; }
+  out(`  Grok Bot. How should Harness wake it? (${MEASURED})`);
+  out("    1) Email     nothing to copy back                          (recommended)");
+  out("    2) Webhook   a little faster; you paste its URL and key here");
+  out("    3) Not now");
+  const choice = (await prompter.ask("    Choose [1]: ")) || "1";
+  if (choice === "3") { out("    Skipped. Later: npx tryharness agents setup grok-bot"); return; }
+  const channel = choice === "2" ? "webhook" : "email";
+  const message = listed.messages?.["grok-bot"]?.[channel];
+  if (!message) { out("    ! Harness did not send the setup message; update tryharness and try again."); return; }
+  const copied = clipboard(message);
+  out(`    1. ${copied ? "This message is on your clipboard. Paste it into Grok:" : "Paste this message into Grok:"}`);
+  out(message.split("\n").map((line) => `       ${line}`).join("\n"));
+  out("    2. Grok opens Harness's approval page. Name the connection Grok Bot and approve.");
+  if (channel === "webhook") {
+    out("    3. In Grok, open Routines, then Harness wake, and copy its webhook URL and key.");
+    const address = await prompter.ask("       Webhook URL: ");
+    const key = await prompter.ask("       Key (hidden): ", { hidden: true });
+    const saved = await daemonRequest({ command: "wake.server", input: { action: "save", agent: "grok-bot", channel: "webhook", address, key } });
+    if (!saved.ok) { out(`    ! ${saved.error}. Try again: npx tryharness agents setup grok-bot`); return; }
+    out("    ✓ Saved. The key is stored sealed on Harness and is never shown again.");
+  } else {
+    out("    3. Grok registers its own address with Harness. Waiting for it (Ctrl-C stops waiting)...");
+    const registered = await waitFor(async () => ((await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch(() => null))?.wakes || []).some((wake) => wake.agent === "grok-bot"));
+    if (!registered) { out("    Not registered yet. When Grok has done it: npx tryharness agents test grok-bot"); return; }
+    out("    ✓ Grok registered its address.");
+  }
+  await testAgent({ agent: "grok-bot", daemonRequest, out });
+}
+
+async function waitFor(check, waitMs = 10 * 60_000, everyMs = 3_000) {
+  const end = Date.now() + waitMs;
+  while (Date.now() < end) {
+    if (await check()) return true;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+  return false;
+}
+
+/** The whole "Your swarm" step. `only` limits it to one agent (npx tryharness agents setup <agent>). */
+export async function setupSwarm({ runtimeRoot, states = [], daemonRequest, prompter = process.stdin.isTTY ? createPrompter() : null, out = console.log, only = null, clipboard = copy }) {
+  const want = (agent) => !only || only === agent;
+  out("\nYour swarm");
+  if (!only) {
+    out("  On this computer: Harness starts them when work is posted");
+    for (const state of states) out(`    ${!state.installed ? "–" : state.configured ? "✓" : "!"} ${state.agent}: ${state.detail}`);
+  }
+  const local = detectLocalAgents().filter((entry) => entry.found && want(entry.agent));
+  if (local.length) out("  Agent apps on this computer: woken by a webhook Harness sets up");
+  for (const entry of local) await setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out });
+  if (only && LABEL[only] && only !== "grok-bot" && !local.length) out(`  ${LABEL[only]} was not found on this computer.`);
+  if (want("grok-bot")) {
+    out("  Cloud agents: woken by email or webhook");
+    await setupGrok({ prompter, daemonRequest, out, clipboard });
+  }
+  if (!only) out("  Built in: Bankr and Quotient run on Harness, nothing to set up");
+}

package/lib/phones.mjs

@@ -13,17 +13,17 @@ const OFFER_TTL_MS = 10 * 60_000;
 const MAX_OFFERS = 5;
 // A message queued at Harness while this computer slept may arrive up to 7 days late; only decisions and posts may.
 const QUEUED_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const QUEUEABLE = new Set(["board.post", "board.run", "board.release", "board.answer", "board.thread.post", "board.thread.send", "board.thread.discard", "board.thread.end", "board.goal.stop",
-  "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume"]);
+const QUEUEABLE = new Set(["board.post", "board.run", "board.release", "board.answer", "board.remove", "board.thread.post", "board.thread.send", "board.thread.discard", "board.thread.end", "board.goal.stop",
+  "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume", "board.swarm.start_run"]);
 const ID = /^[A-Za-z0-9_-]{8,64}$/;
 const KEY = /^[A-Za-z0-9_-]{80,100}$/;
 const KINDS = new Set(["phone", "browser"]);
 const PHONE_COMMANDS = new Set([
-  "board.list", "board.get", "board.children", "board.agents", "board.post", "board.run", "board.release", "board.answer",
+  "board.list", "board.get", "board.children", "board.agents", "board.post", "board.run", "board.release", "board.answer", "board.remove",
   "board.thread.read", "board.thread.post", "board.thread.send", "board.thread.discard", "board.thread.auto", "board.thread.end",
   "board.goal.list", "board.goal.get", "board.goal.stop", "board.room.read",
   "board.swarm.list", "board.swarm.read", "board.swarm.start", "board.swarm.post", "board.swarm.stop", "board.swarm.stop_all", "board.swarm.resume", "board.swarm.folder", "board.swarm.coordinator",
-  "board.swarm.diff", "board.swarm.merge", "board.swarm.discard",
+  "board.swarm.diff", "board.swarm.merge", "board.swarm.discard", "board.swarm.start_run",
 ]);
 // What the chat owner does on the board, in Harness's name (was src/server/mcp/board.ts HARNESS_COMMANDS).
 const HARNESS_COMMANDS = new Set([
@@ -34,7 +34,7 @@ const HARNESS_COMMANDS = new Set([
 const BROWSER_PERSON_COMMANDS = new Set([...PHONE_COMMANDS, "board.goal.resume", "board.standing", "board.standing.check", "board.standing.off"]);
 const BROWSER_READS = new Set(["sessions.search", "sessions.read", "sessions.raw", "tasks.status", "relay.request", "relay.open"]);
 
-export async function createPhoneDesk({ store, identityFile, boardCommand, reads = {}, version }) {
+export async function createPhoneDesk({ store, identityFile, boardCommand, reads = {}, version, onMessage = () => {}, machine = () => null }) {
   const identity = await loadOrCreateIdentity(identityFile);
   const offers = new Map();
   const keys = new Map();
@@ -96,6 +96,8 @@ export async function createPhoneDesk({ store, identityFile, boardCommand, reads
     if (queued ? age > QUEUED_MAX_AGE_MS || age < -MAX_SKEW_MS : Math.abs(age) > MAX_SKEW_MS) return { ok: false, error: "the message is too old or the device's clock is off", code: "stale" };
     if (!store.firstPhoneRequest(device.id, String(envelope.requestId))) return { ok: false, error: "this message was already received", code: "replayed" };
     store.touchPhone(device.id);
+    // Any message from a paired device keeps a Mac in Standby awake for the next hour (Lid-Closed Mode).
+    onMessage();
     if (request.call?.command === "phone.forget") {
       const forgotten = revoke(device.id);
       return { ok: true, envelope: await seal(key, "d2p", device.id, envelope.requestId, { ok: forgotten.ok }) };
@@ -131,6 +133,8 @@ export async function createPhoneDesk({ store, identityFile, boardCommand, reads
       const { as: _as, writtenBy: _written, provenance: _provenance, ...rest } = callInput;
       return settled(() => boardCommand({ ...rest, command, agent: as, ...(writtenBy.length ? { provenance: { trust: "agent", chain: writtenBy } } : {}) }));
     }
+    // Lid-Closed Mode's wake: no arguments, never queued, and it can only keep the Mac awake and say how it is.
+    if (command === "machine.wake") return { ok: true, machine: machine() };
     if (!PHONE_COMMANDS.has(command)) return { ok: false, error: `a phone cannot call ${command || "that"}` };
     // The phone is the person; whatever it names itself, it acts as "user".
     return settled(() => boardCommand({ ...callInput, command, agent: "user", ...(command === "board.list" && callInput.all === undefined ? { all: true } : {}) }));

package/lib/runner.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { spawn } from "node:child_process";
 
@@ -27,14 +28,29 @@ export function resolveWorkingDirectory(requested) {
   return requested;
 }
 
+// A run another agent started without the person's tap (docs/member-runs.md): anything that would ask is refused, file
+// edits only in its worktree, shell commands only inside the operating system's sandbox with no network, and no hooks or
+// settings from the repository. A review gets no edits at all.
+export const RESTRICTED_CLAUDE_SETTINGS = {
+  disableAllHooks: true,
+  permissions: { deny: ["WebFetch", "WebSearch"] },
+  sandbox: { enabled: true, autoAllowBashIfSandboxed: true, allowUnsandboxedCommands: false, failIfUnavailable: true, excludedCommands: [], network: { allowedDomains: [], strictAllowlist: true } },
+};
+// Only the Harness board MCP, as Claude Code: none of the person's other MCP servers or claude.ai connectors load.
+export const restrictedMcpConfig = () => ({ mcpServers: { harness: { command: process.execPath, args: [fileURLToPath(new URL("./mcp-stdio.mjs", import.meta.url)), "--agent", "claude-code"] } } });
+const restrictedClaude = (task) => ["--permission-mode", "dontAsk", "--allowedTools", task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
+  "--setting-sources", "user", "--settings", JSON.stringify(RESTRICTED_CLAUDE_SETTINGS), "--strict-mcp-config", "--mcp-config", JSON.stringify(restrictedMcpConfig())];
+
 export function agentInvocation(task) {
   if (task.agent === "claude-code") {
     return {
       command: "claude",
       // A review reads and reports: plan mode lets Claude Code read and run read-only tools but never edit.
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
     };
   }
+  // Only Claude Code has a restricted mode; any other agent's restricted run is refused here, whatever let it start.
+  if (task.restricted) throw new Error(`${task.agent} has no restricted mode; it runs only after the person's Start`);
   if (task.agent === "codex") {
     return {
       command: "codex",
@@ -146,7 +162,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
   let child;
   try {
     child = spawn(invocation.command, invocation.args, { cwd });
-    if (invocation.stdin !== undefined) child.stdin.end(invocation.stdin);
+    child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(slot);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);

package/lib/store.mjs

@@ -78,6 +78,7 @@ export function openStore(file) {
       trust text not null default 'agent',
       origin_chain text not null default '[]',
       usage text,
+      removed_at text,
       created_at text not null,
       updated_at text not null
     );
@@ -208,6 +209,7 @@ export function openStore(file) {
   }
   if (!boardColumns.has("kind") && boardColumns.size) db.exec("alter table board_tasks add column kind text not null default 'task'");
   if (!boardColumns.has("usage") && boardColumns.size) db.exec("alter table board_tasks add column usage text");
+  if (!boardColumns.has("removed_at") && boardColumns.size) db.exec("alter table board_tasks add column removed_at text");
   if (!boardColumns.has("trust") && boardColumns.size) db.exec("alter table board_tasks add column trust text not null default 'agent'; alter table board_tasks add column origin_chain text not null default '[]'");
 
   const statements = [];
@@ -299,6 +301,10 @@ export function openStore(file) {
       });
       return parsed.meta;
     },
+    endedSince(since) {
+      const rows = execute("all", "select status, count(*) as count from board_tasks where kind not in ('goal', 'group') and status in ('done', 'failed', 'unknown') and reported_at >= ? group by status", since);
+      return Object.fromEntries(rows.map((row) => [row.status, Number(row.count)]));
+    },
     counts() {
       const rows = execute("all", "select agent, count(*) as count from sessions group by agent");
       return Object.fromEntries(rows.map((row) => [row.agent, Number(row.count)]));
@@ -453,7 +459,7 @@ export function openStore(file) {
         paused_reason: row.paused_reason, sessions: JSON.parse(row.sessions || "{}"), guests: JSON.parse(row.guests || "[]"), posts: this.roomCount(id), spend: this.goalSpend(id) };
     },
     goals({ all = false } = {}) {
-      return execute("all", `select id from board_tasks where kind = 'goal' ${all ? "" : "and status in ('open', 'paused')"} order by created_at desc limit 50`).map((row) => this.getTask(row.id));
+      return execute("all", `select id from board_tasks where kind = 'goal' and removed_at is null ${all ? "" : "and status in ('open', 'paused')"} order by created_at desc limit 50`).map((row) => this.getTask(row.id));
     },
     setGoalState(id, { status, result, pausedReason, maxPosts }) {
       const now = new Date().toISOString();
@@ -470,6 +476,11 @@ export function openStore(file) {
       const row = execute("all", "select goal_id, guests from board_goals").find((entry) => JSON.parse(entry.guests || "[]").some((guest) => guest.thread === thread));
       return row?.goal_id || null;
     },
+    // At posting only: the task's room is part of how it was posted, not a change anyone races.
+    setParent(id, parentId) {
+      execute("run", "update board_tasks set parent_id = ? where id = ?", parentId, id);
+      return this.getTask(id);
+    },
     setGoalFolder(id, workspace) {
       execute("run", "update board_goals set workspace = ? where goal_id = ?", workspace, id);
     },
@@ -534,7 +545,7 @@ export function openStore(file) {
     },
     // A thread's runs (wakes and jobs), oldest first, for its transcript.
     threadRuns(goalId) {
-      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, usage, created_at, updated_at, reported_at
+      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, run_authorized_at, usage, created_at, updated_at, reported_at
         from board_tasks where parent_id = ? and kind in ('wake', 'task') order by created_at asc`, goalId)
         .map((row) => ({ ...row, usage: row.usage ? JSON.parse(row.usage) : null }));
     },
@@ -549,8 +560,10 @@ export function openStore(file) {
       const row = execute("all", "select goal_id, sessions from board_goals").find((entry) => JSON.parse(entry.sessions || "{}")[agent] === sessionId);
       return row?.goal_id || null;
     },
+    // The rooms an agent's own sessions are told about: threads it was brought into, not every task's room (the daemon
+    // runs those, and the task itself is already on its list).
     activeGoalsFor(agent) {
-      return this.goals().filter((goal) => goal.status === "open" && goal.goal.team.includes(agent));
+      return this.goals().filter((goal) => goal.status === "open" && goal.goal.team.includes(agent) && !this.meta(`task-room:${goal.id}`));
     },
     authorizeGoalRun(id) {
       const now = new Date().toISOString();
@@ -581,6 +594,14 @@ export function openStore(file) {
     setRunSession(id, sessionId) {
       execute("run", "update board_tasks set session_id = ?, updated_at = ? where id = ?", sessionId, new Date().toISOString(), id);
     },
+    // A run the daemon stopped itself for a safety rule (Lid-Closed Mode): the task goes back on the board, still
+    // authorized, and its next run picks up where this one stopped.
+    requeueRun(id) {
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = 'open', holder = target_agent, claimed_by = null, claimed_at = null, lease_until = null, updated_at = @now, version = version + 1
+        where id = @id and status = 'running'`, { id, now });
+      return written.changes === 1 ? { ok: true, task: this.getTask(id) } : { ok: false, error: `task is ${this.getTask(id)?.status ?? "missing"}` };
+    },
     // A daemon restart lost every agent process it was running; those outcomes are unknown, never assumed.
     settleInterruptedRuns() {
       const now = new Date().toISOString();
@@ -744,6 +765,16 @@ export function openStore(file) {
       return { ok: true, thread: this.getThread(taskId), task: this.getTask(taskId) };
     },
     // Messages another person's agent sent on this agent's tasks since it last read the board.
+    lastSeenAt(agent) {
+      return execute("get", "select last_seen_at from board_agents where agent = ?", agent)?.last_seen_at || null;
+    },
+    // Work an agent asked for that finished, failed or came back with a question since it last called the board: how an
+    // asker that cannot be woken (the Claude app, ChatGPT) learns of its answers.
+    finishedFor(agent, since) {
+      return execute("all", `select id, objective, target_agent, claimed_by, status, updated_at from board_tasks
+        where origin_agent = ? and kind = 'task' and removed_at is null and status in ('done', 'failed', 'needs_input') and updated_at > ?
+        order by updated_at desc limit 20`, agent, since || "1970-01-01T00:00:00.000Z");
+    },
     unreadFor(agent) {
       const seen = execute("get", "select last_seen_at from board_agents where agent = ?", agent)?.last_seen_at || "1970-01-01T00:00:00.000Z";
       return execute("all", `select m.task_id, t.objective, m.sender, count(*) as count from board_messages m join board_tasks t on t.id = m.task_id
@@ -789,10 +820,12 @@ export function openStore(file) {
       return execute("all", "select agent, last_seen_at from board_agents order by last_seen_at desc");
     },
     listTasks({ agent, status, all = false, limit = 20 } = {}) {
-      const clauses = [];
+      const clauses = ["b.removed_at is null"];
       const params = { limit: Math.max(1, Math.min(100, Number(limit) || 20)) };
       if (status) { clauses.push("b.status = @status"); params.status = status; }
       else if (!all) clauses.push("b.status in ('open', 'claimed', 'running', 'needs_input')");
+      // An agent's whole-board list is work, not threads: those it reads as its rooms.
+      if (agent && agent !== "user" && all) clauses.push("b.kind not in ('goal', 'wake')");
       if (agent && !all) {
         clauses.push("b.kind not in ('group', 'goal', 'wake') and (b.target_agent is null or b.target_agent = @agent or b.origin_agent = @agent or b.claimed_by = @agent)");
         params.agent = agent;
@@ -807,6 +840,18 @@ export function openStore(file) {
         from board_tasks b left join board_threads th on th.task_id = b.id ${clauses.length ? `where ${clauses.join(" and ")}` : ""} order by b.created_at desc limit @limit`, params)
         .map((row) => ({ ...row, origin_chain: JSON.parse(row.origin_chain || "[]"), version: Number(row.version), held_messages: Number(row.held_messages), child_count: Number(row.child_count), child_done: Number(row.child_done), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < now }));
     },
+    // Off the board for good, row kept: unfinished work and its parts close first, so nothing picks them up again.
+    removeTask(id) {
+      const now = new Date().toISOString();
+      const ids = [id, ...execute("all", "select id from board_tasks where parent_id = ?", id).map((row) => row.id)];
+      const running = [];
+      for (const taskId of ids) {
+        if (execute("get", "select 1 from board_tasks where id = ? and status = 'running'", taskId)) running.push(taskId);
+        execute("run", "update board_tasks set status = 'failed', result = 'Removed by you.', holder = null, reported_at = ?, updated_at = ?, version = version + 1 where id = ? and kind != 'goal' and status in ('open', 'claimed', 'needs_input', 'running')", now, now, taskId);
+        execute("run", "update board_tasks set removed_at = ?, updated_at = ? where id = ? and removed_at is null", now, now, taskId);
+      }
+      return { ids, running };
+    },
     getTask(id) {
       const row = execute("get", "select * from board_tasks where id = ?", id);
       if (!row) return null;