tryharness 0.7.26 → 0.7.29

package/README.md

@@ -68,10 +68,11 @@ on low battery and when the machine is hot.
 What they do:
 
 - **Briefs:** every brief a local coding agent gets carries a context pack (the files in its
-  repository most likely needed, earlier sessions on them, and a recording's minute or a
-  screenshot from your added folders when one is close) and the thread's task frame: what you
+  repository most likely needed, earlier sessions on them, and a page, passage, picture or
+  recording's minute from your added folders or the thread's files when one stands out) and the
+  thread's task frame: what you
   named resolved to file and line, the repository's state, other threads changing the same
-  repository, and each run's receipt. Agents can call `search_code`, `search_media`,
+  repository, and each run's receipt. Agents can call `search_code`, `search_files`,
   `compare_screens` (two screenshots of UI work, before and after: what changed and which text)
   and `search_screen` (what you saw in tabs shared with Harness, asked of your own Harness window
   sealed over the `tryharness link` line, so Harness's server carries it unread; your Allow in
@@ -91,7 +92,7 @@ What they do:
 ```sh
 npx tryharness local                  # what is installed, where it runs, what is indexed, the last learning
 npx tryharness local learn            # start the learner now
-npx tryharness local add ~/Recordings # a folder of recordings and screenshots agents can search
+npx tryharness local add ~/Documents # a folder agents can search by what is in its files
 npx tryharness watch                  # watches and what each last read
 npx tryharness watch add "keeper heartbeat" --run "cat state/heartbeat.json" --age completedAt --above 900 --every 5m
 ```

package/cli.mjs

@@ -29,6 +29,7 @@ import {
 } from "./lib/localmodels.mjs";
 import {
   installService,
+  launcherMissing,
   serviceInfo,
   uninstallService,
 } from "./lib/service.mjs";
@@ -300,6 +301,11 @@ async function connect() {
     spin.start("Getting the newest desktop app");
     const shown = await desktop();
     spin.stop(shown.text, shown.ok ? 0 : 2);
+    // The app brings the daemon's launcher: the daemon starts through it from now on (service.mjs).
+    if (launcherMissing()) {
+      installService({ runtimeRoot });
+      await waitForDaemon().catch(() => {});
+    }
   }
   // The relay's core local models (localmodels.mjs) and the server that runs them come down with setup, so agents get
   // context packs, code search, the handoff firewall and images checked before they leave from the first task. Each file
@@ -361,6 +367,10 @@ async function connect() {
     );
   }
   ui.info("History indexes locally in the background");
+  if (!readJson(paths.config, {}).libraryOff)
+    ui.info(
+      `Your agents on this computer can search what is in your Desktop, Documents and Downloads. It stays on this computer${process.platform === "darwin" ? "; your Mac asks you once, when Harness first reads them" : ""}.\n${pc.dim("Change it: npx tryharness local off")}`
+    );
   ui.info(
     `Your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start. Tasks another agent wrote wait for you.\n${pc.dim("Change it: npx tryharness board standing")}`
   );
