tryharness 0.4.2 → 0.5.0

package/lib/store.mjs

@@ -1,7 +1,9 @@
+import { randomUUID } from "node:crypto";
 import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
+import { provenanceFor } from "./provenance.mjs";
 
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 6;
 const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
@@ -49,21 +51,99 @@ export function openStore(file) {
       transcript,
       tokenize='unicode61'
     );
-    create table if not exists handoffs (
+    create table if not exists board_tasks (
       id text primary key,
-      target_agent text not null,
-      target_session_id text,
-      title text not null,
-      body text not null,
-      source text,
+      objective text not null,
+      brief text not null default '',
+      origin_agent text not null,
+      target_agent text,
+      status text not null,
+      parent_id text,
+      context_refs text not null default '[]',
+      claimed_by text,
+      claimed_at text,
+      result text,
+      reported_at text,
+      holder text,
+      version integer not null default 1,
+      run_workspace text,
+      run_requested_at text,
+      run_authorized_by text,
+      run_authorized_at text,
+      session_id text,
+      lease_until text,
+      kind text not null default 'task',
+      trust text not null default 'agent',
+      origin_chain text not null default '[]',
+      usage text,
+      created_at text not null,
+      updated_at text not null
+    );
+    create index if not exists board_tasks_status_idx on board_tasks(status, created_at desc);
+    create table if not exists board_agents (
+      agent text primary key,
+      last_seen_at text not null
+    );
+    create table if not exists board_threads (
+      task_id text primary key,
+      with_agent text not null,
+      role text not null,
+      auto_send integer not null default 0,
+      opened_at text not null,
+      closed_at text,
+      outcome text
+    );
+    create table if not exists board_messages (
+      id text primary key,
+      task_id text not null,
+      seq integer not null,
+      direction text not null,
+      sender text not null,
+      recipient text not null,
+      text text not null,
+      refs text not null default '[]',
+      state text not null,
+      flag_reason text,
       created_at text not null,
-      consumed_at text
+      sent_at text,
+      delivered_at text
+    );
+    create index if not exists board_messages_task_idx on board_messages(task_id, seq);
+    create table if not exists board_contributions (
+      id text primary key,
+      task_id text not null,
+      seq integer not null,
+      kind text not null,
+      author text not null,
+      text text not null,
+      source text,
+      created_at text not null
+    );
+    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 board_vectors (
+      contribution_id text primary key,
+      version text not null,
+      vector blob not null
     );
   `);
   const sessionColumns = new Set(db.all("pragma table_info(sessions)").map((column) => column.name));
   if (!sessionColumns.has("parser_version")) {
     db.exec("alter table sessions add column parser_version integer not null default 0");
   }
+  // Boards written before the lock existed: give every task a holder and a version.
+  const boardColumns = new Set(db.all("pragma table_info(board_tasks)").map((column) => column.name));
+  if (!boardColumns.has("holder")) {
+    db.exec(`alter table board_tasks add column holder text;
+      alter table board_tasks add column version integer not null default 1;
+      update board_tasks set holder = case status when 'open' then target_agent when 'claimed' then claimed_by when 'needs_input' then origin_agent else null end;`);
+  }
+  for (const column of ["run_workspace", "run_requested_at", "run_authorized_by", "run_authorized_at", "session_id", "lease_until"]) {
+    if (!boardColumns.has(column) && boardColumns.size) db.exec(`alter table board_tasks add column ${column} text`);
+  }
+  if (!boardColumns.has("kind") && boardColumns.size) db.exec("alter table board_tasks add column kind text not null default 'task'");
+  if (!boardColumns.has("usage") && boardColumns.size) db.exec("alter table board_tasks add column usage text");
+  if (!boardColumns.has("trust") && boardColumns.size) db.exec("alter table board_tasks add column trust text not null default 'agent'; alter table board_tasks add column origin_chain text not null default '[]'");
 
   const statements = [];
   const prepare = (sql) => {
@@ -117,6 +197,13 @@ export function openStore(file) {
       select agent, session_id, title, cwd, transcript from sessions;`);
   }
 
