tryharness 0.7.4 → 0.7.7

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";
 
@@ -13,6 +14,11 @@ export function stopAgentTask(runId) {
   return true;
 }
 
+/** The process ids of the runs in progress, so they are not mistaken for the person's own sessions. */
+export function runningPids() {
+  return [...children.values()].map((child) => child.pid).filter(Boolean);
+}
+
 export function resolveWorkingDirectory(requested) {
   if (!requested || !path.isAbsolute(requested)) throw new Error("Delegated tasks require an absolute working directory.");
   let stat;
@@ -22,17 +28,33 @@ 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",
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions", "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      // 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.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",
-      args: ["exec", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "-"],
+      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
       stdin: task.brief,
     };
   }
@@ -40,7 +62,7 @@ export function agentInvocation(task) {
   // this non-interactive run; its complete built-in tool set remains enabled.
   if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", "-p", task.brief] };
   if (task.agent === "opencode") {
-    return { command: "opencode", args: ["run", "--format", "json", "--auto", "--title", task.title, "--", task.brief] };
+    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
   }
   throw new Error(`Unsupported agent: ${task.agent}`);
 }
@@ -74,9 +96,57 @@ export function usageCollector() {
   };
 }
 
+// What an agent did, as the steps of one event in its JSON stream: "say" for its words to the person, "do" for a tool
+// it used. Claude Code, Codex, Pi and OpenCode each say this their own way; anything else is not a step.
+const brief = (input) => {
+  if (!input || typeof input !== "object") return String(input ?? "").slice(0, 200);
+  const named = input.command ?? input.cmd ?? input.file_path ?? input.path ?? input.filePath ?? input.pattern ?? input.url ?? input.query ?? input.description;
+  return String(named ?? JSON.stringify(input)).slice(0, 200);
+};
+export function stepsOf(event) {
+  if (!event || typeof event !== "object") return [];
+  if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+    return event.message.content.flatMap((block) => block.type === "text" && block.text?.trim() ? [{ kind: "say", text: block.text.trim() }]
+      : block.type === "tool_use" ? [{ kind: "do", text: `${block.name}: ${brief(block.input)}` }] : []);
+  }
+  if (event.type === "item.completed" && event.item) {
+    const item = event.item;
+    if (item.type === "agent_message" && item.text?.trim()) return [{ kind: "say", text: item.text.trim() }];
+    if (item.type === "command_execution") return [{ kind: "do", text: `ran: ${String(item.command ?? "").slice(0, 200)}` }];
+    if (item.type === "file_change") return [{ kind: "do", text: `edited: ${(item.changes ?? []).map((change) => change.path).join(", ").slice(0, 200)}` }];
+    if (item.type === "mcp_tool_call") return [{ kind: "do", text: `${item.server ?? "tool"}: ${item.tool ?? ""}` }];
+    if (item.type === "web_search") return [{ kind: "do", text: `searched: ${String(item.query ?? "").slice(0, 200)}` }];
+    return [];
+  }
+  if (event.type === "message_end" && event.message?.role === "assistant" && Array.isArray(event.message.content)) {
+    return event.message.content.flatMap((block) => block.type === "text" && block.text?.trim() ? [{ kind: "say", text: block.text.trim() }]
+      : block.type === "toolCall" ? [{ kind: "do", text: `${block.name}: ${brief(block.arguments)}` }] : []);
+  }
+  const part = event.part;
+  if (part?.type === "text" && part.text?.trim() && (part.time?.end || event.type === "text")) return [{ kind: "say", text: part.text.trim() }];
+  if (part?.type === "tool" && part.state?.status === "completed") return [{ kind: "do", text: `${part.tool}: ${brief(part.state.input)}` }];
+  return [];
+}
+
+/** The steps of a run from its log, oldest first; at most `limit`, the latest kept. */
+export function readRunSteps(file, limit = 200) {
+  let raw = "";
+  try { raw = fs.readFileSync(file, "utf8"); } catch { return []; }
+  const steps = [];
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("{")) continue;
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    steps.push(...stepsOf(event));
+  }
+  return steps.slice(-limit);
+}
+
 export function runAgentTask(task, emit, observe = () => {}) {
-  if (running.has(task.agent)) {
-    emit("failed", `A ${task.agent} task is already running on this machine.`);
+  // One run per folder: two agents in one checkout would trip over each other; a thread's worktree is its own folder.
+  const slot = task.cwd ? path.resolve(task.cwd) : task.agent;
+  if (running.has(slot)) {
+    emit("failed", `Another run is already working in ${task.cwd || "that folder"}.`);
     return;
   }
   let cwd;
@@ -92,13 +162,13 @@ 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(task.agent);
+    running.delete(slot);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);
     return;
   }
