tryharness 0.4.2 → 0.5.0

package/lib/daemon.mjs

@@ -10,8 +10,13 @@ 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.2";
+const DAEMON_VERSION = "0.4.3";
 const PROTOCOL_VERSION = 1;
 const RESCAN_MS = 60_000;
 const TASK_LOG_PAGE = 64_000;
@@ -61,6 +66,23 @@ export async function startDaemon() {
     const chunk = raw.slice(offset, offset + TASK_LOG_PAGE);
     return { ...task, log: chunk, offset, nextOffset: offset + chunk.length, logLength: raw.length };
   };
+  // Runs left starting/running by a previous daemon process lost their agent process
+  // with it; their outcome is unknown, never assumed finished.
+  try {
+    for (const name of fs.readdirSync(paths.runs)) {
+      if (!name.endsWith(".json")) continue;
+      const task = readJson(path.join(paths.runs, name), null);
+      if (task && validRunId(task.runId) && (task.status === "starting" || task.status === "running")) {
+        persistTask({ ...task, status: "interrupted", updatedAt: new Date().toISOString() });
+      }
+    }
+  } catch {}
+  const taskStatus = (runId) => {
+    const task = validRunId(runId) ? taskRuns.get(runId) || readJson(taskFiles(runId).state, null) : null;
+    if (!task) return null;
+    const message = typeof task.message === "string" ? task.message.slice(0, 100_000) : null;
+    return { runId: task.runId, status: task.status, message, sessionId: task.sessionId || null, cwd: task.cwd || null };
+  };
   saveStatus();
   log(`daemon ${DAEMON_VERSION} starting; agents=${installedAgents.join(",") || "none"}`);
 
@@ -208,6 +230,241 @@ export async function startDaemon() {
   if (process.platform !== "win32") {
     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.
+  // 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, 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);
+    store.touchAgent(agent);
+    const id = String(request.id || "");
+    const expected = Number.isInteger(request.expectedVersion) ? request.expectedVersion : null;
+    let outcome;
+    if (request.command === "board.post") {
+      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 && !(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, 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);
+      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);
+    else if (request.command === "board.release") outcome = store.releaseTask(id, agent, expected);
+    else if (request.command === "board.run") outcome = agent === "user" ? store.authorizeRun(id, agent) : { ok: false, error: "only the user can authorize a run" };
+    else return { ok: false, error: "unknown command" };
+    if (outcome.ok) notifyBoard(outcome.task);
+    return outcome;
+  };
+
+  // The board worker. An authorized task for an agent installed here is claimed by the daemon
+  // in that agent's name, run through the same runner as a pushed run (so `tryharness task <id>
+  // --follow` and the run record work unchanged), and reported back on the task. One run per
+  // agent at a time; the rest wait open. Nothing here polls: a board write calls runBoard.
+  const activeRuns = new Map();
+  for (const id of store.settleInterruptedRuns()) log(`board task ${id} was running when the daemon stopped; marked unknown`);
+  const runBoard = () => {
+    for (const task of store.runnableTasks(installedAgents.filter((agent) => !activeRuns.has(agent)))) {
+      const agent = task.target_agent;
+      if (activeRuns.has(agent)) continue;
+      const claimed = store.claimTask(task.id, agent, task.version, null);
+      if (!claimed.ok) continue;
+      const started = store.startRun(task.id, agent);
+      if (!started.ok) continue;
+      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 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}`);
+        }
+      });
+    }
+  };
+
   const control = net.createServer((socket) => {
     socket.setEncoding("utf8");
     let buffer = "";
@@ -217,7 +474,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 });
@@ -225,14 +484,20 @@ 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 (request.command === "handoffs.create") {
-        const id = request.id || randomUUID();
-        store.addHandoff({ id, targetAgent: request.agent, targetSessionId: request.sessionId, title: request.title || "Harness handoff", body: request.body || "", source: request.source });
-        reply({ ok: true, id });
-      } else if (request.command === "handoffs.list") reply({ ok: true, handoffs: store.listHandoffs(request.agent) });
-      else if (request.command === "handoffs.get") {
-        const handoff = store.getHandoff(request.id, request.consume === true);
-        reply(handoff && handoff.target_agent === request.agent ? { ok: true, handoff } : { ok: false, error: "handoff not found" });
+      } 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" });
@@ -248,15 +513,21 @@ export async function startDaemon() {
   });
   if (process.platform !== "win32") try { fs.chmodSync(paths.socket, 0o600); } catch {}
 
-  let socket = null;
   let retry = 1_000;
   let reconnectTimer = null;
-  const send = (message) => {
-    try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
-  };
-  const startTask = (message) => {
+  // Runs an agent for a board task, writing the run record and log under the task id. A run id
+  // is executed at most once: a known record answers with its outcome instead of a rerun.
+  const startTask = (message, report) => {
     if (!validRunId(message.runId)) {
-      send({ type: "event", runId: message.runId, kind: "failed", text: "Invalid task run id." });
+      report("failed", "Invalid task run id.");
+      return;
+    }
+    // A run id is executed at most once, even if the same task arrives again.
+    const known = taskStatus(message.runId);
+    if (known) {
+      if (known.status === "done" || known.status === "failed") report(known.status, known.message || undefined);
+      else if (known.status === "running") report("accepted");
+      else report("failed", "This run was interrupted earlier and is not started again.");
       return;
     }
     ensureDir(paths.runs);
@@ -285,10 +556,11 @@ 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);
-      send({ type: "event", runId: message.runId, kind, ...(text ? { text } : {}), ...(extra || {}) });
+      report(kind, text, extra);
     };
     const observe = (stream, raw) => {
       try { fs.appendFileSync(files.log, stream === "stderr" ? `\n[stderr] ${raw}` : raw, { mode: 0o600 }); } catch {}
@@ -313,7 +585,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.run", "handoffs.put", "handoffs.read"] });
+        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;
@@ -335,28 +608,45 @@ export async function startDaemon() {
           catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
           return;
         }
-        if (message.type === "handoffs_list") {
-          try { send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { handoffs: store.listHandoffs(message.input?.agent) } }); }
-          catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+        if (message.type === "tasks_status") {
+          const runIds = Array.isArray(message.input?.runIds) ? message.input.runIds.slice(0, 50) : [];
+          send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { tasks: runIds.map(taskStatus).filter(Boolean) } });
           return;
         }
-        if (message.type === "handoffs_get") {
-          try {
-            const handoff = store.getHandoff(message.input?.id, message.input?.consume === true);
-            send({ type: "bridge_response", requestId: message.requestId, ok: Boolean(handoff), result: handoff ? { handoff } : null });
-          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+        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 === "handoff") {
-          try {
-            store.addHandoff({ id: message.handoff?.id || randomUUID(), targetAgent: message.handoff?.agent, targetSessionId: message.handoff?.sessionId, title: message.handoff?.title || "Harness handoff", body: message.handoff?.body || "", source: message.handoff?.source });
-            send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { stored: true } });
-          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+        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 === "task") {
-          startTask(message);
+        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.
+          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;
+        }
+
       });
       const dropped = (error) => {
         state.connected = false;
@@ -374,6 +664,7 @@ export async function startDaemon() {
     }
   };
   connect();
+  setImmediate(runBoard);
   const heartbeat = setInterval(() => send({ type: "ping" }), 30_000);
   const rescan = setInterval(() => void sync(), RESCAN_MS);
   const watchers = [];
@@ -393,6 +684,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];
+    },
+  };
+}