tryharness 0.4.3 → 0.5.1

package/lib/daemon.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import WebSocket from "ws";
 import { randomBytes, randomUUID } from "node:crypto";
 import { detectAgents, run } from "./commands.mjs";
@@ -10,16 +11,37 @@ import { parseSessionFile } from "./parsers.mjs";
 import { historyRoots, paths } from "./paths.mjs";
 import { openStore } from "./store.mjs";
 import { runAgentTask } from "./runner.mjs";
+import { notificationFor, notifyDesktop } from "./notify.mjs";
+import { secretReason } from "./secrets.mjs";
+import { provenanceFor, provenanceLine } from "./provenance.mjs";
+import { createEmbedder, EMBEDDING_VERSION, modelPresent } from "./embedder.mjs";
+import { fromBlob, toBlob, topK } from "./vectors.mjs";
 
-const DAEMON_VERSION = "0.4.3";
+const DAEMON_VERSION = readJson(fileURLToPath(new URL("../package.json", import.meta.url)), {}).version;
 const PROTOCOL_VERSION = 1;
 const RESCAN_MS = 60_000;
 const TASK_LOG_PAGE = 64_000;
 
+function daemonAnswers(socketPath) {
+  return new Promise((resolve) => {
+    const probe = net.createConnection(socketPath);
+    probe.once("connect", () => { probe.destroy(); resolve(true); });
+    probe.once("error", () => resolve(false));
+  });
+}
+
 export async function startDaemon() {
   ensureDir(paths.home);
   const config = readJson(paths.config, {});
   if (!config.origin || !config.token) throw new Error("Harness is not paired. Run: npx tryharness");
+  // node-sqlite3-wasm locks with a directory that exists only during a transaction. A daemon
+  // killed mid-transaction leaves it behind and every later open fails "database is locked";
+  // with no daemon answering, nothing can hold it.
+  const lock = `${paths.database}.lock`;
+  if (fs.existsSync(lock) && !(await daemonAnswers(paths.socket))) {
+    fs.rmdirSync(lock);
+    appendLog(paths.log, "removed a stale database lock left by a stopped daemon");
+  }
   const store = openStore(paths.database);
   const detected = detectAgents();
   const installedAgents = detected.filter((entry) => entry.path).map((entry) => entry.agent);
@@ -226,21 +248,101 @@ export async function startDaemon() {
     try { if (fs.existsSync(paths.socket)) fs.unlinkSync(paths.socket); } catch {}
   }
   let socket = null;
+  const relayWaiters = new Map();
   const send = (message) => {
     try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
   };
+  // A question for Harness over the bridge, answered by its bridge_response. Rejects when the
+  // daemon is not connected or Harness does not answer in time.
+  const askHarness = (type, input, timeoutMs = 15_000) => new Promise((resolve, reject) => {
+    if (!state.connected) { reject(new Error("the daemon is not connected to Harness")); return; }
+    const requestId = randomUUID();
+    const timer = setTimeout(() => { relayWaiters.delete(requestId); reject(new Error("Harness did not answer; is the daemon connected?")); }, timeoutMs);
+    relayWaiters.set(requestId, (response) => { clearTimeout(timer); resolve(response); });
+    send({ type, requestId, input });
+  });
+  // Agents that live on the server, not on any machine: a task for one of them goes up to
+  // Harness and lives there; reading or answering it comes back the same way.
+  const CLOUD_TARGETS = new Set(["bankr", "quotient", "muse"]);
+  const forwardToHarness = (request) => ({ pending: askHarness("board_call", { ...request, agent: String(request.agent) }).then((response) => (response.ok ? response : Promise.reject(new Error(response.error || "Harness refused the request")))) });
 
   // Board callers identify themselves by agent name (the stdio MCP passes --agent; the CLI is
   // "user"; the server names hosted callers). The name is an identity label for attribution
   // and the holder check, not an execution grant: a run needs the user's authorization.
-  const validAgent = (value) => /^[a-z0-9][a-z0-9._-]{0,63}$/.test(String(value || ""));
+  // One slash admits another person's agent, handle first: "ana/claude-code".
+  const validAgent = (value) => /^[a-z0-9][a-z0-9._-]{0,63}(\/[a-z0-9][a-z0-9._-]{0,63})?$/.test(String(value || ""));
+  // A thread's outbound leg: a message the person released (or auto-send let through) goes up
+  // the bridge; the server acknowledges it once the other side has it. Unacknowledged
+  // messages go again on reconnect, so a dropped socket never loses a reply.
+  const sendThreadMessage = (message) => send({ type: "thread_message", taskId: message.task_id, messageId: message.id, seq: message.seq, to: message.recipient, text: message.text, refs: message.refs, sentAt: message.sent_at });
   // Every change to the board goes up the bridge as identity and status; the server mirrors it
   // and the PiP follows from there. Briefs and results never ride this message.
+  // The person is told on their desktop about what waits on them, whether or not Harness is
+  // open: a run an agent asked for, a question, an unknown outcome, work posted for Harness, a
+  // claim gone stale. Once per change; off with `tryharness notify off`.
+  const lastSeen = new Map();
+  const notificationsOn = () => readJson(paths.config, {}).notifications !== false;
+  const notifyPerson = (task, previous) => {
+    if (!notificationsOn()) return;
+    const body = notificationFor(task, { previous });
+    if (body) notifyDesktop(body);
+  };
   const notifyBoard = (task) => {
     if (!task) return;
-    send({ type: "board_changed", task: { id: task.id, status: task.status, holder: task.holder, version: task.version, origin_agent: task.origin_agent, target_agent: task.target_agent, claimed_by: task.claimed_by, session_id: task.session_id || null, updated_at: task.updated_at } });
+    send({ type: "board_changed", task: { id: task.id, status: task.status, holder: task.holder, version: task.version, origin_agent: task.origin_agent, target_agent: task.target_agent, claimed_by: task.claimed_by, session_id: task.session_id || null, parent_id: task.parent_id || null, kind: task.kind || "task", updated_at: task.updated_at } });
+    notifyPerson(task, lastSeen.get(task.id) || null);
+    lastSeen.set(task.id, { status: task.status, run_workspace: task.run_workspace, run_authorized_at: task.run_authorized_at });
+    // The last part to finish closes its group, which is then announced too.
+    if (task.parent_id) { const group = store.refreshGroup(task.parent_id); if (group) notifyBoard(group); }
     setImmediate(runBoard);
   };
+  const staleTold = new Set();
+  const staleCheck = setInterval(() => {
+    if (!notificationsOn()) return;
+    for (const task of store.listTasks({ all: false, limit: 100 })) {
+      if (task.stale && !staleTold.has(task.id)) { staleTold.add(task.id); notifyDesktop(`${task.claimed_by}'s claim went stale on: ${String(task.objective).slice(0, 80)}. Release with tryharness board release ${String(task.id).slice(0, 8)}`); }
+      if (!task.stale) staleTold.delete(task.id);
+    }
+  }, 60_000);
+  // The context space's embedder: the model setup downloaded, loaded lazily, run in the
+  // background one contribution at a time so no request waits on it. Until the model is
+  // present, search answers from words and says so.
+  let embedder = null;
+  let embedding = false;
+  const embedderReady = () => modelPresent(paths.models);
+  const embedPending = async () => {
+    if (embedding || !embedderReady()) return;
+    embedding = true;
+    try {
+      embedder ||= createEmbedder({ modelsDir: paths.models });
+      for (const contribution of store.contributionsToEmbed(EMBEDDING_VERSION, 5)) {
+        const [vector] = await embedder.embedDocuments([contribution.text]);
+        store.storeVector(contribution.id, EMBEDDING_VERSION, toBlob(vector));
+      }
+    } catch (error) {
+      log(`embedding failed: ${error.message}`);
+    } finally {
+      embedding = false;
+    }
+  };
+  const embedTimer = setInterval(() => void embedPending(), 2_000);
+  const searchContext = async (taskId, query, k) => {
+    const text = store.searchContextText(taskId, query, k);
+    const context = store.contextCount(taskId);
+    if (!embedderReady()) return { retrieval: "text", embedder: "absent", context, entries: text.map(({ rank, ...entry }) => ({ ...entry, score: Number(entry.score.toFixed(3)) })) };
+    embedder ||= createEmbedder({ modelsDir: paths.models });
+    const queryVector = await embedder.embedQuery(query);
+    const rows = store.vectorsFor(taskId, EMBEDDING_VERSION).map((row) => ({ id: row.id, vector: fromBlob(row.vector) }));
+    const best = topK(queryVector, rows, k);
+    const byId = new Map(best.map((hit) => [hit.id, hit.score]));
+    // Words still count: a text hit with no vector yet rides along below the vector hits.
+    for (const hit of text) if (!byId.has(hit.id)) byId.set(hit.id, 0);
+    const entries = [...byId.entries()].map(([id, score]) => ({ ...store.getContribution(id), score: Number(score.toFixed(3)) })).filter((entry) => entry.id).sort((a, b) => b.score - a.score).slice(0, k);
+    return { retrieval: rows.length ? "vectors" : "text", embedder: "ready", context, entries: entries.map(({ seq, ...entry }) => entry) };
+  };
+  // Tasks written before the context space existed get their brief and result as entries.
+  for (const id of store.backfillContributions()) log(`context: backfilled task ${id}`);
+
   const boardCommand = (request) => {
     if (!validAgent(request.agent)) return { ok: false, error: "board requests need an agent name" };
     const agent = String(request.agent);
@@ -252,22 +354,92 @@ export async function startDaemon() {
       const objective = String(request.objective || "").trim();
       if (!objective) return { ok: false, error: "a task needs an objective" };
       if (request.targetAgent != null && !validAgent(request.targetAgent)) return { ok: false, error: "invalid target agent" };
+      // Provenance is code's: the local parent's label and what Harness sent from above the poster can only tighten it.
+      const parentTask = request.parentId ? store.getTask(String(request.parentId)) : null;
+      const claimed = request.provenance && typeof request.provenance === "object" && request.provenance.trust === "agent" ? request.provenance : null;
+      const upstream = parentTask ? { trust: claimed ? "agent" : parentTask.trust, chain: parentTask.origin_chain } : claimed;
+      const provenance = provenanceFor(agent, upstream);
+      if (CLOUD_TARGETS.has(String(request.targetAgent || "")) && !request.thread) {
+        if (!state.connected) return { ok: false, error: `${request.targetAgent} lives in Harness, and the daemon is not connected to it right now` };
+        return forwardToHarness({ ...request, provenance: upstream });
+      }
       const runWorkspace = request.runWorkspace ? String(request.runWorkspace) : null;
       if (runWorkspace && !path.isAbsolute(runWorkspace)) return { ok: false, error: "a run needs an absolute workspace directory" };
-      if (runWorkspace && !request.targetAgent) return { ok: false, error: "a run needs a target agent" };
+      if (runWorkspace && !request.targetAgent && !(Array.isArray(request.targetAgents) && request.targetAgents.length)) return { ok: false, error: "a run needs a target agent" };
       const refs = Array.isArray(request.contextRefs) ? request.contextRefs.slice(0, 50) : [];
       // The server may name the task (its run id) so the run record, the session layer and the board agree.
       if (request.id != null && !validRunId(request.id)) return { ok: false, error: "invalid task id" };
       if (request.id != null && store.getTask(String(request.id))) return { ok: false, error: "a task with this id already exists", task: store.getTask(String(request.id)) };
+      const thread = request.thread && typeof request.thread === "object" ? request.thread : null;
+      if (thread && (!validAgent(thread.with) || !["asker", "target"].includes(thread.role))) return { ok: false, error: "a thread needs the other side's agent and a role" };
+      // Several agents at once: one group task with a part per agent.
+      const targetAgents = Array.isArray(request.targetAgents) ? [...new Set(request.targetAgents.map(String))] : null;
+      if (targetAgents) {
+        if (thread) return { ok: false, error: "a thread with another person has one target" };
+        if (!targetAgents.length || targetAgents.length > 8 || !targetAgents.every(validAgent)) return { ok: false, error: "target_agents must be one to eight agent names" };
+        if (targetAgents.length === 1) request.targetAgent = targetAgents[0];
+        else {
+          const posted = store.postGroup({ ...(request.id != null ? { id: String(request.id) } : {}), objective: objective.slice(0, 500), brief: String(request.brief || "").slice(0, 200_000), originAgent: agent, provenance,
+            targetAgents, contextRefs: refs, runWorkspace, runAuthorizedBy: runWorkspace && agent === "user" ? "user" : null });
+          for (const part of posted.children) notifyBoard(store.getTask(part.id));
+          notifyBoard(posted.group);
+          return { ok: true, task: posted.group };
+        }
+      }
       const task = store.postTask({ id: request.id != null ? String(request.id) : randomUUID(), objective: objective.slice(0, 500), brief: String(request.brief || "").slice(0, 200_000),
-        originAgent: agent, targetAgent: request.targetAgent ? String(request.targetAgent) : null, parentId: request.parentId ? String(request.parentId) : null, contextRefs: refs,
-        runWorkspace, runAuthorizedBy: runWorkspace && agent === "user" ? "user" : null });
-      outcome = { ok: true, task };
-    } else if (request.command === "board.list") return { ok: true, tasks: store.listTasks({ agent, status: request.status ? String(request.status) : undefined, all: request.all === true, limit: request.limit }) };
+        originAgent: agent, provenance, targetAgent: request.targetAgent ? String(request.targetAgent) : null, parentId: request.parentId ? String(request.parentId) : null, contextRefs: refs,
+        runWorkspace: thread ? null : runWorkspace, runAuthorizedBy: !thread && runWorkspace && agent === "user" ? "user" : null });
+      if (thread) store.openThread(task.id, { withAgent: String(thread.with), role: thread.role });
+      outcome = { ok: true, task: store.getTask(task.id), thread: thread ? store.getThread(task.id) : null };
+    } else if (request.command === "board.list") {
+      const tasks = store.listTasks({ agent, status: request.status ? String(request.status) : undefined, all: request.all === true, limit: request.limit });
+      return request.unread ? { ok: true, tasks, unread: store.unreadFor(agent) } : { ok: true, tasks };
+    } else if (request.command === "board.context.add") {
+      if (!store.getTask(id)) return { ok: false, error: "task not found" };
+      const kind = String(request.kind || "note");
+      if (!["note", "log", "link", "file", "repro"].includes(kind)) return { ok: false, error: "kind must be note, log, link, file or repro" };
+      const entry = store.addContribution({ taskId: id, kind, author: agent, text: String(request.text || "").slice(0, 20_000), source: request.source ? String(request.source).slice(0, 1_024) : null });
+      return entry ? { ok: true, entry, context: store.contextCount(id) } : { ok: false, error: "nothing to add" };
+    } else if (request.command === "board.context.search") {
+      if (!store.getTask(id)) return { ok: false, error: "task not found" };
+      return { ok: true, pending: searchContext(id, String(request.query || ""), Math.max(1, Math.min(20, Number(request.limit) || 8))) };
+    } else if (request.command === "board.thread.read") {
+      const thread = store.getThread(id);
+      return thread ? { ok: true, thread, task: store.getTask(id), messages: store.threadMessages(id) } : { ok: false, error: "no thread on this task" };
+    } else if (request.command === "board.thread.post") {
+      const text = String(request.text || "").slice(0, 50_000);
+      if (!text.trim()) return { ok: false, error: "a message needs text" };
+      const refs = (Array.isArray(request.refs) ? request.refs : []).filter((ref) => ref && ["log", "repro", "link", "file"].includes(ref.kind) && typeof ref.ref === "string").slice(0, 20);
+      const flagReason = secretReason(text) || secretReason(JSON.stringify(refs));
+      outcome = store.postMessage({ id: randomUUID(), taskId: id, sender: agent, text, refs, flagReason });
+      if (outcome.ok && flagReason) store.revertAutoSend(id);
+      if (outcome.ok && outcome.message.state === "sent") sendThreadMessage(outcome.message);
+      if (outcome.ok) { outcome = { ...outcome, task: store.getTask(id) }; if (flagReason) notifyDesktop(`A reply to ${outcome.message.recipient} was held: it looks like ${flagReason}. Review it in Harness or tryharness board show ${id.slice(0, 8)}`); else if (outcome.message.state === "held") notifyDesktop(`${agent} drafted a reply to ${outcome.message.recipient}; send it from Harness or tryharness board send ${id.slice(0, 8)}`); }
+    } else if (request.command === "board.thread.send" || request.command === "board.thread.discard") {
+      if (agent !== "user") return { ok: false, error: "only the user sends or discards a held reply" };
+      const messageId = String(request.messageId || "");
+      if (request.command === "board.thread.discard") { outcome = store.discardMessage(messageId); if (outcome.ok) outcome = { ...outcome, task: store.getTask(id) }; }
+      else { outcome = store.releaseMessage(messageId); if (outcome.ok) { sendThreadMessage(outcome.message); outcome = { ...outcome, task: store.getTask(id) }; } }
+    } else if (request.command === "board.thread.auto") {
+      if (agent !== "user") return { ok: false, error: "only the user changes auto-send" };
+      outcome = store.setAutoSend(id, request.on === true);
+      if (outcome.ok) outcome = { ...outcome, task: store.getTask(id) };
+    } else if (request.command === "board.thread.end") {
+      const task = store.getTask(id);
+      if (!task) return { ok: false, error: "task not found" };
+      if (agent !== "user" && task.claimed_by !== agent) return { ok: false, error: "only the user or the agent holding the task ends its thread" };
+      outcome = store.closeThread(id, String(request.outcome || "").slice(0, 20_000) || null);
+      if (outcome.ok && !outcome.already) send({ type: "thread_end", taskId: id, by: agent, outcome: outcome.thread.outcome });
+    }
     else if (request.command === "board.get") {
       const task = store.getTask(id);
-      return task ? { ok: true, task } : { ok: false, error: "task not found" };
-    } else if (request.command === "board.agents") return { ok: true, agents: store.agentsSeen(), running: [...activeRuns.entries()].map(([runAgent, taskId]) => ({ agent: runAgent, id: taskId })) };
+      if (task) return { ok: true, task };
+      return state.connected ? forwardToHarness(request) : { ok: false, error: "task not found" };
+    } else if (request.command === "board.children") return { ok: true, tasks: store.children(id).map((child) => store.getTask(child.id)).filter(Boolean) };
+    // A trace reads both homes, and only Harness can: the machine asks it.
+    else if (request.command === "board.trace") return state.connected ? forwardToHarness(request) : { ok: false, error: "a trace reads the whole chain on this machine and in Harness, and the daemon is not connected to Harness right now" };
+    else if (request.command === "board.agents") return { ok: true, agents: store.agentsSeen(), running: [...activeRuns.entries()].map(([runAgent, taskId]) => ({ agent: runAgent, id: taskId })) };
+    else if (["board.claim", "board.report", "board.answer", "board.release"].includes(request.command) && !store.getTask(id) && state.connected) return forwardToHarness(request);
     else if (request.command === "board.claim") outcome = store.claimTask(id, agent, expected, Number.isInteger(request.leaseMinutes) ? request.leaseMinutes : 60);
     else if (request.command === "board.report") outcome = store.reportTask(id, agent, { status: String(request.status || ""), result: String(request.result || "").slice(0, 200_000) }, expected);
     else if (request.command === "board.answer") outcome = store.answerTask(id, agent, String(request.answer || "").slice(0, 20_000), expected);
