@bondsmith/bondsmithd 0.1.15 → 0.1.17

package/dist/index.js

@@ -4,12 +4,14 @@
 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;
 
@@ -18,7 +20,7 @@ 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 = 19;
+var PROTOCOL_VERSION = 21;
 
 // ../../packages/local-agent-protocol/src/branch-name.ts
 var MAX_BRANCH_NAME_LENGTH = 250;
@@ -46,6 +48,19 @@ var PROJECT_PATH_INVALID_REASONS = [
   "permission_denied"
 ];
 
+// ../../packages/local-agent-protocol/src/project-worktree.ts
+var WORKTREE_REMOVE_REFUSALS = [
+  "not_found",
+  "locked",
+  "session_active",
+  "has_changes"
+];
+var WORKTREE_BRANCH_OUTCOMES = ["deleted", "kept", "not_merged", "failed"];
+var MAX_PROJECT_WORKTREES = 100;
+var MAX_WORKTREE_PATH_LENGTH = 1024;
+var MAX_WORKTREE_BRANCH_LENGTH = 255;
+var MAX_WORKTREE_HEAD_LENGTH = 64;
+
 // ../../packages/local-agent-protocol/src/schemas.ts
 import { z as z3 } from "zod";
 
@@ -185,6 +200,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),
@@ -205,9 +222,9 @@ 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({
@@ -260,6 +277,36 @@ var projectPathValidationSchema = z3.discriminatedUnion("valid", [
   z3.object({ valid: z3.literal(false), reason: z3.enum(PROJECT_PATH_INVALID_REASONS) })
 ]);
 var noNul = (value) => !value.includes("\0");
+var projectWorktreeSchema = z3.object({
+  path: z3.string().max(MAX_WORKTREE_PATH_LENGTH),
+  branch: z3.string().max(MAX_WORKTREE_BRANCH_LENGTH).nullable(),
+  head: z3.string().max(MAX_WORKTREE_HEAD_LENGTH),
+  prunable: z3.boolean(),
+  locked: z3.boolean(),
+  dirty: z3.boolean(),
+  sessionId: z3.string().nullable()
+});
+var worktreeRemoveResultSchema = z3.discriminatedUnion("removed", [
+  z3.object({ removed: z3.literal(true), branch: z3.enum(WORKTREE_BRANCH_OUTCOMES) }),
+  z3.object({ removed: z3.literal(false), reason: z3.enum(WORKTREE_REMOVE_REFUSALS) })
+]);
+var WORKTREE_LIST_REPLY_OVERHEAD_BYTES = 4096;
+var utf8Bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
+function fitsWorktreeLimits(row) {
+  return row.path.length <= MAX_WORKTREE_PATH_LENGTH && (row.branch === null || row.branch.length <= MAX_WORKTREE_BRANCH_LENGTH) && row.head.length <= MAX_WORKTREE_HEAD_LENGTH;
+}
+function fitWorktreeReply(worktrees) {
+  const kept = [];
+  let bytes = WORKTREE_LIST_REPLY_OVERHEAD_BYTES;
+  for (const row of worktrees) {
+    if (!fitsWorktreeLimits(row)) continue;
+    const rowBytes = utf8Bytes(row) + 1;
+    if (kept.length >= MAX_PROJECT_WORKTREES || bytes + rowBytes > MAX_DAEMON_REPLY_BYTES) break;
+    kept.push(row);
+    bytes += rowBytes;
+  }
+  return { worktrees: kept, truncated: kept.length < worktrees.length };
+}
 var worktreeSetupSchema = z3.object({
   copyGlobs: z3.array(z3.string().min(1).max(MAX_COPY_GLOB_LENGTH).refine(noNul).refine(isSafeCopyGlob)).max(MAX_COPY_GLOBS),
   setupCommand: z3.string().max(MAX_SETUP_COMMAND_LENGTH).refine(noNul).optional()
@@ -356,6 +403,19 @@ var browserMessageSchema = z3.discriminatedUnion("type", [
     path: z3.string().min(1).max(4096),
     requestId: z3.string().min(1).max(200)
   }),
+  z3.object({
+    type: z3.literal("worktree.list"),
+    repoPath: z3.string().min(1).max(4096).refine(noNul),
+    requestId: z3.string().min(1).max(200)
+  }),
+  z3.object({
+    type: z3.literal("worktree.remove"),
+    repoPath: z3.string().min(1).max(4096).refine(noNul),
+    worktreePath: z3.string().min(1).max(4096).refine(noNul),
+    force: z3.boolean(),
+    deleteBranch: z3.boolean(),
+    requestId: z3.string().min(1).max(200)
+  }),
   z3.object({ type: z3.literal("daemon.getInfo") }),
   // Second-controller enrollment (ADR-011/ADR-012, BD-433) — deliberately
   // unsigned: the requesting browser has no trusted key yet to sign with.
@@ -388,6 +448,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({
@@ -445,13 +510,25 @@ 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"),
     requestId: z3.string(),
     result: projectPathValidationSchema
   }),
+  z3.object({
+    type: z3.literal("worktree.listed"),
+    requestId: z3.string(),
+    worktrees: z3.array(projectWorktreeSchema).max(MAX_PROJECT_WORKTREES),
+    truncated: z3.boolean()
+  }),
+  z3.object({
+    type: z3.literal("worktree.removed"),
+    requestId: z3.string(),
+    result: worktreeRemoveResultSchema
+  }),
   z3.object({
     type: z3.literal("daemon.info"),
     hostname: z3.string(),
@@ -541,7 +618,9 @@ var SIGNABLE_ACTIONS = [
   "workspace.getDiff",
   "workspace.readFileRange",
   "workspace.getPlan",
-  "project.validatePath"
+  "project.validatePath",
+  "worktree.list",
+  "worktree.remove"
 ];
 var envelopeSchema = z4.object({
   version: z4.literal(1),
@@ -1043,7 +1122,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;
@@ -1181,8 +1260,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";
@@ -1252,7 +1331,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 = [];
@@ -1276,7 +1355,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();
@@ -1287,134 +1366,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";
@@ -1462,8 +1420,8 @@ 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"]);
@@ -1507,8 +1465,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
@@ -1545,14 +1503,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;
@@ -1876,23 +1834,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);
@@ -1919,7 +1877,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(),
@@ -1942,7 +1900,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;
@@ -2263,12 +2221,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;
@@ -2277,12 +2235,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.15" : "dev";
+var DAEMON_VERSION = true ? "0.1.17" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -2291,6 +2249,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;
@@ -2427,8 +2620,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 };
 }
@@ -2520,6 +2713,19 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
   }
   return { conn, releaseAllSubscriptions };
 }
+var removalQueues = /* @__PURE__ */ new Map();
+function inRepoOrder(repoPath, task) {
+  const result = (removalQueues.get(repoPath) ?? Promise.resolve()).then(task);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  removalQueues.set(repoPath, tail);
+  void tail.then(() => {
+    if (removalQueues.get(repoPath) === tail) removalQueues.delete(repoPath);
+  });
+  return result;
+}
 function error(message, requestId) {
   return { type: "error", message, requestId };
 }
@@ -2649,6 +2855,8 @@ async function dispatch(conn, message, {
   getWorkspaceDiff: getWorkspaceDiff2,
   readFileRange: readFileRange2,
   validateProjectPath: validateProjectPath2,
+  listProjectWorktrees: listProjectWorktrees2,
+  removeManagedWorktree: removeManagedWorktree2,
   hostname: hostname3,
   daemonFingerprint,
   pendingAuthorizations,
@@ -2762,14 +2970,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")));
@@ -2880,12 +3088,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));
@@ -2901,6 +3110,47 @@ async function dispatch(conn, message, {
       }
       return;
     }
+    case "worktree.list": {
+      try {
+        const project = await validateProjectPath2(message.repoPath);
+        if (!project.valid) {
+          conn.send(error(`can't list worktrees: ${project.reason}`, message.requestId));
+          return;
+        }
+        const worktrees = await listProjectWorktrees2(project.path, sessionManager.list());
+        conn.send({
+          type: "worktree.listed",
+          requestId: message.requestId,
+          ...fitWorktreeReply(worktrees)
+        });
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to list worktrees"), message.requestId));
+      }
+      return;
+    }
+    case "worktree.remove": {
+      try {
+        const project = await validateProjectPath2(message.repoPath);
+        if (!project.valid) {
+          conn.send(error(`can't remove a worktree: ${project.reason}`, message.requestId));
+          return;
+        }
+        const result = await inRepoOrder(
+          project.path,
+          () => removeManagedWorktree2({
+            repoPath: project.path,
+            worktreePath: message.worktreePath,
+            force: message.force,
+            deleteBranch: message.deleteBranch,
+            getSessions: () => sessionManager.list()
+          })
+        );
+        conn.send({ type: "worktree.removed", requestId: message.requestId, result });
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to remove the worktree"), message.requestId));
+      }
+      return;
+    }
     case "daemon.getInfo": {
       conn.send({ type: "daemon.info", hostname: hostname3(), daemonFingerprint });
       return;
@@ -3319,9 +3569,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
@@ -3460,8 +3710,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,
@@ -3572,16 +3822,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;
@@ -3801,6 +4051,256 @@ async function getWorkspaceDiff(cwd, path, staged, baseline) {
   }
 }
 
+// src/sessions/git/managed-worktree.ts
+import { realpath as realpath4 } from "fs/promises";
+import { sep as sep2 } from "path";
+
+// src/sessions/git/worktree.ts
+import { execFile as execFileCb3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFile3 = promisify3(execFileCb3);
+var WorktreeBranchNameTakenError = class extends Error {
+  constructor(branch) {
+    super(`a branch named "${branch}" already exists`);
+    this.name = "WorktreeBranchNameTakenError";
+  }
+};
+var WorktreePathExistsError = class extends Error {
+  constructor(path) {
+    super(`worktree path already exists: ${path}`);
+    this.name = "WorktreePathExistsError";
+  }
+};
+var WorktreeHasUncommittedChangesError = class extends Error {
+  constructor(path) {
+    super(
+      `worktree at ${path} has uncommitted or untracked changes \u2014 not removing it. Commit or discard the changes, then remove it yourself (git worktree remove ${path}).`
+    );
+    this.name = "WorktreeHasUncommittedChangesError";
+  }
+};
+function stderrOf(error2) {
+  if (typeof error2 !== "object" || error2 === null) return "";
+  const stderr = error2.stderr;
+  return typeof stderr === "string" ? stderr : "";
+}
+async function createWorktree(sourceCwd, worktreePath, branch, startPoint) {
+  const args = ["worktree", "add", "--no-track", "-b", branch, worktreePath];
+  if (startPoint) args.push(startPoint);
+  try {
+    await execFile3("git", [...SAFE_GIT_CONFIG, ...args], { cwd: sourceCwd });
+  } catch (error2) {
+    const stderr = stderrOf(error2);
+    if (stderr.includes("a branch named")) {
+      throw new WorktreeBranchNameTakenError(branch);
+    }
+    if (stderr.includes("already exists")) {
+      throw new WorktreePathExistsError(worktreePath);
+    }
+    throw error2;
+  }
+}
+async function removeWorktree(sourceCwd, worktreePath, { force = false } = {}) {
+  const args = ["worktree", "remove", ...force ? ["--force"] : [], "--", worktreePath];
+  try {
+    await execFile3("git", [...SAFE_GIT_CONFIG, ...args], { cwd: sourceCwd });
+  } catch (error2) {
+    const stderr = stderrOf(error2);
+    if (stderr.includes("contains modified or untracked files")) {
+      throw new WorktreeHasUncommittedChangesError(worktreePath);
+    }
+    throw error2;
+  }
+}
+var BranchNotMergedError = class extends Error {
+  constructor(branch) {
+    super(`the branch "${branch}" is not fully merged, so it was kept`);
+    this.name = "BranchNotMergedError";
+  }
+};
+async function deleteMergedBranch(sourceCwd, branch) {
+  try {
+    await execFile3("git", [...SAFE_GIT_CONFIG, "branch", "-d", "--", branch], { cwd: sourceCwd });
+  } catch (error2) {
+    if (stderrOf(error2).includes("not fully merged")) throw new BranchNotMergedError(branch);
+    throw error2;
+  }
+}
+
+// src/sessions/git/worktree-list.ts
+import { realpath as realpath3 } from "fs/promises";
+
+// src/sessions/worktree-root.ts
+import { lstat as lstat3, realpath as realpath2 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute3, join as join9, resolve as resolve2 } from "path";
+function worktreeRoot() {
+  return join9(homedir6(), ".bondsmith", "worktrees");
+}
+function worktreePathFor(sessionId) {
+  return join9(worktreeRoot(), sessionId);
+}
+async function canonicalPath(path) {
+  try {
+    return await realpath2(path);
+  } catch (error2) {
+    const code = error2.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") throw error2;
+    const parent = dirname4(path);
+    if (parent === path) return path;
+    return join9(await canonicalPath(parent), basename(path));
+  }
+}
+async function managedWorktreeLocation(path, root = worktreeRoot()) {
+  if (!isAbsolute3(path) || path.includes("\0") || path !== resolve2(path)) return null;
+  const name = basename(path);
+  if (!isValidSessionId(name)) return null;
+  const realRoot = await canonicalPath(root);
+  if (await canonicalPath(dirname4(path)) !== realRoot) return null;
+  return join9(realRoot, name);
+}
+async function requireManagedWorktreeDirectory(path, root = worktreeRoot()) {
+  const location = await managedWorktreeLocation(path, root);
+  if (!location) return null;
+  try {
+    if (!(await lstat3(location)).isDirectory()) return null;
+    return await realpath2(location);
+  } catch (error2) {
+    if (error2.code === "ENOENT") return null;
+    throw error2;
+  }
+}
+
+// src/sessions/git/worktree-list.ts
+var BRANCH_REF_PREFIX = "refs/heads/";
+function parseWorktreeList(output) {
+  const entries = [];
+  let current = null;
+  for (const field of output.split("\0")) {
+    if (field === "") {
+      if (current) entries.push(current);
+      current = null;
+    } else if (field.startsWith("worktree ")) {
+      current = {
+        path: field.slice("worktree ".length),
+        branch: null,
+        head: "",
+        prunable: false,
+        locked: false
+      };
+    } else if (current && field.startsWith("HEAD ")) {
+      current.head = field.slice("HEAD ".length);
+    } else if (current && field.startsWith("branch ")) {
+      const ref = field.slice("branch ".length);
+      current.branch = ref.startsWith(BRANCH_REF_PREFIX) ? ref.slice(BRANCH_REF_PREFIX.length) : ref;
+    } else if (current && (field === "prunable" || field.startsWith("prunable "))) {
+      current.prunable = true;
+    } else if (current && (field === "locked" || field.startsWith("locked "))) {
+      current.locked = true;
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+async function listDaemonWorktrees(repoPath) {
+  const [, ...linked] = parseWorktreeList(
+    await runGit(["worktree", "list", "--porcelain", "-z"], repoPath)
+  );
+  const ownPath = await realpath3(repoPath);
+  const locations = await Promise.all(linked.map((entry) => managedWorktreeLocation(entry.path)));
+  return linked.flatMap((entry, index) => {
+    const location = locations[index];
+    return location && location !== ownPath ? [{ ...entry, path: location }] : [];
+  });
+}
+async function findManagedWorktree(repoPath, requestedPath) {
+  const location = await requireManagedWorktreeDirectory(requestedPath);
+  if (!location) return null;
+  const entries = await listDaemonWorktrees(repoPath);
+  return entries.find((entry) => entry.path === location) ?? null;
+}
+
+// src/sessions/git/managed-worktree.ts
+var STATUS_CONCURRENCY = 8;
+async function mapWithConcurrency(items, limit, map) {
+  const results = new Array(items.length);
+  let next = 0;
+  let failed = false;
+  const worker = async () => {
+    while (!failed && next < items.length) {
+      const index = next++;
+      try {
+        results[index] = await map(items[index]);
+      } catch (error2) {
+        failed = true;
+        throw error2;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
+async function sessionInWorktree(worktreePath, sessions) {
+  for (const session of sessions) {
+    const real = await realpath4(session.cwd).catch(() => session.cwd);
+    const inside = [session.cwd, real].some(
+      (cwd) => cwd === worktreePath || cwd.startsWith(`${worktreePath}${sep2}`)
+    );
+    if (inside) return session;
+  }
+  return null;
+}
+async function hasChanges(worktreePath) {
+  try {
+    return (await runGit(["status", "--porcelain", "--untracked-files=normal"], worktreePath)).trim() !== "";
+  } catch {
+    return true;
+  }
+}
+async function listProjectWorktrees(repoPath, sessions) {
+  const entries = await listDaemonWorktrees(repoPath);
+  return mapWithConcurrency(entries, STATUS_CONCURRENCY, async (entry) => ({
+    path: entry.path,
+    branch: entry.branch,
+    head: entry.head,
+    prunable: entry.prunable,
+    locked: entry.locked,
+    dirty: entry.prunable ? false : await hasChanges(entry.path),
+    sessionId: (await sessionInWorktree(entry.path, sessions))?.id ?? null
+  }));
+}
+async function dropBranch(repoPath, branch) {
+  try {
+    await deleteMergedBranch(repoPath, branch);
+    return "deleted";
+  } catch (error2) {
+    if (error2 instanceof BranchNotMergedError) return "not_merged";
+    console.error("Failed to delete the branch of a removed worktree", { branch, error: error2 });
+    return "failed";
+  }
+}
+async function removeManagedWorktree(input) {
+  const entry = await findManagedWorktree(input.repoPath, input.worktreePath);
+  if (!entry) return { removed: false, reason: "not_found" };
+  if (entry.locked) return { removed: false, reason: "locked" };
+  if (await sessionInWorktree(entry.path, input.getSessions())) {
+    return { removed: false, reason: "session_active" };
+  }
+  try {
+    await removeWorktree(input.repoPath, entry.path, { force: input.force });
+  } catch (error2) {
+    if (error2 instanceof WorktreeHasUncommittedChangesError) {
+      return { removed: false, reason: "has_changes" };
+    }
+    throw error2;
+  }
+  const branch = input.deleteBranch && entry.branch ? await dropBranch(input.repoPath, entry.branch) : "kept";
+  console.log(
+    `Removed worktree ${entry.path} (branch ${entry.branch ?? "none"}: ${branch}${input.force ? ", forced" : ""})`
+  );
+  return { removed: true, branch };
+}
+
 // src/ws/server.ts
 import { hostname } from "os";
 import { WebSocketServer } from "ws";
@@ -3931,63 +4431,43 @@ ${new TmuxNotFoundError().message}
 // src/sessions/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
 
-// src/sessions/git/worktree.ts
-import { execFile as execFileCb3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFile3 = promisify3(execFileCb3);
-var WorktreeBranchNameTakenError = class extends Error {
-  constructor(branch) {
-    super(`a branch named "${branch}" already exists`);
-    this.name = "WorktreeBranchNameTakenError";
-  }
-};
-var WorktreePathExistsError = class extends Error {
-  constructor(path) {
-    super(`worktree path already exists: ${path}`);
-    this.name = "WorktreePathExistsError";
-  }
-};
-var WorktreeHasUncommittedChangesError = class extends Error {
-  constructor(path) {
-    super(
-      `worktree at ${path} has uncommitted or untracked changes \u2014 not removing it. Commit or discard the changes, then remove it yourself (git worktree remove ${path}).`
-    );
-    this.name = "WorktreeHasUncommittedChangesError";
-  }
-};
-function stderrOf(error2) {
-  if (typeof error2 !== "object" || error2 === null) return "";
-  const stderr = error2.stderr;
-  return typeof stderr === "string" ? stderr : "";
+// src/sessions/agent-reports/lifecycle.ts
+import { readdir, rm as rm4, stat as stat3 } from "fs/promises";
+import { basename as basename2, join as join10 } 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(join10(plansDir, `${basename2(sessionId)}${suffix}`), { force: true })
+    )
+  );
 }
-async function createWorktree(sourceCwd, worktreePath, branch, startPoint) {
-  const args = ["worktree", "add", "--no-track", "-b", branch, worktreePath];
-  if (startPoint) args.push(startPoint);
-  try {
-    await execFile3("git", [...SAFE_GIT_CONFIG, ...args], { cwd: sourceCwd });
-  } catch (error2) {
-    const stderr = stderrOf(error2);
-    if (stderr.includes("a branch named")) {
-      throw new WorktreeBranchNameTakenError(branch);
-    }
-    if (stderr.includes("already exists")) {
-      throw new WorktreePathExistsError(worktreePath);
-    }
-    throw error2;
+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 removeWorktree(sourceCwd, worktreePath) {
+async function sweepOrphanedHookPlanFiles(liveSessionIds, plansDir = HOOK_PLANS_DIR) {
+  let names;
   try {
-    await execFile3("git", [...SAFE_GIT_CONFIG, "worktree", "remove", worktreePath], {
-      cwd: sourceCwd
-    });
+    names = await readdir(plansDir);
   } catch (error2) {
-    const stderr = stderrOf(error2);
-    if (stderr.includes("contains modified or untracked files")) {
-      throw new WorktreeHasUncommittedChangesError(worktreePath);
-    }
+    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 = join10(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/worktree-setup/setup-command.ts
@@ -4029,22 +4509,15 @@ function decodeSkippedFiles(raw) {
 
 // src/sessions/tmux/agent-state.ts
 var AGENT_STATE_OPTION = "@bondsmith-agent-state";
-var HEADLINE_OPTION = "@bondsmith-headline";
 var PULL_REQUESTS_OPTION = "@bondsmith-prs";
 var PULL_REQUEST_URL = /https?:\/\/[^\s/]+\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
-var MAX_HEADLINE_CHARS = 200;
-var LIVE_SESSION_REPORTS_FORMAT = `#{session_name}	#{${AGENT_STATE_OPTION}}	#{window_bell_flag}	#{${SETUP_FAILED_OPTION}}	#{${SETUP_SKIPPED_OPTION}}	#{${PULL_REQUESTS_OPTION}}	#{${HEADLINE_OPTION}}`;
+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);
@@ -4061,8 +4534,7 @@ function parseLiveSessionReports(output) {
       bell = "",
       setupFailed = "",
       setupSkipped = "",
-      pullRequests = "",
-      ...headline
+      pullRequests = ""
     ] = line.split("	");
     if (sessionName) {
       reports.set(sessionName, {
@@ -4070,8 +4542,7 @@ function parseLiveSessionReports(output) {
         bell: bell === "1",
         setupFailed: setupFailed === "1",
         setupSkipped: decodeSkippedFiles(setupSkipped),
-        pullRequestUrls: parsePullRequestUrls(pullRequests),
-        headline: cleanHeadline(headline.join(" "))
+        pullRequestUrls: parsePullRequestUrls(pullRequests)
       });
     }
   }
@@ -4122,56 +4593,67 @@ function resolveSessionAttention(report, lastActivityAt, { nowMs, acknowledgedAt
 
 // 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 { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { mkdir as mkdir4, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join11 } 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 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),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 pullRequestHookScript() {
+function recordPullRequestScript(commandExpr, outputExpr) {
   return [
     `let d="";`,
     `process.stdin.on("data",c=>d+=c).on("end",()=>{try{`,
-    `const j=JSON.parse(d),c=j.tool_input?.command,o=j.tool_response?.stdout;`,
+    `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;`,
@@ -4182,29 +4664,49 @@ function pullRequestHookScript() {
   ].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 pullRequestHookCommand(nodePath = process.execPath) {
-  const run = `${shellQuote3(nodePath)} -e ${shellQuote3(pullRequestHookScript())}`;
-  return `[ -n "$${SESSION_ENV_VAR}" ] && { input=$(cat); case "$input" in *"gh pr create"*) 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`;
+  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 });
@@ -4216,38 +4718,43 @@ function claudeSettings() {
           matcher: "ExitPlanMode",
           hooks: [run(planHookCommand(), PLAN_HOOK_TIMEOUT_SECONDS)]
         },
+        {
+          matcher: TASK_TOOLS.join("|"),
+          hooks: [run(taskHookCommand(), TASK_HOOK_TIMEOUT_SECONDS)]
+        },
         {
           matcher: "Bash",
           hooks: [run(pullRequestHookCommand(), PULL_REQUEST_HOOK_TIMEOUT_SECONDS)]
         }
       ],
-      // Working from the moment a prompt is sent, which is also the task the session is on; waiting when it needs the user; done when a turn ends.
-      UserPromptSubmit: [
-        {
-          hooks: [report("working"), run(headlineHookCommand(), HEADLINE_HOOK_TIMEOUT_SECONDS)]
-        }
+      // 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)] }
       ],
-      PermissionRequest: [{ matcher: "*", hooks: [report("waiting")] }],
       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 = join11(homedir7(), ".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 {
@@ -4288,14 +4795,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 = join11(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
@@ -4308,6 +4815,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) {
@@ -4333,13 +4863,13 @@ async function resolveWorktreeStartPoint(sourceCwd, baseBranch) {
 
 // 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 realpath5 } from "fs/promises";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join12, relative, sep as sep3 } 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(`..${sep3}`) && !isAbsolute4(rel);
 }
 async function ignoredPaths(worktree, paths) {
   if (paths.length === 0) return /* @__PURE__ */ new Set();
@@ -4368,16 +4898,16 @@ 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 realpath5(sourceRoot);
+    const worktree = await realpath5(worktreeRoot2);
     const candidates = [];
     for await (const match of glob(patterns, { cwd: source })) {
-      if (match.split(sep2).includes(".git")) continue;
+      if (match.split(sep3).includes(".git")) continue;
       try {
         if (await isCopyCandidate(source, worktree, match)) candidates.push(match);
       } catch (error2) {
@@ -4417,11 +4947,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 realpath5(from))) return false;
   try {
-    await lstat3(join10(worktree, match));
+    await lstat4(join12(worktree, match));
     return false;
   } catch (error2) {
     if (error2.code === "ENOENT") return true;
@@ -4429,11 +4959,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 realpath5(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;
@@ -4448,9 +4978,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;
@@ -4481,7 +5008,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(
@@ -4530,6 +5057,7 @@ async function createTmuxSession(input) {
     id: input.id,
     title: input.title,
     command: input.command,
+    agent: agentIdFor(input.command),
     cwd,
     tmuxSessionName,
     status: "running",
@@ -4566,6 +5094,7 @@ function parseTmuxSessions(output) {
       id,
       title,
       command,
+      agent: agentIdFor(command),
       cwd,
       tmuxSessionName: sessionName,
       status: "running",
@@ -4649,6 +5178,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());
@@ -4744,7 +5276,6 @@ ${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 }
@@ -4767,12 +5298,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) && JSON.stringify(a.pullRequestUrls ?? []) === JSON.stringify(b.pullRequestUrls ?? []) && (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
@@ -4896,6 +5430,8 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         getWorkspaceDiff,
         readFileRange,
         validateProjectPath,
+        listProjectWorktrees,
+        removeManagedWorktree,
         hostname: () => hostname(),
         daemonFingerprint,
         pendingAuthorizations,
@@ -4939,10 +5475,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();
@@ -5001,6 +5537,8 @@ async function start() {
     getWorkspaceDiff,
     readFileRange,
     validateProjectPath,
+    listProjectWorktrees,
+    removeManagedWorktree,
     hostname: hostname2,
     pendingAuthorizations,
     presentPendingAuthorization,