tryharness 0.7.25 → 0.7.28

package/cli.mjs

@@ -1247,13 +1247,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 +1752,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 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 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/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.`);