@@ -295,16 +467,17 @@ export async function startDaemon() {
       activeRuns.set(agent, task.id);
       notifyBoard(started.task);
       const refs = task.context_refs.length ? "\n\nContext:\n" + task.context_refs.map((ref) => `- ${ref.kind}: ${ref.ref}${ref.note ? ` (${ref.note})` : ""}`).join("\n") : "";
-      const brief = `${task.objective}\n\n${task.brief}${refs}`.trim();
+      const notice = provenanceLine(task);
+      const brief = `${notice ? `${notice}\n\n` : ""}${task.objective}\n\n${task.brief}${refs}`.trim();
       startTask({ runId: task.id, agent, title: task.objective.slice(0, 120), brief, cwd: task.run_workspace }, (kind, text, extra) => {
         if (kind === "session" && text) { store.setRunSession(task.id, text); notifyBoard(store.getTask(task.id)); }
         if (kind === "done" || kind === "failed") {
           activeRuns.delete(agent);
+          if (extra?.usage) store.setRunUsage(task.id, extra.usage);
           const reported = store.reportTask(task.id, agent, { status: kind, result: text || "" });
           if (reported.ok) notifyBoard(reported.task);
           else log(`board task ${task.id} finished ${kind} but could not be reported: ${reported.error}`);
         }
-        void extra;
       });
     }
   };