+  // Why a conditional write landed nowhere, with the task as it is now so the caller re-reads.
+  const conflict = (task, agent, expectedVersion, describe) => {
+    if (!task) return { ok: false, error: "task not found" };
+    if (expectedVersion != null && Number(expectedVersion) !== task.version) return { ok: false, error: `task changed since version ${expectedVersion}; it is now version ${task.version}`, conflict: true, task };
+    return { ok: false, error: describe(task), conflict: true, task };
+  };
+
   return {
     db,
     needsIndex(agent, sessionId, mtime, size) {
@@ -194,21 +281,306 @@ export function openStore(file) {
         order by case when session_id = ? then 0 else 1 end, indexed_at desc limit 1`, agent, sessionHint, sessionHint, sessionHint);
       return found || null;
     },
-    addHandoff({ id, targetAgent, targetSessionId, title, body, source }) {
-      execute("run", `insert or replace into handoffs(id, target_agent, target_session_id, title, body, source, created_at, consumed_at)
-        values(?, ?, ?, ?, ?, ?, ?, null)`, id, targetAgent, targetSessionId || null, title, body, source || null, new Date().toISOString());
-    },
-    listHandoffs(targetAgent) {
-      return targetAgent
-        ? execute("all", `select id, target_agent, target_session_id, title, source, created_at
-            from handoffs where target_agent = ? and consumed_at is null order by created_at desc limit 20`, targetAgent)
-        : execute("all", `select id, target_agent, target_session_id, title, source, created_at
-            from handoffs where consumed_at is null order by created_at desc limit 20`);
-    },
-    getHandoff(id, consume = false) {
-      const row = execute("get", "select * from handoffs where id = ?", id);
-      if (row && consume) execute("run", "update handoffs set consumed_at = ? where id = ?", new Date().toISOString(), id);
-      return row || null;
+    // The task board: work any agent posts for another agent on this machine. Pull only; a
+    // task runs when its target reads the board and claims it, never on its own. Brief and
+    // result never leave the machine unless the claimer sends them somewhere itself.
+    //
+    // Every task has one holder, the only identity allowed to write it next, and a version
+    // that every write bumps. A write is one conditional update: it lands only for the holder,
+    // in the expected status, at the version the caller last saw when it names one. Anything
+    // else is a conflict that returns the current task, so two agents can never overwrite each
+    // other and a caller acting on a stale read finds out instead of winning.
+    postTask({ id = randomUUID(), objective, brief = "", originAgent, provenance = provenanceFor(originAgent), targetAgent = null, parentId = null, contextRefs = [], runWorkspace = null, runAuthorizedBy = null }) {
+      const now = new Date().toISOString();
+      execute("run", `insert into board_tasks(id, objective, brief, origin_agent, target_agent, status, parent_id, context_refs, holder, version,
+          run_workspace, run_requested_at, run_authorized_by, run_authorized_at, trust, origin_chain, created_at, updated_at)
+        values(@id, @objective, @brief, @originAgent, @targetAgent, 'open', @parentId, @contextRefs, @targetAgent, 1, @runWorkspace, @runRequestedAt, @runAuthorizedBy, @runAuthorizedAt, @trust, @chain, @now, @now)`,
+        { id, objective, brief, originAgent, targetAgent, parentId, contextRefs: JSON.stringify(contextRefs), runWorkspace, runRequestedAt: runWorkspace ? now : null,
+          trust: provenance.trust === "user" ? "user" : "agent", chain: JSON.stringify(provenance.chain || []),
+          runAuthorizedBy: runWorkspace ? runAuthorizedBy : null, runAuthorizedAt: runWorkspace && runAuthorizedBy ? now : null, now });
+      if (brief) this.addContribution({ taskId: id, kind: "brief", author: originAgent, text: `${objective}\n\n${brief}`, source: "task" });
+      else this.addContribution({ taskId: id, kind: "brief", author: originAgent, text: objective, source: "task" });
+      return this.getTask(id);
+    },
+    // A task for several agents at once: one group task the person sees, one part per agent that
+    // each agent claims, runs and reports on its own. The group closes when the last part does,
+    // carrying every result; it cannot itself be claimed.
+    postGroup({ id = randomUUID(), objective, brief = "", originAgent, provenance = provenanceFor(originAgent), targetAgents, contextRefs = [], runWorkspace = null, runAuthorizedBy = null }) {
+      const now = new Date().toISOString();
+      execute("run", `insert into board_tasks(id, objective, brief, origin_agent, target_agent, status, parent_id, context_refs, holder, version, kind, trust, origin_chain, created_at, updated_at)
+        values(@id, @objective, @brief, @originAgent, null, 'open', null, @contextRefs, null, 1, 'group', @trust, @chain, @now, @now)`,
+        { id, objective, brief, originAgent, contextRefs: JSON.stringify(contextRefs), trust: provenance.trust === "user" ? "user" : "agent", chain: JSON.stringify(provenance.chain || []), now });
+      this.addContribution({ taskId: id, kind: "brief", author: originAgent, text: brief ? `${objective}\n\n${brief}` : objective, source: "task" });
+      const children = targetAgents.map((targetAgent) => this.postTask({ objective, brief, originAgent, provenance, targetAgent, parentId: id, contextRefs, runWorkspace, runAuthorizedBy }));
+      return { group: this.getTask(id), children };
+    },
+    children(parentId) {
+      return execute("all", "select id, target_agent, status, claimed_by, holder, result, run_workspace, run_authorized_at, session_id, version from board_tasks where parent_id = ? order by created_at asc", parentId)
+        .map((row) => ({ ...row, version: Number(row.version) }));
+    },
+    refreshGroup(parentId) {
+      const group = this.getTask(parentId);
+      if (!group || group.kind !== "group" || ["done", "failed", "unknown"].includes(group.status)) return null;
+      const parts = this.children(parentId);
+      if (!parts.length || parts.some((part) => !["done", "failed", "unknown"].includes(part.status))) return null;
+      const status = parts.some((part) => part.status === "failed") ? "failed" : parts.some((part) => part.status === "unknown") ? "unknown" : "done";
+      const result = parts.map((part) => `${part.target_agent} (${part.status}): ${part.result || "no result"}`).join("\n\n");
+      const now = new Date().toISOString();
+      execute("run", "update board_tasks set status = ?, result = ?, holder = null, reported_at = ?, updated_at = ?, version = version + 1 where id = ?", status, result, now, now, parentId);
+      this.addContribution({ taskId: parentId, kind: "result", author: "harness", text: result, source: `group:${status}` });
+      return this.getTask(parentId);
+    },
+    // Run authority is a separate write from the post: an agent may ask for a run, only the user grants it.
+    authorizeRun(id, agent) {
+      if (this.getThread(id)) return { ok: false, error: "a task shared with another person's agent never runs on its own; work it in a session where you are present" };
+      const group = this.getTask(id);
+      if (group?.kind === "group") {
+        const outcomes = this.children(id).map((part) => this.authorizeRun(part.id, agent));
+        return outcomes.some((outcome) => outcome.ok) ? { ok: true, task: this.getTask(id), parts: outcomes } : (outcomes[0] || { ok: false, error: "the group has no parts" });
+      }
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set run_authorized_by = @agent, run_authorized_at = @now, updated_at = @now, version = version + 1
+        where id = @id and status = 'open' and run_workspace is not null and run_authorized_at is null`, { id, agent, now });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, null, (task) => task.run_authorized_at ? "the run is already authorized" : !task.run_workspace ? "this task did not ask for a run" : `task is ${task.status}`);
+    },
+    // Tasks the daemon should run now: authorized, still open, for an agent installed here.
+    runnableTasks(agents) {
+      if (!agents.length) return [];
+      return execute("all", `select * from board_tasks where status = 'open' and run_authorized_at is not null and target_agent in (${agents.map(() => "?").join(", ")})
+          and id not in (select task_id from board_threads)
+        order by run_authorized_at asc`, ...agents).map((row) => ({ ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), origin_chain: JSON.parse(row.origin_chain || "[]") }));
+    },
+    startRun(id, agent) {
+      const now = new Date().toISOString();
+      const written = execute("run", "update board_tasks set status = 'running', updated_at = @now, version = version + 1 where id = @id and status = 'claimed' and holder = @agent", { id, agent, now });
+      return written.changes === 1 ? { ok: true, task: this.getTask(id) } : conflict(this.getTask(id), agent, null, (task) => `task is ${task.status}`);
+    },
+    // What the run cost as its agent reported it; read back by the chain's trace.
+    setRunUsage(id, usage) {
+      execute("run", "update board_tasks set usage = ? where id = ?", JSON.stringify(usage), id);
+    },
+    setRunSession(id, sessionId) {
+      execute("run", "update board_tasks set session_id = ?, updated_at = ? where id = ?", sessionId, new Date().toISOString(), id);
+    },
+    // A daemon restart lost every agent process it was running; those outcomes are unknown, never assumed.
+    settleInterruptedRuns() {
+      const now = new Date().toISOString();
+      const affected = execute("all", "select id from board_tasks where status = 'running'").map((row) => row.id);
+      if (affected.length) execute("run", `update board_tasks set status = 'unknown', holder = null, result = 'The daemon restarted during this run; its outcome is unknown. Check the workspace.', reported_at = @now, updated_at = @now, version = version + 1 where status = 'running'`, { now });
+      return affected;
+    },
+    // The task's context space: everything written about the task, by anyone on it, searchable
+    // by meaning once the daemon has embedded it and by words before that. Briefs, results,
+    // answers and thread messages land here on their own; notes, logs, links and file excerpts
+    // are added on purpose. Vectors are derived locally and never leave the machine.
+    addContribution({ id = randomUUID(), taskId, kind, author, text, source = null }) {
+      const body = String(text || "").trim();
+      if (!body) return null;
+      const seq = Number(execute("get", "select coalesce(max(seq), 0) as seq from board_contributions where task_id = ?", taskId).seq) + 1;
+      const now = new Date().toISOString();
+      execute("run", "insert or ignore into board_contributions(id, task_id, seq, kind, author, text, source, created_at) values(?, ?, ?, ?, ?, ?, ?, ?)", id, taskId, seq, kind, author, body.slice(0, 20_000), source, now);
+      execute("run", "insert into board_contributions_fts(id, task_id, text) values(?, ?, ?)", id, taskId, body.slice(0, 20_000));
+      return this.getContribution(id);
+    },
+    getContribution(id) {
+      const row = execute("get", "select * from board_contributions where id = ?", id);
+      return row ? { ...row, seq: Number(row.seq) } : null;
+    },
+    backfillContributions() {
+      const rows = execute("all", "select * from board_tasks t where not exists (select 1 from board_contributions c where c.task_id = t.id)");
+      for (const task of rows) {
+        this.addContribution({ taskId: task.id, kind: "brief", author: task.origin_agent, text: task.brief ? `${task.objective}\n\n${task.brief}` : task.objective, source: "task" });
+        if (task.result) this.addContribution({ taskId: task.id, kind: task.status === "needs_input" ? "question" : "result", author: task.claimed_by || task.target_agent || "agent", text: task.result, source: `report:${task.status}` });
+      }
+      return rows.map((task) => task.id);
+    },
+    contributionsToEmbed(version, limit = 5) {
+      return execute("all", `select c.* from board_contributions c left join board_vectors v on v.contribution_id = c.id
+        where v.contribution_id is null or v.version != ? order by c.created_at asc limit ?`, version, limit).map((row) => ({ ...row, seq: Number(row.seq) }));
+    },
+    storeVector(contributionId, version, blob) {
+      execute("run", "insert into board_vectors(contribution_id, version, vector) values(?, ?, ?) on conflict(contribution_id) do update set version = excluded.version, vector = excluded.vector", contributionId, version, blob);
+    },
+    vectorsFor(taskId, version) {
+      return execute("all", "select v.contribution_id as id, v.vector from board_vectors v join board_contributions c on c.id = v.contribution_id where c.task_id = ? and v.version = ?", taskId, version);
+    },
+    contextCount(taskId) {
+      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) };
+    },
+    // 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);
+      if (!terms.length) return [];
+      const match = terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+      return execute("all", `select c.id, c.kind, c.author, c.text, c.source, c.created_at, bm25(board_contributions_fts) as rank
+        from board_contributions_fts f join board_contributions c on c.id = f.id
+        where board_contributions_fts match @match and f.task_id = @taskId order by rank limit @k`, { match, taskId, k: Math.max(1, Math.min(50, k)) })
+        .map((row) => ({ ...row, score: -Number(row.rank) }));
+    },
+
+    // A thread with another person's agent, on the task both daemons hold under the same id.
+    // 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());
+      return this.getThread(taskId);
+    },
+    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;
+    },
+    threadMessages(taskId) {
+      return execute("all", "select * from board_messages where task_id = ? order by seq asc", taskId).map((row) => ({ ...row, seq: Number(row.seq), refs: JSON.parse(row.refs || "[]") }));
+    },
+    nextSeq(taskId) {
+      const row = execute("get", "select coalesce(max(seq), 0) as seq from board_messages where task_id = ?", taskId);
+      return Number(row.seq) + 1;
+    },
+    receiveMessage({ id, taskId, seq, sender, text, refs = [], sentAt }) {
+      const thread = this.getThread(taskId);
+      if (!thread) return { ok: false, error: "no thread on this task" };
+      if (thread.closed_at) return { ok: false, error: "the thread is closed" };
+      const existing = execute("get", "select id from board_messages where id = ?", id);
+      if (existing) return { ok: true, duplicate: true, message: this.threadMessages(taskId).find((message) => message.id === id) };
+      execute("run", `insert into board_messages(id, task_id, seq, direction, sender, recipient, text, refs, state, created_at, sent_at, delivered_at)
+        values(@id, @taskId, @seq, 'in', @sender, 'me', @text, @refs, 'received', @now, @sentAt, @now)`,
+        { id, taskId, seq: Number.isInteger(seq) ? seq : this.nextSeq(taskId), sender, text, refs: JSON.stringify(refs), now: new Date().toISOString(), sentAt: sentAt || null });
+      execute("run", "update board_tasks set updated_at = ?, version = version + 1 where id = ?", new Date().toISOString(), taskId);
+      this.addContribution({ id: `msg:${id}`, taskId, kind: "message", author: sender, text, source: `message:${id}` });
+      return { ok: true, message: this.threadMessages(taskId).find((message) => message.id === id) };
+    },
+    postMessage({ id, taskId, sender, text, refs = [], flagReason = null }) {
+      const thread = this.getThread(taskId);
+      if (!thread) return { ok: false, error: "no thread on this task" };
+      if (thread.closed_at) return { ok: false, error: "the thread is closed" };
+      const state = flagReason ? "flagged" : thread.auto_send ? "sent" : "held";
+      const now = new Date().toISOString();
+      execute("run", `insert into board_messages(id, task_id, seq, direction, sender, recipient, text, refs, state, flag_reason, created_at, sent_at)
+        values(@id, @taskId, @seq, 'out', @sender, @recipient, @text, @refs, @state, @flagReason, @now, @sentAt)`,
+        { id, taskId, seq: this.nextSeq(taskId), sender, recipient: thread.with_agent, text, refs: JSON.stringify(refs), state, flagReason, now, sentAt: state === "sent" ? now : null });
+      execute("run", "update board_tasks set updated_at = ?, version = version + 1 where id = ?", now, taskId);
+      this.addContribution({ id: `msg:${id}`, taskId, kind: "message", author: sender, text, source: `message:${id}` });
+      return { ok: true, message: this.threadMessages(taskId).find((message) => message.id === id) };
+    },
+    releaseMessage(messageId) {
+      const now = new Date().toISOString();
+      const written = execute("run", "update board_messages set state = 'sent', sent_at = ?, flag_reason = null where id = ? and state in ('held', 'flagged')", now, messageId);
+      if (written.changes !== 1) return { ok: false, error: "no held message with that id" };
+      const message = execute("get", "select * from board_messages where id = ?", messageId);
+      execute("run", "update board_tasks set updated_at = ?, version = version + 1 where id = ?", now, message.task_id);
+      return { ok: true, message: { ...message, seq: Number(message.seq), refs: JSON.parse(message.refs || "[]") } };
+    },
+    discardMessage(messageId) {
+      const written = execute("run", "delete from board_messages where id = ? and state in ('held', 'flagged')", messageId);
+      if (written.changes === 1) { execute("run", "delete from board_contributions where id = ?", `msg:${messageId}`); execute("run", "delete from board_contributions_fts where id = ?", `msg:${messageId}`); execute("run", "delete from board_vectors where contribution_id = ?", `msg:${messageId}`); }
+      return written.changes === 1 ? { ok: true } : { ok: false, error: "no held message with that id" };
+    },
+    markDelivered(messageId) {
+      execute("run", "update board_messages set state = 'delivered', delivered_at = ? where id = ? and state = 'sent'", new Date().toISOString(), messageId);
+    },
+    undeliveredMessages() {
+      return execute("all", "select * from board_messages where direction = 'out' and state = 'sent' order by created_at asc").map((row) => ({ ...row, seq: Number(row.seq), refs: JSON.parse(row.refs || "[]") }));
+    },
+    setAutoSend(taskId, on) {
+      const thread = this.getThread(taskId);
+      if (!thread) return { ok: false, error: "no thread on this task" };
+      execute("run", "update board_threads set auto_send = ? where task_id = ?", on ? 1 : 0, taskId);
+      return { ok: true, thread: this.getThread(taskId) };
+    },
+    // A flag on any message turns auto-send off again; the person switches it back on knowingly.
+    revertAutoSend(taskId) {
+      execute("run", "update board_threads set auto_send = 0 where task_id = ?", taskId);
+    },
+    closeThread(taskId, outcome) {
+      const thread = this.getThread(taskId);
+      if (!thread) return { ok: false, error: "no thread on this task" };
+      if (thread.closed_at) return { ok: true, thread, already: true };
+      const now = new Date().toISOString();
+      execute("run", "update board_threads set closed_at = ?, outcome = ? where task_id = ?", now, outcome || null, taskId);
+      execute("run", "update board_tasks set status = 'done', holder = null, result = coalesce(?, result), reported_at = ?, updated_at = ?, version = version + 1 where id = ? and status not in ('done', 'failed')", outcome || null, now, now, taskId);
+      return { ok: true, thread: this.getThread(taskId), task: this.getTask(taskId) };
+    },
+    // Messages another person's agent sent on this agent's tasks since it last read the board.
+    unreadFor(agent) {
+      const seen = execute("get", "select last_seen_at from board_agents where agent = ?", agent)?.last_seen_at || "1970-01-01T00:00:00.000Z";
+      return execute("all", `select m.task_id, t.objective, m.sender, count(*) as count from board_messages m join board_tasks t on t.id = m.task_id
+        where m.direction = 'in' and m.created_at > ? and (t.claimed_by = ? or t.target_agent = ? or t.origin_agent = ?) group by m.task_id, t.objective, m.sender`, seen, agent, agent, agent)
+        .map((row) => ({ ...row, count: Number(row.count) }));
+    },
+    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());
+    },
+    agentsSeen() {
+      return execute("all", "select agent, last_seen_at from board_agents order by last_seen_at desc");
+    },
+    listTasks({ agent, status, all = false, limit = 20 } = {}) {
+      const clauses = [];
+      const params = { limit: Math.max(1, Math.min(100, Number(limit) || 20)) };
+      if (status) { clauses.push("b.status = @status"); params.status = status; }
+      else if (!all) clauses.push("b.status in ('open', 'claimed', 'running', 'needs_input')");
+      if (agent && !all) {
+        clauses.push("b.kind != 'group' and (b.target_agent is null or b.target_agent = @agent or b.origin_agent = @agent or b.claimed_by = @agent)");
+        params.agent = agent;
+      }
+      const now = new Date().toISOString();
+      return execute("all", `select b.id, b.objective, b.origin_agent, b.target_agent, b.status, b.parent_id, b.kind, b.claimed_by, b.holder, b.version, b.lease_until,
+          b.run_workspace, b.run_authorized_at, b.session_id, b.trust, b.origin_chain, b.created_at, b.updated_at, th.with_agent as thread_with, th.closed_at as thread_closed_at,
+          (select count(*) from board_messages m where m.task_id = b.id and m.state in ('held', 'flagged')) as held_messages,
+          (select count(*) from board_tasks c where c.parent_id = b.id) as child_count,
+          (select count(*) from board_tasks c where c.parent_id = b.id and c.status in ('done', 'failed', 'unknown')) as child_done,
+          (select group_concat(c.target_agent, ', ') from board_tasks c where c.parent_id = b.id) as child_agents
+        from board_tasks b left join board_threads th on th.task_id = b.id ${clauses.length ? `where ${clauses.join(" and ")}` : ""} order by b.created_at desc limit @limit`, params)
+        .map((row) => ({ ...row, origin_chain: JSON.parse(row.origin_chain || "[]"), version: Number(row.version), held_messages: Number(row.held_messages), child_count: Number(row.child_count), child_done: Number(row.child_done), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < now }));
+    },
+    getTask(id) {
+      const row = execute("get", "select * from board_tasks where id = ?", id);
+      if (!row) return null;
+      const task = { ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), origin_chain: JSON.parse(row.origin_chain || "[]"), usage: row.usage ? JSON.parse(row.usage) : null, stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < new Date().toISOString() };
+      return row.kind === "group" ? { ...task, children: this.children(id) } : task;
+    },
+    // An interactive claim carries a lease; when it lapses the claim shows stale and the origin
+    // or the user may release it. It is never released on its own. Daemon runs carry none.
+    claimTask(id, agent, expectedVersion = null, leaseMinutes = 60) {
+      if (this.getTask(id)?.kind === "group") return { ok: false, error: "a task for several agents is worked through its parts; claim the part posted for you" };
+      const now = new Date().toISOString();
+      const leaseUntil = leaseMinutes == null ? null : new Date(Date.now() + Math.max(0, Number(leaseMinutes) || 0) * 60_000).toISOString();
+      const written = execute("run", `update board_tasks set status = 'claimed', claimed_by = @agent, holder = @agent, claimed_at = @now, lease_until = @leaseUntil, updated_at = @now, version = version + 1
+        where id = @id and status = 'open' and (holder is null or holder = @agent) and (@expected is null or version = @expected)`,
+        { id, agent, now, leaseUntil, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => task.status !== "open" ? `task is ${task.status}${task.claimed_by ? ` by ${task.claimed_by}` : ""}` : `task is for ${task.holder}`);
+    },
+    reportTask(id, agent, { status, result = "" }, expectedVersion = null) {
+      if (!["done", "failed", "needs_input"].includes(status)) return { ok: false, error: "status must be done, failed or needs_input" };
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = @status, result = @result, reported_at = @now, updated_at = @now, version = version + 1,
+          holder = case when @status = 'needs_input' then origin_agent else null end
+        where id = @id and status in ('claimed', 'running') and holder = @agent and (@expected is null or version = @expected)`,
+        { id, agent, status, result, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) { this.addContribution({ taskId: id, kind: status === "needs_input" ? "question" : "result", author: agent, text: result, source: `report:${status}` }); return { ok: true, task: this.getTask(id) }; }
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => ["claimed", "running"].includes(task.status) ? `task is held by ${task.holder}` : task.status === "open" ? "claim the task before reporting on it" : `task is ${task.status}`);
+    },
+    releaseTask(id, agent, expectedVersion = null) {
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = 'open', holder = target_agent, claimed_by = null, claimed_at = null, lease_until = null, result = null, reported_at = null, updated_at = @now, version = version + 1
+        where id = @id and status in ('claimed', 'needs_input') and (origin_agent = @agent or @agent = 'user') and (@expected is null or version = @expected)`,
+        { id, agent, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => ["claimed", "needs_input"].includes(task.status) ? `only ${task.origin_agent} or the user can release this task` : `task is ${task.status}`);
+    },
+    answerTask(id, agent, answer, expectedVersion = null) {
+      if (!String(answer || "").trim()) return { ok: false, error: "an answer is needed" };
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = 'claimed', holder = claimed_by, updated_at = @now, version = version + 1,
+          brief = brief || char(10) || char(10) || 'Question from ' || claimed_by || ': ' || coalesce(result, '') || char(10) || 'Answer from ' || @agent || ': ' || @answer,
+          result = null, reported_at = null
+        where id = @id and status = 'needs_input' and holder = @agent and (@expected is null or version = @expected)`,
+        { id, agent, answer, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) { this.addContribution({ taskId: id, kind: "answer", author: agent, text: answer, source: "answer" }); return { ok: true, task: this.getTask(id) }; }
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => task.status !== "needs_input" ? `task is ${task.status}` : `only ${task.holder} can answer this task`);
     },
     close() {
       for (const statement of statements) {

package/lib/vectors.mjs

@@ -0,0 +1,43 @@
+// Vector helpers for the daemon's context space: cosine over normalized 768-float vectors,
+// a brute-force top-k, and the bytes that go in and out of SQLite. A task holds hundreds of
+// entries, not millions, so a scan is the right index until one outgrows it.
+
+export function cosine(a, b) {
+  if (a.length !== b.length) throw new Error(`vector lengths differ: ${a.length} and ${b.length}`);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+/** rows: [{ id, vector: Float32Array }]; returns [{ id, score }] best first, at most k. */
+export function topK(query, rows, k = 10) {
+  const scored = [];
+  for (const row of rows) {
+    if (!row?.vector || row.vector.length !== query.length) continue;
+    scored.push({ id: row.id, score: cosine(query, row.vector) });
+  }
+  scored.sort((x, y) => y.score - x.score);
+  return scored.slice(0, Math.max(0, k));
+}
+
+/** Float32Array -> Buffer for a SQLite blob column (little-endian, a copy). */
+export function toBlob(vector) {
+  const out = Buffer.alloc(vector.length * 4);
+  for (let i = 0; i < vector.length; i += 1) out.writeFloatLE(vector[i], i * 4);
+  return out;
+}
+
+/** Buffer (or Uint8Array) from SQLite -> Float32Array (a copy). */
+export function fromBlob(blob) {
+  const bytes = Buffer.isBuffer(blob) ? blob : Buffer.from(blob.buffer, blob.byteOffset, blob.byteLength);
+  const out = new Float32Array(bytes.length / 4);
+  for (let i = 0; i < out.length; i += 1) out[i] = bytes.readFloatLE(i * 4);
+  return out;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tryharness",
-  "version": "0.4.2",
-  "description": "One-command local daemon for Harness memory, coding-agent history, handoffs, and delegated tasks.",
+  "version": "0.5.0",
+  "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
   },
@@ -30,6 +30,8 @@
   "license": "MIT",
   "dependencies": {
     "node-sqlite3-wasm": "0.8.60",
-    "ws": "^8.18.3"
+    "ws": "^8.18.3",
+    "@huggingface/tokenizers": "^0.1.3",
+    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
   }
 }