-  running.add(task.agent);
+  running.add(slot);
   children.set(task.runId, child);
 
   let resultText = "";
@@ -126,14 +196,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
       if (event.type === "result" && typeof event.result === "string") resultText = event.result;
       if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") resultText = event.item.text;
       if (["text", "message.part.updated"].includes(event.type) && typeof event.part?.text === "string") resultText = event.part.text;
-      const progress = event.type === "assistant" && Array.isArray(event.message?.content)
-        ? event.message.content.filter((block) => block.type === "text").map((block) => block.text).join(" ")
-        : event.type === "message_update" && typeof event.text === "string"
-          ? event.text
-          : event.type === "item.completed" && event.item?.type && event.item.type !== "agent_message"
-            ? event.item.type + (event.item.command ? ": " + event.item.command : "")
-            : typeof event.part?.text === "string" ? event.part.text : null;
-      if (progress?.trim()) emit("progress", progress.trim().slice(0, 200));
+      for (const step of stepsOf(event)) emit("progress", step.text.slice(0, 200), { step });
     }
   });
   child.stderr?.on("data", (chunk) => {
@@ -142,13 +205,13 @@ export function runAgentTask(task, emit, observe = () => {}) {
     tail = (tail + "\n" + raw).slice(-4_000);
   });
   child.on("close", (code) => {
-    running.delete(task.agent);
+    running.delete(slot);
     children.delete(task.runId);
     if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
     else emit("failed", (`${task.agent} exited with code ${code}.\n${tail}`).slice(0, 4_000), { usage: usage.result() });
   });
   child.on("error", (error) => {
-    running.delete(task.agent);
+    running.delete(slot);
     children.delete(task.runId);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);
   });

