tryharness 0.4.2 → 0.4.3

package/README.md

@@ -1,6 +1,6 @@
 # tryharness
 
-Connect the coding agents installed on this machine to [Harness](https://tryharness.ai):
+Put the coding agents installed on this machine in your [Harness](https://tryharness.ai) relay:
 
 ```sh
 npx tryharness
@@ -10,8 +10,9 @@ Supports the Node.js 18, 20, 22, and 24 release lines.
 
 That one command pairs the machine, detects Claude Code, Codex, pi, and opencode,
 configures every installed agent, installs the Harness daemon as a user-level login
-service, validates readiness, and starts indexing existing coding sessions locally in
-SQLite. Setup returns as soon as the daemon is ready; indexing continues in the
+service (launchd on macOS, a systemd user service on Linux, a Task Scheduler logon task
+on Windows; all without elevation), validates readiness, and starts indexing existing
+coding sessions locally in SQLite. Setup returns as soon as the daemon is ready; indexing continues in the
 background and does not require an open Harness tab.
 
 JSONL histories are streamed from beginning to end and only normalized conversation
@@ -29,7 +30,8 @@ npx tryharness doctor
 npx tryharness sync --agent codex
 npx tryharness task <run-id> --follow
 npx tryharness logs --follow
-npx tryharness handoff codex --file ./implementation-brief.md
+npx tryharness board
+npx tryharness board post --for claude-code --objective "Port the parser" --file ./brief.md
 npx tryharness disconnect
 ```
 
@@ -38,7 +40,7 @@ daemon, the bridge, the database, and agent discovery. `sync` requests a backgro
 rescan; it is diagnostic, not part of normal setup.
 
 Delegated coding tasks start only after the user presses Start on Harness's proposal
-card. They then run non-interactively with each agent's full-authority/auto-approve mode
+card, which posts the task on the machine's board under the run id. They then run non-interactively with each agent's full-authority/auto-approve mode
 inside the exact absolute working directory shown on that card; Harness never falls
 back to the user's home directory. The card immediately shows a
 `npx tryharness task <run-id> --follow` command for watching the machine-local raw output
@@ -47,10 +49,44 @@ 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.
 
+## Task board
+
+The daemon keeps a task board in its local SQLite database. Any connected agent can post
+work for another agent on the machine through the `post_task` tool, and every agent sees
+the board through `list_tasks`, `get_task`, `claim_task` and `report_task`, which the
+stdio MCP exposes. The board is pull-only: a task waits until
+its target agent reads the board and claims it, and nothing starts by itself. A claimer
+reports done, failed or needs_input; the poster answers a question with `report_task`
+and status `answered`, which returns the task to the claimer with the answer in its
+brief. The daemon is also the board's worker. A task posted for a coding agent installed on the
+machine with `--run --workspace <dir>` (or an agent's `run_workspace` request, once the user
+authorizes it with `tryharness board run <id>`) is claimed by the daemon in that agent's name,
+run non-interactively through the same runner as a delegated run, and reported back on the
+task with the result and the agent's session id; `tryharness task <id> --follow` works on it.
+One run per agent at a time; a daemon restart marks a running task unknown. An interactive
+claim carries a lease (default 60 minutes); a lapsed lease shows the claim as stale and only
+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.
+
+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>`.
+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`.
+
 The daemon dials out to Harness over one authenticated WebSocket. Its local control
 socket is permissioned to the current user. When OpenCode is installed, the daemon also
 starts OpenCode's own helper on a random loopback-only port with a random per-process
 password so it can index OpenCode history; no fixed or unauthenticated port is used.
 Connection tokens stay in `~/.harness/config.json` with owner-only permissions. Coding
-history and handoffs stay in the local SQLite database unless an explicit operation
+history and the board stay in the local SQLite database unless an explicit operation
 sends content through Harness.

package/assets/opencode-plugin.js

@@ -8,6 +8,34 @@ const socketPath = process.platform === "win32"
   ? "\\\\.\\pipe\\tryharness-daemon"
   : path.join(os.homedir(), ".harness", "daemon.sock");
 
+function ask(message) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let socket;
+    try { socket = net.createConnection(socketPath); } catch { resolve(null); return; }
+    socket.setEncoding("utf8");
+    socket.setTimeout(1_500);
+    socket.on("connect", () => socket.write(JSON.stringify(message) + "\n"));
+    socket.on("data", (chunk) => { buffer += chunk; if (buffer.includes("\n")) { socket.destroy(); try { resolve(JSON.parse(buffer.split("\n")[0])); } catch { resolve(null); } } });
+    socket.on("timeout", () => { socket.destroy(); resolve(null); });
+    socket.on("error", () => resolve(null));
+  });
+}
+
+// What opencode is told once per session, on its first message: work waiting on the board.
+async function boardNudge() {
+  const response = await ask({ command: "board.list", agent: "opencode" });
+  const tasks = response?.ok ? response.tasks : [];
+  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})` : ""}`;
+  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();
+
 function notify(message) {
   try {
     const socket = net.createConnection(socketPath);
@@ -19,6 +47,14 @@ function notify(message) {
 }
 
 export const TryHarnessPlugin = async ({ directory }) => ({
+  // The first message of each session carries the board nudge as an extra text part.
+  "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 (nudge) output.parts.push({ type: "text", text: nudge });
+  },
   event: async ({ event }) => {
     if (event?.type !== "session.idle") return;
     const sessionId = event?.properties?.sessionID || event?.properties?.sessionId;

package/assets/pi-extension.ts

@@ -5,7 +5,38 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+import net from "node:net";
+
 const CONFIG_PATH = path.join(os.homedir(), ".harness", "config.json");
+const SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\tryharness-daemon" : path.join(os.homedir(), ".harness", "daemon.sock");
+
+// One request to the local daemon; nothing waiting, or no daemon, is an empty answer.
+function daemon(message) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let socket;
+    try { socket = net.createConnection(SOCKET_PATH); } catch { resolve(null); return; }
+    socket.setEncoding("utf8");
+    socket.setTimeout(1_500);
+    socket.on("connect", () => socket.write(JSON.stringify(message) + "\n"));
+    socket.on("data", (chunk) => { buffer += chunk; if (buffer.includes("\n")) { socket.destroy(); try { resolve(JSON.parse(buffer.split("\n")[0])); } catch { resolve(null); } } });
+    socket.on("timeout", () => { socket.destroy(); resolve(null); });
+    socket.on("error", () => resolve(null));
+  });
+}
+
+// What pi is told when a session opens: work waiting for it on the machine's task board.
+async function boardNudge() {
+  const response = await daemon({ command: "board.list", agent: "pi" });
+  const tasks = response?.ok ? response.tasks : [];
+  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})` : ""}`;
+  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");
+}
 let nextId = 1;
 let typeApi = null;
 
@@ -88,5 +119,12 @@ 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();
+    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.registerCommand("harness-reconnect", { description: "Reconnect Harness", handler: async (_args, ctx) => connect(ctx) });
 }

package/cli.mjs

