@bondsmith/bondsmithd 0.1.14 → 0.1.16

package/dist/index.js

@@ -4,20 +4,23 @@
 import { createServer } from "http";
 import { existsSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { dirname as dirname5, join as join12 } from "path";
+import { dirname as dirname6, join as join13 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/local-agent-protocol/src/session.ts
 var SESSION_STATUSES = ["running", "exited"];
 var AGENT_STATES = ["working", "waiting", "done"];
+var AGENT_IDS = ["claude", "codex", "opencode"];
+var TASK_STATUSES = ["pending", "in_progress", "completed"];
 var MAX_SKIPPED_FILES_REPORTED = 20;
+var MAX_SESSION_PULL_REQUESTS = 20;
 
 // ../../packages/local-agent-protocol/src/messages.ts
 var REPLAYED_COMMAND_MESSAGE = "command already used (replay rejected)";
 var INVALID_MESSAGE_ERROR = "invalid message";
 
 // ../../packages/local-agent-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 17;
+var PROTOCOL_VERSION = 20;
 
 // ../../packages/local-agent-protocol/src/branch-name.ts
 var MAX_BRANCH_NAME_LENGTH = 250;
@@ -184,6 +187,8 @@ var MAX_WIRE_MESSAGE_BYTES = 256 * 1024;
 var MAX_DAEMON_REPLY_BYTES = 200 * 1024;
 var MAX_RANGE_LINES = 500;
 var MAX_PLAN_CHARS = 32 * 1024;
+var MAX_PLAN_TASKS = 50;
+var MAX_TASK_TEXT_CHARS = 120;
 var MAX_TERMINAL_DIMENSION = 1e3;
 var terminalSizeSchema = z3.object({
   cols: z3.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
@@ -204,9 +209,10 @@ var localSessionSchema = z3.object({
   worktreeOf: z3.string().nullable(),
   // .catch(undefined): a state this version doesn't know must never drop the whole session message.
   agentState: z3.enum(AGENT_STATES).nullable().optional().catch(void 0),
+  agent: z3.enum(AGENT_IDS).nullable().optional().catch(void 0),
   worktreeSetupFailed: z3.boolean().optional().catch(void 0),
   worktreeSetupSkipped: z3.array(z3.string().max(300)).max(MAX_SKIPPED_FILES_REPORTED).optional().catch(void 0),
-  headline: z3.string().nullable().optional().catch(void 0)
+  pullRequestUrls: z3.array(z3.string().max(300)).max(MAX_SESSION_PULL_REQUESTS).optional().catch(void 0)
 });
 var workspaceFileEntrySchema = z3.object({
   path: z3.string(),
@@ -317,6 +323,11 @@ var browserMessageSchema = z3.discriminatedUnion("type", [
     sessionId: z3.string(),
     ...terminalSizeSchema.shape
   }),
+  z3.object({
+    type: z3.literal("session.setMouseMode"),
+    sessionId: z3.string(),
+    enabled: z3.boolean()
+  }),
   z3.object({ type: z3.literal("session.stop"), sessionId: z3.string() }),
   z3.object({
     type: z3.literal("workspace.getStatus"),
@@ -381,6 +392,11 @@ var connectionAuthenticationFailureReasonSchema = z3.enum([
   "key_agreement_failed"
 ]);
 var connectionRejectionReasonSchema = z3.enum(["origin_not_allowed", "token_invalid"]);
+var sessionTaskSchema = z3.object({
+  subject: z3.string().max(MAX_TASK_TEXT_CHARS),
+  activeForm: z3.string().max(MAX_TASK_TEXT_CHARS).optional(),
+  status: z3.enum(TASK_STATUSES)
+});
 var daemonMessageSchema = z3.discriminatedUnion("type", [
   z3.object({ type: z3.literal("session.list"), sessions: z3.array(localSessionSchema) }),
   z3.object({
@@ -438,7 +454,8 @@ var daemonMessageSchema = z3.discriminatedUnion("type", [
     type: z3.literal("workspace.plan"),
     sessionId: z3.string(),
     requestId: z3.string(),
-    plan: z3.string().max(MAX_PLAN_CHARS).nullable()
+    plan: z3.string().max(MAX_PLAN_CHARS).nullable(),
+    tasks: z3.array(sessionTaskSchema).max(MAX_PLAN_TASKS).default([])
   }),
   z3.object({
     type: z3.literal("project.pathValidated"),
@@ -527,6 +544,7 @@ var SIGNABLE_ACTIONS = [
   "session.input",
   "session.insertText",
   "session.resize",
+  "session.setMouseMode",
   "session.stop",
   "session.list",
   "workspace.getStatus",
@@ -1035,7 +1053,7 @@ async function callTRPCQuery(baseUrl, procedure, input) {
 // src/pairing/pairing.ts
 var DEFAULT_POLL_INTERVAL_MS = 3e3;
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function ensurePaired(options) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -1173,8 +1191,8 @@ async function bindFirstController(params, response) {
 }
 
 // src/projects/validate-path.ts
-import { stat as stat2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, resolve } from "path";
+import { stat } from "fs/promises";
+import { isAbsolute, resolve } from "path";
 
 // src/sessions/expand-home.ts
 import { homedir } from "os";
@@ -1244,7 +1262,7 @@ function runGitDiffAllowingExitCodes(args, cwd, allowedExitCodes) {
 var GIT_INPUT_TIMEOUT_MS = 3e4;
 async function runGitWithInput(args, cwd, input, options = {}) {
   const { allowedExitCodes = [], timeoutMs = GIT_INPUT_TIMEOUT_MS } = options;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn2("git", [...SAFE_GIT_CONFIG, ...args], { cwd });
     const stdout = [];
     const stderr = [];
@@ -1268,7 +1286,7 @@ async function runGitWithInput(args, cwd, input, options = {}) {
       "close",
       (code) => settle(() => {
         if (code === 0 || code !== null && allowedExitCodes.includes(code)) {
-          resolve2(Buffer.concat(stdout).toString("utf8"));
+          resolve3(Buffer.concat(stdout).toString("utf8"));
           return;
         }
         const message = Buffer.concat(stderr).toString("utf8").trim();
@@ -1279,134 +1297,13 @@ async function runGitWithInput(args, cwd, input, options = {}) {
   });
 }
 
-// src/sessions/files/plan-file.ts
-import { constants as constants2 } from "fs";
-import { open as open2 } from "fs/promises";
+// src/sessions/agent-reports/layout.ts
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-
-// src/sessions/files/read-range.ts
-import { constants } from "fs";
-import { lstat, open, realpath, stat } from "fs/promises";
-import { isAbsolute, join as join2, sep } from "path";
-var MAX_RANGE_FILE_BYTES = 2 * 1024 * 1024;
-var REPLY_ENVELOPE_BYTES = 8 * 1024;
-var BINARY_SNIFF_BYTES = 8e3;
-function fileVersion(stats) {
-  return `${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.ino}`;
-}
-async function locateInside(cwd, path) {
-  if (isAbsolute(path)) return { refused: "not_allowed" };
-  try {
-    const root = await realpath(cwd);
-    const lexical = join2(root, path);
-    if ((await lstat(lexical)).isSymbolicLink()) return { refused: "not_allowed" };
-    const real = await realpath(lexical);
-    return real === root || real.startsWith(root + sep) ? { found: real } : { refused: "missing" };
-  } catch {
-    return { refused: "missing" };
-  }
-}
-async function readExactly(handle, size) {
-  const buffer = Buffer.allocUnsafe(size + 1);
-  let filled = 0;
-  while (filled < buffer.length) {
-    const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
-    if (bytesRead === 0) break;
-    filled += bytesRead;
-  }
-  return filled === size ? buffer.subarray(0, size) : void 0;
-}
-async function currentFileVersion(cwd, path) {
-  const located = await locateInside(cwd, path);
-  if (!("found" in located)) return void 0;
-  try {
-    return fileVersion(await stat(located.found));
-  } catch {
-    return void 0;
-  }
-}
-function splitLines(text) {
-  if (text === "") return [];
-  const lines = text.split("\n");
-  if (lines[lines.length - 1] === "") lines.pop();
-  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
-}
-async function readFileRange(cwd, path, startLine, lineCount, version) {
-  const refuse = (reason) => ({ ok: false, path, reason });
-  const located = await locateInside(cwd, path);
-  if (!("found" in located)) return refuse(located.refused);
-  let content;
-  let handle;
-  try {
-    handle = await open(
-      located.found,
-      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
-    );
-    const before = await handle.stat();
-    if (!before.isFile()) return refuse("not_allowed");
-    if (fileVersion(before) !== version) return refuse("changed");
-    if (before.size > MAX_RANGE_FILE_BYTES) return refuse("too_large");
-    const bytes = await readExactly(handle, before.size);
-    if (bytes === void 0 || fileVersion(await handle.stat()) !== version) {
-      return refuse("changed");
-    }
-    content = bytes;
-  } catch {
-    return refuse("missing");
-  } finally {
-    await handle?.close();
-  }
-  if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return refuse("binary");
-  const lines = splitLines(content.toString("utf8"));
-  const page = [];
-  let budget = MAX_DAEMON_REPLY_BYTES - REPLY_ENVELOPE_BYTES;
-  const wanted = Math.min(lineCount, MAX_RANGE_LINES);
-  for (let index = startLine - 1; index < lines.length && page.length < wanted; index++) {
-    const line = lines[index];
-    const cost = Buffer.byteLength(JSON.stringify(line)) + 1;
-    if (cost > budget) {
-      if (page.length === 0) return refuse("too_large");
-      break;
-    }
-    budget -= cost;
-    page.push(line);
-  }
-  return { ok: true, path, startLine, lines: page, totalLines: lines.length, version };
-}
-
-// src/sessions/files/plan-file.ts
+import { join as join2 } from "path";
+var HOOK_PLANS_DIR = join2(homedir2(), ".bondsmith", "plans");
+var PLAN_FILE_SUFFIX = ".md";
+var TASKS_FILE_SUFFIX = ".tasks.jsonl";
 var PLAN_FILE_PATH = ".bondsmith/plan.md";
-var MAX_PLAN_BYTES = MAX_PLAN_CHARS * 4;
-var ABSENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ELOOP", "ENOTDIR"]);
-var HOOK_PLANS_DIR = join3(homedir2(), ".bondsmith", "plans");
-async function readPlanAt(root, relativePath) {
-  const located = await locateInside(root, relativePath);
-  if (!("found" in located)) return null;
-  let handle;
-  try {
-    handle = await open2(
-      located.found,
-      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
-    );
-    if (!(await handle.stat()).isFile()) return null;
-    const buffer = Buffer.alloc(MAX_PLAN_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, MAX_PLAN_BYTES, 0);
-    const plan = buffer.toString("utf8", 0, bytesRead).trim();
-    return plan ? plan.slice(0, MAX_PLAN_CHARS) : null;
-  } catch (error2) {
-    if (ABSENT_CODES.has(error2.code ?? "")) return null;
-    throw error2;
-  } finally {
-    await handle?.close();
-  }
-}
-function readPlanFile(cwd) {
-  return readPlanAt(cwd, PLAN_FILE_PATH);
-}
-function readHookPlan(sessionId, plansDir = HOOK_PLANS_DIR) {
-  return readPlanAt(plansDir, `${sessionId}.md`);
-}
 
 // src/sessions/tmux/client.ts
 import { execFile as execFileCb2 } from "child_process";
@@ -1454,8 +1351,14 @@ async function runTmux(args, options) {
     throw error2;
   }
 }
-async function sendKeysLiteral(tmuxSessionName, text) {
-  await runTmux(["send-keys", "-t", tmuxSessionName, "-l", text]);
+async function sendKeysLiteral(tmuxSessionName, text2) {
+  await runTmux(["send-keys", "-t", tmuxSessionName, "-l", text2]);
+}
+async function setMouseMode(tmuxSessionName, enabled) {
+  await runTmux(["set-option", "-t", tmuxSessionName, "mouse", enabled ? "on" : "off"]);
+}
+async function cancelCopyMode(tmuxSessionName) {
+  await runTmux(["copy-mode", "-q", "-t", tmuxSessionName]);
 }
 async function capturePane(tmuxSessionName) {
   return runTmux(["capture-pane", "-t", tmuxSessionName, "-p", "-e"]);
@@ -1493,8 +1396,8 @@ var NO_SERVER_MESSAGE_PATTERNS = [
 function isNoServerError(error2) {
   if (typeof error2 !== "object" || error2 === null) return false;
   const { message, stderr } = error2;
-  const text = [message, stderr].filter((part) => typeof part === "string").join("\n");
-  return NO_SERVER_MESSAGE_PATTERNS.some((pattern) => pattern.test(text));
+  const text2 = [message, stderr].filter((part) => typeof part === "string").join("\n");
+  return NO_SERVER_MESSAGE_PATTERNS.some((pattern) => pattern.test(text2));
 }
 
 // src/sessions/git/base.ts
@@ -1531,14 +1434,14 @@ async function resolveComparisonBase(cwd) {
 }
 
 // src/sessions/git/baseline.ts
-import { lstat as lstat2 } from "fs/promises";
-import { join as join4 } from "path";
+import { lstat } from "fs/promises";
+import { join as join3 } from "path";
 var SESSION_START_REF = "session start";
 var MAX_PREEXISTING_FILES = 200;
 var DELETED = "deleted";
 async function fingerprintFile(cwd, path) {
   try {
-    const stats = await lstat2(join4(cwd, path));
+    const stats = await lstat(join3(cwd, path));
     return `${stats.size}:${Math.trunc(stats.mtimeMs)}`;
   } catch {
     return DELETED;
@@ -1862,23 +1765,23 @@ function gitFailure(error2, path) {
       "git isn't installed, or isn't on the PATH of the terminal running bondsmithd."
     );
   }
-  const text = typeof stderr === "string" ? stderr : "";
-  if (text.includes("dubious ownership")) {
+  const text2 = typeof stderr === "string" ? stderr : "";
+  if (text2.includes("dubious ownership")) {
     return new Error(
       `git doesn't trust this folder because another user owns it. If you trust it, run: git config --global --add safe.directory ${shellQuote(path)}`
     );
   }
-  const fatal = text.split("\n").find((line) => line.startsWith("fatal:"));
+  const fatal = text2.split("\n").find((line) => line.startsWith("fatal:"));
   return new Error(
     fatal ?? (error2 instanceof Error ? error2.message : "git failed to inspect that folder.")
   );
 }
 async function validateProjectPath(input) {
   const expanded = expandHome(input.trim());
-  if (!isAbsolute2(expanded)) return { valid: false, reason: "relative_path" };
+  if (!isAbsolute(expanded)) return { valid: false, reason: "relative_path" };
   const path = resolve(expanded);
   try {
-    const stats = await stat2(path);
+    const stats = await stat(path);
     if (!stats.isDirectory()) return { valid: false, reason: "not_a_directory" };
   } catch (error2) {
     const reason = invalidReasonForFsError(error2);
@@ -1905,7 +1808,7 @@ import { randomBytes, verify as verify2 } from "crypto";
 // src/security/trusted-controllers.ts
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname, join as join5 } from "path";
+import { dirname, join as join4 } from "path";
 import { z as z12 } from "zod";
 var trustedControllerSchema = z12.object({
   id: z12.string(),
@@ -1928,7 +1831,7 @@ var trustedControllersFileSchema = z12.object({
   controllers: z12.array(trustedControllerSchema)
 });
 function defaultTrustedControllersPath() {
-  return join5(homedir3(), ".bondsmith", "trusted-controllers.json");
+  return join4(homedir3(), ".bondsmith", "trusted-controllers.json");
 }
 async function loadTrustedControllers(path = defaultTrustedControllersPath()) {
   let raw;
@@ -2249,12 +2152,12 @@ var ConnectionAuthState = class {
 };
 
 // src/sessions/agents/installed-agents.ts
-import { accessSync, constants as constants3, statSync } from "fs";
-import { delimiter, join as join6 } from "path";
-var KNOWN_AGENTS = ["claude", "codex", "opencode"];
+import { accessSync, constants, statSync } from "fs";
+import { delimiter, join as join5 } from "path";
+var KNOWN_AGENTS = AGENT_IDS;
 function isExecutableFile(path) {
   try {
-    accessSync(path, constants3.X_OK);
+    accessSync(path, constants.X_OK);
     return statSync(path).isFile();
   } catch {
     return false;
@@ -2263,12 +2166,12 @@ function isExecutableFile(path) {
 function listInstalledAgents(env = process.env) {
   const directories = (env.PATH ?? "").split(delimiter).filter((directory) => directory !== "");
   return KNOWN_AGENTS.filter(
-    (agent) => directories.some((directory) => isExecutableFile(join6(directory, agent)))
+    (agent) => directories.some((directory) => isExecutableFile(join5(directory, agent)))
   );
 }
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.14" : "dev";
+var DAEMON_VERSION = true ? "0.1.16" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -2277,6 +2180,241 @@ function isVersionRequest(argv) {
   return argv.some((arg) => VERSION_FLAGS.includes(arg));
 }
 
+// src/sessions/agent-reports/read-file.ts
+import { constants as constants3 } from "fs";
+import { open as open2 } from "fs/promises";
+
+// src/sessions/files/read-range.ts
+import { constants as constants2 } from "fs";
+import { lstat as lstat2, open, realpath, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join6, sep } from "path";
+var MAX_RANGE_FILE_BYTES = 2 * 1024 * 1024;
+var REPLY_ENVELOPE_BYTES = 8 * 1024;
+var BINARY_SNIFF_BYTES = 8e3;
+function fileVersion(stats) {
+  return `${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.ino}`;
+}
+async function locateInside(cwd, path) {
+  if (isAbsolute2(path)) return { refused: "not_allowed" };
+  try {
+    const root = await realpath(cwd);
+    const lexical = join6(root, path);
+    if ((await lstat2(lexical)).isSymbolicLink()) return { refused: "not_allowed" };
+    const real = await realpath(lexical);
+    return real === root || real.startsWith(root + sep) ? { found: real } : { refused: "missing" };
+  } catch {
+    return { refused: "missing" };
+  }
+}
+async function readExactly(handle, size) {
+  const buffer = Buffer.allocUnsafe(size + 1);
+  let filled = 0;
+  while (filled < buffer.length) {
+    const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
+    if (bytesRead === 0) break;
+    filled += bytesRead;
+  }
+  return filled === size ? buffer.subarray(0, size) : void 0;
+}
+async function currentFileVersion(cwd, path) {
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return void 0;
+  try {
+    return fileVersion(await stat2(located.found));
+  } catch {
+    return void 0;
+  }
+}
+function splitLines(text2) {
+  if (text2 === "") return [];
+  const lines = text2.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+async function readFileRange(cwd, path, startLine, lineCount, version) {
+  const refuse = (reason) => ({ ok: false, path, reason });
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return refuse(located.refused);
+  let content;
+  let handle;
+  try {
+    handle = await open(
+      located.found,
+      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
+    );
+    const before = await handle.stat();
+    if (!before.isFile()) return refuse("not_allowed");
+    if (fileVersion(before) !== version) return refuse("changed");
+    if (before.size > MAX_RANGE_FILE_BYTES) return refuse("too_large");
+    const bytes = await readExactly(handle, before.size);
+    if (bytes === void 0 || fileVersion(await handle.stat()) !== version) {
+      return refuse("changed");
+    }
+    content = bytes;
+  } catch {
+    return refuse("missing");
+  } finally {
+    await handle?.close();
+  }
+  if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return refuse("binary");
+  const lines = splitLines(content.toString("utf8"));
+  const page = [];
+  let budget = MAX_DAEMON_REPLY_BYTES - REPLY_ENVELOPE_BYTES;
+  const wanted = Math.min(lineCount, MAX_RANGE_LINES);
+  for (let index = startLine - 1; index < lines.length && page.length < wanted; index++) {
+    const line = lines[index];
+    const cost = Buffer.byteLength(JSON.stringify(line)) + 1;
+    if (cost > budget) {
+      if (page.length === 0) return refuse("too_large");
+      break;
+    }
+    budget -= cost;
+    page.push(line);
+  }
+  return { ok: true, path, startLine, lines: page, totalLines: lines.length, version };
+}
+
+// src/sessions/agent-reports/read-file.ts
+var ABSENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ELOOP", "ENOTDIR"]);
+async function readFileAt(root, relativePath, read) {
+  const located = await locateInside(root, relativePath);
+  if (!("found" in located)) return null;
+  let handle;
+  try {
+    handle = await open2(
+      located.found,
+      constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
+    );
+    const info = await handle.stat();
+    if (!info.isFile()) return null;
+    return await read(handle, info.size);
+  } catch (error2) {
+    if (ABSENT_CODES.has(error2.code ?? "")) return null;
+    throw error2;
+  } finally {
+    await handle?.close();
+  }
+}
+
+// src/sessions/agent-reports/task-list.ts
+import { z as z13 } from "zod";
+var text = z13.string().refine((value) => value.trim() !== "");
+var optionalText = text.optional().catch(void 0);
+var taskStatus = z13.enum(TASK_STATUSES).optional().catch(void 0);
+var taskId = z13.union([z13.string(), z13.number()]).transform(String);
+var taskEventSchema = z13.discriminatedUnion("op", [
+  z13.object({
+    op: z13.literal("add"),
+    id: taskId.optional().catch(void 0),
+    subject: text,
+    activeForm: optionalText
+  }),
+  z13.object({
+    op: z13.literal("update"),
+    id: taskId,
+    subject: optionalText,
+    activeForm: optionalText,
+    status: taskStatus
+  }),
+  z13.object({ op: z13.literal("remove"), id: taskId }),
+  z13.object({ op: z13.literal("replace"), tasks: z13.array(z13.unknown()) })
+]);
+var replacementTaskSchema = z13.object({
+  subject: text,
+  activeForm: optionalText,
+  status: taskStatus
+});
+function applyEvent(tasks, event) {
+  switch (event.op) {
+    case "replace":
+      return event.tasks.flatMap((candidate) => {
+        const task = replacementTaskSchema.safeParse(candidate);
+        if (!task.success) return [];
+        const { subject, activeForm, status = "pending" } = task.data;
+        return [{ id: null, subject, activeForm, status }];
+      });
+    case "add":
+      return [
+        ...tasks,
+        {
+          id: event.id ?? null,
+          subject: event.subject,
+          activeForm: event.activeForm,
+          status: "pending"
+        }
+      ];
+    case "update":
+      return tasks.map(
+        (task) => task.id === event.id ? {
+          ...task,
+          subject: event.subject ?? task.subject,
+          activeForm: event.activeForm ?? task.activeForm,
+          status: event.status ?? task.status
+        } : task
+      );
+    case "remove":
+      return tasks.filter((task) => task.id !== event.id);
+  }
+}
+var cut = (value) => value.slice(0, MAX_TASK_TEXT_CHARS);
+function replayTasks(log) {
+  let tasks = [];
+  for (const line of log.split("\n")) {
+    if (!line.trim()) continue;
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const event = taskEventSchema.safeParse(raw);
+    if (event.success) tasks = applyEvent(tasks, event.data);
+  }
+  return tasks.slice(0, MAX_PLAN_TASKS).map(({ subject, activeForm, status }) => ({
+    subject: cut(subject),
+    ...activeForm && { activeForm: cut(activeForm) },
+    status
+  }));
+}
+
+// src/sessions/agent-reports/readers.ts
+var MAX_PLAN_BYTES = MAX_PLAN_CHARS * 4;
+var MAX_TASK_LOG_BYTES = 1024 * 1024;
+async function readPlanAt(root, relativePath) {
+  const text2 = await readFileAt(root, relativePath, async (handle) => {
+    const buffer = Buffer.alloc(MAX_PLAN_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, MAX_PLAN_BYTES, 0);
+    return buffer.toString("utf8", 0, bytesRead).trim();
+  });
+  return text2 ? text2.slice(0, MAX_PLAN_CHARS) : null;
+}
+function readPlanFile(cwd) {
+  return readPlanAt(cwd, PLAN_FILE_PATH);
+}
+function readHookPlan(sessionId, plansDir = HOOK_PLANS_DIR) {
+  return readPlanAt(plansDir, `${sessionId}${PLAN_FILE_SUFFIX}`);
+}
+async function readHookTasks(sessionId, plansDir = HOOK_PLANS_DIR) {
+  const log = await readFileAt(
+    plansDir,
+    `${sessionId}${TASKS_FILE_SUFFIX}`,
+    async (handle, size) => {
+      const length = Math.min(size, MAX_TASK_LOG_BYTES);
+      const buffer = Buffer.alloc(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, size - length);
+      const text2 = buffer.toString("utf8", 0, bytesRead);
+      return length < size ? text2.slice(text2.indexOf("\n") + 1) : text2;
+    }
+  );
+  return log === null ? [] : replayTasks(log);
+}
+
+// src/sessions/agent-reports/session-report.ts
+async function readSessionReport(session) {
+  const plan = await readHookPlan(session.id) ?? await readPlanFile(session.cwd) ?? await getSessionPlan(session.tmuxSessionName);
+  return { plan, tasks: await readHookTasks(session.id) };
+}
+
 // src/security/verify-command.ts
 import { verify as verify3 } from "crypto";
 var ENVELOPE_MAX_AGE_MS = 6e4;
@@ -2413,8 +2551,8 @@ function createOutputPacer(options) {
 
 // src/ws/sanitize-insert-text.ts
 var DISALLOWED_CHARACTERS = /[\x00-\x08\x0b-\x1f\x7f-\x9f‪-‮⁦-⁩]/g;
-function sanitizeInsertText(text) {
-  const withLineFeeds = text.replace(/\r\n?/g, "\n");
+function sanitizeInsertText(text2) {
+  const withLineFeeds = text2.replace(/\r\n?/g, "\n");
   const sanitized = withLineFeeds.replace(DISALLOWED_CHARACTERS, "");
   return { text: sanitized, strippedCount: withLineFeeds.length - sanitized.length };
 }
@@ -2445,6 +2583,7 @@ function verifyRejectionMessage(reason) {
 var REVOKED_REJECTION_MESSAGE = "connection has not completed its handshake";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
+var WHEEL_ONLY_INPUT = /^(?:\x1b\[<6[45];\d+;\d+M)+$/;
 function releaseSession(conn, ptyAttachments, sessionId) {
   const listener = conn.getOutputListener(sessionId);
   if (listener) ptyAttachments.release(sessionId, listener);
@@ -2458,6 +2597,7 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
   let admissionChain = Promise.resolve();
   const conn = {
     subscriptions: /* @__PURE__ */ new Set(),
+    mouseModeSessions: /* @__PURE__ */ new Map(),
     send,
     bufferedBytes,
     isClosed: () => closed,
@@ -2496,6 +2636,11 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
     for (const sessionId of [...conn.subscriptions]) {
       releaseSession(conn, ptyAttachments, sessionId);
     }
+    for (const tmuxSessionName of conn.mouseModeSessions.values()) {
+      setMouseMode(tmuxSessionName, false).catch(() => {
+      });
+    }
+    conn.mouseModeSessions.clear();
   }
   return { conn, releaseAllSubscriptions };
 }
@@ -2729,6 +2874,11 @@ async function dispatch(conn, message, {
         return;
       }
       sessionManager.acknowledge(message.sessionId);
+      const tmuxSessionName = conn.mouseModeSessions.get(message.sessionId);
+      if (tmuxSessionName && !WHEEL_ONLY_INPUT.test(message.data)) {
+        await cancelCopyMode(tmuxSessionName).catch(() => {
+        });
+      }
       ptyAttachments.write(message.sessionId, message.data);
       return;
     }
@@ -2736,14 +2886,14 @@ async function dispatch(conn, message, {
       const session = getSessionOrError(sessionManager, conn, message.sessionId);
       if (!session) return;
       sessionManager.acknowledge(message.sessionId);
-      const { text, strippedCount } = sanitizeInsertText(message.text);
+      const { text: text2, strippedCount } = sanitizeInsertText(message.text);
       if (strippedCount > 0) {
         console.warn(`bondsmithd: stripped ${strippedCount} control characters from inserted text`);
       }
       try {
         await sendKeysLiteral(
           session.tmuxSessionName,
-          `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`
+          `${BRACKETED_PASTE_START}${text2}${BRACKETED_PASTE_END}`
         );
       } catch (err) {
         conn.send(error(errorMessageOf(err, "failed to insert text")));
@@ -2759,6 +2909,20 @@ async function dispatch(conn, message, {
       ptyAttachments.resize(message.sessionId, message.cols, message.rows);
       return;
     }
+    case "session.setMouseMode": {
+      const session = sessionManager.get(message.sessionId);
+      if (!session) return;
+      if (message.enabled) conn.mouseModeSessions.set(session.id, session.tmuxSessionName);
+      else conn.mouseModeSessions.delete(session.id);
+      try {
+        await setMouseMode(session.tmuxSessionName, message.enabled);
+        if (message.enabled && conn.isClosed()) await setMouseMode(session.tmuxSessionName, false);
+      } catch (err) {
+        if (message.enabled) conn.mouseModeSessions.delete(session.id);
+        console.warn(`bondsmithd: ${errorMessageOf(err, "failed to set mouse mode")}`);
+      }
+      return;
+    }
     case "session.stop": {
       try {
         if (!await sessionManager.stop(message.sessionId)) {
@@ -2840,12 +3004,13 @@ async function dispatch(conn, message, {
       const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
       if (!session) return;
       try {
-        const plan = await readHookPlan(session.id) ?? await readPlanFile(session.cwd) ?? await getSessionPlan(session.tmuxSessionName);
+        const { plan, tasks } = await readSessionReport(session);
         conn.send({
           type: "workspace.plan",
           sessionId: message.sessionId,
           requestId: message.requestId,
-          plan
+          plan,
+          tasks
         });
       } catch (err) {
         conn.send(error(errorMessageOf(err, "failed to read the session plan"), message.requestId));
@@ -3279,9 +3444,9 @@ function isMatchingKeyPair(publicKeyPem, privateKeyPem) {
     return false;
   }
 }
-function extractPemBlock(text, label) {
+function extractPemBlock(text2, label) {
   const pattern = new RegExp(`-----BEGIN ${label}-----[\\s\\S]*?-----END ${label}-----\\n?`);
-  return text.match(pattern)?.[0] ?? null;
+  return text2.match(pattern)?.[0] ?? null;
 }
 
 // src/security/daemon-proof.ts
@@ -3420,8 +3585,8 @@ var PendingAuthorizationStore = class {
       requestToken: randomUUID()
     };
     let settleFn;
-    const resultPromise = new Promise((resolve2) => {
-      settleFn = resolve2;
+    const resultPromise = new Promise((resolve3) => {
+      settleFn = resolve3;
     });
     const entry = {
       authorization,
@@ -3532,16 +3697,16 @@ var PendingAuthorizationStore = class {
 };
 
 // src/security/revocation-sync.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var POLL_INTERVAL_MS = 3e4;
 var POLL_JITTER_MS = 6e3;
 var POLL_REQUEST_TIMEOUT_MS = 1e4;
 var BACKOFF_BASE_MS = 2e3;
 var BACKOFF_MAX_MS = 2e4;
 var MAX_CONSECUTIVE_FAILURE_BACKOFFS = 4;
-var checkRevocationStatusResponseSchema = z13.object({
-  pairingRevoked: z13.boolean(),
-  revokedControllerPublicKeys: z13.array(z13.string())
+var checkRevocationStatusResponseSchema = z14.object({
+  pairingRevoked: z14.boolean(),
+  revokedControllerPublicKeys: z14.array(z14.string())
 });
 function jitteredInterval(deps) {
   const interval = deps.pollIntervalMs ?? POLL_INTERVAL_MS;
@@ -3891,6 +4056,45 @@ ${new TmuxNotFoundError().message}
 // src/sessions/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
 
+// src/sessions/agent-reports/lifecycle.ts
+import { readdir, rm as rm4, stat as stat3 } from "fs/promises";
+import { basename, join as join9 } from "path";
+var SWEEP_MIN_AGE_MS = 6e4;
+async function removeHookPlanFiles(sessionId, plansDir = HOOK_PLANS_DIR) {
+  await Promise.all(
+    [PLAN_FILE_SUFFIX, TASKS_FILE_SUFFIX].map(
+      (suffix) => rm4(join9(plansDir, `${basename(sessionId)}${suffix}`), { force: true })
+    )
+  );
+}
+function hookFileSessionId(name) {
+  for (const suffix of [PLAN_FILE_SUFFIX, TASKS_FILE_SUFFIX]) {
+    const sessionId = name.endsWith(suffix) ? name.slice(0, -suffix.length) : "";
+    if (sessionId && !sessionId.includes(".")) return sessionId;
+  }
+  return null;
+}
+async function sweepOrphanedHookPlanFiles(liveSessionIds, plansDir = HOOK_PLANS_DIR) {
+  let names;
+  try {
+    names = await readdir(plansDir);
+  } catch (error2) {
+    if (ABSENT_CODES.has(error2.code ?? "")) return;
+    throw error2;
+  }
+  const now = Date.now();
+  await Promise.all(
+    names.map(async (name) => {
+      const sessionId = hookFileSessionId(name);
+      if (sessionId === null || liveSessionIds.has(sessionId)) return;
+      const path = join9(plansDir, name);
+      const modifiedMs = await stat3(path).then((info) => info.mtimeMs).catch(() => null);
+      if (modifiedMs === null || now - modifiedMs < SWEEP_MIN_AGE_MS) return;
+      await rm4(path, { force: true });
+    })
+  );
+}
+
 // src/sessions/git/worktree.ts
 import { execFile as execFileCb3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -3989,19 +4193,18 @@ function decodeSkippedFiles(raw) {
 
 // src/sessions/tmux/agent-state.ts
 var AGENT_STATE_OPTION = "@bondsmith-agent-state";
-var HEADLINE_OPTION = "@bondsmith-headline";
-var MAX_HEADLINE_CHARS = 200;
-var LIVE_SESSION_REPORTS_FORMAT = `#{session_name}	#{${AGENT_STATE_OPTION}}	#{window_bell_flag}	#{${SETUP_FAILED_OPTION}}	#{${SETUP_SKIPPED_OPTION}}	#{${HEADLINE_OPTION}}`;
+var PULL_REQUESTS_OPTION = "@bondsmith-prs";
+var PULL_REQUEST_URL = /https?:\/\/[^\s/]+\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
+var LIVE_SESSION_REPORTS_FORMAT = `#{session_name}	#{${AGENT_STATE_OPTION}}	#{window_bell_flag}	#{${SETUP_FAILED_OPTION}}	#{${SETUP_SKIPPED_OPTION}}	#{${PULL_REQUESTS_OPTION}}`;
 var AGENT_STATE_OUTPUT_GRACE_MS = 2e3;
 var FUTURE_REPORT_ALLOWANCE_MS = 2e3;
 var WORKING_SILENCE_MS = 12e4;
 var SETTLE_QUIET_MS = 8e3;
 var ACKNOWLEDGE_GRACE_MS = 3e3;
 var SETTLED_STATES = /* @__PURE__ */ new Set(["waiting", "done"]);
-function cleanHeadline(raw) {
-  const line = raw.replace(/\s+/g, " ").trim();
-  if (!line) return null;
-  return line.length > MAX_HEADLINE_CHARS ? `${line.slice(0, MAX_HEADLINE_CHARS - 1)}\u2026` : line;
+function parsePullRequestUrls(raw) {
+  const urls = [...new Set(raw.match(PULL_REQUEST_URL) ?? [])];
+  return urls.slice(-MAX_SESSION_PULL_REQUESTS);
 }
 function isAgentState(value) {
   return AGENT_STATES.includes(value);
@@ -4015,7 +4218,7 @@ function parseLiveSessionReports(output) {
       bell = "",
       setupFailed = "",
       setupSkipped = "",
-      ...headline
+      pullRequests = ""
     ] = line.split("	");
     if (sessionName) {
       reports.set(sessionName, {
@@ -4023,17 +4226,22 @@ function parseLiveSessionReports(output) {
         bell: bell === "1",
         setupFailed: setupFailed === "1",
         setupSkipped: decodeSkippedFiles(setupSkipped),
-        headline: cleanHeadline(headline.join(" "))
+        pullRequestUrls: parsePullRequestUrls(pullRequests)
       });
     }
   }
   return reports;
 }
-function resolveAgentState(raw, lastActivityAt, nowMs = Date.now()) {
+function parseReport(raw) {
   if (!raw) return null;
   const [state, epoch] = raw.split(":");
   if (!state || !isAgentState(state) || !epoch || !/^\d+$/.test(epoch)) return null;
-  const reportedAtMs = Number(epoch) * 1e3;
+  return { state, reportedAtMs: Number(epoch) * 1e3 };
+}
+function resolveAgentState(raw, lastActivityAt, nowMs = Date.now()) {
+  const parsed = parseReport(raw);
+  if (!parsed) return null;
+  const { state, reportedAtMs } = parsed;
   if (reportedAtMs > nowMs + FUTURE_REPORT_ALLOWANCE_MS) return null;
   if (SETTLED_STATES.has(state) && lastActivityAt) {
     if (Date.parse(lastActivityAt) > reportedAtMs + AGENT_STATE_OUTPUT_GRACE_MS) return null;
@@ -4053,79 +4261,137 @@ function hasSettled(lastActivityAt, acknowledgedAtMs, nowMs = Date.now()) {
   }
   return nowMs - lastActivityMs >= SETTLE_QUIET_MS;
 }
+var REPORT_ROUNDING_MS = 1e3;
+function isDoneAcknowledged(raw, acknowledgedAtMs) {
+  const reportedAtMs = parseReport(raw)?.reportedAtMs;
+  if (acknowledgedAtMs === null || reportedAtMs === void 0) return false;
+  return acknowledgedAtMs >= reportedAtMs + REPORT_ROUNDING_MS;
+}
 function resolveSessionAttention(report, lastActivityAt, { nowMs, acknowledgedAtMs = null } = {}) {
   if (report?.bell) return "waiting";
   const reported = resolveAgentState(report?.agentState, lastActivityAt, nowMs);
+  if (reported === "done" && isDoneAcknowledged(report?.agentState, acknowledgedAtMs)) return null;
   if (reported) return reported;
   return hasSettled(lastActivityAt, acknowledgedAtMs, nowMs) ? "waiting" : null;
 }
 
 // src/sessions/tmux/create.ts
 import { access } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
 
-// src/sessions/agents/claude-hooks.ts
+// src/sessions/agents/adapter.ts
+var ENV_ASSIGNMENT_WORD = String.raw`\w+=\S*`;
+var ENV_ASSIGNMENT = new RegExp(`^${ENV_ASSIGNMENT_WORD}$`);
+function leadingBinary(command) {
+  return command.split(/\s+/).filter(Boolean).find((word) => !ENV_ASSIGNMENT.test(word));
+}
+function plainAdapter(id) {
+  return {
+    id,
+    matches: (command) => leadingBinary(command) === id,
+    prepareCommand: async (command) => command
+  };
+}
+
+// src/sessions/agents/claude/hooks.ts
 import { execFile as execFile4 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir4, rename as rename4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir4, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { promisify as promisify4 } from "util";
 
 // src/sessions/session-env.ts
 var SESSION_ENV_VAR = "BONDSMITH_SESSION";
 
-// src/sessions/agents/claude-hook-scripts.ts
-var REPLY_ONLY_PROMPT = /^(y|yes|yep|yeah|no|nope|ok|okay|k|sure|go|go on|go ahead|continue|proceed|thanks|thank you|thx|done|great|nice|cool|lgtm)[.!\s]*$/i;
-var MIN_HEADLINE_CHARS = 4;
-function planHookScript(plansDir) {
+// src/sessions/agent-reports/hook-scripts.ts
+function storePlanScript(plansDir, planExpr) {
   return [
     `let d="";`,
     `process.stdin.on("data",c=>d+=c).on("end",()=>{try{`,
-    `const p=JSON.parse(d).tool_response?.plan;if(!p)return;`,
+    `const j=JSON.parse(d),p=${planExpr};if(typeof p!=="string"||!p)return;`,
     `const fs=require("fs"),path=require("path"),dir=${JSON.stringify(plansDir)};`,
     // basename keeps an odd session value from naming a file outside the plans folder.
-    `const name=path.basename(process.env.${SESSION_ENV_VAR})+".md",tmp=path.join(dir,"."+name+"."+process.pid);`,
+    `const name=path.basename(process.env.${SESSION_ENV_VAR})+${JSON.stringify(PLAN_FILE_SUFFIX)},tmp=path.join(dir,"."+name+"."+process.pid);`,
     // Written aside and renamed: a reader never sees half a plan, and a symlink in the way is replaced, not followed.
     `fs.mkdirSync(dir,{recursive:true,mode:0o700});`,
     `fs.writeFileSync(tmp,p,{mode:0o600});fs.renameSync(tmp,path.join(dir,name))`,
     `}catch{}})`
   ].join("");
 }
-function headlineHookScript() {
+function appendTaskEventScript(plansDir, eventExpr) {
+  return [
+    `let d="";`,
+    `process.stdin.on("data",c=>d+=c).on("end",()=>{try{`,
+    `const j=JSON.parse(d),e=${eventExpr};if(!e)return;`,
+    `const fs=require("fs"),path=require("path"),dir=${JSON.stringify(plansDir)},c=fs.constants;`,
+    `fs.mkdirSync(dir,{recursive:true,mode:0o700});`,
+    // O_NOFOLLOW so a symlink in the way is refused rather than written through.
+    `const fd=fs.openSync(path.join(dir,path.basename(process.env.${SESSION_ENV_VAR})+${JSON.stringify(TASKS_FILE_SUFFIX)}),c.O_WRONLY|c.O_APPEND|c.O_CREAT|c.O_NOFOLLOW,0o600);`,
+    `try{fs.writeSync(fd,JSON.stringify(e)+"\\n")}finally{fs.closeSync(fd)}`,
+    `}catch{}})`
+  ].join("");
+}
+var PR_CREATE_MENTION = "gh pr create";
+var PR_CREATE_COMMAND = /(?:^|[;&|\n(])\s*(?:\w+=\S*\s+)*gh\s+pr\s+create\b/;
+function recordPullRequestScript(commandExpr, outputExpr) {
   return [
     `let d="";`,
     `process.stdin.on("data",c=>d+=c).on("end",()=>{try{`,
-    `const p=JSON.parse(d).prompt;if(typeof p!=="string")return;`,
-    `const t=p.replace(/\\s+/g," ").trim();`,
-    `if(t.length<${MIN_HEADLINE_CHARS}||${REPLY_ONLY_PROMPT.toString()}.test(t))return;`,
-    `const h=t.length>${MAX_HEADLINE_CHARS}?t.slice(0,${MAX_HEADLINE_CHARS - 1})+"\\u2026":t;`,
-    // execFileSync takes the text as an argument, so the prompt is never parsed by a shell.
-    `require("child_process").execFileSync("tmux",["set-option","-t",process.env.TMUX_PANE,"-q","${HEADLINE_OPTION}",h])`,
+    `const j=JSON.parse(d),c=${commandExpr},o=${outputExpr};`,
+    `if(typeof c!=="string"||typeof o!=="string"||!${PR_CREATE_COMMAND.toString()}.test(c))return;`,
+    `const m=o.match(${PULL_REQUEST_URL.toString()});if(!m)return;const u=m[m.length-1];`,
+    `const cp=require("child_process"),p=process.env.TMUX_PANE;`,
+    `const cur=cp.execFileSync("tmux",["show-options","-qv","-t",p,"${PULL_REQUESTS_OPTION}"],{encoding:"utf8"}).split(/\\s+/).filter(Boolean);`,
+    `if(cur.includes(u))return;`,
+    `cp.execFileSync("tmux",["set-option","-t",p,"-q","${PULL_REQUESTS_OPTION}",cur.concat(u).slice(-${MAX_SESSION_PULL_REQUESTS}).join(" ")])`,
     `}catch{}})`
   ].join("");
 }
 
-// src/sessions/agents/claude-settings.ts
+// src/sessions/agent-reports/hook-commands.ts
 function shellQuote3(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function nodeHookCommand(script, nodePath) {
   return `[ -n "$${SESSION_ENV_VAR}" ] && ${shellQuote3(nodePath)} -e ${shellQuote3(script)}; exit 0`;
 }
+function recordPullRequestCommand(script, nodePath) {
+  const run = `${shellQuote3(nodePath)} -e ${shellQuote3(script)}`;
+  return `[ -n "$${SESSION_ENV_VAR}" ] && { input=$(cat); case "$input" in *"${PR_CREATE_MENTION}"*) printf '%s' "$input" | ${run};; esac; }; exit 0`;
+}
+function stateHookCommand(state) {
+  return `[ -n "$${SESSION_ENV_VAR}" ] && tmux set-option -t "$TMUX_PANE" -q ${AGENT_STATE_OPTION} "${state}:$(date +%s)"; exit 0`;
+}
+
+// src/sessions/agents/claude/scripts.ts
+var PLAN = `j.tool_response?.plan??j.tool_input?.plan`;
+var TASK_EVENT_BY_TOOL = {
+  TaskCreate: `{op:"add",id:j.tool_response?.task?.id,subject:i.subject,activeForm:i.activeForm}`,
+  TaskUpdate: `i.status==="deleted"?{op:"remove",id:i.taskId}:{op:"update",id:i.taskId,subject:i.subject,status:i.status,activeForm:i.activeForm}`,
+  TodoWrite: `Array.isArray(i.todos)?{op:"replace",tasks:i.todos.map(t=>({subject:t?.content,status:t?.status,activeForm:t?.activeForm}))}:undefined`
+};
+var TASK_TOOLS = Object.keys(TASK_EVENT_BY_TOOL);
+var TASK_EVENT = `(()=>{const i=j.tool_input||{};switch(j.tool_name){${Object.entries(
+  TASK_EVENT_BY_TOOL
+).map(([tool, event]) => `case${JSON.stringify(tool)}:return ${event};`).join("")}}})()`;
+var planHookScript = (plansDir) => storePlanScript(plansDir, PLAN);
+var taskHookScript = (plansDir) => appendTaskEventScript(plansDir, TASK_EVENT);
+var pullRequestHookScript = () => recordPullRequestScript(`j.tool_input?.command`, `j.tool_response?.stdout`);
+
+// src/sessions/agents/claude/settings.ts
 function planHookCommand(nodePath = process.execPath, plansDir = HOOK_PLANS_DIR) {
   return nodeHookCommand(planHookScript(plansDir), nodePath);
 }
-function headlineHookCommand(nodePath = process.execPath) {
-  return nodeHookCommand(headlineHookScript(), nodePath);
+function taskHookCommand(nodePath = process.execPath, plansDir = HOOK_PLANS_DIR) {
+  return nodeHookCommand(taskHookScript(plansDir), nodePath);
 }
-function stateHookCommand(state) {
-  return `[ -n "$${SESSION_ENV_VAR}" ] && tmux set-option -t "$TMUX_PANE" -q ${AGENT_STATE_OPTION} "${state}:$(date +%s)"; exit 0`;
+function pullRequestHookCommand(nodePath = process.execPath) {
+  return recordPullRequestCommand(pullRequestHookScript(), nodePath);
 }
 var STATE_HOOK_TIMEOUT_SECONDS = 5;
 var PLAN_HOOK_TIMEOUT_SECONDS = 10;
-var HEADLINE_HOOK_TIMEOUT_SECONDS = 5;
+var TASK_HOOK_TIMEOUT_SECONDS = 10;
+var PULL_REQUEST_HOOK_TIMEOUT_SECONDS = 5;
 function claudeSettings() {
   const run = (command, timeout) => ({ type: "command", command, timeout });
   const report = (state) => run(stateHookCommand(state), STATE_HOOK_TIMEOUT_SECONDS);
@@ -4135,35 +4401,44 @@ function claudeSettings() {
         {
           matcher: "ExitPlanMode",
           hooks: [run(planHookCommand(), PLAN_HOOK_TIMEOUT_SECONDS)]
-        }
-      ],
-      // Working from the moment a prompt is sent, which is also the task the session is on; waiting whenever the user is next to act.
-      UserPromptSubmit: [
+        },
+        {
+          matcher: TASK_TOOLS.join("|"),
+          hooks: [run(taskHookCommand(), TASK_HOOK_TIMEOUT_SECONDS)]
+        },
         {
-          hooks: [report("working"), run(headlineHookCommand(), HEADLINE_HOOK_TIMEOUT_SECONDS)]
+          matcher: "Bash",
+          hooks: [run(pullRequestHookCommand(), PULL_REQUEST_HOOK_TIMEOUT_SECONDS)]
         }
       ],
-      PermissionRequest: [{ matcher: "*", hooks: [report("waiting")] }],
-      Stop: [{ hooks: [report("waiting")] }],
+      // Working from the moment a prompt is sent; waiting when it needs the user; done when a turn ends.
+      UserPromptSubmit: [{ hooks: [report("working")] }],
+      // The plan is stored while it waits for approval, so it shows before the user decides.
+      PermissionRequest: [
+        { matcher: "*", hooks: [report("waiting")] },
+        { matcher: "ExitPlanMode", hooks: [run(planHookCommand(), PLAN_HOOK_TIMEOUT_SECONDS)] }
+      ],
+      Stop: [{ hooks: [report("done")] }],
       StopFailure: [{ hooks: [report("waiting")] }]
     }
   };
 }
 
-// src/sessions/agents/claude-hooks.ts
+// src/sessions/agents/claude/hooks.ts
 var execFileAsync = promisify4(execFile4);
-var CLAUDE_HOOKS_DIR = join9(homedir6(), ".bondsmith", "hooks");
+var CLAUDE_HOOKS_DIR = join10(homedir6(), ".bondsmith", "hooks");
 var AGENT_HOOKS_ENV_VAR = "BONDSMITH_AGENT_HOOKS";
 var HOOKS_OFF_VALUES = /^(off|0|false|no)$/i;
 var CLAUDE_BINARY = "claude";
-var LEADING_CLAUDE = new RegExp(`^(\\s*)${CLAUDE_BINARY}(?=\\s|$)`);
+var LEADING_CLAUDE = new RegExp(
+  `^(\\s*(?:${ENV_ASSIGNMENT_WORD}\\s+)*)${CLAUDE_BINARY}(?=\\s|$)`
+);
 var SETTINGS_FLAG = "--settings";
 var SUPPORT_PROBE_TIMEOUT_MS = 1e4;
 var SUPPORT_RETRY_AFTER_MS = 6e4;
 function isPlainClaudeCommand(command) {
-  const words = command.trim().split(/\s+/);
-  if (words[0] !== CLAUDE_BINARY) return false;
-  return !words.some((word) => word === SETTINGS_FLAG || word.startsWith(`${SETTINGS_FLAG}=`));
+  if (leadingBinary(command) !== CLAUDE_BINARY) return false;
+  return !command.trim().split(/\s+/).some((word) => word === SETTINGS_FLAG || word.startsWith(`${SETTINGS_FLAG}=`));
 }
 async function probeSettingsSupport() {
   try {
@@ -4204,14 +4479,14 @@ async function prepareAgentCommand(command, {
   if (HOOKS_OFF_VALUES.test(env[AGENT_HOOKS_ENV_VAR] ?? "")) return command;
   if (!isPlainClaudeCommand(command)) return command;
   if (!await supportsSettings()) return command;
-  const file = join9(hooksDir, "claude-settings.json");
+  const file = join10(hooksDir, "claude-settings.json");
   const staging = `${file}.${randomUUID2()}.tmp`;
   try {
     await mkdir4(hooksDir, { recursive: true });
     await writeFile4(staging, JSON.stringify(claudeSettings(), null, "	"));
     await rename4(staging, file);
   } catch (error2) {
-    await rm4(staging, { force: true }).catch(() => void 0);
+    await rm5(staging, { force: true }).catch(() => void 0);
     console.error(
       "could not write the Claude Code hook settings; starting claude without them",
       error2
@@ -4224,6 +4499,29 @@ async function prepareAgentCommand(command, {
   );
 }
 
+// src/sessions/agents/claude/adapter.ts
+var claudeAdapter = {
+  id: "claude",
+  matches: (command) => leadingBinary(command) === "claude",
+  prepareCommand: (command) => prepareAgentCommand(command)
+};
+
+// src/sessions/agents/registry.ts
+var ADAPTERS = {
+  claude: claudeAdapter,
+  codex: plainAdapter("codex"),
+  opencode: plainAdapter("opencode")
+};
+function adapterFor(command) {
+  return Object.values(ADAPTERS).find((adapter) => adapter.matches(command));
+}
+function agentIdFor(command) {
+  return adapterFor(command)?.id ?? null;
+}
+async function prepareCommand(command) {
+  return await adapterFor(command)?.prepareCommand(command) ?? command;
+}
+
 // src/sessions/git/start-point.ts
 var WorktreeBaseBranchNotFoundError = class extends Error {
   constructor(branch) {
@@ -4247,15 +4545,26 @@ async function resolveWorktreeStartPoint(sourceCwd, baseBranch) {
   throw new WorktreeBaseBranchNotFoundError(baseBranch);
 }
 
+// src/sessions/worktree-root.ts
+import { lstat as lstat3, realpath as realpath2 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, join as join11, resolve as resolve2 } from "path";
+function worktreeRoot() {
+  return join11(homedir7(), ".bondsmith", "worktrees");
+}
+function worktreePathFor(sessionId) {
+  return join11(worktreeRoot(), sessionId);
+}
+
 // src/sessions/worktree-setup/copy-files.ts
 import { constants as constants4 } from "fs";
-import { copyFile, glob, lstat as lstat3, mkdir as mkdir5, realpath as realpath2 } from "fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join10, relative, sep as sep2 } from "path";
+import { copyFile, glob, lstat as lstat4, mkdir as mkdir5, realpath as realpath3 } from "fs/promises";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join12, relative, sep as sep2 } from "path";
 var GIT_EXIT_NONE_IGNORED = 1;
 var TRACKED_CHECK_BATCH = 200;
 function isInside(root, path) {
   const rel = relative(root, path);
-  return rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute3(rel);
+  return rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute4(rel);
 }
 async function ignoredPaths(worktree, paths) {
   if (paths.length === 0) return /* @__PURE__ */ new Set();
@@ -4284,13 +4593,13 @@ async function trackedPaths(worktree, paths) {
   }
   return tracked;
 }
-async function copyFilesIntoWorktree(sourceRoot, worktreeRoot, globs) {
+async function copyFilesIntoWorktree(sourceRoot, worktreeRoot2, globs) {
   const result = { copied: [], failed: 0, skipped: [] };
   const patterns = globs.filter(isSafeCopyGlob);
   if (patterns.length === 0) return result;
   try {
-    const source = await realpath2(sourceRoot);
-    const worktree = await realpath2(worktreeRoot);
+    const source = await realpath3(sourceRoot);
+    const worktree = await realpath3(worktreeRoot2);
     const candidates = [];
     for await (const match of glob(patterns, { cwd: source })) {
       if (match.split(sep2).includes(".git")) continue;
@@ -4333,11 +4642,11 @@ async function copyFilesIntoWorktree(sourceRoot, worktreeRoot, globs) {
   return result;
 }
 async function isCopyCandidate(source, worktree, match) {
-  const from = join10(source, match);
-  if (!(await lstat3(from)).isFile()) return false;
-  if (!isInside(source, await realpath2(from))) return false;
+  const from = join12(source, match);
+  if (!(await lstat4(from)).isFile()) return false;
+  if (!isInside(source, await realpath3(from))) return false;
   try {
-    await lstat3(join10(worktree, match));
+    await lstat4(join12(worktree, match));
     return false;
   } catch (error2) {
     if (error2.code === "ENOENT") return true;
@@ -4345,11 +4654,11 @@ async function isCopyCandidate(source, worktree, match) {
   }
 }
 async function copyOne(source, worktree, match) {
-  const to = join10(worktree, match);
-  await mkdir5(dirname4(to), { recursive: true });
-  if (!isInside(worktree, await realpath2(dirname4(to)))) return false;
+  const to = join12(worktree, match);
+  await mkdir5(dirname5(to), { recursive: true });
+  if (!isInside(worktree, await realpath3(dirname5(to)))) return false;
   try {
-    await copyFile(join10(source, match), to, constants4.COPYFILE_EXCL);
+    await copyFile(join12(source, match), to, constants4.COPYFILE_EXCL);
   } catch (error2) {
     if (error2.code === "EEXIST") return false;
     throw error2;
@@ -4364,9 +4673,6 @@ var InvalidCwdError = class extends Error {
     this.name = "InvalidCwdError";
   }
 };
-function worktreePathFor(sessionId) {
-  return join11(homedir7(), ".bondsmith", "worktrees", sessionId);
-}
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
   let cwd = sourceCwd;
@@ -4397,7 +4703,7 @@ async function createTmuxSession(input) {
   const tmuxSessionName = tmuxSessionNameFor(input.id);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const baseline = await captureBaseline(cwd, { freshCheckout: worktreeOf !== null });
-  const agentCommand = await prepareAgentCommand(input.command);
+  const agentCommand = await prepareCommand(input.command);
   const setupCommand = worktreeOf ? input.worktreeSetup?.setupCommand?.trim() : void 0;
   const launchCommand = setupCommand ? wrapCommandWithSetup({ setupCommand, command: agentCommand, tmuxSessionName }) : agentCommand;
   await runTmux(
@@ -4446,6 +4752,7 @@ async function createTmuxSession(input) {
     id: input.id,
     title: input.title,
     command: input.command,
+    agent: agentIdFor(input.command),
     cwd,
     tmuxSessionName,
     status: "running",
@@ -4482,6 +4789,7 @@ function parseTmuxSessions(output) {
       id,
       title,
       command,
+      agent: agentIdFor(command),
       cwd,
       tmuxSessionName: sessionName,
       status: "running",
@@ -4565,6 +4873,9 @@ var SessionManager = class {
     for (const [id, baseline] of discovered.baselines) {
       this.baselines.set(id, baseline);
     }
+    sweepOrphanedHookPlanFiles(new Set(this.sessions.keys())).catch(
+      (error2) => console.error("Failed to sweep stored plans of ended sessions", error2)
+    );
   }
   list() {
     return Array.from(this.sessions.values());
@@ -4660,7 +4971,7 @@ ${error2.message}
             agentState: resolveSessionAttention(report, enriched.lastActivityAt, {
               acknowledgedAtMs: this.acknowledgements.get(session.id) ?? null
             }),
-            headline: report?.headline ?? null,
+            ...report?.pullRequestUrls?.length && { pullRequestUrls: report.pullRequestUrls },
             ...report?.setupFailed && { worktreeSetupFailed: true },
             ...report?.setupSkipped?.length && { worktreeSetupSkipped: report.setupSkipped }
           };
@@ -4682,12 +4993,15 @@ ${error2.message}
     this.sessions.delete(session.id);
     this.baselines.delete(session.id);
     this.acknowledgements.delete(session.id);
+    removeHookPlanFiles(session.id).catch(
+      (error2) => console.error("Failed to remove the session's stored plan", { sessionId: session.id, error: error2 })
+    );
     this.emitUpdated(updated);
     return updated;
   }
 };
 function snapshotEquals(a, b) {
-  return a.branch === b.branch && a.repositoryFullName === b.repositoryFullName && a.changedFileCount === b.changedFileCount && a.lastActivityAt === b.lastActivityAt && (a.agentState ?? null) === (b.agentState ?? null) && (a.headline ?? null) === (b.headline ?? null) && (a.worktreeSetupFailed ?? false) === (b.worktreeSetupFailed ?? false) && JSON.stringify(a.worktreeSetupSkipped ?? []) === JSON.stringify(b.worktreeSetupSkipped ?? []);
+  return a.branch === b.branch && a.repositoryFullName === b.repositoryFullName && a.changedFileCount === b.changedFileCount && a.lastActivityAt === b.lastActivityAt && (a.agentState ?? null) === (b.agentState ?? null) && JSON.stringify(a.pullRequestUrls ?? []) === JSON.stringify(b.pullRequestUrls ?? []) && (a.worktreeSetupFailed ?? false) === (b.worktreeSetupFailed ?? false) && JSON.stringify(a.worktreeSetupSkipped ?? []) === JSON.stringify(b.worktreeSetupSkipped ?? []);
 }
 
 // src/ws/server.ts
@@ -4854,10 +5168,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join12(dirname5(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join12(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join12(repoRoot, ".env.local");
-  const envDefault = join12(repoRoot, ".env");
+  const repoRoot = join13(dirname6(fileURLToPath(import.meta.url)), "..", "..", "..");
+  if (!existsSync(join13(repoRoot, "pnpm-workspace.yaml"))) return;
+  const envLocal = join13(repoRoot, ".env.local");
+  const envDefault = join13(repoRoot, ".env");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();