package/lib/sealed.mjs

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import { timingSafeEqual, webcrypto } from "node:crypto";
+
+// Harness sealed channel, version 1 (HSC1): the phone talks to this daemon through Harness, and
+// Harness carries only ciphertext. The browser twin is src/shared/crypto/sealedChannel.ts; both
+// must produce the same bytes, and smoke `phone-channel` drives one against the other.
+//
+// - The daemon has a static ECDH P-256 identity. Its public key reaches the phone only inside the
+//   pairing QR code, never through Harness, so Harness cannot stand in for the daemon.
+// - Pairing: the QR also carries a one-time 32-byte secret. The phone proves it scanned the code
+//   with HMAC-SHA256(secret, offer, device key, daemon key); Harness never sees the secret, so it
+//   cannot pair a device of its own.
+// - Every message: AES-256-GCM under HKDF-SHA256(ECDH(device, daemon)), a fresh 96-bit nonce,
+//   and the direction, device and request id bound as associated data. Requests carry a
+//   timestamp; the daemon refuses stale ones and any request id it has already seen.
+// Not provided: forward secrecy (both keys are static). Revoking a device ends its key.
+
+const subtle = webcrypto.subtle;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const CURVE = { name: "ECDH", namedCurve: "P-256" };
+export const SEALED_VERSION = 1;
+export const MAX_SKEW_MS = 5 * 60_000;
+
+export const b64u = (bytes) => Buffer.from(bytes).toString("base64url");
+export const fromB64u = (text) => new Uint8Array(Buffer.from(String(text), "base64url"));
+
+export async function loadOrCreateIdentity(file) {
+  try {
+    const saved = JSON.parse(fs.readFileSync(file, "utf8"));
+    const privateKey = await subtle.importKey("jwk", saved.privateJwk, CURVE, false, ["deriveBits"]);
+    return { privateKey, publicKey: saved.publicKey };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new Error(`the phone identity at ${file} is unreadable: ${error.message}`);
+  }
+  const pair = await subtle.generateKey(CURVE, true, ["deriveBits"]);
+  const publicKey = b64u(new Uint8Array(await subtle.exportKey("raw", pair.publicKey)));
+  const privateJwk = await subtle.exportKey("jwk", pair.privateKey);
+  fs.writeFileSync(file, JSON.stringify({ version: SEALED_VERSION, publicKey, privateJwk }), { mode: 0o600, flag: "wx" });
+  return loadOrCreateIdentity(file);
+}
+
+export async function pairProof(secret, offerId, devicePublicKey, daemonPublicKey) {
+  const key = await subtle.importKey("raw", fromB64u(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return b64u(new Uint8Array(await subtle.sign("HMAC", key, encoder.encode(`HSC1-pair\n${offerId}\n${devicePublicKey}\n${daemonPublicKey}`))));
+}
+
+export async function channelKey(privateKey, peerPublicKey, deviceId) {
+  const peer = await subtle.importKey("raw", fromB64u(peerPublicKey), CURVE, false, []);
+  const shared = await subtle.deriveBits({ name: "ECDH", public: peer }, privateKey, 256);
+  const material = await subtle.importKey("raw", shared, "HKDF", false, ["deriveKey"]);
+  return subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt: encoder.encode("HSC1"), info: encoder.encode(`HSC1 channel ${deviceId}`) },
+    material, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"],
+  );
+}
+
+const aad = (direction, deviceId, requestId) => encoder.encode(`HSC1|${direction}|${deviceId}|${requestId}`);
+
+export async function seal(key, direction, deviceId, requestId, value) {
+  const iv = webcrypto.getRandomValues(new Uint8Array(12));
+  const ct = await subtle.encrypt({ name: "AES-GCM", iv, additionalData: aad(direction, deviceId, requestId) }, key, encoder.encode(JSON.stringify(value)));
+  return { v: SEALED_VERSION, deviceId, requestId, iv: b64u(iv), ct: b64u(new Uint8Array(ct)) };
+}
+
+// Throws on a wrong key, a wrong direction, device or request id, or any changed byte.
+export async function open(key, direction, envelope) {
+  const plain = await subtle.decrypt(
+    { name: "AES-GCM", iv: fromB64u(envelope.iv), additionalData: aad(direction, envelope.deviceId, envelope.requestId) },
+    key, fromB64u(envelope.ct),
+  );
+  return JSON.parse(decoder.decode(plain));
+}
+
+export function constantTimeEqual(a, b) {
+  const left = Buffer.from(String(a)), right = Buffer.from(String(b));
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+
+// Threads with another person's computer (HSC1 relay): the two daemons' static identities give
+// one key per pair of machines; every request, message and ending is bound to its thread and id as
+// associated data. A peer's key comes from Harness's directory the first time and is pinned by
+// handle on this machine; a different key later is refused until the person trusts it.
+export async function relayKey(privateKey, peerPublicKey) {
+  const peer = await subtle.importKey("raw", fromB64u(peerPublicKey), CURVE, false, []);
+  const shared = await subtle.deriveBits({ name: "ECDH", public: peer }, privateKey, 256);
+  const material = await subtle.importKey("raw", shared, "HKDF", false, ["deriveKey"]);
+  return subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt: encoder.encode("HSC1"), info: encoder.encode("HSC1 relay") }, material, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+export async function sealBound(key, bound, value) {
+  const iv = webcrypto.getRandomValues(new Uint8Array(12));
+  const ct = await subtle.encrypt({ name: "AES-GCM", iv, additionalData: encoder.encode(`HSC1|${bound}`) }, key, encoder.encode(JSON.stringify(value)));
+  return { iv: b64u(iv), ct: b64u(new Uint8Array(ct)) };
+}
+export async function openBound(key, bound, sealed) {
+  const plain = await subtle.decrypt({ name: "AES-GCM", iv: fromB64u(sealed.iv), additionalData: encoder.encode(`HSC1|${bound}`) }, key, fromB64u(sealed.ct));
+  return JSON.parse(decoder.decode(plain));
+}
+// What two people read to each other to check they hold each other's key: SHA-256 of the key, 20 hex digits in groups of four.
+export async function fingerprint(publicKey) {
+  const digest = Buffer.from(await subtle.digest("SHA-256", fromB64u(publicKey))).toString("hex");
+  return digest.slice(0, 20).match(/.{4}/g).join(" ");
+}

package/lib/store.mjs

@@ -3,7 +3,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
 import { provenanceFor } from "./provenance.mjs";
 
-const SCHEMA_VERSION = 6;
+const SCHEMA_VERSION = 9;
 const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
@@ -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
     );