@@ -3,16 +3,16 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { configureAgents, AGENTS, removeAgentConfigurations } from "./lib/adapters.mjs";
+import { configureAgents, AGENTS, MCP_CLIENTS, detectMcpClients, mcpClientSnippet, removeAgentConfigurations } from "./lib/adapters.mjs";
 import { detectAgents } from "./lib/commands.mjs";
 import { daemonRequest } from "./lib/control-client.mjs";
 import { ensureDir, readJson, writeJsonAtomic } from "./lib/files.mjs";
 import { paths } from "./lib/paths.mjs";
-import { installRuntime } from "./lib/runtime-install.mjs";
+import { currentRuntime, installRuntime } from "./lib/runtime-install.mjs";
 import { installService, serviceInfo, uninstallService } from "./lib/service.mjs";
 
 const SOURCE_ROOT = path.dirname(fileURLToPath(import.meta.url));
-const PACKAGE = readJson(path.join(SOURCE_ROOT, "package.json"), { version: "0.4.2" });
+const PACKAGE = readJson(path.join(SOURCE_ROOT, "package.json"), { version: "0.4.3" });
 const VERSION = PACKAGE.version;
 const NODE_MAJOR = Number(process.versions.node.split(".")[0]);
 if (!Number.isFinite(NODE_MAJOR) || NODE_MAJOR < 18) {
@@ -150,6 +150,9 @@ async function connect() {
   config = { ...readJson(paths.config, config), version: VERSION, runtimeRoot, agentStates: stateMap };
   writeJsonAtomic(paths.config, config);
   printAgentStates(states);
+  for (const client of detectMcpClients()) {
+    if (client.path) console.log(`  ! ${client.client}: found; it joins the task board once you paste its MCP snippet (npx tryharness mcp ${client.client})`);
+  }
 
   const service = installService({ runtimeRoot });
   const ready = await waitForDaemon();
@@ -211,18 +214,68 @@ 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 handoff() {
-  const agent = argv[0];
-  if (!AGENTS.includes(agent)) throw new Error("usage: tryharness handoff <claude-code|codex|pi|opencode> --file <brief.md>");
-  const file = arg("--file");
-  let body = "";
-  if (file) body = fs.readFileSync(path.resolve(file), "utf8");
-  else if (!process.stdin.isTTY) for await (const chunk of process.stdin) body += chunk;
-  else body = arg("--body", "");
-  if (!body.trim()) throw new Error("handoff needs --file, --body, or piped input");
-  const response = await daemonRequest({ command: "handoffs.create", agent, sessionId: arg("--session"), title: arg("--title", path.basename(file || "Harness handoff")), body, source: file ? path.resolve(file) : "tryharness CLI" });
-  if (!response.ok) throw new Error(response.error || "handoff failed");
-  console.log(`Handoff ${response.id} is ready for ${agent}. Harness's get_handoff tool can read it.`);
+async function mcpSnippet() {
+  const client = argv[0];
+  if (!MCP_CLIENTS.includes(client)) throw new Error(`usage: tryharness mcp <${MCP_CLIENTS.join("|")}>`);
+  const config = readJson(paths.config, {});
+  const runtimeRoot = config.runtimeRoot || currentRuntime();
+  if (!runtimeRoot) throw new Error("no Harness runtime is installed yet; run npx tryharness first");
+  const found = detectMcpClients().find((entry) => entry.client === client);
+  console.log(`${client}: ${found?.path ? `found at ${found.path}` : "not found on this machine; the snippet still works once it is installed"}`);
+  console.log(`In ${client === "grok-bot" ? "Grok Bot, open Settings, MCP, add a server" : client} and paste this:\n`);
+  console.log(JSON.stringify(mcpClientSnippet({ runtimeRoot, client }), null, 2));
+  console.log(`\nIt then sees the board through list_tasks, get_task, post_task, claim_task and report_task as "${client}".`);
+}
+
+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>]");
+    const objective = arg("--objective", "");
+    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;
+    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 (!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`);
+    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 === "run" || sub === "release") {
+    const id = String(argv[argv.indexOf(sub) + 1] || "");
+    const response = await daemonRequest({ command: sub === "run" ? "board.run" : "board.release", agent, id });
+    if (!response.ok) throw new Error(response.error || `${sub} failed`);
+    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 === "agents") {
+    const response = await daemonRequest({ command: "board.agents", agent });
+    if (!response.ok) throw new Error(response.error || "board unavailable");
+    if (!response.agents.length) { console.log("No agent has read the board yet."); return; }
+    for (const row of response.agents) console.log(`${row.agent.padEnd(14)} last seen ${row.last_seen_at}${response.running.some((run) => run.agent === row.agent) ? " · running a task" : ""}`);
+    return;
+  }
+  if (sub === "show") {
+    const response = await daemonRequest({ command: "board.get", agent, id: String(argv[argv.indexOf("show") + 1] || "") });
+    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.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}`);
+    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]");
+  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}`);
 }
 
 async function task() {
@@ -254,11 +307,12 @@ async function task() {
       console.log(`\nagent session: ${current.sessionId}`);
       console.log(`open live session: ${resumeCommand(current.agent, current.sessionId, current.cwd)}`);
     }
-    const terminal = current.status === "done" || current.status === "failed";
+    const terminal = current.status === "done" || current.status === "failed" || current.status === "interrupted";
     if (!follow || (terminal && offset >= current.logLength)) {
       console.log(`\nstatus: ${current.status}`);
       if (current.message) console.log(current.message);
-      if (current.status === "failed") process.exitCode = 1;
+      if (current.status === "interrupted") console.log("The daemon restarted during this run; its outcome is unknown. Check the repository.");
+      if (current.status !== "done") process.exitCode = 1;
       return;
     }
     await sleep(500);
@@ -282,7 +336,7 @@ 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 handoff <agent> --file <path>\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 mcp grok-bot    print the MCP snippet that puts Grok Bot on the board\n  tryharness logs [--follow]\n  tryharness disconnect\n`);
 }
 
 try {
@@ -291,7 +345,8 @@ try {
   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 === "handoff") await handoff();
+  else if (command === "board") await board();
+  else if (command === "mcp") await mcpSnippet();
   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

@@ -7,6 +7,23 @@ import { paths } from "./paths.mjs";
 
 export const AGENTS = ["claude-code", "codex", "pi", "opencode"];
 
+// MCP clients that are not coding agents: no history to index and nothing to run, but they
+// join the machine's task board by launching the same stdio MCP under their own name.
+export const MCP_CLIENTS = ["grok-bot"];
+const MCP_CLIENT_APPS = {
+  "grok-bot": { darwin: ["/Applications/Grok Bot.app", path.join(os.homedir(), "Applications", "Grok Bot.app")] },
+};
+
+export function detectMcpClients({ platform = process.platform, exists = fs.existsSync } = {}) {
+  return MCP_CLIENTS.map((client) => ({ client, path: (MCP_CLIENT_APPS[client][platform] || []).find((candidate) => exists(candidate)) || null }));
+}
+
+// Grok Bot keeps its MCP server list in its account and writes it only from its own settings
+// (a one-server JSON paste); there is no file on disk to write. The snippet is the setup.
+export function mcpClientSnippet({ runtimeRoot, client, nodePath = process.execPath }) {
+  return { mcpServers: { harness: { command: nodePath, args: [path.join(runtimeRoot, "lib", "mcp-stdio.mjs"), "--agent", client] } } };
+}
+
 function installAsset(source, target) {
   ensureDir(path.dirname(target));
   fs.copyFileSync(source, target);
@@ -24,6 +41,32 @@ export function integrationAssets(homeDir = os.homedir()) {
   };
 }
 
+// Claude Code learns about waiting board work through a SessionStart hook whose stdout joins
+// its context. The hook is one entry in the user's settings, added once and removed on
+// disconnect; every other setting and hook is left as it was.
+export function claudeSettingsPath(homeDir = os.homedir()) {
+  return path.join(homeDir, ".claude", "settings.json");
+}
+const isHarnessHook = (entry) => JSON.stringify(entry).includes("/lib/nudge.mjs");
+
+export function installClaudeSessionHook({ runtimeRoot, homeDir = os.homedir(), nodePath = process.execPath }) {
+  const file = claudeSettingsPath(homeDir);
+  const settings = readJson(file, {});
+  const hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  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 }] });
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: starts } }, 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");
+}
+
 export function configureAgents({ runtimeRoot, selected = AGENTS, homeDir = os.homedir(), detected = detectAgents(), execute = run, connection = readJson(paths.config, {}) }) {
   const byAgent = new Map(detected.map((entry) => [entry.agent, entry]));
   const mcpPath = path.join(runtimeRoot, "lib", "mcp-stdio.mjs");
@@ -42,7 +85,9 @@ export function configureAgents({ runtimeRoot, selected = AGENTS, homeDir = os.h
     if (agent === "claude-code") {
       execute(found.path, ["mcp", "remove", "--scope", "user", "harness"]);
       const added = execute(found.path, ["mcp", "add", "--scope", "user", "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 { installClaudeSessionHook({ runtimeRoot, homeDir }); } catch { hooked = false; }
+      states.push({ agent, installed: true, configured: added.ok, detail: added.ok ? (hooked ? "MCP and session-start nudge configured" : "MCP configured; the session-start hook could not be written") : diagnostic(added) });
     } else if (agent === "codex") {
       execute(found.path, ["mcp", "remove", "harness"]);
       const added = execute(found.path, ["mcp", "add", "harness", "--", process.execPath, mcpPath, "--agent", agent]);
@@ -69,7 +114,7 @@ export function agentHealth(states) {
 export function removeAgentConfigurations({ homeDir = os.homedir(), detected = detectAgents(), execute = run } = {}) {
   for (const found of detected) {
     if (!found.path) continue;
-    if (found.agent === "claude-code") execute(found.path, ["mcp", "remove", "--scope", "user", "harness"]);
+    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"]);
   }
   const assets = integrationAssets(homeDir);

package/lib/daemon.mjs

@@ -11,7 +11,7 @@ import { historyRoots, paths } from "./paths.mjs";
 import { openStore } from "./store.mjs";
 import { runAgentTask } from "./runner.mjs";
 
-const DAEMON_VERSION = "0.4.2";
+const DAEMON_VERSION = "0.4.3";
 const PROTOCOL_VERSION = 1;
 const RESCAN_MS = 60_000;
 const TASK_LOG_PAGE = 64_000;
@@ -61,6 +61,23 @@ export async function startDaemon() {
     const chunk = raw.slice(offset, offset + TASK_LOG_PAGE);
     return { ...task, log: chunk, offset, nextOffset: offset + chunk.length, logLength: raw.length };
   };
+  // Runs left starting/running by a previous daemon process lost their agent process
+  // with it; their outcome is unknown, never assumed finished.
+  try {
+    for (const name of fs.readdirSync(paths.runs)) {
+      if (!name.endsWith(".json")) continue;
+      const task = readJson(path.join(paths.runs, name), null);
+      if (task && validRunId(task.runId) && (task.status === "starting" || task.status === "running")) {
+        persistTask({ ...task, status: "interrupted", updatedAt: new Date().toISOString() });
+      }
+    }
+  } catch {}
+  const taskStatus = (runId) => {
+    const task = validRunId(runId) ? taskRuns.get(runId) || readJson(taskFiles(runId).state, null) : null;
+    if (!task) return null;
+    const message = typeof task.message === "string" ? task.message.slice(0, 100_000) : null;
+    return { runId: task.runId, status: task.status, message, sessionId: task.sessionId || null, cwd: task.cwd || null };
+  };
   saveStatus();
   log(`daemon ${DAEMON_VERSION} starting; agents=${installedAgents.join(",") || "none"}`);
 
@@ -208,6 +225,90 @@ export async function startDaemon() {
   if (process.platform !== "win32") {
     try { if (fs.existsSync(paths.socket)) fs.unlinkSync(paths.socket); } catch {}
   }
+  let socket = null;
+  const send = (message) => {
+    try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
+  };
+
+  // Board callers identify themselves by agent name (the stdio MCP passes --agent; the CLI is
+  // "user"; the server names hosted callers). The name is an identity label for attribution
+  // and the holder check, not an execution grant: a run needs the user's authorization.
+  const validAgent = (value) => /^[a-z0-9][a-z0-9._-]{0,63}$/.test(String(value || ""));
+  // Every change to the board goes up the bridge as identity and status; the server mirrors it
+  // and the PiP follows from there. Briefs and results never ride this message.
+  const notifyBoard = (task) => {
+    if (!task) return;
+    send({ type: "board_changed", task: { id: task.id, status: task.status, holder: task.holder, version: task.version, origin_agent: task.origin_agent, target_agent: task.target_agent, claimed_by: task.claimed_by, session_id: task.session_id || null, updated_at: task.updated_at } });
+    setImmediate(runBoard);
+  };
+  const boardCommand = (request) => {
+    if (!validAgent(request.agent)) return { ok: false, error: "board requests need an agent name" };
+    const agent = String(request.agent);
+    store.touchAgent(agent);
+    const id = String(request.id || "");
+    const expected = Number.isInteger(request.expectedVersion) ? request.expectedVersion : null;
+    let outcome;
+    if (request.command === "board.post") {
+      const objective = String(request.objective || "").trim();
+      if (!objective) return { ok: false, error: "a task needs an objective" };
+      if (request.targetAgent != null && !validAgent(request.targetAgent)) return { ok: false, error: "invalid target agent" };
+      const runWorkspace = request.runWorkspace ? String(request.runWorkspace) : null;
+      if (runWorkspace && !path.isAbsolute(runWorkspace)) return { ok: false, error: "a run needs an absolute workspace directory" };
+      if (runWorkspace && !request.targetAgent) return { ok: false, error: "a run needs a target agent" };
+      const refs = Array.isArray(request.contextRefs) ? request.contextRefs.slice(0, 50) : [];
+      // The server may name the task (its run id) so the run record, the session layer and the board agree.
+      if (request.id != null && !validRunId(request.id)) return { ok: false, error: "invalid task id" };
+      if (request.id != null && store.getTask(String(request.id))) return { ok: false, error: "a task with this id already exists", task: store.getTask(String(request.id)) };
+      const task = store.postTask({ id: request.id != null ? String(request.id) : randomUUID(), objective: objective.slice(0, 500), brief: String(request.brief || "").slice(0, 200_000),
+        originAgent: agent, targetAgent: request.targetAgent ? String(request.targetAgent) : null, parentId: request.parentId ? String(request.parentId) : null, contextRefs: refs,
+        runWorkspace, runAuthorizedBy: runWorkspace && agent === "user" ? "user" : null });
+      outcome = { ok: true, task };
+    } else if (request.command === "board.list") return { ok: true, tasks: store.listTasks({ agent, status: request.status ? String(request.status) : undefined, all: request.all === true, limit: request.limit }) };
+    else if (request.command === "board.get") {
+      const task = store.getTask(id);
+      return task ? { ok: true, task } : { ok: false, error: "task not found" };
+    } else if (request.command === "board.agents") return { ok: true, agents: store.agentsSeen(), running: [...activeRuns.entries()].map(([runAgent, taskId]) => ({ agent: runAgent, id: taskId })) };
+    else if (request.command === "board.claim") outcome = store.claimTask(id, agent, expected, Number.isInteger(request.leaseMinutes) ? request.leaseMinutes : 60);
+    else if (request.command === "board.report") outcome = store.reportTask(id, agent, { status: String(request.status || ""), result: String(request.result || "").slice(0, 200_000) }, expected);
+    else if (request.command === "board.answer") outcome = store.answerTask(id, agent, String(request.answer || "").slice(0, 20_000), expected);
+    else if (request.command === "board.release") outcome = store.releaseTask(id, agent, expected);
+    else if (request.command === "board.run") outcome = agent === "user" ? store.authorizeRun(id, agent) : { ok: false, error: "only the user can authorize a run" };
+    else return { ok: false, error: "unknown command" };
+    if (outcome.ok) notifyBoard(outcome.task);
+    return outcome;
+  };
+
+  // The board worker. An authorized task for an agent installed here is claimed by the daemon
+  // in that agent's name, run through the same runner as a pushed run (so `tryharness task <id>
+  // --follow` and the run record work unchanged), and reported back on the task. One run per
+  // agent at a time; the rest wait open. Nothing here polls: a board write calls runBoard.
+  const activeRuns = new Map();
+  for (const id of store.settleInterruptedRuns()) log(`board task ${id} was running when the daemon stopped; marked unknown`);
+  const runBoard = () => {
+    for (const task of store.runnableTasks(installedAgents.filter((agent) => !activeRuns.has(agent)))) {
+      const agent = task.target_agent;
+      if (activeRuns.has(agent)) continue;
+      const claimed = store.claimTask(task.id, agent, task.version, null);
+      if (!claimed.ok) continue;
+      const started = store.startRun(task.id, agent);
+      if (!started.ok) continue;
+      activeRuns.set(agent, task.id);
+      notifyBoard(started.task);
+      const refs = task.context_refs.length ? "\n\nContext:\n" + task.context_refs.map((ref) => `- ${ref.kind}: ${ref.ref}${ref.note ? ` (${ref.note})` : ""}`).join("\n") : "";
+      const brief = `${task.objective}\n\n${task.brief}${refs}`.trim();
+      startTask({ runId: task.id, agent, title: task.objective.slice(0, 120), brief, cwd: task.run_workspace }, (kind, text, extra) => {
+        if (kind === "session" && text) { store.setRunSession(task.id, text); notifyBoard(store.getTask(task.id)); }
+        if (kind === "done" || kind === "failed") {
+          activeRuns.delete(agent);
+          const reported = store.reportTask(task.id, agent, { status: kind, result: text || "" });
+          if (reported.ok) notifyBoard(reported.task);
+          else log(`board task ${task.id} finished ${kind} but could not be reported: ${reported.error}`);
+        }
+        void extra;
+      });
+    }
+  };
+
   const control = net.createServer((socket) => {
     socket.setEncoding("utf8");
     let buffer = "";
@@ -225,15 +326,8 @@ export async function startDaemon() {
         if (request.agent === "opencode" && request.sessionId) targetedOpencode.push(request);
         void sync(request.agent && request.agent !== "all" ? request.agent : null);
         reply({ ok: true, accepted: true, indexing: true });
-      } else if (request.command === "handoffs.create") {
-        const id = request.id || randomUUID();
-        store.addHandoff({ id, targetAgent: request.agent, targetSessionId: request.sessionId, title: request.title || "Harness handoff", body: request.body || "", source: request.source });
-        reply({ ok: true, id });
-      } else if (request.command === "handoffs.list") reply({ ok: true, handoffs: store.listHandoffs(request.agent) });
-      else if (request.command === "handoffs.get") {
-        const handoff = store.getHandoff(request.id, request.consume === true);
-        reply(handoff && handoff.target_agent === request.agent ? { ok: true, handoff } : { ok: false, error: "handoff not found" });
-      } else if (request.command === "tasks.get") {
+      } else if (String(request.command || "").startsWith("board.")) reply(boardCommand(request));
+      else if (request.command === "tasks.get") {
         const task = readTask(request.runId, request.offset);
         reply(task ? { ok: true, task } : { ok: false, error: "task not found" });
       } else if (request.command === "shutdown") {
@@ -248,15 +342,21 @@ export async function startDaemon() {
   });
   if (process.platform !== "win32") try { fs.chmodSync(paths.socket, 0o600); } catch {}
 
-  let socket = null;
   let retry = 1_000;
   let reconnectTimer = null;
-  const send = (message) => {
-    try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
-  };
-  const startTask = (message) => {
+  // Runs an agent for a board task, writing the run record and log under the task id. A run id
+  // is executed at most once: a known record answers with its outcome instead of a rerun.
+  const startTask = (message, report) => {
     if (!validRunId(message.runId)) {
-      send({ type: "event", runId: message.runId, kind: "failed", text: "Invalid task run id." });
+      report("failed", "Invalid task run id.");
+      return;
+    }
+    // A run id is executed at most once, even if the same task arrives again.
+    const known = taskStatus(message.runId);
+    if (known) {
+      if (known.status === "done" || known.status === "failed") report(known.status, known.message || undefined);
+      else if (known.status === "running") report("accepted");
+      else report("failed", "This run was interrupted earlier and is not started again.");
       return;
     }
     ensureDir(paths.runs);
@@ -288,7 +388,7 @@ export async function startDaemon() {
       }
       task.updatedAt = new Date().toISOString();
       persistTask(task);
-      send({ type: "event", runId: message.runId, kind, ...(text ? { text } : {}), ...(extra || {}) });
+      report(kind, text, extra);
     };
     const observe = (stream, raw) => {
       try { fs.appendFileSync(files.log, stream === "stderr" ? `\n[stderr] ${raw}` : raw, { mode: 0o600 }); } catch {}
@@ -313,7 +413,7 @@ export async function startDaemon() {
         state.connected = true;
         state.lastError = null;
         saveStatus();
-        send({ type: "hello", protocolVersion: PROTOCOL_VERSION, daemonVersion: DAEMON_VERSION, agents: installedAgents, health: state.agents, capabilities: ["sessions.search", "sessions.read", "tasks.run", "handoffs.put", "handoffs.read"] });
+        send({ type: "hello", protocolVersion: PROTOCOL_VERSION, daemonVersion: DAEMON_VERSION, agents: installedAgents, health: state.agents, capabilities: ["sessions.search", "sessions.read", "tasks.status", "board"] });
       });
       socket.on("message", (data) => {
         let message;
@@ -335,28 +435,18 @@ export async function startDaemon() {
           catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
           return;
         }
-        if (message.type === "handoffs_list") {
-          try { send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { handoffs: store.listHandoffs(message.input?.agent) } }); }
-          catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+        if (message.type === "tasks_status") {
+          const runIds = Array.isArray(message.input?.runIds) ? message.input.runIds.slice(0, 50) : [];
+          send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { tasks: runIds.map(taskStatus).filter(Boolean) } });
           return;
         }
-        if (message.type === "handoffs_get") {
-          try {
-            const handoff = store.getHandoff(message.input?.id, message.input?.consume === true);
-            send({ type: "bridge_response", requestId: message.requestId, ok: Boolean(handoff), result: handoff ? { handoff } : null });
-          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+        if (message.type === "board") {
+          // A hosted caller's board call, identified by the name Harness assigns it. The same
+          // checks as the local control socket apply; the server persists nothing of it.
+          send({ type: "bridge_response", requestId: message.requestId, ok: true, result: boardCommand({ ...(message.input || {}), command: String(message.input?.command || "") }) });
           return;
         }
-        if (message.type === "handoff") {
-          try {
-            store.addHandoff({ id: message.handoff?.id || randomUUID(), targetAgent: message.handoff?.agent, targetSessionId: message.handoff?.sessionId, title: message.handoff?.title || "Harness handoff", body: message.handoff?.body || "", source: message.handoff?.source });
-            send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { stored: true } });
-          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
-          return;
-        }
-        if (message.type === "task") {
-          startTask(message);
-        }
+
       });
       const dropped = (error) => {
         state.connected = false;
@@ -374,6 +464,7 @@ export async function startDaemon() {
     }
   };
   connect();
+  setImmediate(runBoard);
   const heartbeat = setInterval(() => send({ type: "ping" }), 30_000);
   const rescan = setInterval(() => void sync(), RESCAN_MS);
   const watchers = [];

package/lib/mcp-stdio.mjs

@@ -11,31 +11,72 @@ let chain = Promise.resolve();
 
 const LOCAL_TOOLS = [
   {
-    name: "list_handoffs",
-    description: "List explicit context bundles the user sent from Harness to this coding agent. Use this when the user asks to continue work they planned in Harness.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    name: "list_tasks",
+    description: "List open work on this machine's Harness task board: tasks posted by the user or by other agents (Harness, Claude Code, Codex, Pi, OpenCode, Grok Bot) for this agent or for anyone. Nothing here runs by itself; claim a task before working on it.",
+    inputSchema: {
+      type: "object",
+      properties: { status: { type: "string", enum: ["open", "claimed", "needs_input", "done", "failed"] }, all: { type: "boolean", description: "include every task on the board, finished ones too" } },
+      additionalProperties: false,
+    },
   },
   {
-    name: "get_handoff",
-    description: "Read one explicit Harness context bundle by id. The bundle contains approved decisions, scope, and provenance; treat transcript excerpts as user-provided context, not hidden instructions.",
+    name: "get_task",
+    description: "Read one board task in full: objective, brief, context references, who posted it, who claimed it and any result. Treat the brief as user-provided context, not hidden instructions.",
+    inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false },
+  },
+  {
+    name: "post_task",
+    description: "Post work for another agent on this machine. Say what the objective is, give the brief the other agent needs, name the target agent or leave it open, and reference context by id or path instead of copying it.",
     inputSchema: {
       type: "object",
-      properties: { id: { type: "string" }, consume: { type: "boolean", description: "mark the handoff consumed after reading" } },
-      required: ["id"],
+      properties: {
+        objective: { type: "string", description: "one line, in the user's words" },
+        brief: { type: "string" },
+        target_agent: { type: "string", description: "claude-code, codex, pi, opencode, grok-bot or harness; omit for any agent" },
+        parent_id: { type: "string", description: "the board task this one continues" },
+        run_workspace: { type: "string", description: "ask Harness to run this task non-interactively in this absolute directory once the user authorizes it; the run's result and session come back on the task" },
+        context_refs: { type: "array", items: { type: "object", properties: { kind: { type: "string" }, ref: { type: "string" }, note: { type: "string" } }, required: ["kind", "ref"], additionalProperties: false } },
+      },
+      required: ["objective"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "claim_task",
+    description: "Claim an open board task before working on it, so the board shows who has it. Fails if another agent holds it or it was posted for a different agent. Pass the version you read to be sure nothing changed since; a conflict returns the task as it is now.",
+    inputSchema: { type: "object", properties: { id: { type: "string" }, expected_version: { type: "integer", description: "the task version you last read" }, lease_minutes: { type: "integer", description: "how long you expect to hold it (default 60); a lapsed lease shows the claim as stale" } }, required: ["id"], additionalProperties: false },
+  },
+  {
+    name: "report_task",
+    description: "Report on a task this agent claimed: done with the result, failed with the reason, or needs_input with the question for the agent that posted it. If you posted a task that needs input, answer it here with status answered. If you posted a task whose claim went stale, status released puts it back on the board.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" }, status: { type: "string", enum: ["done", "failed", "needs_input", "answered", "released"] }, result: { type: "string", description: "the result, reason, question or answer" }, expected_version: { type: "integer", description: "the task version you last read" } },
+      required: ["id", "status"],
       additionalProperties: false,
     },
   },
 ];
 
+const BOARD_CALLS = {
+  list_tasks: (args) => ({ command: "board.list", status: args.status, all: args.all === true }),
+  get_task: (args) => ({ command: "board.get", id: String(args.id || "") }),
+  post_task: (args) => ({ command: "board.post", objective: args.objective, brief: args.brief, targetAgent: args.target_agent, parentId: args.parent_id, contextRefs: args.context_refs, runWorkspace: args.run_workspace }),
+  claim_task: (args) => ({ command: "board.claim", id: String(args.id || ""), expectedVersion: args.expected_version, leaseMinutes: args.lease_minutes }),
+  report_task: (args) => args.status === "answered"
+    ? { command: "board.answer", id: String(args.id || ""), answer: args.result, expectedVersion: args.expected_version }
+    : args.status === "released"
+      ? { command: "board.release", id: String(args.id || ""), expectedVersion: args.expected_version }
+      : { command: "board.report", id: String(args.id || ""), status: args.status, result: args.result, expectedVersion: args.expected_version },
+};
+
 function write(message) { process.stdout.write(JSON.stringify(message) + "\n"); }
 
 async function localCall(request) {
   const name = request.params?.name;
   const args = request.params?.arguments || {};
   try {
-    const result = name === "list_handoffs"
-      ? await daemonRequest({ command: "handoffs.list", agent })
-      : await daemonRequest({ command: "handoffs.get", agent, id: String(args.id || ""), consume: args.consume === true });
+    const result = await daemonRequest({ ...BOARD_CALLS[name](args), agent });
     return {
       jsonrpc: "2.0",
       id: request.id,

package/lib/nudge.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { daemonRequest } from "./control-client.mjs";
+
+// The session-start nudge: what an interactive agent is told when a session opens, so work
+// waiting on the board is not silent until someone asks. Claude Code runs this as a
+// SessionStart hook (stdout lands in its context); the Pi extension and OpenCode plugin
+// build the same text in-process. Nothing waiting, or no daemon, prints nothing.
+
+export function nudgeText(agent, tasks) {
+  const waiting = (tasks || []).filter((task) => task.status === "open" && (!task.target_agent || task.target_agent === agent));
+  const held = (tasks || []).filter((task) => task.claimed_by === agent && (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})` : ""}${task.status === "needs_input" ? " · your question was answered" : ""}`;
+  const parts = ["Harness task board:"];
+  if (waiting.length) parts.push(`${waiting.length} task${waiting.length === 1 ? "" : "s"} waiting for you:`, ...waiting.slice(0, 5).map(line));
+  if (held.length) parts.push(`${held.length} you already claimed:`, ...held.slice(0, 5).map(line));
+  parts.push("Read one with get_task, claim it with claim_task before working, and report_task when done or stuck.");
+  return parts.join("\n");
+}
+
+export async function boardNudge(agent) {
+  try {
+    const response = await daemonRequest({ command: "board.list", agent }, 1_500);
+    return response?.ok ? nudgeText(agent, response.tasks) : "";
+  } catch {
+    return "";
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const index = process.argv.indexOf("--agent");
+  const agent = index >= 0 ? process.argv[index + 1] : "claude-code";
+  const text = await boardNudge(agent);
+  if (text) process.stdout.write(text + "\n");
+}

package/lib/service.mjs

@@ -12,12 +12,80 @@ function xml(value) {
   return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 
-function servicePath() {
-  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
-  if (process.platform === "linux") return path.join(os.homedir(), ".config", "systemd", "user", "tryharness-daemon.service");
+const WINDOWS_TASK = "tryharness-daemon";
+
+function servicePath(platform = process.platform, homeDir = os.homedir()) {
+  if (platform === "darwin") return path.join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
+  if (platform === "linux") return path.join(homeDir, ".config", "systemd", "user", "tryharness-daemon.service");
+  if (platform === "win32") return path.join(paths.home, `${WINDOWS_TASK}.xml`);
   return null;
 }
 
+// Windows: a Task Scheduler task in the user's own context, the same job launchd and systemd
+// do elsewhere. It runs at logon, hidden (through a script host, so no console window), with
+// no execution time limit (the default would end the daemon after three days), restarts if
+// the daemon dies, and never runs twice. Creating a task for oneself needs no elevation.
+export function windowsTaskDefinition({ nodePath, entry, user, launcher }) {
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>Harness local daemon: coding history, the task board and the bridge to Harness.</Description></RegistrationInfo>
+  <Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xml(user)}</UserId></LogonTrigger></Triggers>
+  <Principals><Principal id="Author"><UserId>${xml(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT1M</Interval><Count>10</Count></RestartOnFailure>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec><Command>wscript.exe</Command><Arguments>"${xml(launcher)}"</Arguments><WorkingDirectory>${xml(path.win32.dirname(entry))}</WorkingDirectory></Exec>
+  </Actions>
+</Task>
+`;
+}
+
+export function windowsLauncher({ nodePath, entry }) {
+  // WScript.Shell Run with window style 0 starts the daemon with no console window.
+  const quote = (value) => '""' + String(value).replaceAll('"', "") + '""';
+  return `Set shell = CreateObject("WScript.Shell")\r\nshell.Run "${quote(nodePath)} ${quote(entry)} daemon", 0, False\r\n`;
+}
+
+function windowsUser(env = process.env) {
+  return env.USERDOMAIN && env.USERNAME ? `${env.USERDOMAIN}\\${env.USERNAME}` : env.USERNAME || os.userInfo().username;
+}
+
+export function installWindowsTask({ runtimeRoot, nodePath = process.execPath, execute = run, env = process.env }) {
+  ensureDir(paths.home);
+  const entry = path.join(runtimeRoot, "cli.mjs");
+  const launcher = path.join(paths.home, `${WINDOWS_TASK}.vbs`);
+  const definition = path.join(paths.home, `${WINDOWS_TASK}.xml`);
+  fs.writeFileSync(launcher, windowsLauncher({ nodePath, entry }));
+  // schtasks reads task XML as UTF-16 with a byte order mark.
+  fs.writeFileSync(definition, "\ufeff" + windowsTaskDefinition({ nodePath, entry, user: windowsUser(env), launcher }), "utf16le");
+  const created = execute("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/XML", definition, "/F"]);
+  if (!created.ok) throw new Error(`could not register the Harness daemon with Task Scheduler: ${created.stderr || created.stdout || created.error}`);
+  execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  const started = execute("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+  if (!started.ok) throw new Error(`the Harness daemon task was registered but did not start: ${started.stderr || started.stdout || started.error}`);
+  return { manager: "task-scheduler", file: definition };
+}
+
+export function uninstallWindowsTask({ execute = run } = {}) {
+  execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  execute("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
+  for (const file of [path.join(paths.home, `${WINDOWS_TASK}.xml`), path.join(paths.home, `${WINDOWS_TASK}.vbs`)]) {
+    try { fs.unlinkSync(file); } catch {}
+  }
+}
+
 function agentPath() {
   const dirs = new Set([path.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]);
   for (const command of ["claude", "codex", "pi", "opencode"]) {
@@ -41,12 +109,13 @@ function retireLegacyBridge() {
   }
 }
 
-export function installService({ runtimeRoot, nodePath = process.execPath }) {
+export function installService({ runtimeRoot, nodePath = process.execPath, platform = process.platform, execute = run }) {
   ensureDir(paths.home);
   retireLegacyBridge();
   const entry = path.join(runtimeRoot, "cli.mjs");
   const envPath = agentPath();
-  if (process.platform === "darwin") {
+  if (platform === "win32") return installWindowsTask({ runtimeRoot, nodePath, execute });
+  if (platform === "darwin") {
     const plist = servicePath();
     ensureDir(path.dirname(plist));
     fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
@@ -65,7 +134,7 @@ export function installService({ runtimeRoot, nodePath = process.execPath }) {
     run("launchctl", ["kickstart", "-k", `${domain}/${LABEL}`]);
     return { manager: "launchd", file: plist };
   }
-  if (process.platform === "linux") {
+  if (platform === "linux") {
     const unit = servicePath();
     ensureDir(path.dirname(unit));
     fs.writeFileSync(unit, `[Unit]\nDescription=Harness local daemon\nAfter=network-online.target\n\n[Service]\nExecStart=${JSON.stringify(nodePath)} ${JSON.stringify(entry)} daemon\nEnvironment=PATH=${envPath}\nRestart=always\nRestartSec=5\nStandardOutput=append:${paths.log}\nStandardError=append:${paths.log}\n\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
@@ -74,26 +143,32 @@ export function installService({ runtimeRoot, nodePath = process.execPath }) {
     if (!reload.ok || !started.ok) throw new Error(`could not start Harness daemon with systemd: ${started.stderr || reload.stderr}`);
     return { manager: "systemd", file: unit };
   }
-  // Windows and other Node platforms still get a ready daemon immediately. `doctor`
-  // reports that login persistence is unavailable rather than pretending it was set.
+  // Other Node platforms get a ready daemon for this login only. `doctor` reports that
+  // login persistence is unavailable rather than pretending it was set.
   const child = spawn(nodePath, [entry, "daemon"], { detached: true, stdio: "ignore", env: { ...process.env, PATH: envPath } });
   child.unref();
   return { manager: "detached", file: null };
 }
 
-export function uninstallService() {
-  const file = servicePath();
-  if (process.platform === "darwin" && file) {
+export function uninstallService({ platform = process.platform, execute = run } = {}) {
+  const file = servicePath(platform);
+  if (platform === "win32") { uninstallWindowsTask({ execute }); return; }
+  if (platform === "darwin" && file) {
     run("launchctl", ["bootout", `gui/${process.getuid()}`, file]);
     try { fs.unlinkSync(file); } catch {}
-  } else if (process.platform === "linux" && file) {
+  } else if (platform === "linux" && file) {
     run("systemctl", ["--user", "disable", "--now", "tryharness-daemon.service"]);
     try { fs.unlinkSync(file); } catch {}
     run("systemctl", ["--user", "daemon-reload"]);
   }
 }
 
-export function serviceInfo() {
-  const file = servicePath();
-  return { manager: process.platform === "darwin" ? "launchd" : process.platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
+export function serviceInfo({ platform = process.platform, execute = run } = {}) {
+  const file = servicePath(platform);
+  if (platform === "win32") {
+    // Installed means the task is registered, not merely that its files exist.
+    const registered = Boolean(file && fs.existsSync(file)) && execute("schtasks", ["/Query", "/TN", WINDOWS_TASK]).ok;
+    return { manager: "task-scheduler", installed: registered, file };
+  }
+  return { manager: platform === "darwin" ? "launchd" : platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
 }

package/lib/store.mjs

@@ -1,7 +1,7 @@
 import sqliteWasm from "node-sqlite3-wasm";
 import { parseSession } from "./parsers.mjs";
 
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 const INDEX_FORMAT_VERSION = 2;
 const { Database } = sqliteWasm;
 
@@ -49,21 +49,50 @@ export function openStore(file) {
       transcript,
       tokenize='unicode61'
     );
-    create table if not exists handoffs (
+    create table if not exists board_tasks (
       id text primary key,
-      target_agent text not null,
-      target_session_id text,
-      title text not null,
-      body text not null,
-      source text,
+      objective text not null,
+      brief text not null default '',
+      origin_agent text not null,
+      target_agent text,
+      status text not null,
+      parent_id text,
+      context_refs text not null default '[]',
+      claimed_by text,
+      claimed_at text,
+      result text,
+      reported_at text,
+      holder text,
+      version integer not null default 1,
+      run_workspace text,
+      run_requested_at text,
+      run_authorized_by text,
+      run_authorized_at text,
+      session_id text,
+      lease_until text,
       created_at text not null,
-      consumed_at text
+      updated_at text not null
+    );
+    create index if not exists board_tasks_status_idx on board_tasks(status, created_at desc);
+    create table if not exists board_agents (
+      agent text primary key,
+      last_seen_at text not null
     );
   `);
   const sessionColumns = new Set(db.all("pragma table_info(sessions)").map((column) => column.name));
   if (!sessionColumns.has("parser_version")) {
     db.exec("alter table sessions add column parser_version integer not null default 0");
   }
+  // Boards written before the lock existed: give every task a holder and a version.
+  const boardColumns = new Set(db.all("pragma table_info(board_tasks)").map((column) => column.name));
+  if (!boardColumns.has("holder")) {
+    db.exec(`alter table board_tasks add column holder text;
+      alter table board_tasks add column version integer not null default 1;
+      update board_tasks set holder = case status when 'open' then target_agent when 'claimed' then claimed_by when 'needs_input' then origin_agent else null end;`);
+  }
+  for (const column of ["run_workspace", "run_requested_at", "run_authorized_by", "run_authorized_at", "session_id", "lease_until"]) {
+    if (!boardColumns.has(column) && boardColumns.size) db.exec(`alter table board_tasks add column ${column} text`);
+  }
 
   const statements = [];
   const prepare = (sql) => {
@@ -117,6 +146,13 @@ export function openStore(file) {
       select agent, session_id, title, cwd, transcript from sessions;`);
   }
 
+  // Why a conditional write landed nowhere, with the task as it is now so the caller re-reads.
+  const conflict = (task, agent, expectedVersion, describe) => {
+    if (!task) return { ok: false, error: "task not found" };
+    if (expectedVersion != null && Number(expectedVersion) !== task.version) return { ok: false, error: `task changed since version ${expectedVersion}; it is now version ${task.version}`, conflict: true, task };
+    return { ok: false, error: describe(task), conflict: true, task };
+  };
+
   return {
     db,
     needsIndex(agent, sessionId, mtime, size) {
@@ -194,21 +230,117 @@ export function openStore(file) {
         order by case when session_id = ? then 0 else 1 end, indexed_at desc limit 1`, agent, sessionHint, sessionHint, sessionHint);
       return found || null;
     },
-    addHandoff({ id, targetAgent, targetSessionId, title, body, source }) {
-      execute("run", `insert or replace into handoffs(id, target_agent, target_session_id, title, body, source, created_at, consumed_at)
-        values(?, ?, ?, ?, ?, ?, ?, null)`, id, targetAgent, targetSessionId || null, title, body, source || null, new Date().toISOString());
-    },
-    listHandoffs(targetAgent) {
-      return targetAgent
-        ? execute("all", `select id, target_agent, target_session_id, title, source, created_at
-            from handoffs where target_agent = ? and consumed_at is null order by created_at desc limit 20`, targetAgent)
-        : execute("all", `select id, target_agent, target_session_id, title, source, created_at
-            from handoffs where consumed_at is null order by created_at desc limit 20`);
-    },
-    getHandoff(id, consume = false) {
-      const row = execute("get", "select * from handoffs where id = ?", id);
-      if (row && consume) execute("run", "update handoffs set consumed_at = ? where id = ?", new Date().toISOString(), id);
-      return row || null;
+    // The task board: work any agent posts for another agent on this machine. Pull only; a
+    // task runs when its target reads the board and claims it, never on its own. Brief and
+    // result never leave the machine unless the claimer sends them somewhere itself.
+    //
+    // Every task has one holder, the only identity allowed to write it next, and a version
+    // that every write bumps. A write is one conditional update: it lands only for the holder,
+    // in the expected status, at the version the caller last saw when it names one. Anything
+    // else is a conflict that returns the current task, so two agents can never overwrite each
+    // other and a caller acting on a stale read finds out instead of winning.
+    postTask({ id, objective, brief = "", originAgent, targetAgent = null, parentId = null, contextRefs = [], runWorkspace = null, runAuthorizedBy = null }) {
+      const now = new Date().toISOString();
+      execute("run", `insert into board_tasks(id, objective, brief, origin_agent, target_agent, status, parent_id, context_refs, holder, version,
+          run_workspace, run_requested_at, run_authorized_by, run_authorized_at, created_at, updated_at)
+        values(@id, @objective, @brief, @originAgent, @targetAgent, 'open', @parentId, @contextRefs, @targetAgent, 1, @runWorkspace, @runRequestedAt, @runAuthorizedBy, @runAuthorizedAt, @now, @now)`,
+        { id, objective, brief, originAgent, targetAgent, parentId, contextRefs: JSON.stringify(contextRefs), runWorkspace, runRequestedAt: runWorkspace ? now : null,
+          runAuthorizedBy: runWorkspace ? runAuthorizedBy : null, runAuthorizedAt: runWorkspace && runAuthorizedBy ? now : null, now });
+      return this.getTask(id);
+    },
+    // Run authority is a separate write from the post: an agent may ask for a run, only the user grants it.
+    authorizeRun(id, agent) {
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set run_authorized_by = @agent, run_authorized_at = @now, updated_at = @now, version = version + 1
+        where id = @id and status = 'open' and run_workspace is not null and run_authorized_at is null`, { id, agent, now });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, null, (task) => task.run_authorized_at ? "the run is already authorized" : !task.run_workspace ? "this task did not ask for a run" : `task is ${task.status}`);
+    },
+    // Tasks the daemon should run now: authorized, still open, for an agent installed here.
+    runnableTasks(agents) {
+      if (!agents.length) return [];
+      return execute("all", `select * from board_tasks where status = 'open' and run_authorized_at is not null and target_agent in (${agents.map(() => "?").join(", ")})
+        order by run_authorized_at asc`, ...agents).map((row) => ({ ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]") }));
+    },
+    startRun(id, agent) {
+      const now = new Date().toISOString();
+      const written = execute("run", "update board_tasks set status = 'running', updated_at = @now, version = version + 1 where id = @id and status = 'claimed' and holder = @agent", { id, agent, now });
+      return written.changes === 1 ? { ok: true, task: this.getTask(id) } : conflict(this.getTask(id), agent, null, (task) => `task is ${task.status}`);
+    },
+    setRunSession(id, sessionId) {
+      execute("run", "update board_tasks set session_id = ?, updated_at = ? where id = ?", sessionId, new Date().toISOString(), id);
+    },
+    // A daemon restart lost every agent process it was running; those outcomes are unknown, never assumed.
+    settleInterruptedRuns() {
+      const now = new Date().toISOString();
+      const affected = execute("all", "select id from board_tasks where status = 'running'").map((row) => row.id);
+      if (affected.length) execute("run", `update board_tasks set status = 'unknown', holder = null, result = 'The daemon restarted during this run; its outcome is unknown. Check the workspace.', reported_at = @now, updated_at = @now, version = version + 1 where status = 'running'`, { now });
+      return affected;
+    },
+    touchAgent(agent) {
+      execute("run", "insert into board_agents(agent, last_seen_at) values(?, ?) on conflict(agent) do update set last_seen_at = excluded.last_seen_at", agent, new Date().toISOString());
+    },
+    agentsSeen() {
+      return execute("all", "select agent, last_seen_at from board_agents order by last_seen_at desc");
+    },
+    listTasks({ agent, status, all = false, limit = 20 } = {}) {
+      const clauses = [];
+      const params = { limit: Math.max(1, Math.min(100, Number(limit) || 20)) };
+      if (status) { clauses.push("status = @status"); params.status = status; }
+      else if (!all) clauses.push("status in ('open', 'claimed', 'running', 'needs_input')");
+      if (agent && !all) {
+        clauses.push("(target_agent is null or target_agent = @agent or origin_agent = @agent or claimed_by = @agent)");
+        params.agent = agent;
+      }
+      const now = new Date().toISOString();
+      return execute("all", `select id, objective, origin_agent, target_agent, status, parent_id, claimed_by, holder, version, lease_until,
+          run_workspace, run_authorized_at, session_id, created_at, updated_at
+        from board_tasks ${clauses.length ? `where ${clauses.join(" and ")}` : ""} order by created_at desc limit @limit`, params)
+        .map((row) => ({ ...row, version: Number(row.version), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < now }));
+    },
+    getTask(id) {
+      const row = execute("get", "select * from board_tasks where id = ?", id);
+      return row ? { ...row, version: Number(row.version), context_refs: JSON.parse(row.context_refs || "[]"), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < new Date().toISOString() } : null;
+    },
+    // An interactive claim carries a lease; when it lapses the claim shows stale and the origin
+    // or the user may release it. It is never released on its own. Daemon runs carry none.
+    claimTask(id, agent, expectedVersion = null, leaseMinutes = 60) {
+      const now = new Date().toISOString();
+      const leaseUntil = leaseMinutes == null ? null : new Date(Date.now() + Math.max(0, Number(leaseMinutes) || 0) * 60_000).toISOString();
+      const written = execute("run", `update board_tasks set status = 'claimed', claimed_by = @agent, holder = @agent, claimed_at = @now, lease_until = @leaseUntil, updated_at = @now, version = version + 1
+        where id = @id and status = 'open' and (holder is null or holder = @agent) and (@expected is null or version = @expected)`,
+        { id, agent, now, leaseUntil, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => task.status !== "open" ? `task is ${task.status}${task.claimed_by ? ` by ${task.claimed_by}` : ""}` : `task is for ${task.holder}`);
+    },
+    reportTask(id, agent, { status, result = "" }, expectedVersion = null) {
+      if (!["done", "failed", "needs_input"].includes(status)) return { ok: false, error: "status must be done, failed or needs_input" };
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = @status, result = @result, reported_at = @now, updated_at = @now, version = version + 1,
+          holder = case when @status = 'needs_input' then origin_agent else null end
+        where id = @id and status in ('claimed', 'running') and holder = @agent and (@expected is null or version = @expected)`,
+        { id, agent, status, result, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => ["claimed", "running"].includes(task.status) ? `task is held by ${task.holder}` : task.status === "open" ? "claim the task before reporting on it" : `task is ${task.status}`);
+    },
+    releaseTask(id, agent, expectedVersion = null) {
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = 'open', holder = target_agent, claimed_by = null, claimed_at = null, lease_until = null, result = null, reported_at = null, updated_at = @now, version = version + 1
+        where id = @id and status in ('claimed', 'needs_input') and (origin_agent = @agent or @agent = 'user') and (@expected is null or version = @expected)`,
+        { id, agent, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => ["claimed", "needs_input"].includes(task.status) ? `only ${task.origin_agent} or the user can release this task` : `task is ${task.status}`);
+    },
+    answerTask(id, agent, answer, expectedVersion = null) {
+      if (!String(answer || "").trim()) return { ok: false, error: "an answer is needed" };
+      const now = new Date().toISOString();
+      const written = execute("run", `update board_tasks set status = 'claimed', holder = claimed_by, updated_at = @now, version = version + 1,
+          brief = brief || char(10) || char(10) || 'Question from ' || claimed_by || ': ' || coalesce(result, '') || char(10) || 'Answer from ' || @agent || ': ' || @answer,
+          result = null, reported_at = null
+        where id = @id and status = 'needs_input' and holder = @agent and (@expected is null or version = @expected)`,
+        { id, agent, answer, now, expected: expectedVersion == null ? null : Number(expectedVersion) });
+      if (written.changes === 1) return { ok: true, task: this.getTask(id) };
+      return conflict(this.getTask(id), agent, expectedVersion, (task) => task.status !== "needs_input" ? `task is ${task.status}` : `only ${task.holder} can answer this task`);
     },
     close() {
       for (const statement of statements) {

package/package.json

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