tryharness 0.4.1 → 0.4.3

package/lib/store.mjs

@@ -1,7 +1,8 @@
 import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
 
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 4;
+const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
 function bindings(values) {
@@ -33,6 +34,7 @@ export function openStore(file) {
       message_count integer not null default 0,
       source_mtime real not null default 0,
       source_size integer not null default 0,
+      parser_version integer not null default 0,
       transcript text not null default '',
       indexed_at text not null,
       primary key(agent, session_id)
@@ -47,17 +49,50 @@ 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,
       created_at text not null,
-      consumed_at text
+      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
     );
   `);
+  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`);
+  }
 
   const statements = [];
   const prepare = (sql) => {
@@ -77,20 +112,21 @@ export function openStore(file) {
     const bound = bindings(values);
     return bound === undefined ? db[method](sql) : db[method](sql, bound);
   };
-  const existing = prepare("select source_mtime, source_size from sessions where agent = ? and session_id = ?");
+  const existing = prepare("select source_mtime, source_size, parser_version from sessions where agent = ? and session_id = ?");
   const upsert = prepare(`
-    insert into sessions(agent, session_id, source, cwd, title, started_at, ended_at, message_count, source_mtime, source_size, transcript, indexed_at)
-    values(@agent, @sessionId, @source, @cwd, @title, @startedAt, @endedAt, @messageCount, @mtime, @size, @transcript, @indexedAt)
+    insert into sessions(agent, session_id, source, cwd, title, started_at, ended_at, message_count, source_mtime, source_size, parser_version, transcript, indexed_at)
+    values(@agent, @sessionId, @source, @cwd, @title, @startedAt, @endedAt, @messageCount, @mtime, @size, @parserVersion, @transcript, @indexedAt)
     on conflict(agent, session_id) do update set
       source=excluded.source, cwd=excluded.cwd, title=excluded.title,
       started_at=excluded.started_at, ended_at=excluded.ended_at,
       message_count=excluded.message_count, source_mtime=excluded.source_mtime,
-      source_size=excluded.source_size, transcript=excluded.transcript,
+      source_size=excluded.source_size, parser_version=excluded.parser_version,
+      transcript=excluded.transcript,
       indexed_at=excluded.indexed_at
   `);
   const deleteSearch = prepare("delete from session_fts where agent = ? and session_id = ?");
   const insertSearch = prepare("insert into session_fts(agent, session_id, title, cwd, transcript) values(?, ?, ?, ?, ?)");
-  const indexParsed = (record) => {
+  const persistParsed = (record) => {
     db.exec("begin immediate");
     try {
       upsert.run(record);
@@ -110,19 +146,40 @@ 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) {
       const row = existing.get(agent, sessionId);
-      return !row || Number(row.source_mtime) !== Number(mtime) || Number(row.source_size) !== Number(size);
+      return !row
+        || Number(row.source_mtime) !== Number(mtime)
+        || Number(row.source_size) !== Number(size)
+        || Number(row.parser_version) !== INDEX_FORMAT_VERSION;
     },
     indexRaw({ agent, sessionId, source = null, raw, mtime = Date.now(), size = raw.length, cwd }) {
       const parsed = parseSession(agent, raw);
-      indexParsed({
+      persistParsed({
         agent, sessionId, source, cwd: cwd || parsed.meta.cwd || null,
         title: parsed.meta.title, startedAt: parsed.meta.startedAt,
         endedAt: parsed.meta.endedAt, messageCount: parsed.meta.messageCount,
-        mtime, size, transcript: parsed.transcript, indexedAt: new Date().toISOString(),
+        mtime, size, parserVersion: INDEX_FORMAT_VERSION,
+        transcript: parsed.transcript, indexedAt: new Date().toISOString(),
+      });
+      return parsed.meta;
+    },
+    indexParsed({ agent, sessionId, source = null, parsed, mtime, size, cwd }) {
+      persistParsed({
+        agent, sessionId, source, cwd: cwd || parsed.meta.cwd || null,
+        title: parsed.meta.title, startedAt: parsed.meta.startedAt,
+        endedAt: parsed.meta.endedAt, messageCount: parsed.meta.messageCount,
+        mtime, size, parserVersion: INDEX_FORMAT_VERSION,
+        transcript: parsed.transcript, indexedAt: new Date().toISOString(),
       });
       return parsed.meta;
     },
@@ -173,21 +230,117 @@ 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, objective, brief = "", 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, created_at, updated_at)
+        values(@id, @objective, @brief, @originAgent, @targetAgent, 'open', @parentId, @contextRefs, @targetAgent, 1, @runWorkspace, @runRequestedAt, @runAuthorizedBy, @runAuthorizedAt, @now, @now)`,
+        { id, objective, brief, originAgent, targetAgent, parentId, contextRefs: JSON.stringify(contextRefs), runWorkspace, runRequestedAt: runWorkspace ? now : null,
+          runAuthorizedBy: runWorkspace ? runAuthorizedBy : null, runAuthorizedAt: runWorkspace && runAuthorizedBy ? now : null, now });
+      return this.getTask(id);
+    },
+    // Run authority is a separate write from the post: an agent may ask for a run, only the user grants it.
+    authorizeRun(id, agent) {
+      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(", ")})
+        order by run_authorized_at asc`, ...agents).map((row) => ({ ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]") }));
+    },
+    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}`);
+    },
+    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;
+    },
+    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("status = @status"); params.status = status; }
+      else if (!all) clauses.push("status in ('open', 'claimed', 'running', 'needs_input')");
+      if (agent && !all) {
+        clauses.push("(target_agent is null or target_agent = @agent or origin_agent = @agent or claimed_by = @agent)");
+        params.agent = agent;
+      }
+      const now = new Date().toISOString();
+      return execute("all", `select id, objective, origin_agent, target_agent, status, parent_id, claimed_by, holder, version, lease_until,
+          run_workspace, run_authorized_at, session_id, created_at, updated_at
+        from board_tasks ${clauses.length ? `where ${clauses.join(" and ")}` : ""} order by created_at desc limit @limit`, params)
+        .map((row) => ({ ...row, version: Number(row.version), 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);
+      return row ? { ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < new Date().toISOString() } : null;
+    },
+    // 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) {
+      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) 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) 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tryharness",
-  "version": "0.4.1",
-  "description": "One-command local daemon for Harness memory, coding-agent history, handoffs, and delegated tasks.",
+  "version": "0.4.3",
+  "description": "One command puts the agents on this machine in your Harness relay: memory, history, and work handed between them.",
   "bin": {
     "tryharness": "cli.mjs"
   },