@@ -145,6 +146,40 @@ export function openStore(file) {
     );
     create index if not exists board_contributions_task_idx on board_contributions(task_id, seq);
     create virtual table if not exists board_contributions_fts using fts5(id unindexed, task_id unindexed, text, tokenize='unicode61');
+    create table if not exists phone_requests (
+      device_id text not null,
+      request_id text not null,
+      received_at text not null,
+      primary key(device_id, request_id)
+    );
+    create table if not exists phone_devices (
+      id text primary key,
+      label text not null,
+      public_key text not null,
+      paired_at text not null,
+      last_seen_at text,
+      revoked_at text
+    );
+    create table if not exists relay_peers (
+      handle text primary key,
+      public_key text not null,
+      pinned_at text not null
+    );
+    create table if not exists swarm_rounds (
+      id integer primary key autoincrement,
+      goal_id text not null,
+      at text not null,
+      coordinator text not null,
+      action text,
+      agent text,
+      loop text,
+      judgments text,
+      progress text not null,
+      estimated_micro_usd integer,
+      elapsed_ms integer not null,
+      error text
+    );
+    create index if not exists swarm_rounds_goal_idx on swarm_rounds(goal_id, at);
     create table if not exists board_vectors (
       contribution_id text primary key,
       version text not null,
@@ -159,6 +194,10 @@ export function openStore(file) {
   const boardColumns = new Set(db.all("pragma table_info(board_tasks)").map((column) => column.name));
   if (!db.all("pragma table_info(board_standing)").some((column) => column.name === "mode")) db.exec("alter table board_standing add column mode text not null default 'named'");
   if (!db.all("pragma table_info(board_contributions)").some((column) => column.name === "mentions")) db.exec("alter table board_contributions add column mentions text");
+  // Devices paired before browsers could pair were all phones.
+  if (!db.all("pragma table_info(phone_devices)").some((column) => column.name === "kind")) db.exec("alter table phone_devices add column kind text not null default 'phone'");
+  // A thread whose other side's computer holds a key: everything on it goes sealed to that key.
+  if (!db.all("pragma table_info(board_threads)").some((column) => column.name === "peer_key")) db.exec("alter table board_threads add column peer_key text");
   if (!db.all("pragma table_info(board_goals)").some((column) => column.name === "guests")) db.exec("alter table board_goals add column guests text not null default '[]'");
   if (!boardColumns.has("holder")) {
     db.exec(`alter table board_tasks add column holder text;
@@ -170,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 = [];
@@ -261,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)]));
@@ -415,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();
@@ -432,9 +476,17 @@ 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);
     },
+    setGoalTeam(id, team) {
+      execute("run", "update board_goals set team = ? where goal_id = ?", JSON.stringify([...new Set(team)]), id);
+    },
     setGoalSession(id, agent, sessionId) {
       const sessions = { ...(this.goal(id)?.sessions || {}), [agent]: sessionId };
       execute("run", "update board_goals set sessions = ? where goal_id = ?", JSON.stringify(sessions), id);
@@ -480,8 +532,38 @@ export function openStore(file) {
       execute("run", "update board_tasks set status = 'failed', result = ?, holder = null, reported_at = ?, updated_at = ?, version = version + 1 where parent_id = ? and status in ('open', 'claimed', 'needs_input', 'running')", reason, now, now, goalId);
       return running;
     },
+    // One coordinator round: what it saw, what it decided and what it cost. The evidence for its limits.
+    recordRound({ goalId, coordinator, action, agent, loop, judgments, progress, estimatedMicroUsd, elapsedMs, error }) {
+      execute("run", `insert into swarm_rounds(goal_id, at, coordinator, action, agent, loop, judgments, progress, estimated_micro_usd, elapsed_ms, error)
+        values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, goalId, new Date().toISOString(), coordinator, action, agent, loop, judgments ? JSON.stringify(judgments) : null,
+        JSON.stringify(progress), Number.isFinite(estimatedMicroUsd) ? Math.round(estimatedMicroUsd) : null, Math.round(elapsedMs), error);
+    },
+    rounds(goalId, limit = 50) {
+      const bounded = Math.max(1, Math.min(500, Number(limit) || 50));
+      return (goalId ? execute("all", "select * from swarm_rounds where goal_id = ? order by id desc limit ?", goalId, bounded) : execute("all", "select * from swarm_rounds order by id desc limit ?", bounded))
+        .map((row) => ({ ...row, judgments: row.judgments ? JSON.parse(row.judgments) : null, progress: JSON.parse(row.progress) }));
+    },
+    // 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, 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 }));
+    },
+    // The coding sessions on this machine, newest first: the person's own and the ones runs started.
+    recentSessions(limit = 30) {
+      return execute("all", `select agent, session_id, title, cwd, started_at, ended_at, message_count, source from sessions
+        order by coalesce(ended_at, started_at, indexed_at) desc limit ?`, Math.max(1, Math.min(100, Number(limit) || 30)))
+        .map((row) => ({ ...row, message_count: Number(row.message_count) }));
+    },
+    // The thread that already carries a session, if any.
+    threadForSession(agent, sessionId) {
+      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();
@@ -512,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();
@@ -558,6 +648,17 @@ export function openStore(file) {
       const row = execute("get", "select count(*) as total, (select count(*) from board_vectors v join board_contributions c on c.id = v.contribution_id where c.task_id = ?) as embedded from board_contributions where task_id = ?", taskId, taskId);
       return { total: Number(row.total), embedded: Number(row.embedded) };
     },
+    // The swarm's memory by words: everything written in the person's threads, best first, with the thread it is in.
+    searchThreads(query, { goalIds = null, k = 8 } = {}) {
+      const terms = [...new Set(String(query).toLowerCase().match(/[\p{L}\p{N}_-]+/gu) || [])].filter((term) => term.length > 1).slice(0, 12);
+      if (!terms.length) return [];
+      const match = terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+      return execute("all", `select c.id, c.task_id as thread, t.objective as thread_title, c.kind, c.author, c.text, c.created_at, bm25(board_contributions_fts) as rank
+        from board_contributions_fts f join board_contributions c on c.id = f.id join board_tasks t on t.id = c.task_id
+        where board_contributions_fts match @match and t.kind = 'goal' order by rank limit 200`, { match })
+        .filter((row) => !goalIds || goalIds.includes(row.thread)).slice(0, Math.max(1, Math.min(30, k)))
+        .map(({ rank, ...row }) => ({ ...row, text: row.text.slice(0, 2_000) }));
+    },
     // Words first: full-text candidates for a query on one task, best first.
     searchContextText(taskId, query, k = 8) {
       const terms = [...new Set(String(query).toLowerCase().match(/[\p{L}\p{N}_-]+/gu) || [])].filter((term) => term.length > 1).slice(0, 12);
@@ -573,10 +674,21 @@ export function openStore(file) {
     // Outbound messages start held (unless auto-send) or flagged (a secret), become sent when
     // the person releases them, and delivered when the server acknowledges them. Inbound ones
     // are received as data with the sender's handle on them.
-    openThread(taskId, { withAgent, role }) {
-      execute("run", "insert or ignore into board_threads(task_id, with_agent, role, auto_send, opened_at) values(?, ?, ?, 0, ?)", taskId, withAgent, role, new Date().toISOString());
+    openThread(taskId, { withAgent, role, peerKey = null }) {
+      execute("run", "insert or ignore into board_threads(task_id, with_agent, role, auto_send, opened_at, peer_key) values(?, ?, ?, 0, ?, ?)", taskId, withAgent, role, new Date().toISOString(), peerKey);
       return this.getThread(taskId);
     },
+    // Another person's computer, by handle: the key first seen for it. A different key later is refused until the person trusts it.
+    relayPeer(handle) {
+      return execute("get", "select handle, public_key, pinned_at from relay_peers where handle = ?", handle) || null;
+    },
+    pinRelayPeer(handle, publicKey) {
+      execute("run", "insert into relay_peers(handle, public_key, pinned_at) values(?, ?, ?) on conflict(handle) do update set public_key = excluded.public_key, pinned_at = excluded.pinned_at", handle, publicKey, new Date().toISOString());
+      return this.relayPeer(handle);
+    },
+    relayPeers() {
+      return execute("all", "select handle, public_key, pinned_at from relay_peers order by pinned_at desc");
+    },
     getThread(taskId) {
       const row = execute("get", "select * from board_threads where task_id = ?", taskId);
       return row ? { ...row, auto_send: Number(row.auto_send) === 1 } : null;
@@ -653,12 +765,54 @@ 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
         where m.direction = 'in' and m.created_at > ? and (t.claimed_by = ? or t.target_agent = ? or t.origin_agent = ?) group by m.task_id, t.objective, m.sender`, seen, agent, agent, agent)
         .map((row) => ({ ...row, count: Number(row.count) }));
     },
+    // Phones (QR code) and browsers (link) paired with this machine. Only the public key is kept; a revoked one is refused at once.
+    addPhone({ id, label, publicKey, kind = "phone" }) {
+      execute("run", "insert into phone_devices(id, label, public_key, paired_at, kind) values(?, ?, ?, ?, ?)", id, label, publicKey, new Date().toISOString(), kind);
+      return this.getPhone(id);
+    },
+    getPhone(id) {
+      return execute("get", "select id, label, public_key, kind, paired_at, last_seen_at, revoked_at from phone_devices where id = ?", id) || null;
+    },
+    phones() {
+      return execute("all", "select id, label, kind, paired_at, last_seen_at, revoked_at from phone_devices order by paired_at desc");
+    },
+    // Once a browser is paired, Harness reaches the person's board, sessions and runs only sealed.
+    sealedOnly() {
+      return Boolean(execute("get", "select 1 as paired from phone_devices where kind = 'browser' and revoked_at is null limit 1"));
+    },
+    // A request id is accepted once per phone, across restarts; ids older than the queue's 7 days are forgotten.
+    firstPhoneRequest(deviceId, requestId) {
+      const now = new Date();
+      execute("run", "delete from phone_requests where received_at < ?", new Date(now.getTime() - 8 * 24 * 60 * 60 * 1000).toISOString());
+      if (execute("get", "select 1 as seen from phone_requests where device_id = ? and request_id = ?", deviceId, requestId)) return false;
+      execute("run", "insert into phone_requests(device_id, request_id, received_at) values(?, ?, ?)", deviceId, requestId, now.toISOString());
+      return true;
+    },
+    touchPhone(id) {
+      execute("run", "update phone_devices set last_seen_at = ? where id = ?", new Date().toISOString(), id);
+    },
+    revokePhone(id) {
+      const phone = this.getPhone(id);
+      if (!phone) return { ok: false, error: "no phone with that id" };
+      if (!phone.revoked_at) execute("run", "update phone_devices set revoked_at = ? where id = ?", new Date().toISOString(), id);
+      return { ok: true, phone: this.getPhone(id) };
+    },
     touchAgent(agent) {
       execute("run", "insert into board_agents(agent, last_seen_at) values(?, ?) on conflict(agent) do update set last_seen_at = excluded.last_seen_at", agent, new Date().toISOString());
     },
@@ -666,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;
@@ -684,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;