tryharness 0.7.4 → 0.7.6

package/lib/mcp-stdio.mjs

@@ -91,13 +91,17 @@ 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 (for example @codex, @claude, @harness) to wake that teammate. 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.",
+    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 },
   },
   {
     name: "search_room",
     description: "Search a goal's room by meaning before starting work, so you build on what teammates already found instead of repeating it.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "the goal id" }, query: { type: "string" } }, required: ["id", "query"], additionalProperties: false },
+  },  {
+    name: "search_swarm",
+    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 },
   },
 ];
 
@@ -105,6 +109,7 @@ const BOARD_CALLS = {
   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 }),
   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 }),
   add_task_context: (args) => ({ command: "board.context.add", id: String(args.id || ""), kind: args.kind, text: args.text, source: args.source }),
   read_thread: (args) => ({ command: "board.thread.read", id: String(args.id || "") }),
@@ -126,7 +131,7 @@ async function localCall(request) {
   const name = request.params?.name;
   const args = request.params?.arguments || {};
   try {
-    const result = await daemonRequest({ ...BOARD_CALLS[name](args), agent }, ["search_task_context", "search_room"].includes(name) ? 20_000 : 5_000);
+    const result = await daemonRequest({ ...BOARD_CALLS[name](args), agent }, ["search_task_context", "search_room", "search_swarm"].includes(name) ? 20_000 : 5_000);
     return {
       jsonrpc: "2.0",
       id: request.id,

package/lib/paths.mjs

@@ -14,6 +14,7 @@ export const paths = {
   status: path.join(harnessHome, "daemon-status.json"),
   socket: process.platform === "win32" ? "\\\\.\\pipe\\tryharness-daemon" : path.join(harnessHome, "daemon.sock"),
   log: path.join(harnessHome, "daemon.log"),
+  phoneIdentity: path.join(harnessHome, "phone-identity.json"),
   runs: path.join(harnessHome, "runs"),
   runtime: path.join(harnessHome, "runtime"),
   models: path.join(harnessHome, "models"),

package/lib/phones.mjs

@@ -0,0 +1,148 @@
+import os from "node:os";
+import { randomBytes } from "node:crypto";
+import { b64u, channelKey, constantTimeEqual, loadOrCreateIdentity, MAX_SKEW_MS, open, pairProof, seal } from "./sealed.mjs";
+
+// The daemon's side of the person's own devices: pairing offers made on this machine (a QR code
+// for a phone, a link opened in a browser), and sealed calls from paired devices, opened here and
+// answered here. Harness only carries the envelopes.
+// A phone acts as the person ("user") within PHONE_COMMANDS. A browser is the Harness window on a
+// desk: it acts as the person or as Harness (the chat owner), within BROWSER_COMMANDS, and reads
+// the coding sessions and run records Harness used to read in the clear.
+
+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 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.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",
+]);
+// 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([
+  "board.list", "board.get", "board.post", "board.claim", "board.report", "board.answer", "board.thread.read", "board.thread.post", "board.standing.check",
+  "board.goal.create", "board.goal.get", "board.goal.list", "board.goal.finish", "board.room.read", "board.room.post", "board.room.search", "board.children", "board.agents",
+  "board.swarm.list", "board.swarm.read", "board.swarm.diff",
+]);
+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 }) {
+  const identity = await loadOrCreateIdentity(identityFile);
+  const offers = new Map();
+  const keys = new Map();
+  const hostname = os.hostname().slice(0, 64);
+
+  const sweep = () => {
+    const now = Date.now();
+    for (const [id, offer] of offers) if (offer.expiresAt < now) offers.delete(id);
+  };
+  const keyFor = async (device) => {
+    if (!keys.has(device.id)) keys.set(device.id, await channelKey(identity.privateKey, device.public_key, device.id));
+    return keys.get(device.id);
+  };
+
+  // What the QR code or link carries. The secret and the daemon's key never pass through Harness.
+  // The kind is fixed here, on the machine: a page cannot turn a phone's code into a browser's.
+  const offer = (origin, kind = "phone") => {
+    if (!KINDS.has(kind)) throw new Error(`unknown device kind ${kind}`);
+    sweep();
+    if (offers.size >= MAX_OFFERS) offers.delete(offers.keys().next().value);
+    const offerId = b64u(randomBytes(16));
+    const secret = b64u(randomBytes(32));
+    offers.set(offerId, { secret, kind, expiresAt: Date.now() + OFFER_TTL_MS });
+    const fragment = new URLSearchParams({ v: "1", o: offerId, s: secret, k: identity.publicKey, h: hostname });
+    const page = kind === "browser" ? "/link" : "/m/pair";
+    return { offerId, kind, expiresInSeconds: OFFER_TTL_MS / 1000, url: `${String(origin).replace(/\/$/, "")}${page}#${fragment}` };
+  };
+
+  const pair = async (input) => {
+    sweep();
+    const { offerId, deviceId, devicePublicKey, proof, requestId } = input;
+    if (![offerId, deviceId, requestId].every((value) => ID.test(String(value))) || !KEY.test(String(devicePublicKey))) return { ok: false, error: "invalid pairing request" };
+    const pending = offers.get(String(offerId));
+    // One attempt per code, right or wrong: a guessed proof burns the code.
+    offers.delete(String(offerId));
+    if (!pending) return { ok: false, error: "this pairing code expired or was already used; make a new one on the computer" };
+    if (!constantTimeEqual(proof, await pairProof(pending.secret, offerId, devicePublicKey, identity.publicKey))) return { ok: false, error: "the pairing proof did not match" };
+    if (store.getPhone(String(deviceId))) return { ok: false, error: "this device is already paired" };
+    const fallback = pending.kind === "browser" ? "Browser" : "Phone";
+    const label = String(input.label || fallback).replace(/[^\p{L}\p{N} ._'-]/gu, "").slice(0, 40) || fallback;
+    const device = store.addPhone({ id: String(deviceId), label, publicKey: String(devicePublicKey), kind: pending.kind });
+    return { ok: true, envelope: await seal(await keyFor(device), "d2p", device.id, String(requestId), { paired: true, hostname, label, kind: device.kind, version }) };
+  };
+
+  const call = async (envelope) => {
+    sweep();
+    if (!envelope || envelope.v !== 1 || !ID.test(String(envelope.deviceId)) || !ID.test(String(envelope.requestId)) || typeof envelope.iv !== "string" || typeof envelope.ct !== "string") {
+      return { ok: false, error: "invalid envelope" };
+    }
+    const device = store.getPhone(envelope.deviceId);
+    if (!device) return { ok: false, error: "unknown device", code: "unpaired" };
+    if (device.revoked_at) return { ok: false, error: "this device was disconnected from the computer", code: "revoked" };
+    const key = await keyFor(device);
+    let request;
+    try { request = await open(key, "p2d", envelope); } catch { return { ok: false, error: "the message could not be opened", code: "unreadable" }; }
+    const queued = request?.queued === true;
+    if (queued && !QUEUEABLE.has(String(request?.call?.command || ""))) return { ok: false, error: "only posts and decisions wait for the computer", code: "refused" };
+    const age = typeof request?.ts === "number" ? Date.now() - request.ts : Infinity;
+    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);
+    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 }) };
+    }
+    const result = await answer(request.call, device);
+    return { ok: true, envelope: await seal(key, "d2p", device.id, envelope.requestId, result) };
+  };
+
+  const settled = async (run) => {
+    try {
+      const result = run();
+      return result?.pending ? { ok: true, ...(await result.pending) } : result;
+    } catch (error) {
+      return { ok: false, error: `the board could not answer: ${error.message}` };
+    }
+  };
+
+  const answer = async (callInput, device) => {
+    const command = String(callInput?.command || "");
+    if (command === "phone.hello") return { ok: true, hostname, version, kind: device.kind };
+    if (device.kind === "browser") {
+      if (BROWSER_READS.has(command)) {
+        const read = reads[command];
+        if (!read) return { ok: false, error: `this computer cannot answer ${command}` };
+        try { return { ok: true, result: await read(callInput) }; } catch (error) { return { ok: false, error: error.message }; }
+      }
+      // The browser says whose call it is: the person's own action, or the chat owner's tool call.
+      const as = callInput.as === "harness" ? "harness" : "user";
+      if (!(as === "harness" ? HARNESS_COMMANDS : BROWSER_PERSON_COMMANDS).has(command)) return { ok: false, error: `a browser cannot call ${command || "that"} as ${as}` };
+      // Words another agent wrote that drove Harness's call ride as a taint the board keeps.
+      const writtenBy = Array.isArray(callInput.writtenBy) ? callInput.writtenBy.map(String).slice(0, 16) : [];
+      if (as === "harness" && command === "board.goal.create" && writtenBy.length) return { ok: false, error: "a goal is set only in a turn the owner started" };
+      const { as: _as, writtenBy: _written, provenance: _provenance, ...rest } = callInput;
+      return settled(() => boardCommand({ ...rest, command, agent: as, ...(writtenBy.length ? { provenance: { trust: "agent", chain: writtenBy } } : {}) }));
+    }
+    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 } : {}) }));
+  };
+
+  // Harness's bridge message: a pairing or a sealed call. Everything returned is safe to pass through Harness.
+  const handle = async (input) => (input?.kind === "pair" ? pair(input) : input?.kind === "call" ? call(input.envelope) : { ok: false, error: "unknown sealed request" });
+
+  const revoke = (id) => {
+    keys.delete(String(id));
+    return store.revokePhone(String(id));
+  };
+
+  return { offer, handle, revoke, list: () => store.phones(), publicKey: identity.publicKey, identity };
+}

package/lib/runner.mjs

@@ -13,6 +13,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;
@@ -26,13 +31,14 @@ 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.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
     };
   }
   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 +46,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 +80,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;
@@ -94,11 +148,11 @@ export function runAgentTask(task, emit, observe = () => {}) {
     child = spawn(invocation.command, invocation.args, { cwd });
     if (invocation.stdin !== undefined) 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 +180,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 +189,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;
 
@@ -145,6 +145,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 +193,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;
@@ -435,6 +473,9 @@ export function openStore(file) {
     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,6 +521,34 @@ 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, 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;
+    },
     activeGoalsFor(agent) {
       return this.goals().filter((goal) => goal.status === "open" && goal.goal.team.includes(agent));
     },
@@ -558,6 +627,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 +653,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;
@@ -659,6 +750,38 @@ export function openStore(file) {
         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());
     },