tryharness 0.4.3 → 0.5.1

package/README.md

@@ -1,6 +1,6 @@
 # tryharness
 
-Put the coding agents installed on this machine in your [Harness](https://tryharness.ai) relay:
+Harness Relay: turn the coding agents installed on this machine into your personal swarm with [Harness](https://tryharness.ai):
 
 ```sh
 npx tryharness
@@ -49,6 +49,16 @@ command as soon as the agent reports its session id, including while the run is
 so the user can enter and steer the agent directly rather than interacting through a
 Harness wrapper.
 
+## Embedder
+
+Setup also downloads the embedding model the daemon uses for a task's context space,
+about 110 MB into `~/.harness/models`, reported like indexing is. It is the same model,
+quantization, pooling and normalization as Harness in the browser (bge-base, q8, CLS,
+L2), under the same version key, run on the wasm build of the ONNX runtime with no native
+addon, so a vector the daemon makes and one the browser makes describe the same space. The
+daemon never asks a browser tab to embed; until the model is present, context search
+answers from full-text search and says so.
+
 ## Task board
 
 The daemon keeps a task board in its local SQLite database. Any connected agent can post
@@ -68,17 +78,26 @@ claim carries a lease (default 60 minutes); a lapsed lease shows the claim as st
 the poster or the user releases it. `tryharness board agents` shows when each agent last read
 the board. Every change goes up the bridge as identity and status only.
 
-Interactive sessions are told about waiting work when they open. Setup adds a Claude Code
-SessionStart hook that prints the board's tasks for it into the session's context, the Pi
-extension shows the same on session start (and puts it in context where pi allows), and the
-OpenCode plugin adds it to the first message of a session. Codex has no hook surface, so it
-reads the board when asked. The nudge is silent when nothing waits or no daemon is running.
+Interactive sessions are told about waiting work when they open and when it changes. Setup adds
+SessionStart and UserPromptSubmit hooks for Claude Code (`~/.claude/settings.json`) and for Codex
+(`~/.codex/hooks.json`; Codex asks once to trust them with `/hooks`), the Pi extension puts the
+queue into pi's system prompt and speaks again after a turn when it changed, and the OpenCode
+plugin adds it to a message when it changed. Every MCP client also gets the queue in the
+connection handshake. The nudge is silent when nothing waits or no daemon is running.
 
 Every task has one holder, the only agent allowed to write it next, and a version that
 every write bumps; a write lands only for the holder at the expected version, and anything
 else comes back as a conflict carrying the task as it is now, so agents cannot overwrite
 each other. Briefs and results stay on the machine; the bridge reports identity and status
 only. Any MCP client on the machine joins the board by launching `lib/mcp-stdio.mjs --agent <name>`.
+
+Work stays where the agent lives. Bankr, Quotient and Muse live in Harness, not on any machine,
+so a task posted for one of them (`tryharness board post --for bankr`, or `post_task` from any
+agent here) goes up the bridge and waits on the server, where Bankr takes it under the limits
+the user set in Harness and Quotient answers it with one search over its tracked markets; the
+daemon must be connected to post it, and `get_task` (or `tryharness board show <id>`) with its
+id reads it back. A task for a coding agent or Grok Bot waits here. A task for several agents
+at once is for agents in one place.
 Grok Bot keeps its MCP servers in its own account settings, so setup prints
 `npx tryharness mcp grok-bot`, a one-server snippet to paste into Grok Bot's MCP settings; it
 then appears on the board as `grok-bot`.

package/assets/opencode-plugin.js

@@ -23,18 +23,26 @@ function ask(message) {
 }
 
 // What opencode is told once per session, on its first message: work waiting on the board.
-async function boardNudge() {
+async function boardNudge(sessionId) {
   const response = await ask({ command: "board.list", agent: "opencode" });
   const tasks = response?.ok ? response.tasks : [];
+  const now = digest(tasks);
+  if (lastDigest.get(sessionId) === now) return "";
+  lastDigest.set(sessionId, now);
   const waiting = tasks.filter((task) => task.status === "open" && (!task.target_agent || task.target_agent === "opencode"));
   const held = tasks.filter((task) => task.claimed_by === "opencode" && (task.status === "claimed" || task.status === "needs_input"));
   if (!waiting.length && !held.length) return "";
-  const line = (task) => `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.origin_agent})` : ""}`;
+  const line = (task) => `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.origin_agent}${task.trust === "agent" ? ", agent-written" : ""})` : ""}`;
   return ["Harness task board:", ...(waiting.length ? [`${waiting.length} task${waiting.length === 1 ? "" : "s"} waiting for you:`, ...waiting.slice(0, 5).map(line)] : []),
     ...(held.length ? [`${held.length} you already claimed:`, ...held.slice(0, 5).map(line)] : []),
     "Read one with get_task, claim it with claim_task before working, and report_task when done or stuck."].join("\n");
 }
-const nudged = new Set();
+// One digest per session: the nudge is added again only when the queue changed.
+const lastDigest = new Map();
+function digest(tasks) {
+  return tasks.filter((task) => (task.status === "open" && (!task.target_agent || task.target_agent === "opencode")) || (task.claimed_by === "opencode" && ["claimed", "needs_input"].includes(task.status)))
+    .map((task) => `${task.id}:${task.status}:${task.version}`).sort().join("|");
+}
 
 function notify(message) {
   try {
@@ -47,12 +55,11 @@ function notify(message) {
 }
 
 export const TryHarnessPlugin = async ({ directory }) => ({
-  // The first message of each session carries the board nudge as an extra text part.
+  // Every message of a session carries the board nudge as an extra text part when the queue changed since the last one.
   "chat.message": async (input, output) => {
     const sessionId = input?.sessionID || input?.sessionId;
-    if (!sessionId || nudged.has(sessionId) || !Array.isArray(output?.parts)) return;
-    nudged.add(sessionId);
-    const nudge = await boardNudge();
+    if (!sessionId || !Array.isArray(output?.parts)) return;
+    const nudge = await boardNudge(sessionId);
     if (nudge) output.parts.push({ type: "text", text: nudge });
   },
   event: async ({ event }) => {

package/assets/pi-extension.ts

@@ -25,14 +25,22 @@ function daemon(message) {
   });
 }
 
-// What pi is told when a session opens: work waiting for it on the machine's task board.
-async function boardNudge() {
+// What pi is told when a session opens, and again after a turn when the queue changed.
+let lastDigest = null;
+function digest(tasks) {
+  return tasks.filter((task) => (task.status === "open" && (!task.target_agent || task.target_agent === "pi")) || (task.claimed_by === "pi" && ["claimed", "needs_input"].includes(task.status)))
+    .map((task) => `${task.id}:${task.status}:${task.version}`).sort().join("|");
+}
+async function boardNudge(onlyIfChanged = false) {
   const response = await daemon({ command: "board.list", agent: "pi" });
   const tasks = response?.ok ? response.tasks : [];
+  const now = digest(tasks);
+  if (onlyIfChanged && now === lastDigest) return "";
+  lastDigest = now;
   const waiting = tasks.filter((task) => task.status === "open" && (!task.target_agent || task.target_agent === "pi"));
   const held = tasks.filter((task) => task.claimed_by === "pi" && (task.status === "claimed" || task.status === "needs_input"));
   if (!waiting.length && !held.length) return "";
-  const line = (task) => `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.origin_agent})` : ""}`;
+  const line = (task) => `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.origin_agent}${task.trust === "agent" ? ", agent-written" : ""})` : ""}`;
   return ["Harness task board:", ...(waiting.length ? [`${waiting.length} task${waiting.length === 1 ? "" : "s"} waiting for you:`, ...waiting.slice(0, 5).map(line)] : []),
     ...(held.length ? [`${held.length} you already claimed:`, ...held.slice(0, 5).map(line)] : []),
     "Read one with get_task, claim it with claim_task before working, and report_task when done or stuck."].join("\n");
@@ -119,12 +127,21 @@ export default function tryHarness(pi) {
     return connecting;
   };
   pi.on("session_start", (_event, ctx) => void connect(ctx).catch((error) => ctx?.ui?.notify?.("Harness unavailable: " + error?.message, "warning")));
-  pi.on("session_start", async (_event, ctx) => {
-    const nudge = await boardNudge();
+  const tell = (nudge, ctx) => {
     if (!nudge) return;
     // Into the model's context when pi offers it; always visible to the person.
     if (typeof pi.sendMessage === "function") { try { pi.sendMessage({ customType: "harness-board", content: nudge, display: true }); } catch {} }
     ctx?.ui?.notify?.(nudge.split("\n").slice(0, 2).join(" "), "info");
+  };
+  pi.on("session_start", async (_event, ctx) => tell(await boardNudge(false), ctx));
+  // Into the model's own context: pi lets an extension return the system prompt it should use
+  // (pi 0.87: before_agent_start -> { systemPrompt }). The queue is appended, never substituted.
+  pi.on("before_agent_start", async (event) => {
+    const nudge = await boardNudge(false);
+    if (!nudge || typeof event?.systemPrompt !== "string") return undefined;
+    return { systemPrompt: `${event.systemPrompt}\n\n${nudge}` };
   });
+  // After each turn (pi 0.87 event name turn_end), only when the queue moved.
+  pi.on("turn_end", async (_event, ctx) => tell(await boardNudge(true), ctx));
   pi.registerCommand("harness-reconnect", { description: "Reconnect Harness", handler: async (_args, ctx) => connect(ctx) });
 }

package/cli.mjs

@@ -9,6 +9,7 @@ import { daemonRequest } from "./lib/control-client.mjs";
 import { ensureDir, readJson, writeJsonAtomic } from "./lib/files.mjs";
 import { paths } from "./lib/paths.mjs";
 import { currentRuntime, installRuntime } from "./lib/runtime-install.mjs";
+import { ensureModel, modelPresent } from "./lib/embedder.mjs";
 import { installService, serviceInfo, uninstallService } from "./lib/service.mjs";
 
 const SOURCE_ROOT = path.dirname(fileURLToPath(import.meta.url));
@@ -157,6 +158,14 @@ async function connect() {
   const service = installService({ runtimeRoot });
   const ready = await waitForDaemon();
   console.log(`daemon: ready via ${service.manager} and connected to Harness`);
+  // The context space's embedder lives with the daemon and comes down with setup, so the machine
+  // can search a task by meaning before the first task exists. About 110 MB, once.
+  try {
+    if (modelPresent(paths.models)) console.log("embedder: ready");
+    else { console.log("embedder: downloading (about 110 MB, once)"); await ensureModel({ modelsDir: paths.models, log: (line) => console.log(`  ${line}`) }); console.log("embedder: ready"); }
+  } catch (error) {
+    console.log(`embedder: not downloaded (${error.message}); task search uses words until the next setup run`);
+  }
   const failed = states.filter((state) => selected.includes(state.agent) && state.installed && !state.configured);
   if (failed.length) {
     throw new Error(`setup is incomplete for ${failed.map((state) => state.agent).join(", ")}. Nothing was hidden; run npx tryharness doctor after fixing the reported CLI error, then rerun setup.`);
@@ -214,6 +223,31 @@ async function sync() {
   console.log(`Local history scan started for ${agent}. It runs in the daemon; this terminal does not need to stay open.`);
 }
 
+async function notify() {
+  const mode = argv[0];
+  if (!["on", "off"].includes(mode)) { const config = readJson(paths.config, {}); console.log(`desktop notifications: ${config.notifications === false ? "off" : "on"} (tryharness notify on|off)`); return; }
+  const config = readJson(paths.config, {});
+  writeJsonAtomic(paths.config, { ...config, notifications: mode === "on" });
+  console.log(`desktop notifications ${mode}. The daemon picks this up on its next change.`);
+}
+
+async function connectAgent() {
+  // Ask another person's listed agent to work an issue with one of ours: a request their Harness shows them.
+  const to = String(argv[0] || "");
+  if (!/^[a-z0-9][a-z0-9-]{1,19}\/[a-z0-9][a-z0-9._-]{0,63}$/.test(to)) throw new Error("usage: tryharness connect <handle/agent> --about <text> [--agent <your agent>] [--file <brief.md>]");
+  const fromAgent = arg("--agent", "claude-code");
+  if (!AGENTS.includes(fromAgent)) throw new Error(`--agent must be one of ${AGENTS.join(", ")}`);
+  const about = arg("--about", "");
+  if (!about.trim()) throw new Error("connect needs --about");
+  const file = arg("--file");
+  let brief = "";
+  if (file) brief = fs.readFileSync(path.resolve(file), "utf8");
+  else if (!process.stdin.isTTY) for await (const chunk of process.stdin) brief += chunk;
+  const response = await daemonRequest({ command: "relay.request", to, fromAgent, about, brief }, 20_000);
+  if (!response.ok) throw new Error(response.error || "request failed");
+  console.log(`Asked ${to} to work "${about}" with your ${fromAgent}. Thread ${String(response.threadId || "").slice(0, 8)} is ${response.status || "requested"}; once they accept, it appears on your board and your ${fromAgent} is told.`);
+}
+
 async function mcpSnippet() {
   const client = argv[0];
   if (!MCP_CLIENTS.includes(client)) throw new Error(`usage: tryharness mcp <${MCP_CLIENTS.join("|")}>`);
@@ -231,8 +265,12 @@ async function board() {
   const sub = argv.find((value) => !value.startsWith("--")) || "list";
   const agent = arg("--as", "user");
   if (sub === "post") {
-    const target = arg("--for");
-    if (target && !AGENTS.includes(target) && target !== "harness" && target !== "grok-bot") throw new Error("usage: tryharness board post --for <agent> --objective <text> [--file <brief.md>] [--run --workspace <dir>]");
+    // --for codex,claude-code posts one task for several agents at once.
+    const targets = String(arg("--for", "")).split(",").map((value) => value.trim()).filter(Boolean);
+    const target = targets.length === 1 ? targets[0] : null;
+    // Coding agents, Grok Bot and Harness live on this machine's board; Bankr, Quotient and Muse live in Harness and the daemon posts there.
+    const allowed = (name) => AGENTS.includes(name) || ["harness", "grok-bot", "muse", "bankr", "quotient"].includes(name);
+    if (targets.some((name) => !allowed(name))) throw new Error("usage: tryharness board post --for <agent[,agent...]> --objective <text> [--file <brief.md>] [--run --workspace <dir>]");
     const objective = arg("--objective", "");
     const file = arg("--file");
     let brief = "";
@@ -240,13 +278,44 @@ async function board() {
     else if (!process.stdin.isTTY) for await (const chunk of process.stdin) brief += chunk;
     if (!objective.trim()) throw new Error("board post needs --objective");
     const runWorkspace = has("--run") ? path.resolve(arg("--workspace", process.cwd())) : null;
-    if (runWorkspace && !AGENTS.includes(target)) throw new Error("--run needs --for with a coding agent installed on this machine");
-    const response = await daemonRequest({ command: "board.post", agent, objective, brief, targetAgent: target || null, runWorkspace });
+    if (runWorkspace && !targets.every((name) => AGENTS.includes(name))) throw new Error("--run needs --for with coding agents installed on this machine");
+    if (targets.length > 1 && targets.some((name) => ["bankr", "quotient", "muse"].includes(name))) throw new Error("a task for several agents at once is for agents on this machine; post a task for bankr, quotient or muse on its own");
+    const response = await daemonRequest({ command: "board.post", agent, objective, brief, targetAgent: target, ...(targets.length > 1 ? { targetAgents: targets } : {}), runWorkspace });
     if (!response.ok) throw new Error(response.error || "post failed");
-    if (runWorkspace) console.log(`Task ${response.task.id} is on the board and ${target} will run it in ${runWorkspace}. Follow it: npx tryharness task ${response.task.id} --follow`);
+    if (targets.length > 1) console.log(`Task ${response.task.id} is on the board for ${targets.join(", ")} at once${runWorkspace ? `, each running in ${runWorkspace}` : ""}. It closes with every result when the last of them finishes.`);
+    else if (runWorkspace) console.log(`Task ${response.task.id} is on the board and ${target} will run it in ${runWorkspace}. Follow it: npx tryharness task ${response.task.id} --follow`);
     else console.log(`Task ${response.task.id} is on the board${target ? ` for ${target}` : ""}. Any agent's list_tasks tool shows it.`);
     return;
   }