@@ -318,7 +491,9 @@ export async function startDaemon() {
       if (newline < 0) return;
       let request;
       try { request = JSON.parse(buffer.slice(0, newline)); }
-      catch { socket.end(JSON.stringify({ ok: false, error: "invalid request" }) + "\n"); return; }
+      catch { request = null; }
+      // Anything but one JSON object is refused here; nothing a local process writes can reach a property read on it.
+      if (!request || typeof request !== "object" || Array.isArray(request)) { socket.end(JSON.stringify({ ok: false, error: "invalid request" }) + "\n"); return; }
       const reply = (value) => socket.end(JSON.stringify(value) + "\n");
       if (request.command === "status") reply({ ok: true, ...state, counts: store.counts() });
       else if (request.command === "doctor") reply({ ok: true, status: state, database: paths.database, socket: paths.socket, log: paths.log });
@@ -326,8 +501,21 @@ export async function startDaemon() {
         if (request.agent === "opencode" && request.sessionId) targetedOpencode.push(request);
         void sync(request.agent && request.agent !== "all" ? request.agent : null);
         reply({ ok: true, accepted: true, indexing: true });
-      } else if (String(request.command || "").startsWith("board.")) reply(boardCommand(request));
-      else if (request.command === "tasks.get") {
+      } else if (String(request.command || "").startsWith("board.")) {
+        // A bad request never takes the daemon down: it is answered as a refusal.
+        let result;
+        try { result = boardCommand(request); } catch (error) { log(`board ${request.command}: ${error.message}`); result = { ok: false, error: `the board could not answer: ${error.message}` }; }
+        if (result?.pending) result.pending.then((value) => reply({ ok: true, ...value }), (error) => reply({ ok: false, error: error.message }));
+        else reply(result);
+      }
+      else if (request.command === "relay.request") {
+        const requestId = randomUUID();
+        const timer = setTimeout(() => { relayWaiters.delete(requestId); reply({ ok: false, error: "Harness did not answer the request; is the daemon connected?" }); }, 15_000);
+        relayWaiters.set(requestId, (response) => { clearTimeout(timer); reply(response); });
+        // `socket` here is the control connection; the bridge's state is what matters.
+        if (!state.connected) { clearTimeout(timer); relayWaiters.delete(requestId); reply({ ok: false, error: "the daemon is not connected to Harness" }); }
+        else send({ type: "relay_request", requestId, input: { to: String(request.to || ""), fromAgent: String(request.fromAgent || ""), about: String(request.about || "").slice(0, 500), brief: String(request.brief || "").slice(0, 200_000), refs: Array.isArray(request.refs) ? request.refs.slice(0, 20) : [] } });
+      } else if (request.command === "tasks.get") {
         const task = readTask(request.runId, request.offset);
         reply(task ? { ok: true, task } : { ok: false, error: "task not found" });
       } else if (request.command === "shutdown") {
@@ -385,6 +573,7 @@ export async function startDaemon() {
         task.status = kind;
         task.finishedAt = new Date().toISOString();
         task.message = text || null;
+        if (extra?.usage) task.usage = extra.usage;
       }
       task.updatedAt = new Date().toISOString();
       persistTask(task);
@@ -413,7 +602,8 @@ export async function startDaemon() {
         state.connected = true;
         state.lastError = null;
         saveStatus();
-        send({ type: "hello", protocolVersion: PROTOCOL_VERSION, daemonVersion: DAEMON_VERSION, agents: installedAgents, health: state.agents, capabilities: ["sessions.search", "sessions.read", "tasks.status", "board"] });
+        send({ type: "hello", protocolVersion: PROTOCOL_VERSION, daemonVersion: DAEMON_VERSION, agents: installedAgents, health: state.agents, capabilities: ["sessions.search", "sessions.read", "tasks.status", "board", "threads"] });
+        for (const message of store.undeliveredMessages()) sendThreadMessage(message);
       });
       socket.on("message", (data) => {
         let message;
@@ -440,10 +630,37 @@ export async function startDaemon() {
           send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { tasks: runIds.map(taskStatus).filter(Boolean) } });
           return;
         }
+        if (message.type === "thread_message") {
+          const input = message.input || {};
+          const received = store.receiveMessage({ id: String(input.messageId || ""), taskId: String(input.taskId || ""), seq: input.seq, sender: String(input.from || "someone"), text: String(input.text || "").slice(0, 50_000), refs: Array.isArray(input.refs) ? input.refs : [], sentAt: input.sentAt });
+          send({ type: "bridge_response", requestId: message.requestId, ok: received.ok, result: received.ok ? { acknowledged: input.messageId } : null, ...(received.ok ? {} : { error: received.error }) });
+          if (received.ok && !received.duplicate) {
+            const task = store.getTask(String(input.taskId));
+            notifyBoard(task);
+            if (notificationsOn()) notifyDesktop(`${input.from} replied on: ${String(task?.objective || "").slice(0, 80)}`);
+          }
+          return;
+        }
+        if (message.type === "thread_ack") { store.markDelivered(String(message.messageId || "")); return; }
+        if (message.type === "bridge_response" && relayWaiters.has(message.requestId)) {
+          relayWaiters.get(message.requestId)(message.ok ? { ok: true, ...(message.result || {}) } : { ok: false, error: message.error || "Harness refused the request" });
+          relayWaiters.delete(message.requestId);
+          return;
+        }
+        if (message.type === "thread_end") {
+          const input = message.input || {};
+          const closed = store.closeThread(String(input.taskId || ""), String(input.outcome || "").slice(0, 20_000) || null);
+          send({ type: "bridge_response", requestId: message.requestId, ok: closed.ok, result: closed.ok ? { closed: input.taskId } : null });
+          if (closed.ok && !closed.already) { notifyBoard(closed.task); if (notificationsOn()) notifyDesktop(`${input.by} ended the thread on: ${String(closed.task?.objective || "").slice(0, 80)}`); }
+          return;
+        }
         if (message.type === "board") {
           // A hosted caller's board call, identified by the name Harness assigns it. The same
           // checks as the local control socket apply; the server persists nothing of it.
-          send({ type: "bridge_response", requestId: message.requestId, ok: true, result: boardCommand({ ...(message.input || {}), command: String(message.input?.command || "") }) });
+          let result;
+          try { result = boardCommand({ ...(message.input || {}), command: String(message.input?.command || "") }); } catch (error) { result = { ok: false, error: `the board could not answer: ${error.message}` }; }
+          if (result?.pending) result.pending.then((value) => send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { ok: true, ...value } }), (error) => send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { ok: false, error: error.message } }));
+          else send({ type: "bridge_response", requestId: message.requestId, ok: true, result });
           return;
         }
 