@@ -426,9 +436,20 @@ async function status() {
 
 // The relay's local models: each one's job, licence, size and whether it is here, where they run, what the context engine
 // has indexed, and what the overnight learner last did. `tryharness local learn` starts the learner now; `local add
-// <folder>` and `local remove <folder>` name folders of recordings and screenshots for search_media and briefs.
+// <folder>` and `local remove <folder>` name folders whose files agents search (search_files) and briefs draw on.
 async function local() {
   const root = path.join(paths.home, "local");
+  if (argv[0] === "on" || argv[0] === "off") {
+    const response = await daemonRequest({ command: `local.${argv[0]}` });
+    if (!response?.ok)
+      throw new Error(response?.error || "the daemon did not answer");
+    console.log(
+      argv[0] === "on"
+        ? `Your agents on this computer can search what is in ${response.folders.join(", ") || "your folders"}.`
+        : "Your folders are no longer searched, and what was read from them is forgotten. Your threads' files still are."
+    );
+    return;
+  }
   if (argv[0] === "add" || argv[0] === "remove") {
     const response = await daemonRequest({
       command: `local.${argv[0]}`,
@@ -438,7 +459,7 @@ async function local() {
       throw new Error(response?.error || "the daemon did not answer");
     console.log(
       argv[0] === "add"
-        ? `Added. The relay reads the recordings and screenshots there in the background${response.downloading ? ", once the image and audio part of the search model has downloaded (555 MB)" : ""}.`
+        ? `Added. The relay reads the files there in the background: documents and PDFs now, pictures, recordings and videos${response.downloading ? " once the image and audio part of the search model has downloaded (555 MB)" : " too"}.`
         : "Removed."
     );
     return;
@@ -485,10 +506,14 @@ async function local() {
       ? `ranking: learned ${current.model.trainedAt}, held-out recall at 10 ${JSON.stringify(current.model.heldOut)}`
       : "ranking: the default until the learner has enough runs"
   );
-  for (const folder of current.media?.folders || [])
-    console.log(`recordings and screenshots: ${folder}`);
-  if (current.media?.folders?.length)
-    console.log(`media files read: ${current.media.files}`);
+  for (const folder of current.library?.folders || [])
+    console.log(`searched by what is in it: ${folder}`);
+  if (current.library?.files)
+    console.log(
+      `files read: ${current.library.files}${current.library.waiting ? ` (${current.library.waiting} parts waiting for the model)` : ""}`
+    );
+  for (const skip of (current.library?.skipped || []).slice(0, 5))
+    console.log(`not read: ${skip.path} (${skip.reason})`);
   if (current.learning)
     console.log(
       `last learning: ${current.learning.at} · ${current.learning.kept ? "kept a new model" : `kept the old one${current.learning.why ? ` (${current.learning.why})` : ""}`}`
@@ -1247,13 +1272,51 @@ async function swarm() {
           : `$${(r.estimated_micro_usd / 1e6).toFixed(4)} est.`;
       const progress = `${r.progress.runsFinished} runs done, ${r.progress.newResults} new, ${r.progress.roundsWithoutProgress} rounds idle`;
       console.log(
-        `${r.at}  ${r.goal_id.slice(0, 8)}  ${r.coordinator.padEnd(11)} ${(r.error ? "error" : (r.action ?? "-")).padEnd(10)} ${(r.agent ?? "").padEnd(11)} ${(r.loop ?? "").padEnd(13)} ${progress}  ${r.elapsed_ms}ms  ${cost}${r.error ? `  ${r.error}` : ""}`
+        `${r.at}  ${r.goal_id.slice(0, 8)}  ${r.coordinator.padEnd(11)} ${(r.action ?? "error").padEnd(10)} ${(r.agent ?? "").padEnd(11)} ${(r.loop ?? "").padEnd(13)} ${progress}  ${r.elapsed_ms}ms  ${cost}${r.error ? `  ${r.action ? "after " : ""}${r.error}` : ""}`
       );
     }
     return;
   }
+  // What a thread may spend of the person's Harness credits: dollars, or off.
+  if (sub === "ceiling") {
+    if (!argv[1] || argv[2] === undefined)
+      throw new Error("usage: tryharness swarm ceiling <thread> <dollars|off>");
+    const response = await daemonRequest({
+      command: "board.swarm.ceiling",
+      agent: "user",
+      id: argv[1],
+      usd: argv[2],
+    });
+    if (!response.ok)
+      throw new Error(response.error || "the limit was not set");
+    console.log(
+      response.thread.ceilingUsd === null
+        ? "This thread has no spending limit of its own."
+        : `This thread may spend $${response.thread.ceilingUsd.toFixed(2)} of your Harness credits.`
+    );
+    return;
+  }
+  // How the coordinator held up, a day at a time: who decided each round, and how many no one could.
+  if (sub === "health") {
+    const response = await daemonRequest({
+      command: "board.swarm.health",
+      agent: "user",
+      ...(argv[1] ? { id: argv[1] } : {}),
+      days: Number(arg("--days", "14")),
+    });
+    if (!response.ok) throw new Error(response.error || "health unavailable");
+    if (!response.days.length) {
+      console.log("No rounds yet.");
+      return;
+    }
+    for (const d of response.days)
+      console.log(
+        `${d.day}  ${String(d.rounds).padStart(4)} rounds: Harness ${d.harness}, backup ${d.backup}, this computer ${d.local}, undecided ${d.undecided}`
+      );
+    return;
+  }
   throw new Error(
-    "usage: tryharness swarm [rounds [<thread>] [--limit n] | coordinator [harness|local]]"
+    "usage: tryharness swarm [rounds [<thread>] [--limit n] | health [<thread>] [--days n] | ceiling <thread> <dollars|off> | coordinator [harness|local]]"
   );
 }
 
@@ -1714,7 +1777,7 @@ async function t3() {
 
 function help() {
   console.log(
-    `tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness local [learn]   the relay's local models, where they run, what is indexed and the last learning\n  tryharness local add|remove <folder>   a folder of recordings and screenshots agents can search by what was said or shown\n  tryharness watch [add <name> --run <command> [--every 5m] [--field f | --age f | --count text] [--above n] [--below n] | start <id> | remove <id>]\n                             watches the relay checks and says out loud only when they are off\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board snippet [<id> share|keep]   code an agent elsewhere asked to see; nothing leaves until you share it\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text> [--ask agent,agent]\n  tryharness swarm rounds [<thread>]   what the coordinator saw, chose and cost each round\n  tryharness swarm coordinator [harness|local]   who coordinates your threads\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours, sealed to their computer\n  tryharness peers           the keys of other people's computers this one has worked with, to compare\n  tryharness agents          how Harness wakes each of your agents, and set up the rest\n  tryharness agents setup <agent> | agents test <agent>\n  tryharness agents cards     what each of your agents is told about the others\n  tryharness agents note <agent> <text> [--clear]   your own note on an agent's card, told to every other agent\n  tryharness agents models [<agent>] [--refresh]   the models each coding agent lists and the one it runs on\n  tryharness agents model <agent> <model> [--effort <level>] | auto | default   the model it runs on; auto lets Harness pick per run\n  tryharness agents routing "<text>" [--clear]   how Auto picks models for your swarm\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness link            connect the browser you use Harness in to this computer, end to end (--print shows the link)\n  tryharness phone pair      show a QR code that pairs your phone with this computer\n  tryharness phone list | revoke <id>\n  tryharness t3              approve Harness in T3 Code once, so your messages go into its threads (t3 status | t3 forget)\n  tryharness logs [--follow]\n  tryharness disconnect\n`
+    `tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness desktop         open the Harness desktop app (setup opens it too; --no-desktop skips it)\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\n  tryharness local [learn]   the relay's local models, where they run, what is indexed and the last learning\n  tryharness local on|off     search over your Desktop, Documents and Downloads by what is in the files (on by default)\n  tryharness local add|remove <folder>   another folder to search the same way\n  tryharness watch [add <name> --run <command> [--every 5m] [--field f | --age f | --count text] [--above n] [--below n] | start <id> | remove <id>]\n                             watches the relay checks and says out loud only when they are off\n  tryharness sync [--agent]  rescan local coding history in the background\n  tryharness task <id> --follow\n                             follow a delegated agent run in this terminal\n  tryharness board [--all]   list open work on the machine's task board\n  tryharness board post --for <agent> --objective <text> [--file <brief.md>]\n  tryharness board show <id>\n  tryharness board post --for codex --objective <text> --run --workspace <dir>\n                             the daemon runs it and reports back on the task\n  tryharness board run <id>  authorize a run an agent asked for\n  tryharness board release <id>\n  tryharness board agents    when each agent last read the board\n  tryharness board --watch   follow the board in this terminal\n  tryharness notify on|off   desktop notifications for what waits on you\n  tryharness board send <task> <message>   send a held reply to another person's agent\n  tryharness board snippet [<id> share|keep]   code an agent elsewhere asked to see; nothing leaves until you share it\n  tryharness board auto <task> on|off      auto-send replies on that thread\n  tryharness board end <task> --outcome <text>\n  tryharness board context <task> <query>  search everything written about a task\n  tryharness goal set --objective <text> [--team a,b] [--workspace <dir>]   a goal your agents work together in one room\n  tryharness goal [list | show <id> | stop <id> | resume <id>]\n  tryharness room <goal> | room post <goal> <text> [--ask agent,agent]\n  tryharness swarm rounds [<thread>]   what the coordinator saw, chose and cost each round\n  tryharness swarm health [<thread>]   who decided each day's rounds: Harness, a backup, or no one\n  tryharness swarm ceiling <thread> <dollars|off>   what a thread may spend of your Harness credits\n  tryharness swarm coordinator [harness|local]   who coordinates your threads\n  tryharness connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours, sealed to their computer\n  tryharness peers           the keys of other people's computers this one has worked with, to compare\n  tryharness agents          how Harness wakes each of your agents, and set up the rest\n  tryharness agents setup <agent> | agents test <agent>\n  tryharness agents cards     what each of your agents is told about the others\n  tryharness agents note <agent> <text> [--clear]   your own note on an agent's card, told to every other agent\n  tryharness agents models [<agent>] [--refresh]   the models each coding agent lists and the one it runs on\n  tryharness agents model <agent> <model> [--effort <level>] | auto | default   the model it runs on; auto lets Harness pick per run\n  tryharness agents routing "<text>" [--clear]   how Auto picks models for your swarm\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness link            connect the browser you use Harness in to this computer, end to end (--print shows the link)\n  tryharness phone pair      show a QR code that pairs your phone with this computer\n  tryharness phone list | revoke <id>\n  tryharness t3              approve Harness in T3 Code once, so your messages go into its threads (t3 status | t3 forget)\n  tryharness logs [--follow]\n  tryharness disconnect\n`
   );
 }
 

package/lib/asks.mjs

@@ -0,0 +1,260 @@
+import { randomUUID } from "node:crypto";
+import { nameOf } from "./members.mjs";
+
+// An ask in a thread for an agent that is not started on this computer (Harness, Grok Bot, Muse, Bankr, Quotient,
+// OpenClaw, Hermes) becomes a task in the thread, in the asker's name. No ask is dropped without a word: each is asked
+// at once, or kept on the board (so a restart keeps it) with why said in the thread and to its asker, and asked when
+// that clears: the agent's earlier ask in the thread ends (one at a time, so the agent reads its own answer first),
+// the thread is resumed, or this computer reaches Harness again. One that cannot be asked is said in the thread, wakes
+// the agent that asked with the reason, and reaches the coordinator's round as a failed job.
+//
+// Agents on Harness's server (Bankr, Quotient, Muse) keep their tasks there and take asks side by side. A send that may
+// have reached Harness is looked up by its id before it goes again, so a retry never makes a second task.
+
+const OPEN_RUN = ["open", "claimed", "running", "needs_input"];
+// Sends lost on the way to Harness before the ask is given up and said as failed.
+const TRIES = 5;
+
+export function createAsks({
+  store,
+  deliver,
+  find,
+  connected,
+  onServer,
+  earlierWaits,
+  say,
+}) {
+  const read = (key) => {
+    try {
+      return JSON.parse(store.meta(key) || "[]");
+    } catch {
+      return [];
+    }
+  };
+  const kept = (threadId) => read(`asks:${threadId}`);
+  const keep = (threadId, asks) =>
+    store.meta(`asks:${threadId}`, JSON.stringify(asks));
+  const change = (threadId, id, fields) =>
+    keep(
+      threadId,
+      kept(threadId).map((each) =>
+        each.id === id ? { ...each, ...fields } : each
+      )
+    );
+  const forget = (threadId, id) =>
+    keep(
+      threadId,
+      kept(threadId).filter((each) => each.id !== id)
+    );
+  const failures = (threadId) => read(`asks-failed:${threadId}`);
+  const sending = new Set();
+  // The ask being made right now: its asker hears what happens to it in its own call, so it is not woken for it.
+  let asking = null;
+
+  const busy = (threadId, agent) =>
+    store
+      .threadRuns(threadId)
+      .some(
+        (run) => run.target_agent === agent && OPEN_RUN.includes(run.status)
+      );
+  const objectiveOf = (thread, ask) =>
+    `Asked in "${thread.objective}": ${ask.reason}`.slice(0, 500);
+
+  // The ask as the thread names it, and as its asker is told.
+  const whose = (ask, toAsker) =>
+    toAsker || ask.asker === "user" ? "your ask" : `${nameOf(ask.asker)}'s ask`;
+  const WHY = {
+    turn: (thread, ask, toAsker) =>
+      [
+        `${nameOf(ask.agent)} has an earlier ask open in this thread; ${whose(ask, toAsker)} goes to it when that one ends.`,
+        earlierWaits(thread.id, ask.agent),
+      ]
+        .filter(Boolean)
+        .join(" "),
+    paused: (thread, ask, toAsker) =>
+      `This thread is paused; ${whose(ask, toAsker)} goes to ${nameOf(ask.agent)} when it is resumed.`,
+    offline: (thread, ask, toAsker) =>
+      `${nameOf(ask.agent)} runs on Harness's server, and this computer is not connected to it right now; ${whose(ask, toAsker)} goes when it reconnects.`,
+    lost: (thread, ask, toAsker) => {
+      const text = `${whose(ask, toAsker)} to ${nameOf(ask.agent)} may not have reached Harness (${ask.lost}); it is sent again within a minute or when this computer reconnects.`;
+      return text[0].toUpperCase() + text.slice(1);
+    },
+  };
+  // The thread hears why an ask waits once for each reason, however often the reason comes back. Offline after a send
+  // that may not have reached Harness is said already: it goes again on reconnect.
+  const said = (thread, snapshot, why) => {
+    const ask =
+      kept(thread.id).find((each) => each.id === snapshot.id) ?? snapshot;
+    const before = ask.said ?? [];
+    if (ask.told !== why) change(thread.id, ask.id, { told: why });
+    if (before.includes(why) || (why === "offline" && ask.lost)) return;
+    change(thread.id, ask.id, { said: [...before, why] });
+    say(thread, WHY[why](thread, ask, false));
+  };
+
+  const fail = (thread, ask, why) => {
+    const reason = String(why || "the board refused it").replace(/\.$/, "");
+    store.meta(
+      `asks-failed:${thread.id}`,
+      JSON.stringify(
+        [
+          ...failures(thread.id),
+          {
+            agent: ask.agent,
+            objective: objectiveOf(thread, ask),
+            result: `Could not be asked: ${reason}`.slice(0, 4_000),
+          },
+        ].slice(-5)
+      )
+    );
+    say(thread, `${nameOf(ask.agent)} could not be asked: ${reason}.`, {
+      wake: ask.asker === "user" || ask.id === asking ? null : ask.asker,
+    });
+    return `${nameOf(ask.agent)} could not be asked: ${reason}.`;
+  };
+
+  // Why an ask is not sent now, or null to send it.
+  const waitOf = (thread, ask, ahead) => {
+    if (thread.status === "paused") return "paused";
+    if (onServer(ask.agent)) return connected() ? null : "offline";
+    return ahead || busy(thread.id, ask.agent) ? "turn" : null;
+  };
+
+  // Returns why the ask could not be asked, when that is known at once.
+  const send = (thread, ask) => {
+    if (!onServer(ask.agent)) {
+      forget(thread.id, ask.id);
+      const sent = deliver(thread, ask);
+      if (sent?.pending)
+        sent.pending.catch((error) => fail(thread, ask, error?.message));
+      else if (!sent?.ok) return fail(thread, ask, sent?.error);
+      return null;
+    }
+    sending.add(ask.id);
+    void sendToServer(thread, ask).finally(() => sending.delete(ask.id));
+    return null;
+  };
+  const sendToServer = async (thread, ask) => {
+    try {
+      if (ask.sent && (await find(ask.id))) return forget(thread.id, ask.id);
+      change(thread.id, ask.id, { sent: true });
+      const sent = deliver(thread, { ...ask, resend: Boolean(ask.sent) });
+      if (sent?.pending) await sent.pending;
+      else if (!sent?.ok)
+        throw Object.assign(new Error(sent?.error), { refused: connected() });
+      forget(thread.id, ask.id);
+    } catch (error) {
+      const tries = (ask.tries ?? 0) + 1;
+      if (error?.refused || tries >= TRIES) {
+        forget(thread.id, ask.id);
+        return fail(thread, ask, error?.message);
+      }
+      const lost = String(error?.message || "no answer").replace(/\.$/, "");
+      change(thread.id, ask.id, { tries, lost });
+      said(thread, ask, "lost");
+    }
+  };
+
+  // Sends what can go now of the asks kept for one agent in a thread, oldest first, and says why the rest wait. Returns why
+  // `fresh` could not be asked, when it failed here.
+  const pump = (threadId, agent, fresh = null) => {
+    const thread = store.getTask(threadId);
+    if (!thread || thread.kind !== "goal") return null;
+    let refused = null;
+    let ahead = false;
+    for (const ask of kept(threadId).filter((each) => each.agent === agent)) {
+      if (sending.has(ask.id)) {
+        ahead = true;
+        continue;
+      }
+      if (!["open", "paused"].includes(thread.status)) {
+        forget(threadId, ask.id);
+        const told = fail(thread, ask, `the thread is ${thread.status}`);
+        if (ask.id === fresh) refused = told;
+        continue;
+      }
+      const why = waitOf(thread, ask, ahead);
+      if (why) {
+        ahead = true;
+        said(thread, ask, why);
+        continue;
+      }
+      const failed = send(thread, ask);
+      if (ask.id === fresh && failed) refused = failed;
+      if (kept(threadId).some((each) => each.id === ask.id)) ahead = true;
+    }
+    return refused;
+  };
+  const agentsWaiting = (threadId) => [
+    ...new Set(kept(threadId).map((each) => each.agent)),
+  ];
+
+  return {
+    // Returns what the asker is told when its ask does not go at once, else null.
+    ask(threadId, agent, { reason, asker, words }) {
+      const ask = {
+        id: randomUUID(),
+        agent,
+        reason,
+        asker,
+        words: String(words ?? reason),
+        at: new Date().toISOString(),
+      };
+      keep(threadId, [...kept(threadId), ask]);
+      asking = ask.id;
+      let refused = null;
+      try {
+        refused = pump(threadId, agent, ask.id);
+      } finally {
+        asking = null;
+      }
+      const waiting = kept(threadId).find((each) => each.id === ask.id);
+      const thread = store.getTask(threadId);
+      return (
+        refused ??
+        (waiting?.told && thread
+          ? WHY[waiting.told](thread, waiting, true)
+          : null)
+      );
+    },
+    // Refused before it became an ask (a coding agent not installed here): said like any ask that could not go.
+    refuse(threadId, agent, { reason, asker }, why) {
+      const thread = store.getTask(threadId);
+      if (!thread) return null;
+      const ask = { id: randomUUID(), agent, reason, asker };
+      asking = ask.id;
+      try {
+        return fail(thread, ask, why);
+      } finally {
+        asking = null;
+      }
+    },
+    // The agent's ask in the thread ended, or the thread changed: what waited for it goes now.
+    changed(threadId, agent = null) {
+      for (const each of agent ? [agent] : agentsWaiting(threadId))
+        pump(threadId, each);
+    },
+    // This computer reached Harness again, or a minute passed: everything kept goes now if it can.
+    retry() {
+      for (const thread of store.goals())
+        for (const agent of agentsWaiting(thread.id)) pump(thread.id, agent);
+    },
+    // The person stopped the thread: what waited stops with it.
+    stopped(threadId) {
+      keep(threadId, []);
+    },
+    // Asks kept for the agent, as the coordinator's round lists work that is already the agent's.
+    waitingFor(threadId, agent) {
+      const thread = store.getTask(threadId);
+      return thread
+        ? kept(threadId)
+            .filter((each) => each.agent === agent)
+            .map((each) => ({ objective: objectiveOf(thread, each) }))
+        : [];
+    },
+    // Asks that could not be asked, as the round's failed jobs.
+    failed(threadId) {
+      return failures(threadId);
+    },
+  };
+}

package/lib/atlas.mjs

@@ -136,9 +136,13 @@ export function openAtlas(file) {
     create index if not exists runs_root_at on runs(root, at);
     create table if not exists run_vectors (agent text not null, session_id text not null, version text not null, vector blob not null, primary key(agent, session_id, version));
     create table if not exists meta (key text primary key, value text not null);
-    create table if not exists media (hash text primary key, path text not null, kind text not null, start_ms integer not null, end_ms integer not null, mtime real not null);
-    create index if not exists media_path on media(path);
+    create table if not exists library (file text not null, vec text not null, source text not null, name text not null,
+      kind text not null, modality text not null, loc real not null, loc_end real, mtime real not null, embed integer not null,
+      primary key(file, vec));
+    create index if not exists library_source on library(source);
+    create virtual table if not exists library_fts using fts5(file unindexed, vec unindexed, name, text);
   `);
+  migrateMedia(db);
   // A blob's pieces never change, so lookups are kept (a few MB for a large repository and its recent versions).
   const blobPieces = new Map();
   const run = (sql, ...values) =>
@@ -327,35 +331,8 @@ export function openAtlas(file) {
         edited: JSON.parse(row.edited),
         vector: fromBlob(row.vector),
       })),
-    /** Recordings' windows and images (media.mjs): one row each, its vector beside the pieces'. */
-    mediaSeen: (file) =>
-      get("select max(mtime) as mtime from media where path = ?", file)
-        ?.mtime ?? null,
-    mediaPaths: () =>
-      all("select distinct path from media").map((row) => row.path),
-    dropMedia: (file) => run("delete from media where path = ?", file),
-    putMedia: (row) =>
-      run(
-        "insert or replace into media(hash, path, kind, start_ms, end_ms, mtime) values(?, ?, ?, ?, ?, ?)",
-        row.hash,
-        row.path,
-        row.kind,
-        row.startMs,
-        row.endMs,
-        row.mtime
-      ),
-    mediaVectors: (version) =>
-      all(
-        "select m.hash, m.path, m.kind, m.start_ms, m.end_ms, v.vector from media m join piece_vectors v on v.hash = m.hash and v.version = ?",
-        version
-      ).map((row) => ({
-        hash: row.hash,
-        path: row.path,
-        kind: row.kind,
-        startMs: Number(row.start_ms),
-        endMs: Number(row.end_ms),
-        vector: fromBlob(row.vector),
-      })),
+    /** The library (library.mjs): parts of the person's files and the threads' files, their vectors beside the pieces'. */
+    library: libraryTables(run, all, get),
     /** Full-text matches: { hash, rank } best first (bm25, lower is better), over every indexed piece. */
     words(terms, limit = 400) {
       if (!terms.length) return [];
@@ -371,6 +348,153 @@ export function openAtlas(file) {
   };
 }
 
+// Recordings and screenshots indexed before the library keep their vectors: their part keys are the same.
+function migrateMedia(db) {
+  const old = db.get(
+    "select name from sqlite_master where type = 'table' and name = 'media'"
+  );
+  if (!old) return;
+  db.exec(`
+    insert or ignore into library(file, vec, source, name, kind, modality, loc, loc_end, mtime, embed)
+      select path, hash, 'folders', path, kind, kind, start_ms, end_ms, mtime, 1 from media;
+    drop table media;
+  `);
+  for (const row of db.all("select distinct file from library")) {
+    const name = path.basename(row.file);
+    db.run("update library set name = ? where file = ?", [name, row.file]);
+    db.run(
+      "insert into library_fts(file, vec, name, text) values(?, ?, ?, '')",
+      [row.file, "", name]
+    );
+  }
+}
+
+const LIBRARY_COLUMNS =
+  "file, vec, source, name, kind, modality, loc, loc_end, mtime, embed";
+const libraryRow = (row) => ({
+  file: row.file,
+  vec: row.vec,
+  source: row.source,
+  name: row.name,
+  kind: row.kind,
+  modality: row.modality,
+  loc: Number(row.loc),
+  locEnd: row.loc_end === null ? null : Number(row.loc_end),
+  mtime: Number(row.mtime),
+});
+
+function libraryTables(run, all, get) {
+  return {
+    /** Every file in one source ("folders", or a thread's id) with when it was read: Map(file, mtime). */
+    files(source) {
+      const rows = all(
+        "select file, max(mtime) as mtime from library where source = ? group by file",
+        source
+      );
+      return new Map(rows.map((row) => [row.file, Number(row.mtime)]));
+    },
+    sources: () =>
+      all("select distinct source from library").map((row) => row.source),
+    drop(file) {
+      run("delete from library where file = ?", file);
+      run("delete from library_fts where file = ?", file);
+    },
+    /** A file's parts: rows of LIBRARY_COLUMNS plus text (the words it is found by). One row of words names the file. */
+    put(rows) {
+      for (const row of rows) {
+        run(
+          `insert or replace into library(${LIBRARY_COLUMNS}) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          row.file,
+          row.vec,
+          row.source,
+          row.name,
+          row.kind,
+          row.modality,
+          row.loc,
+          row.locEnd ?? null,
+          row.mtime,
+          row.embed ? 1 : 0
+        );
+        if (row.text)
+          run(
+            "insert into library_fts(file, vec, name, text) values(?, ?, '', ?)",
+            row.file,
+            row.vec,
+            row.text
+          );
+      }
+      const first = rows[0];
+      if (first)
+        run(
+          "insert into library_fts(file, vec, name, text) values(?, '', ?, '')",
+          first.file,
+          first.name.replace(/[._-]/g, " ")
+        );
+    },
+    /** Parts still to embed: the newest files first. */
+    toEmbed: (version, modalities, limit = 32) =>
+      all(
+        `select l.*, f.text from library l
+        left join piece_vectors v on v.hash = l.vec and v.version = ?
+        left join library_fts f on f.file = l.file and f.vec = l.vec
+        where l.embed = 1 and v.hash is null and l.modality in (${modalities.map(() => "?").join(",")})
+        group by l.file, l.vec order by l.mtime desc limit ?`,
+        version,
+        ...modalities,
+        limit
+      ).map((row) => ({ ...libraryRow(row), text: row.text ?? "" })),
+    waiting: (version) =>
+      Number(
+        get(
+          `select count(*) as n from library l left join piece_vectors v on v.hash = l.vec and v.version = ?
+          where l.embed = 1 and v.hash is null`,
+          version
+        ).n
+      ),
+    /** Every part with a vector: { ...row, vector }. */
+    vectors: (version) =>
+      all(
+        `select l.*, v.vector from library l join piece_vectors v on v.hash = l.vec and v.version = ?`,
+        version
+      ).map((row) => ({ ...libraryRow(row), vector: fromBlob(row.vector) })),
+    /** The files holding a word or phrase (FTS5 syntax): Map(file, [vec of each matching part, best first]). */
+    holding(match, limit = 2_000) {
+      const out = new Map();
+      for (const row of all(
+        "select file, vec from library_fts where library_fts match ? order by bm25(library_fts, 0, 0, 3.0, 1.0) limit ?",
+        match,
+        limit
+      )) {
+        if (!out.has(row.file)) out.set(row.file, []);
+        if (row.vec) out.get(row.file).push(row.vec);
+      }
+      return out;
+    },
+    part(file, vec) {
+      const row = get(
+        `select ${LIBRARY_COLUMNS} from library where file = ? and vec = ?`,
+        file,
+        vec
+      );
+      if (!row) return null;
+      const words = get(
+        "select text from library_fts where file = ? and vec = ?",
+        file,
+        vec
+      );
+      return { ...libraryRow(row), text: words?.text ?? "" };
+    },
+    first(file) {
+      const row = get(
+        `select ${LIBRARY_COLUMNS} from library where file = ? order by loc limit 1`,
+        file
+      );
+      return row ? { ...libraryRow(row), text: "" } : null;
+    },
+    count: () => Number(get("select count(distinct file) as n from library").n),
+  };
+}
+
 const git = (cwd, args, input) =>
   spawnSync("git", args, {
     cwd,

package/lib/cards.mjs

@@ -214,7 +214,8 @@ export function cardLine(card, now = Date.now()) {
     parts.push(
       `Its own sessions show its changes tested after the last edit ${checks.tested} of ${checks.tested + checks.untested + checks.failing} times${checks.failing ? ` (${checks.failing} with tests failing)` : ""}.`
     );
-  else if (member(card.id)?.home === "machine")
+  // Said only of an agent with no work at all: one with finished work and no receipts has its count above.
+  else if (!done && !failed && member(card.id)?.home === "machine")
     parts.push("Has finished no work on this board yet.");
   if (card.working || card.waiting)
     parts.push(`Now: ${card.working} running, ${card.waiting} waiting for it.`);