+  if (sub === "send" || sub === "discard") {
+    const id = String(argv[argv.indexOf(sub) + 1] || "");
+    const messageId = String(argv[argv.indexOf(sub) + 2] || "");
+    if (!id || !messageId) throw new Error(`usage: tryharness board ${sub} <task id> <message id>`);
+    const response = await daemonRequest({ command: sub === "send" ? "board.thread.send" : "board.thread.discard", agent, id, messageId });
+    if (!response.ok) throw new Error(response.error || `${sub} failed`);
+    console.log(sub === "send" ? `Sent to ${response.message.recipient}.` : "Discarded.");
+    return;
+  }
+  if (sub === "auto" || sub === "end") {
+    const id = String(argv[argv.indexOf(sub) + 1] || "");
+    const response = sub === "auto"
+      ? await daemonRequest({ command: "board.thread.auto", agent, id, on: argv[argv.indexOf(sub) + 2] !== "off" })
+      : await daemonRequest({ command: "board.thread.end", agent, id, outcome: arg("--outcome", "") });
+    if (!response.ok) throw new Error(response.error || `${sub} failed`);
+    console.log(sub === "auto" ? `Auto-send ${response.thread.auto_send ? "on" : "off"} for ${id.slice(0, 8)}. It turns off again if a reply is flagged.` : `Thread ended; the other side is told.`);
+    return;
+  }
+  if (sub === "context") {
+    const id = String(argv[argv.indexOf(sub) + 1] || "");
+    const query = argv.slice(argv.indexOf(sub) + 2).filter((value) => !value.startsWith("--")).join(" ");
+    if (!id || !query) throw new Error("usage: tryharness board context <task id> <what you are looking for>");
+    const response = await daemonRequest({ command: "board.context.search", agent, id, query, limit: 8 }, 20_000);
+    if (!response.ok) throw new Error(response.error || "search failed");
+    const how = response.retrieval === "vectors" ? "meaning" : response.embedder === "absent" ? "words (the embedder is not downloaded yet; run npx tryharness)" : `words (${response.context?.embedded ?? 0} of ${response.context?.total ?? 0} entries embedded so far)`;
+    console.log(`${response.entries.length} result${response.entries.length === 1 ? "" : "s"} by ${how}`);
+    for (const entry of response.entries) console.log(`\n[${entry.kind} · ${entry.author}${entry.source ? ` · ${entry.source}` : ""} · ${entry.score}]\n${entry.text.slice(0, 400)}`);
+    return;
+  }
   if (sub === "run" || sub === "release") {
     const id = String(argv[argv.indexOf(sub) + 1] || "");
     const response = await daemonRequest({ command: sub === "run" ? "board.run" : "board.release", agent, id });
@@ -254,6 +323,25 @@ async function board() {
     console.log(sub === "run" ? `Run authorized; ${response.task.target_agent} starts it now. Follow it: npx tryharness task ${id} --follow` : `Task ${id} is open again.`);
     return;
   }
+  if (sub === "watch" || has("--watch")) {
+    // The terminal view that follows the board: one line per change, no Harness window needed.
+    const seen = new Map();
+    let first = true;
+    for (;;) {
+      const response = await daemonRequest({ command: "board.list", agent, all: true, limit: 100 }).catch(() => null);
+      if (response?.ok) {
+        for (const t of response.tasks) {
+          const key = `${t.status}:${t.version}:${t.stale ? "stale" : ""}`;
+          if (seen.get(t.id) === key) continue;
+          seen.set(t.id, key);
+          if (!first || ["open", "claimed", "running", "needs_input"].includes(t.status)) console.log(`${new Date().toLocaleTimeString()}  ${t.id.slice(0, 8)}  ${(t.stale ? "stale" : t.status).padEnd(11)} ${t.origin_agent} → ${t.target_agent || "anyone"}${t.claimed_by ? ` (${t.claimed_by})` : ""}${t.run_workspace && !t.run_authorized_at ? " [wants to run]" : ""}  ${t.objective}`);
+        }
+        if (first) console.log("watching the board (Ctrl-C stops)");
+        first = false;
+      } else if (first) { console.log("daemon not running; waiting"); first = false; }
+      await sleep(2_000);
+    }
+  }
   if (sub === "agents") {
     const response = await daemonRequest({ command: "board.agents", agent });
     if (!response.ok) throw new Error(response.error || "board unavailable");
@@ -266,16 +354,36 @@ async function board() {
     if (!response.ok) throw new Error(response.error || "task not found");
     const { task: t } = response;
     console.log(`${t.id} · ${t.status}${t.stale ? " (stale claim)" : ""} · from ${t.origin_agent}${t.target_agent ? ` for ${t.target_agent}` : ""}${t.claimed_by ? ` · claimed by ${t.claimed_by}` : ""} · held by ${t.holder || "nobody"} · version ${t.version}\n${t.objective}\n`);
+    if (t.kind === "group") for (const part of t.children || []) console.log(`  part for ${part.target_agent}: ${part.status}${part.claimed_by ? ` (${part.claimed_by})` : ""} · ${part.id}${part.result ? `\n    ${String(part.result).slice(0, 200)}` : ""}`);
     if (t.run_workspace) console.log(`run: ${t.run_authorized_at ? `authorized by ${t.run_authorized_by}` : "requested, waiting for: npx tryharness board run " + t.id} · ${t.run_workspace}${t.session_id ? `\nagent session: ${t.session_id}\nopen live session: ${resumeCommand(t.target_agent, t.session_id, t.run_workspace)}` : ""}\n`);
     if (t.brief) console.log(t.brief + "\n");
     if (t.result) console.log(`${t.status === "needs_input" ? "question" : "result"}: ${t.result}`);
+    const thread = await daemonRequest({ command: "board.thread.read", agent, id: t.id });
+    if (thread.ok) {
+      console.log(`\nthread with ${thread.thread.with_agent}${thread.thread.closed_at ? " (ended)" : thread.thread.auto_send ? " (auto-send on)" : " (replies held for you)"}`);
+      for (const m of thread.messages) console.log(`  ${m.direction === "in" ? "←" : "→"} ${m.sender} [${m.state}${m.flag_reason ? `: ${m.flag_reason}` : ""}] ${m.text.slice(0, 300)}${m.state === "held" || m.state === "flagged" ? `\n    send: tryharness board send ${t.id} ${m.id}` : ""}`);
+    }
+    return;
+  }
+  if (sub === "trace") {
+    const response = await daemonRequest({ command: "board.trace", agent, id: String(argv[argv.indexOf("trace") + 1] || "") }, 30_000);
+    if (!response.ok) throw new Error(response.error || "trace unavailable");
+    const t = response.trace;
+    const time = (value) => (value == null ? "-" : value < 1_000 ? `${value}ms` : value < 120_000 ? `${(value / 1_000).toFixed(1)}s` : `${(value / 60_000).toFixed(1)}m`);
+    console.log(`${t.hops} hop${t.hops === 1 ? "" : "s"} · ${t.status} · ${time(t.wall_ms)} end to end${t.finished_at ? "" : " so far"} · ${time(t.person_ms)} waiting on you · agents: ${t.agents.join(", ")}`);
+    for (const span of t.spans) console.log(`${"  ".repeat(span.depth)}${span.id.slice(0, 8)} ${span.origin_agent} → ${span.worked_by || span.target_agent || "anyone"} [${span.status}${span.trust === "agent" ? `, written by ${span.origin_chain.join(" → ")}` : ""}] you ${time(span.person_ms)} · queue ${time(span.queue_ms)} · work ${time(span.work_ms)} · ${span.objective.slice(0, 60)}`);
+    if (t.slowest) console.log(`slowest: ${t.slowest.id.slice(0, 8)} (${t.slowest.worked_by}) ${time(t.slowest.work_ms)}`);
+    const c = t.cost;
+    const usd = (microCents) => `$${(microCents / 100_000_000).toFixed(4)}`;
+    console.log(`cost: ${usd(c.charged_micro_cents)} charged by Harness${c.held_micro_cents ? `, ${usd(c.held_micro_cents)} held` : ""}; agents reported $${c.agent_reported_usd.toFixed(4)} and ${c.tokens.input + c.tokens.output} tokens${c.unrecorded.length ? `; no figure for ${c.unrecorded.map((id) => id.slice(0, 8)).join(", ")}` : ""}`);
+    for (const wait of t.waiting_on) console.log(`waiting: ${wait.id.slice(0, 8)} is ${wait.status}${wait.holder ? ` with ${wait.holder}` : ""}`);
     return;
   }
-  if (sub !== "list") throw new Error("usage: tryharness board [list --all | show <id> | post --for <agent> --objective <text> [--file <brief.md>] [--run --workspace <dir>] | run <id> | release <id> | agents]");
+  if (sub !== "list") throw new Error("usage: tryharness board [list --all | show <id> | trace <id> | post --for <agent> --objective <text> [--file <brief.md>] [--run --workspace <dir>] | run <id> | release <id> | agents]");
   const response = await daemonRequest({ command: "board.list", agent, all: has("--all") });
   if (!response.ok) throw new Error(response.error || "board unavailable");
   if (!response.tasks.length) { console.log("The board is empty."); return; }
-  for (const t of response.tasks) console.log(`${t.id}  ${(t.stale ? "stale" : t.status).padEnd(11)} ${t.origin_agent} → ${t.target_agent || "anyone"}${t.claimed_by ? ` (${t.claimed_by})` : ""}${t.run_workspace && !t.run_authorized_at ? " [wants to run]" : ""}  ${t.objective}`);
+  for (const t of response.tasks) console.log(`${t.id}  ${(t.stale ? "stale" : t.status).padEnd(11)} ${t.origin_agent} → ${t.kind === "group" ? `${t.child_agents} (${t.child_done} of ${t.child_count} done)` : t.target_agent || "anyone"}${t.claimed_by ? ` (${t.claimed_by})` : ""}${t.run_workspace && !t.run_authorized_at ? " [wants to run]" : ""}  ${t.objective}`);
 }
 
 async function task() {
@@ -336,17 +444,19 @@ async function disconnect() {
 }
 
 function help() {
-  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\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 mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
+  console.log(`tryharness ${VERSION}\n\nCommands:\n  tryharness                 set up everything and start the daemon\n  tryharness status          show daemon, bridge, agent, and index health\n  tryharness doctor          diagnose the complete connection\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 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 connect <handle/agent> --about <text>   ask another person's agent to work an issue with yours\n  tryharness mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
 }
 
 try {
-  if (command === "connect" || command === "setup") await connect();
+  if (command === "setup" || (command === "connect" && !argv[0])) await connect();
   else if (command === "status" || command === "bridge") await status();
   else if (command === "doctor") await doctor();
   else if (command === "sync" || command === "backfill" || command === "drain") await sync();
   else if (command === "task") await task();
   else if (command === "board") await board();
   else if (command === "mcp") await mcpSnippet();
+  else if (command === "notify") await notify();
+  else if (command === "connect") await connectAgent();
   else if (command === "logs") logs();
   else if (command === "disconnect") await disconnect();
   else if (command === "daemon") { const { startDaemon } = await import("./lib/daemon.mjs"); await startDaemon(); }

package/lib/adapters.mjs

@@ -53,18 +53,56 @@ export function installClaudeSessionHook({ runtimeRoot, homeDir = os.homedir(),
   const file = claudeSettingsPath(homeDir);
   const settings = readJson(file, {});
   const hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  const nudge = JSON.stringify(path.join(runtimeRoot, "lib", "nudge.mjs"));
   const starts = (Array.isArray(hooks.SessionStart) ? hooks.SessionStart : []).filter((entry) => !isHarnessHook(entry));
-  starts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${JSON.stringify(path.join(runtimeRoot, "lib", "nudge.mjs"))} --agent claude-code`, timeout: 10 }] });
+  starts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent claude-code`, timeout: 10 }] });
+  // Mid-session: on every prompt, one line only when the queue changed since the session last saw it.
+  const prompts = (Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : []).filter((entry) => !isHarnessHook(entry));
+  prompts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent claude-code --if-changed`, timeout: 10 }] });
   ensureDir(path.dirname(file));
