@bondsmith/bondsmithd 0.1.16 → 0.1.17

package/dist/index.js

@@ -20,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 = 20;
+var PROTOCOL_VERSION = 21;
 
 // ../../packages/local-agent-protocol/src/branch-name.ts
 var MAX_BRANCH_NAME_LENGTH = 250;
@@ -48,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";
 
@@ -264,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()
@@ -360,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.
@@ -462,6 +518,17 @@ var daemonMessageSchema = z3.discriminatedUnion("type", [
     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(),
@@ -551,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),
@@ -2171,7 +2240,7 @@ function listInstalledAgents(env = process.env) {
 }
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.16" : "dev";
+var DAEMON_VERSION = true ? "0.1.17" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -2644,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 };
 }
@@ -2773,6 +2855,8 @@ async function dispatch(conn, message, {
   getWorkspaceDiff: getWorkspaceDiff2,
   readFileRange: readFileRange2,
   validateProjectPath: validateProjectPath2,
+  listProjectWorktrees: listProjectWorktrees2,
+  removeManagedWorktree: removeManagedWorktree2,
   hostname: hostname3,
   daemonFingerprint,
   pendingAuthorizations,
@@ -3026,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;
@@ -3926,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";
@@ -4058,12 +4433,12 @@ 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";
+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(join9(plansDir, `${basename(sessionId)}${suffix}`), { force: true })
+      (suffix) => rm4(join10(plansDir, `${basename2(sessionId)}${suffix}`), { force: true })
     )
   );
 }
@@ -4087,7 +4462,7 @@ async function sweepOrphanedHookPlanFiles(liveSessionIds, plansDir = HOOK_PLANS_
     names.map(async (name) => {
       const sessionId = hookFileSessionId(name);
       if (sessionId === null || liveSessionIds.has(sessionId)) return;
-      const path = join9(plansDir, name);
+      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 });
@@ -4095,65 +4470,6 @@ async function sweepOrphanedHookPlanFiles(liveSessionIds, plansDir = HOOK_PLANS_
   );
 }
 
-// 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) {
-  try {
-    await execFile3("git", [...SAFE_GIT_CONFIG, "worktree", "remove", worktreePath], {
-      cwd: sourceCwd
-    });
-  } catch (error2) {
-    const stderr = stderrOf(error2);
-    if (stderr.includes("contains modified or untracked files")) {
-      throw new WorktreeHasUncommittedChangesError(worktreePath);
-    }
-    throw error2;
-  }
-}
-
 // src/sessions/worktree-setup/setup-command.ts
 var SETUP_FAILED_OPTION = "@bondsmith-setup-failed";
 var WRAPPER_SCRIPT = `printf '\\033[1m%s\\033[0m\\n' 'Setting up worktree\u2026'
@@ -4296,8 +4612,8 @@ function plainAdapter(id) {
 import { execFile as execFile4 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 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 join10 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join11 } from "path";
 import { promisify as promisify4 } from "util";
 
 // src/sessions/session-env.ts
@@ -4426,7 +4742,7 @@ function claudeSettings() {
 
 // src/sessions/agents/claude/hooks.ts
 var execFileAsync = promisify4(execFile4);
-var CLAUDE_HOOKS_DIR = join10(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";
@@ -4479,7 +4795,7 @@ 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 = join10(hooksDir, "claude-settings.json");
+  const file = join11(hooksDir, "claude-settings.json");
   const staging = `${file}.${randomUUID2()}.tmp`;
   try {
     await mkdir4(hooksDir, { recursive: true });
@@ -4545,26 +4861,15 @@ 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 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";
+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}`) && !isAbsolute4(rel);
+  return rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute4(rel);
 }
 async function ignoredPaths(worktree, paths) {
   if (paths.length === 0) return /* @__PURE__ */ new Set();
@@ -4598,11 +4903,11 @@ async function copyFilesIntoWorktree(sourceRoot, worktreeRoot2, globs) {
   const patterns = globs.filter(isSafeCopyGlob);
   if (patterns.length === 0) return result;
   try {
-    const source = await realpath3(sourceRoot);
-    const worktree = await realpath3(worktreeRoot2);
+    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) {
@@ -4644,7 +4949,7 @@ async function copyFilesIntoWorktree(sourceRoot, worktreeRoot2, globs) {
 async function isCopyCandidate(source, worktree, match) {
   const from = join12(source, match);
   if (!(await lstat4(from)).isFile()) return false;
-  if (!isInside(source, await realpath3(from))) return false;
+  if (!isInside(source, await realpath5(from))) return false;
   try {
     await lstat4(join12(worktree, match));
     return false;
@@ -4656,7 +4961,7 @@ async function isCopyCandidate(source, worktree, match) {
 async function copyOne(source, worktree, match) {
   const to = join12(worktree, match);
   await mkdir5(dirname5(to), { recursive: true });
-  if (!isInside(worktree, await realpath3(dirname5(to)))) return false;
+  if (!isInside(worktree, await realpath5(dirname5(to)))) return false;
   try {
     await copyFile(join12(source, match), to, constants4.COPYFILE_EXCL);
   } catch (error2) {
@@ -5125,6 +5430,8 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         getWorkspaceDiff,
         readFileRange,
         validateProjectPath,
+        listProjectWorktrees,
+        removeManagedWorktree,
         hostname: () => hostname(),
         daemonFingerprint,
         pendingAuthorizations,
@@ -5230,6 +5537,8 @@ async function start() {
     getWorkspaceDiff,
     readFileRange,
     validateProjectPath,
+    listProjectWorktrees,
+    removeManagedWorktree,
     hostname: hostname2,
     pendingAuthorizations,
     presentPendingAuthorization,

package/package.json

@@ -1,6 +1,7 @@
 {
+	"version": "0.1.17",
+	"protocolVersion": 21,
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.16",
 	"private": false,
 	"description": "Local daemon for Bondsmith agent sessions — runs on the user's own machine, pairs with a Bondsmith account, and exposes tmux-backed terminal sessions to the Bondsmith web app over a signed WebSocket protocol.",
 	"homepage": "https://bondsmith.dev",