tryharness 0.7.6 → 0.7.8

package/lib/places.mjs

@@ -0,0 +1,297 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn, spawnSync } from "node:child_process";
+
+// Where a coding session runs, and how it opens there again. A session's place comes from its own environment: the
+// Harness piece inside the agent sends it when the session starts (the Claude Code and Codex hooks, nudge.mjs; the
+// opencode plugin; the pi extension), or the daemon reads it from the running process when nothing did. Terminals and
+// editors put their own ids into everything they start, the same on every OS (TERM_PROGRAM, TMUX_PANE, WEZTERM_PANE,
+// KITTY_WINDOW_ID, VSCODE_GIT_ASKPASS_NODE: the editor's own install); macOS adds the app (__CFBundleIdentifier).
+//
+// Any other agent (a custom harness) does the same with one line to the daemon's socket as a session starts:
+//   {"command":"board.live.place","agent":"<its id>","sessionId":"<id>","folder":"<absolute path>","pids":[<its pid>],
+//    "env":{<its environment>},"reopen":{"link":"http://127.0.0.1:<port>/…","command":"<what a person types to resume>"}}
+// `reopen` is optional: a page it serves on this computer opens directly; a command is only ever copied for the person
+// to paste, never run. Only PLACE_ENV is kept of `env`.
+
+const PS = ["/bin/ps", "/usr/bin/ps"].find((file) => fs.existsSync(file)) || "ps";
+
+/** The names a place is read from: nothing else of a session's environment is kept. */
+export const PLACE_ENV = ["__CFBundleIdentifier", "TERM_PROGRAM", "TMUX", "TMUX_PANE", "WEZTERM_PANE", "KITTY_WINDOW_ID", "KITTY_LISTEN_ON", "WT_SESSION", "VSCODE_GIT_ASKPASS_NODE", "CLAUDE_CODE_ENTRYPOINT", "T3CODE_CLI_PATH"];
+
+export function placeEnv(env) {
+  const picked = {};
+  for (const name of PLACE_ENV) if (typeof env?.[name] === "string" && env[name] && env[name].length <= 1024) picked[name] = env[name];
+  return picked;
+}
+
+/** A running process's environment, as far as this OS shows another process's (Linux /proc, macOS ps); {} elsewhere. */
+export function processEnv(pid) {
+  if (!Number.isInteger(pid) || pid <= 1) return {};
+  if (process.platform === "linux") {
+    try {
+      return placeEnv(Object.fromEntries(fs.readFileSync(`/proc/${pid}/environ`, "utf8").split("\0").filter((entry) => entry.includes("="))
+        .map((entry) => [entry.slice(0, entry.indexOf("=")), entry.slice(entry.indexOf("=") + 1)])));
+    } catch { return {}; }
+  }
+  if (process.platform !== "darwin") return {};
+  // `ps eww` prints the command, then each variable as NAME=value, space separated (values may hold spaces).
+  const line = spawnSync(PS, ["eww", "-o", "command=", "-p", String(pid)], { encoding: "utf8", timeout: 3_000 }).stdout || "";
+  const env = {};
+  for (const name of PLACE_ENV) {
+    const found = line.match(new RegExp(`(?:^|\\s)${name}=(.*?)(?=\\s[A-Za-z_][A-Za-z0-9_]*=|\\s*$)`));
+    if (found?.[1]) env[name] = found[1];
+  }
+  return placeEnv(env);
+}
+
+export const appDirs = () => (process.env.HARNESS_APP_DIRS ? process.env.HARNESS_APP_DIRS.split(path.delimiter) : ["/Applications", path.join(os.homedir(), "Applications")]);
+
+// ── Editors built on VS Code ──────────────────────────────────────────────────
+
+/** Each one's app, link scheme, command-line tool, settings folder and extensions folder. */
+const EDITORS = [
+  { id: "cursor", name: "Cursor", bundle: "com.todesktop.230313mzl4w4u92", match: /cursor/i, scheme: "cursor", cli: "cursor", data: "Cursor", extensions: ".cursor" },
+  { id: "windsurf", name: "Windsurf", bundle: "com.exafunction.windsurf", match: /windsurf/i, scheme: "windsurf", cli: "windsurf", data: "Windsurf", extensions: ".windsurf" },
+  { id: "vscode-insiders", name: "Visual Studio Code - Insiders", bundle: "com.microsoft.VSCodeInsiders", match: /insiders/i, scheme: "vscode-insiders", cli: "code-insiders", data: "Code - Insiders", extensions: ".vscode-insiders" },
+  { id: "vscode", name: "Visual Studio Code", bundle: "com.microsoft.VSCode", match: /visual studio code|microsoft vs code|[\\/]code[\\/]/i, scheme: "vscode", cli: "code", data: "Code", extensions: ".vscode" },
+];
+export const EDITOR_IDS = EDITORS.map((editor) => editor.id);
+const editorById = (id) => EDITORS.find((editor) => editor.id === id) ?? null;
+export const editorName = (id) => editorById(id)?.name ?? null;
+
+/** An editor's install with its command-line tool, from a path inside it (or where its installer puts it). */
+export function editorInstall(editorId, hint = "") {
+  const editor = editorById(editorId);
+  if (!editor) return null;
+  const tries = [];
+  const app = String(hint).match(/^(.*?\.app)(?:\/|$)/)?.[1];
+  if (app) tries.push({ app, cli: path.join(app, "Contents", "Resources", "app", "bin", editor.cli) });
+  // Linux and Windows: the editor's executable sits beside its bin folder.
+  else if (hint && path.isAbsolute(hint)) tries.push({ app: path.dirname(hint), cli: path.join(path.dirname(hint), "bin", editor.cli + (process.platform === "win32" ? ".cmd" : "")) });
+  for (const dir of appDirs()) {
+    const at = path.join(dir, `${editor.name}.app`);
+    tries.push({ app: at, cli: path.join(at, "Contents", "Resources", "app", "bin", editor.cli) });
+  }
+  return tries.find((entry) => fs.existsSync(entry.cli)) ?? null;
+}
+
+function editorData(editor) {
+  if (process.env.HARNESS_EDITOR_ROOT) return path.join(process.env.HARNESS_EDITOR_ROOT, editor.data);
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", editor.data);
+  if (process.platform === "win32") return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), editor.data);
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), editor.data);
+}
+
+/** Whether an editor has an extension installed (and not marked for removal). */
+export function editorHas(editorId, extension) {
+  const editor = editorById(editorId);
+  if (!editor) return false;
+  const dir = path.join(process.env.HARNESS_EDITOR_ROOT || os.homedir(), editor.extensions, "extensions");
+  let removed = {};
+  try { removed = JSON.parse(fs.readFileSync(path.join(dir, ".obsolete"), "utf8")); } catch {}
+  try { return fs.readdirSync(dir).some((name) => name.toLowerCase().startsWith(`${extension}-`) && !removed[name]); } catch { return false; }
+}
+
+/**
+ * The folder the person opens in an editor that holds `folder`: the deepest one the editor has a record of (it keeps one
+ * per folder it opened, User/workspaceStorage/<id>/workspace.json), else the folder itself.
+ */
+export function editorFolder(editorId, folder) {
+  const editor = editorById(editorId);
+  if (!editor || !folder) return folder || null;
+  const root = path.join(editorData(editor), "User", "workspaceStorage");
+  let best = null;
+  let dirs = [];
+  try { dirs = fs.readdirSync(root); } catch {}
+  for (const dir of dirs) {
+    let opened;
+    try { opened = fileURLToPath(JSON.parse(fs.readFileSync(path.join(root, dir, "workspace.json"), "utf8")).folder); } catch { continue; }
+    if ((folder === opened || folder.startsWith(opened + path.sep)) && (!best || opened.length > best.length)) best = opened;
+  }
+  return best ?? folder;
+}
+
+/**
+ * The editor's window on a folder comes up, by the editor's own command-line tool: the window that has the folder open,
+ * else a new one on it. No link, so the editor asks nothing; its tool brings itself forward.
+ */
+export function openEditorFolder(place, folder) {
+  if (!place?.cli || !folder || !path.isAbsolute(folder) || !fs.existsSync(place.cli)) return false;
+  const env = { ...process.env };
+  // Not inside one of its terminals: a tool started there would replace that window's folder.
+  delete env.VSCODE_IPC_HOOK_CLI;
+  delete env.ELECTRON_RUN_AS_NODE;
+  const windows = process.platform === "win32";
+  const child = spawn(place.cli, [windows ? `"${folder}"` : folder], { env, detached: !windows, stdio: "ignore", shell: windows });
+  child.on("error", () => {});
+  child.unref();
+  return true;
+}
+
+/** How many times the person started a command in an editor's terminal, by the editor's own record of its last commands. */
+export function editorTerminalStarts(editorId, command) {
+  const editor = editorById(editorId);
+  const db = editor ? path.join(editorData(editor), "User", "globalStorage", "state.vscdb") : null;
+  if (!db || !fs.existsSync(db) || !fs.existsSync(SQLITE)) return 0;
+  const found = spawnSync(SQLITE, ["-readonly", "-cmd", ".timeout 500", db, "select value from ItemTable where key = 'terminal.history.entries.commands';"], { encoding: "utf8", timeout: 3_000 });
+  let entries = [];
+  try { entries = JSON.parse(found.stdout || "{}").entries || []; } catch { return 0; }
+  return entries.filter((entry) => path.basename(String(entry?.key || "").trim().split(/\s+/)[0] || "") === command).length;
+}
+
+// ── The agents ────────────────────────────────────────────────────────────────
+
+/** How each agent picks a session up again; its own panel in an editor, when it has one; its name in T3 Code. */
+const AGENTS = {
+  "claude-code": { command: "claude", resume: "claude --resume", t3: "claudeAgent",
+    panel: { extension: "anthropic.claude-code", link: (scheme, id) => `${scheme}://anthropic.claude-code/open?session=${id}` } },
+  codex: { command: "codex", resume: "codex resume", t3: "codex",
+    panel: { extension: "openai.chatgpt", link: (scheme, id) => `${scheme}://openai.chatgpt/local/${id}` } },
+  pi: { command: "pi", resume: "pi --session" },
+  opencode: { command: "opencode", resume: "opencode --session" },
+};
+export const agentCommand = (agent) => AGENTS[agent]?.command ?? null;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const PLAIN_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const quote = (text) => `'${String(text).replace(/'/g, `'\\''`)}'`;
+
+/** The command a person types to pick a session up again, in its folder. */
+export function resumeLine(agent, sessionId, folder = null) {
+  const resume = AGENTS[agent]?.resume;
+  if (!resume || !PLAIN_ID.test(String(sessionId || ""))) return null;
+  return `${folder && path.isAbsolute(folder) ? `cd ${quote(folder)} && ` : ""}${resume} ${sessionId}`;
+}
+
+/** A session in its agent's own panel in an editor (Claude Code's, OpenAI's Codex extension), when it is installed there. */
+export function panelLink(agent, editorId, sessionId) {
+  const panel = AGENTS[agent]?.panel;
+  const editor = editorById(editorId);
+  if (!panel || !editor || !UUID.test(String(sessionId || "")) || !editorHas(editorId, panel.extension)) return null;
+  return panel.link(editor.scheme, sessionId);
+}
+
+// ── T3 Code ───────────────────────────────────────────────────────────────────
+
+const SQLITE = "/usr/bin/sqlite3";
+const T3_BUNDLE = "com.t3tools.t3code";
+export const t3Home = () => process.env.T3_HOME || path.join(os.homedir(), ".t3", "userdata");
+
+/** T3 Code's state database: 0.0.46 nightlies (Orchestrator V2) keep a copy of their own, statev2.sqlite; the newer file is the one in use. */
+function t3Database(home) {
+  const [found] = ["statev2.sqlite", "state.sqlite"].map((name) => path.join(home, name))
+    .map((file) => { try { return { file, at: fs.statSync(file).mtimeMs }; } catch { return null; } })
+    .filter(Boolean).sort((a, b) => b.at - a.at);
+  return found?.file ?? null;
+}
+function t3Query(home, sql) {
+  const db = t3Database(home);
+  if (!db || !fs.existsSync(SQLITE)) return null;
+  const found = spawnSync(SQLITE, ["-readonly", "-cmd", ".timeout 500", db, sql], { encoding: "utf8", timeout: 3_000 });
+  return found.status === 0 ? (found.stdout || "").trim() : null;
+}
+const t3Tables = (home) => new Set((t3Query(home, "select name from sqlite_master where type = 'table';") || "").split("\n"));
+
+/**
+ * The T3 Code thread that has a provider session: the thread T3 ran it in (nightlies record the session on the thread's
+ * provider thread; 0.0.45 in provider_session_runtime), else T3's import of it.
+ */
+export function t3Thread(sessionId, home = t3Home()) {
+  if (!PLAIN_ID.test(String(sessionId || ""))) return null;
+  const tables = t3Tables(home);
+  // The id is checked above: letters, digits and . _ : - only.
+  const parts = [];
+  if (tables.has("orchestration_v2_projection_provider_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_provider_threads where thread_id is not null and json_extract(payload_json, '$.nativeThreadRef.nativeId') = '${sessionId}'`);
+  if (tables.has("orchestration_v2_projection_threads")) parts.push(`select thread_id, updated_at as at from orchestration_v2_projection_threads where deleted_at is null and thread_id in ('import:claudeAgent:${sessionId}', 'import:codex:${sessionId}')`);
+  else if (tables.has("provider_session_runtime")) parts.push(`select thread_id, last_seen_at as at from provider_session_runtime where thread_id like '%:${sessionId}' or json_extract(resume_cursor_json, '$.resume') = '${sessionId}'`);
+  if (!parts.length) return null;
+  return t3Query(home, `select thread_id from (${parts.join(" union all ")}) order by at desc limit 1;`) || null;
+}
+
+/** T3 Code's own link to one of its threads (t3code://threads/<environment>/<thread>). */
+export function t3Link(threadId, home = t3Home()) {
+  let environment = "";
+  try { environment = fs.readFileSync(path.join(home, "environment-id"), "utf8").trim(); } catch { return null; }
+  return threadId && PLAIN_ID.test(environment) ? `t3code://threads/${environment}/${encodeURIComponent(threadId)}` : null;
+}
+
+/** How many threads the person ran an agent in T3 Code since a time: threads T3 itself ran (an import it never ran is not use). */
+export function t3Runs(agent, sinceIso, home = t3Home()) {
+  const provider = AGENTS[agent]?.t3;
+  if (!provider || !/^[0-9TZ:.-]+$/.test(sinceIso)) return 0;
+  const tables = t3Tables(home);
+  const parts = [];
+  if (tables.has("orchestration_v2_projection_provider_threads")) parts.push(`select thread_id from orchestration_v2_projection_provider_threads where provider = '${provider}' and updated_at > '${sinceIso}'`);
+  if (tables.has("provider_session_runtime")) parts.push(`select thread_id from provider_session_runtime where provider_name = '${provider}' and last_seen_at > '${sinceIso}' and (thread_id not like 'import:%' or resume_cursor_json like '%turnCount%')`);
+  return parts.length ? Number(t3Query(home, `select count(*) from (${parts.join(" union ")});`) || 0) || 0 : 0;
+}
+
+// T3 Code opens thread and prompt links from other apps only in its newer builds (0.0.46 nightlies on); 0.0.45 hands
+// t3code:// links to its sign-in alone. Read once per installed build: its bundle carries the link handler's own error
+// message (code names do not survive its minifier; this text does).
+const t3LinkSupport = new Map();
+export function t3OpensLinks(app) {
+  const archive = path.join(app, "Contents", "Resources", "app.asar");
+  let stamp = "";
+  try { stamp = String(fs.statSync(archive).mtimeMs); } catch { return false; }
+  const known = t3LinkSupport.get(archive);
+  if (known?.stamp === stamp) return known.ok;
+  let ok = false;
+  try { ok = fs.readFileSync(archive).includes("so T3 Code did not open it"); } catch {}
+  t3LinkSupport.set(archive, { stamp, ok });
+  return ok;
+}
+
+/** T3 Code's app: the one running when several builds are installed (stable and nightly side by side), else one that opens links, else any. */
+export function t3App() {
+  const apps = appDirs().flatMap((dir) => { try { return fs.readdirSync(dir).filter((entry) => /^T3 Code\b.*\.app$/.test(entry)).map((entry) => path.join(dir, entry)); } catch { return []; } });
+  if (!apps.length) return null;
+  const running = apps.length > 1 ? spawnSync(PS, ["-axo", "comm="], { encoding: "utf8", maxBuffer: 16 << 20 }).stdout || "" : "";
+  const app = apps.find((candidate) => running.includes(`${candidate}/Contents/MacOS/`)) ?? apps.find((candidate) => t3OpensLinks(candidate)) ?? apps[0];
+  return { name: path.basename(app, ".app"), app };
+}
+
+// ── A place ───────────────────────────────────────────────────────────────────
+
+const TERMINAL_NAMES = { Apple_Terminal: "Terminal", "iTerm.app": "iTerm", WezTerm: "WezTerm", ghostty: "Ghostty", WarpTerminal: "Warp", Hyper: "Hyper", kitty: "kitty", alacritty: "Alacritty" };
+
+/**
+ * Where a session runs, from its environment and the app found up its process tree (`host`, live.mjs hostApp):
+ *   t3        T3 Code;
+ *   editor    an editor built on VS Code: its terminal, or an agent's own panel there ("surface");
+ *   codex-app the Codex app;
+ *   terminal  a terminal app, with the ids that pick its pane on any OS (tmux, WezTerm, kitty) and its tty;
+ *   app       any other app.
+ * The environment comes first: the app a process sits under can be a different one (a terminal started from an editor).
+ */
+export function placeFrom({ env = {}, host = null, tty = null, folder = null }) {
+  const bundle = env.__CFBundleIdentifier || null;
+  const hostName = host?.name ?? "";
+  const editorOf = () => EDITORS.find((editor) => editor.bundle === bundle) ?? EDITORS.find((editor) => editor.match.test(env.VSCODE_GIT_ASKPASS_NODE || ""))
+    ?? (env.TERM_PROGRAM === "vscode" || env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode" ? editorById("vscode") : null);
+  const editorPlace = (editor) => {
+    const install = editorInstall(editor.id, env.VSCODE_GIT_ASKPASS_NODE || host?.app || "");
+    const panel = env.CLAUDE_CODE_ENTRYPOINT === "claude-vscode" || env.TERM_PROGRAM !== "vscode";
+    return { kind: "editor", editor: editor.id, name: editor.name, app: install?.app ?? host?.app ?? null, cli: install?.cli ?? null, surface: panel ? "panel" : "terminal", folder };
+  };
+  if (env.T3CODE_CLI_PATH || bundle === T3_BUNDLE) return { kind: "t3", name: "T3 Code", folder };
+  const editor = editorOf();
+  if (editor) return editorPlace(editor);
+  const ids = { tty,
+    tmux: env.TMUX && /^%\d+$/.test(env.TMUX_PANE || "") ? env.TMUX_PANE : null,
+    wezterm: /^\d+$/.test(env.WEZTERM_PANE || "") ? env.WEZTERM_PANE : null,
+    kitty: /^\d+$/.test(env.KITTY_WINDOW_ID || "") ? { id: env.KITTY_WINDOW_ID, socket: env.KITTY_LISTEN_ON || null } : null };
+  if (env.TERM_PROGRAM && env.TERM_PROGRAM !== "vscode") return { kind: "terminal", name: hostName || TERMINAL_NAMES[env.TERM_PROGRAM] || env.TERM_PROGRAM, app: host?.app ?? null, ...ids, folder };
+  // Nothing in its environment says: the app it runs under.
+  if (/^T3 Code\b/.test(hostName)) return { kind: "t3", name: "T3 Code", folder };
+  const hosted = EDITORS.find((entry) => entry.name === hostName);
+  if (hosted) return editorPlace(hosted);
+  if (hostName === "Codex") return { kind: "codex-app", name: "Codex", app: host.app, folder };
+  if (tty || ids.tmux || ids.wezterm || ids.kitty) return { kind: "terminal", name: hostName || "Terminal", app: host?.app ?? null, ...ids, folder };
+  return host ? { kind: "app", name: hostName, app: host.app, folder } : null;
+}
+
+/** One key per place the person uses an agent in: both T3 builds are T3; an editor's terminal and its panel differ. */
+export const placeKey = (place) => (place.kind === "editor" ? `editor:${place.editor}:${place.surface}` : place.kind === "t3" ? "t3" : `${place.kind}:${place.name}`);

package/lib/runner.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { spawn } from "node:child_process";
 
@@ -27,14 +28,29 @@ export function resolveWorkingDirectory(requested) {
   return requested;
 }
 
+// A run another agent started without the person's tap (docs/member-runs.md): anything that would ask is refused, file
+// edits only in its worktree, shell commands only inside the operating system's sandbox with no network, and no hooks or
+// settings from the repository. A review gets no edits at all.
+export const RESTRICTED_CLAUDE_SETTINGS = {
+  disableAllHooks: true,
+  permissions: { deny: ["WebFetch", "WebSearch"] },
+  sandbox: { enabled: true, autoAllowBashIfSandboxed: true, allowUnsandboxedCommands: false, failIfUnavailable: true, excludedCommands: [], network: { allowedDomains: [], strictAllowlist: true } },
+};
+// Only the Harness board MCP, as Claude Code: none of the person's other MCP servers or claude.ai connectors load.
+export const restrictedMcpConfig = () => ({ mcpServers: { harness: { command: process.execPath, args: [fileURLToPath(new URL("./mcp-stdio.mjs", import.meta.url)), "--agent", "claude-code"] } } });
+const restrictedClaude = (task) => ["--permission-mode", "dontAsk", "--allowedTools", task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
+  "--setting-sources", "user", "--settings", JSON.stringify(RESTRICTED_CLAUDE_SETTINGS), "--strict-mcp-config", "--mcp-config", JSON.stringify(restrictedMcpConfig())];
+
 export function agentInvocation(task) {
   if (task.agent === "claude-code") {
     return {
       command: "claude",
       // A review reads and reports: plan mode lets Claude Code read and run read-only tools but never edit.
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
     };
   }
+  // Only Claude Code has a restricted mode; any other agent's restricted run is refused here, whatever let it start.
+  if (task.restricted) throw new Error(`${task.agent} has no restricted mode; it runs only after the person's Start`);
   if (task.agent === "codex") {
     return {
       command: "codex",
@@ -146,7 +162,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
   let child;
   try {
     child = spawn(invocation.command, invocation.args, { cwd });
-    if (invocation.stdin !== undefined) child.stdin.end(invocation.stdin);
+    child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(slot);
     emit("failed", `Could not start ${task.agent}: ${error.message}`);

package/lib/store.mjs

@@ -78,6 +78,7 @@ export function openStore(file) {
       trust text not null default 'agent',
       origin_chain text not null default '[]',
       usage text,
+      removed_at text,
       created_at text not null,
       updated_at text not null
     );
@@ -208,6 +209,7 @@ export function openStore(file) {
   }
   if (!boardColumns.has("kind") && boardColumns.size) db.exec("alter table board_tasks add column kind text not null default 'task'");
   if (!boardColumns.has("usage") && boardColumns.size) db.exec("alter table board_tasks add column usage text");
+  if (!boardColumns.has("removed_at") && boardColumns.size) db.exec("alter table board_tasks add column removed_at text");
   if (!boardColumns.has("trust") && boardColumns.size) db.exec("alter table board_tasks add column trust text not null default 'agent'; alter table board_tasks add column origin_chain text not null default '[]'");
 
   const statements = [];
@@ -299,6 +301,10 @@ export function openStore(file) {
       });
       return parsed.meta;
     },
+    endedSince(since) {
+      const rows = execute("all", "select status, count(*) as count from board_tasks where kind not in ('goal', 'group') and status in ('done', 'failed', 'unknown') and reported_at >= ? group by status", since);
+      return Object.fromEntries(rows.map((row) => [row.status, Number(row.count)]));
+    },
     counts() {
       const rows = execute("all", "select agent, count(*) as count from sessions group by agent");
       return Object.fromEntries(rows.map((row) => [row.agent, Number(row.count)]));
@@ -453,7 +459,7 @@ export function openStore(file) {
         paused_reason: row.paused_reason, sessions: JSON.parse(row.sessions || "{}"), guests: JSON.parse(row.guests || "[]"), posts: this.roomCount(id), spend: this.goalSpend(id) };
     },
     goals({ all = false } = {}) {
-      return execute("all", `select id from board_tasks where kind = 'goal' ${all ? "" : "and status in ('open', 'paused')"} order by created_at desc limit 50`).map((row) => this.getTask(row.id));
+      return execute("all", `select id from board_tasks where kind = 'goal' and removed_at is null ${all ? "" : "and status in ('open', 'paused')"} order by created_at desc limit 50`).map((row) => this.getTask(row.id));
     },
     setGoalState(id, { status, result, pausedReason, maxPosts }) {
       const now = new Date().toISOString();
@@ -470,6 +476,11 @@ export function openStore(file) {
       const row = execute("all", "select goal_id, guests from board_goals").find((entry) => JSON.parse(entry.guests || "[]").some((guest) => guest.thread === thread));
       return row?.goal_id || null;
     },
+    // At posting only: the task's room is part of how it was posted, not a change anyone races.
+    setParent(id, parentId) {
+      execute("run", "update board_tasks set parent_id = ? where id = ?", parentId, id);
+      return this.getTask(id);
+    },
     setGoalFolder(id, workspace) {
       execute("run", "update board_goals set workspace = ? where goal_id = ?", workspace, id);
     },
@@ -534,7 +545,7 @@ export function openStore(file) {
     },
     // A thread's runs (wakes and jobs), oldest first, for its transcript.
     threadRuns(goalId) {
-      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, usage, created_at, updated_at, reported_at
+      return execute("all", `select id, kind, objective, target_agent, claimed_by, status, holder, result, session_id, run_workspace, run_authorized_at, usage, created_at, updated_at, reported_at
         from board_tasks where parent_id = ? and kind in ('wake', 'task') order by created_at asc`, goalId)
         .map((row) => ({ ...row, usage: row.usage ? JSON.parse(row.usage) : null }));
     },
@@ -549,8 +560,10 @@ export function openStore(file) {
       const row = execute("all", "select goal_id, sessions from board_goals").find((entry) => JSON.parse(entry.sessions || "{}")[agent] === sessionId);
       return row?.goal_id || null;
     },
+    // The rooms an agent's own sessions are told about: threads it was brought into, not every task's room (the daemon
+    // runs those, and the task itself is already on its list).
     activeGoalsFor(agent) {
-      return this.goals().filter((goal) => goal.status === "open" && goal.goal.team.includes(agent));
+      return this.goals().filter((goal) => goal.status === "open" && goal.goal.team.includes(agent) && !this.meta(`task-room:${goal.id}`));
     },
     authorizeGoalRun(id) {
       const now = new Date().toISOString();
@@ -581,6 +594,14 @@ export function openStore(file) {
     setRunSession(id, sessionId) {
       execute("run", "update board_tasks set session_id = ?, updated_at = ? where id = ?", sessionId, new Date().toISOString(), id);
     },
+    // A run the daemon stopped itself for a safety rule (Lid-Closed Mode): the task goes back on the board, still
+    // authorized, and its next run picks up where this one stopped.
+    requeueRun(id) {
+      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, updated_at = @now, version = version + 1
+        where id = @id and status = 'running'`, { id, now });
+      return written.changes === 1 ? { ok: true, task: this.getTask(id) } : { ok: false, error: `task is ${this.getTask(id)?.status ?? "missing"}` };
+    },
     // A daemon restart lost every agent process it was running; those outcomes are unknown, never assumed.
     settleInterruptedRuns() {
       const now = new Date().toISOString();
@@ -744,6 +765,16 @@ export function openStore(file) {
       return { ok: true, thread: this.getThread(taskId), task: this.getTask(taskId) };
     },
     // Messages another person's agent sent on this agent's tasks since it last read the board.
+    lastSeenAt(agent) {
+      return execute("get", "select last_seen_at from board_agents where agent = ?", agent)?.last_seen_at || null;
+    },
+    // Work an agent asked for that finished, failed or came back with a question since it last called the board: how an
+    // asker that cannot be woken (the Claude app, ChatGPT) learns of its answers.
+    finishedFor(agent, since) {
+      return execute("all", `select id, objective, target_agent, claimed_by, status, updated_at from board_tasks
+        where origin_agent = ? and kind = 'task' and removed_at is null and status in ('done', 'failed', 'needs_input') and updated_at > ?
+        order by updated_at desc limit 20`, agent, since || "1970-01-01T00:00:00.000Z");
+    },
     unreadFor(agent) {
       const seen = execute("get", "select last_seen_at from board_agents where agent = ?", agent)?.last_seen_at || "1970-01-01T00:00:00.000Z";
       return execute("all", `select m.task_id, t.objective, m.sender, count(*) as count from board_messages m join board_tasks t on t.id = m.task_id
@@ -789,10 +820,12 @@ export function openStore(file) {
       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 clauses = ["b.removed_at is null"];
       const params = { limit: Math.max(1, Math.min(100, Number(limit) || 20)) };
       if (status) { clauses.push("b.status = @status"); params.status = status; }
       else if (!all) clauses.push("b.status in ('open', 'claimed', 'running', 'needs_input')");
+      // An agent's whole-board list is work, not threads: those it reads as its rooms.
+      if (agent && agent !== "user" && all) clauses.push("b.kind not in ('goal', 'wake')");
       if (agent && !all) {
         clauses.push("b.kind not in ('group', 'goal', 'wake') and (b.target_agent is null or b.target_agent = @agent or b.origin_agent = @agent or b.claimed_by = @agent)");
         params.agent = agent;
@@ -807,6 +840,18 @@ export function openStore(file) {
         from board_tasks b left join board_threads th on th.task_id = b.id ${clauses.length ? `where ${clauses.join(" and ")}` : ""} order by b.created_at desc limit @limit`, params)
         .map((row) => ({ ...row, origin_chain: JSON.parse(row.origin_chain || "[]"), version: Number(row.version), held_messages: Number(row.held_messages), child_count: Number(row.child_count), child_done: Number(row.child_done), stale: row.status === "claimed" && Boolean(row.lease_until) && row.lease_until < now }));
     },
+    // Off the board for good, row kept: unfinished work and its parts close first, so nothing picks them up again.
+    removeTask(id) {
+      const now = new Date().toISOString();
+      const ids = [id, ...execute("all", "select id from board_tasks where parent_id = ?", id).map((row) => row.id)];
+      const running = [];
+      for (const taskId of ids) {
+        if (execute("get", "select 1 from board_tasks where id = ? and status = 'running'", taskId)) running.push(taskId);
+        execute("run", "update board_tasks set status = 'failed', result = 'Removed by you.', holder = null, reported_at = ?, updated_at = ?, version = version + 1 where id = ? and kind != 'goal' and status in ('open', 'claimed', 'needs_input', 'running')", now, now, taskId);
+        execute("run", "update board_tasks set removed_at = ?, updated_at = ? where id = ? and removed_at is null", now, now, taskId);
+      }
+      return { ids, running };
+    },
     getTask(id) {
       const row = execute("get", "select * from board_tasks where id = ?", id);
       if (!row) return null;