-  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts } }, null, 2) + "\n");
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts } }, null, 2) + "\n");
+}
+
+// Codex reads the same hook shape from ~/.codex/hooks.json (SessionStart and UserPromptSubmit,
+// stdout added as developer context). Codex asks the person to trust a new or changed hook once,
+// with /hooks in its TUI, before it runs; setup says so.
+export function codexHooksPath(homeDir = os.homedir()) {
+  return path.join(homeDir, ".codex", "hooks.json");
+}
+
+export function installCodexHooks({ runtimeRoot, homeDir = os.homedir(), nodePath = process.execPath }) {
+  const file = codexHooksPath(homeDir);
+  const settings = readJson(file, {});
+  const hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  const nudge = JSON.stringify(path.join(runtimeRoot, "lib", "nudge.mjs"));
+  const starts = (Array.isArray(hooks.SessionStart) ? hooks.SessionStart : []).filter((entry) => !isHarnessHook(entry));
+  starts.push({ matcher: "startup|resume", hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent codex`, statusMessage: "Reading the Harness board", timeout: 10 }] });
+  const prompts = (Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : []).filter((entry) => !isHarnessHook(entry));
+  prompts.push({ hooks: [{ type: "command", command: `${JSON.stringify(nodePath)} ${nudge} --agent codex --if-changed`, timeout: 10 }] });
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts, UserPromptSubmit: prompts } }, null, 2) + "\n");
+}
+
+export function removeCodexHooks(homeDir = os.homedir()) {
+  const file = codexHooksPath(homeDir);
+  const settings = readJson(file, null);
+  if (!settings?.hooks) return;
+  const hooks = { ...settings.hooks };
+  for (const event of ["SessionStart", "UserPromptSubmit"]) {
+    if (Array.isArray(hooks[event])) hooks[event] = hooks[event].filter((entry) => !isHarnessHook(entry));
+  }
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks }, null, 2) + "\n");
 }
 
 export function removeClaudeSessionHook(homeDir = os.homedir()) {
   const file = claudeSettingsPath(homeDir);
   const settings = readJson(file, null);
-  if (!settings?.hooks || !Array.isArray(settings.hooks.SessionStart)) return;
-  const starts = settings.hooks.SessionStart.filter((entry) => !isHarnessHook(entry));
-  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...settings.hooks, SessionStart: starts } }, null, 2) + "\n");
+  if (!settings?.hooks) return;
+  const hooks = { ...settings.hooks };
+  for (const event of ["SessionStart", "UserPromptSubmit"]) {
+    if (Array.isArray(hooks[event])) hooks[event] = hooks[event].filter((entry) => !isHarnessHook(entry));
+  }
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks }, null, 2) + "\n");
 }
 
 export function configureAgents({ runtimeRoot, selected = AGENTS, homeDir = os.homedir(), detected = detectAgents(), execute = run, connection = readJson(paths.config, {}) }) {
@@ -91,7 +129,9 @@ export function configureAgents({ runtimeRoot, selected = AGENTS, homeDir = os.h
     } else if (agent === "codex") {
       execute(found.path, ["mcp", "remove", "harness"]);
       const added = execute(found.path, ["mcp", "add", "harness", "--", process.execPath, mcpPath, "--agent", agent]);
-      states.push({ agent, installed: true, configured: added.ok, detail: added.ok ? "MCP configured" : diagnostic(added) });
+      let hooked = true;
+      try { installCodexHooks({ runtimeRoot, homeDir }); } catch { hooked = false; }
+      states.push({ agent, installed: true, configured: added.ok, detail: added.ok ? (hooked ? "MCP and session hooks configured; in Codex run /hooks once to trust them" : "MCP configured; the session hooks could not be written") : diagnostic(added) });
     } else if (agent === "pi") {
       installAsset(path.join(runtimeRoot, "assets", "pi-extension.ts"), assets.pi);
       states.push({ agent, installed: true, configured: fs.existsSync(assets.pi), detail: "extension installed" });
@@ -115,7 +155,8 @@ export function removeAgentConfigurations({ homeDir = os.homedir(), detected = d
   for (const found of detected) {
     if (!found.path) continue;
     if (found.agent === "claude-code") { execute(found.path, ["mcp", "remove", "--scope", "user", "harness"]); removeClaudeSessionHook(homeDir); }
-    else if (found.agent === "codex" || found.agent === "opencode") execute(found.path, ["mcp", "remove", "harness"]);
+    else if (found.agent === "codex") { execute(found.path, ["mcp", "remove", "harness"]); removeCodexHooks(homeDir); }
+    else if (found.agent === "opencode") execute(found.path, ["mcp", "remove", "harness"]);
   }
   const assets = integrationAssets(homeDir);
   for (const target of Object.values(assets)) {