@@ -484,6 +701,8 @@ export async function startDaemon() {
 
   const shutdown = () => {
     clearInterval(heartbeat);
+    clearInterval(staleCheck);
+    clearInterval(embedTimer);
     clearInterval(rescan);
     for (const watcher of watchers) watcher.close();
     try { socket?.close(); } catch {}

package/lib/embedder.mjs

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir } from "./files.mjs";
+
+// The daemon's own embedder for the context space: the same model, quantization, pooling
+// and normalization as the browser (src/shared/memory/embeddingService.ts), so the two
+// sides describe the same space under the same version key. It runs on onnxruntime-web's
+// Node build (wasm, no native addon) with the same tokenizer library transformers.js uses,
+// and mirrors transformers' feature-extraction pipeline step by step: tokenize with special
+// tokens, truncate to the model's 512, pad to the batch, take the [CLS] vector, L2-normalize.
+// Weights are downloaded into the Harness home during setup, never fetched from a browser.
+
+export const EMBEDDING_MODEL = "Xenova/bge-base-en-v1.5";
+export const EMBEDDING_DIMENSIONS = 768;
+export const EMBEDDING_VERSION = "bge-base-en-v1.5:q8:cls:l2:asymmetric:v1";
+const QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
+const MODEL_FILES = ["config.json", "tokenizer.json", "tokenizer_config.json", "onnx/model_quantized.onnx"];
+const REMOTE = `https://huggingface.co/${EMBEDDING_MODEL}/resolve/main/`;
+// One text per run: a q8 model quantizes per batch tensor, so the same text in different company
+// differs in the last decimals (transformers.js shows the same, cosine 0.992 alone versus batched).
+// Entries arrive one at a time and a vector must not depend on its neighbours, so no batching.
+const BATCH = 1;
+
+export function modelDirectory(modelsDir) {
+  return path.join(modelsDir, ...EMBEDDING_MODEL.split("/"));
+}
+
+/** True when every model file is present and non-empty. */
+export function modelPresent(modelsDir) {
+  const dir = modelDirectory(modelsDir);
+  return MODEL_FILES.every((file) => {
+    try { return fs.statSync(path.join(dir, file)).size > 0; } catch { return false; }
+  });
+}
+
+async function download(url, target, { fetchImpl, log }) {
+  const partial = `${target}.partial`;
+  ensureDir(path.dirname(target));
+  let have = 0;
+  try { have = fs.statSync(partial).size; } catch {}
+  const headers = have > 0 ? { range: `bytes=${have}-` } : {};
+  const response = await fetchImpl(url, { headers, redirect: "follow" });
+  if (response.status === 416) { fs.renameSync(partial, target); return; }
+  if (!response.ok) throw new Error(`download of ${path.basename(target)} failed: HTTP ${response.status}`);
+  const resumed = response.status === 206;
+  const total = Number(response.headers.get("content-length") || 0) + (resumed ? have : 0);
+  const out = fs.createWriteStream(partial, { flags: resumed ? "a" : "w" });
+  let done = resumed ? have : 0;
+  let shown = -1;
+  const name = path.basename(target);
+  for await (const chunk of response.body) {
+    if (!out.write(chunk)) await new Promise((resolve) => out.once("drain", resolve));
+    done += chunk.length;
+    const percent = total ? Math.floor((done / total) * 10) * 10 : -1;
+    if (percent !== shown && percent >= 0) { shown = percent; log?.(`embedder: ${name} ${percent}%`); }
+  }
+  await new Promise((resolve, reject) => { out.end(); out.on("finish", resolve); out.on("error", reject); });
+  if (total && done !== total) throw new Error(`download of ${name} stopped at ${done} of ${total} bytes; run setup again to resume`);
+  fs.renameSync(partial, target);
+}
+
+/** Downloads any missing model file into modelsDir. Idempotent; a partial file resumes. */
+export async function ensureModel({ modelsDir, log = () => {}, fetchImpl = fetch } = {}) {
+  const dir = modelDirectory(modelsDir);
+  const missing = MODEL_FILES.filter((file) => { try { return fs.statSync(path.join(dir, file)).size === 0; } catch { return true; } });
+  if (!missing.length) return { downloaded: [], present: true };
+  log(`embedder: downloading ${EMBEDDING_MODEL} (${missing.length} file${missing.length === 1 ? "" : "s"}, about 110 MB) into ${modelsDir}`);
+  for (const file of missing) await download(REMOTE + file, path.join(dir, file), { fetchImpl, log });
+  log("embedder: ready");
+  return { downloaded: missing, present: true };
+}
+
+function truncate(encoded, maxLength) {
+  for (const key of Object.keys(encoded)) encoded[key] = encoded[key].slice(0, maxLength);
+}
+
+function pad(encoded, maxLength, padId) {
+  for (const key of Object.keys(encoded)) {
+    const fill = key === "input_ids" ? padId : 0;
+    while (encoded[key].length < maxLength) encoded[key].push(fill);
+  }
+}
+
+/**
+ * A lazily loaded embedder over local files only. Loading the session takes about half a
+ * second and inference runs on the calling thread (onnxruntime-web's Node build has no
+ * worker), so each short text holds the event loop for a few tens of milliseconds;
+ * callers embed in the background, never inside a request the person is waiting on.
+ */
+export function createEmbedder({ modelsDir }) {
+  const dir = modelDirectory(modelsDir);
+  let loading = null;
+  const load = () => {
+    if (loading) return loading;
+    loading = (async () => {
+      if (!modelPresent(modelsDir)) throw new Error(`the embedding model is not present in ${modelsDir}; run npx tryharness to download it`);
+      const [{ Tokenizer }, ort] = await Promise.all([import("@huggingface/tokenizers"), import("onnxruntime-web")]);
+      const tokenizerJson = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer.json"), "utf8"));
+      const tokenizerConfig = JSON.parse(fs.readFileSync(path.join(dir, "tokenizer_config.json"), "utf8"));
+      const modelConfig = JSON.parse(fs.readFileSync(path.join(dir, "config.json"), "utf8"));
+      const tokenizer = new Tokenizer(tokenizerJson, tokenizerConfig);
+      ort.env.wasm.numThreads = 1;
+      const session = await ort.InferenceSession.create(path.join(dir, "onnx", "model_quantized.onnx"), { executionProviders: ["wasm"] });
+      return {
+        ort, tokenizer, session,
+        maxLength: Number(tokenizerConfig.model_max_length) || 512,
+        padId: Number(modelConfig.pad_token_id ?? 0),
+        wantsTypeIds: session.inputNames.includes("token_type_ids"),
+      };
+    })();
+    loading.catch(() => { loading = null; });
+    return loading;
+  };
+
+  const embedBatch = async (texts) => {
+    const { ort, tokenizer, session, maxLength, padId, wantsTypeIds } = await load();
+    const encoded = texts.map((text) => {
+      const { ids, attention_mask, token_type_ids } = tokenizer.encode(text, { add_special_tokens: true, return_token_type_ids: true });
+      return { input_ids: [...ids], attention_mask: [...attention_mask], ...(wantsTypeIds ? { token_type_ids: [...(token_type_ids || ids.map(() => 0))] } : {}) };
+    });
+    const width = Math.min(Math.max(...encoded.map((e) => e.input_ids.length)), maxLength);
+    for (const e of encoded) {
+      if (e.input_ids.length > width) truncate(e, width);
+      else if (e.input_ids.length < width) pad(e, width, padId);
+    }
+    const tensor = (key) => new ort.Tensor("int64", BigInt64Array.from(encoded.flatMap((e) => e[key].map((v) => BigInt(v)))), [texts.length, width]);
+    const feeds = { input_ids: tensor("input_ids"), attention_mask: tensor("attention_mask"), ...(wantsTypeIds ? { token_type_ids: tensor("token_type_ids") } : {}) };
+    const outputs = await session.run(feeds);
+    const hidden = outputs.last_hidden_state;
+    const [, seq, dims] = hidden.dims;
+    const data = hidden.data;
+    return texts.map((_, row) => {
+      const start = row * seq * dims;
+      const vector = new Float32Array(dims);
+      let norm = 0;
+      for (let i = 0; i < dims; i += 1) { vector[i] = data[start + i]; norm += vector[i] * vector[i]; }
+      norm = Math.sqrt(norm) || 1;
+      for (let i = 0; i < dims; i += 1) vector[i] /= norm;
+      return vector;
+    });
+  };
+
+  return {
+    version: EMBEDDING_VERSION,
+    dimensions: EMBEDDING_DIMENSIONS,
+    ready: () => load().then(() => true),
+    async embedDocuments(texts) {
+      const out = [];
+      for (let i = 0; i < texts.length; i += BATCH) out.push(...(await embedBatch(texts.slice(i, i + BATCH))));
+      return out;
+    },
+    async embedQuery(text) {
+      return (await embedBatch([QUERY_PREFIX + text]))[0];
+    },
+  };
+}