@staff0rd/assist 0.481.0 → 0.482.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.481.0",
+  version: "0.482.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -6665,10 +6665,10 @@ async function prepareRun(id, resumeSessionId) {
 import chalk39 from "chalk";
 function reportDuplicateRun(itemId2, holder) {
   const since = holder.timestamp ? `, started ${holder.timestamp}` : "";
-  const reason2 = `another session is already running it (pid ${holder.pid}${since}); close that session before running it again`;
+  const reason4 = `another session is already running it (pid ${holder.pid}${since}); close that session before running it again`;
   console.log(chalk39.yellow(`Already running: ${formatItemId(itemId2)}`));
-  console.log(chalk39.dim(`Refusing to start a second run \u2014 ${reason2}.`));
-  appendDaemonLog(`backlog run ${itemId2}: refused \u2014 ${reason2}`);
+  console.log(chalk39.dim(`Refusing to start a second run \u2014 ${reason4}.`));
+  appendDaemonLog(`backlog run ${itemId2}: refused \u2014 ${reason4}`);
 }
 
 // src/commands/backlog/consumePause.ts
@@ -8332,11 +8332,11 @@ import {
 var SPAWN_TIMEOUT_MS = 1e4;
 var RETRY_DELAY_MS2 = 200;
 var STALE_LOCK_MS = SPAWN_TIMEOUT_MS + 5e3;
-async function ensureDaemonRunning(reason2 = "unspecified") {
+async function ensureDaemonRunning(reason4 = "unspecified") {
   if (await isDaemonRunning()) return;
   mkdirSync10(daemonPaths.dir, { recursive: true });
   const holdsLock = acquireSpawnLock();
-  if (holdsLock) spawnDaemon(reason2);
+  if (holdsLock) spawnDaemon(reason4);
   try {
     await waitForDaemon();
   } finally {
@@ -8385,12 +8385,12 @@ function releaseSpawnLock() {
   } catch {
   }
 }
-function spawnDaemon(reason2) {
+function spawnDaemon(reason4) {
   const log = openSync2(daemonPaths.log, "a");
   const child = spawn4(process.execPath, [process.argv[1], "daemon", "run"], {
     detached: true,
     stdio: ["ignore", log, log],
-    env: { ...process.env, ASSIST_DAEMON_SPAWN_REASON: reason2 }
+    env: { ...process.env, ASSIST_DAEMON_SPAWN_REASON: reason4 }
   });
   child.unref();
 }
@@ -8971,7 +8971,7 @@ async function patchSubtaskStatus(req, res, id, idx) {
 }
 
 // src/commands/backlog/rewindItemToPhase.ts
-async function rewindItemToPhase(orm, item, phaseNumber, reason2) {
+async function rewindItemToPhase(orm, item, phaseNumber, reason4) {
   const plan2 = resolveRewindPlan(item);
   if (phaseNumber < 1 || phaseNumber > plan2.length) {
     return {
@@ -8990,7 +8990,7 @@ async function rewindItemToPhase(orm, item, phaseNumber, reason2) {
   await appendComment(
     orm,
     item.id,
-    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason2}`,
+    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason4}`,
     { phase: phaseNumber }
   );
   await updateCurrentPhase(orm, item.id, phaseNumber);
@@ -9001,11 +9001,11 @@ async function rewindItemToPhase(orm, item, phaseNumber, reason2) {
 
 // src/commands/backlog/web/rewindItemPhase.ts
 async function rewindItemPhase(req, res, id) {
-  const { phase, reason: reason2 } = await parseRewindBody(req);
+  const { phase, reason: reason4 } = await parseRewindBody(req);
   const result = await findItemOr404(res, id);
   if (!result) return;
   const { orm, item } = result;
-  const outcome = await rewindItemToPhase(orm, item, phase, reason2);
+  const outcome = await rewindItemToPhase(orm, item, phase, reason4);
   if (!outcome.ok) {
     respondJson(res, 400, { error: outcome.error });
     return;
@@ -11750,8 +11750,8 @@ function countCopyRows(data) {
 
 // src/commands/backlog/dump/parseDump.ts
 var NEWLINE = 10;
-function invalid(reason2) {
-  throw new Error(`Invalid dump: ${reason2}`);
+function invalid(reason4) {
+  throw new Error(`Invalid dump: ${reason4}`);
 }
 function readLine(dump, start3) {
   const eol = dump.indexOf(NEWLINE, start3);
@@ -13123,14 +13123,14 @@ async function unstar(id) {
 
 // src/commands/backlog/wontdo/index.ts
 import chalk98 from "chalk";
-async function wontdo(id, reason2) {
+async function wontdo(id, reason4) {
   const found = await findOneItem(id);
   if (!found) return;
   const { orm, item } = found;
   await updateStatus(orm, item.id, "wontdo");
-  if (reason2) {
+  if (reason4) {
     const phase = item.currentPhase ?? 1;
-    await appendComment(orm, item.id, reason2, { phase, type: "summary" });
+    await appendComment(orm, item.id, reason4, { phase, type: "summary" });
   }
   console.log(
     chalk98.red(`Won't do item ${formatItemId(item.id)}: ${item.name}`)
@@ -14697,9 +14697,9 @@ function resolvePermission(toolName, parts) {
   if (denied) return denied;
   const reasons = [];
   for (const part of parts) {
-    const reason2 = isApprovedRead(part, toolName);
-    if (!reason2) return void 0;
-    reasons.push(reason2);
+    const reason4 = isApprovedRead(part, toolName);
+    if (!reason4) return void 0;
+    reasons.push(reason4);
   }
   return {
     permissionDecision: "allow",
@@ -14823,13 +14823,13 @@ function cliHookCheck(command, toolName = "Bash") {
   if (reportDeny(toolName, parts)) return;
   const reasons = [];
   for (const part of parts) {
-    const reason2 = isApprovedRead(part, toolName);
-    if (!reason2) {
+    const reason4 = isApprovedRead(part, toolName);
+    if (!reason4) {
       console.log(`not approved (unrecognised: ${part})`);
       process.exitCode = 1;
       return;
     }
-    reasons.push(`  ${part} -> ${reason2}`);
+    reasons.push(`  ${part} -> ${reason4}`);
   }
   console.log(`approved
 ${reasons.join("\n")}`);
@@ -17888,14 +17888,14 @@ async function editHook() {
   const input = tryParseInput2(await readStdin());
   if (!input) return;
   const existing = input.tool_name === "Write" ? readExisting(input.tool_input.file_path) : void 0;
-  const reason2 = decideOverrideGuard(input, existing) ?? decideCommentGuard(input, existing) ?? decideMigrationGuard(input, existing);
-  if (!reason2) return;
+  const reason4 = decideOverrideGuard(input, existing) ?? decideCommentGuard(input, existing) ?? decideMigrationGuard(input, existing);
+  if (!reason4) return;
   console.log(
     JSON.stringify({
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
         permissionDecision: "deny",
-        permissionDecisionReason: reason2
+        permissionDecisionReason: reason4
       }
     })
   );
@@ -18841,10 +18841,12 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { execFile as execFile8 } from "child_process";
 import { copyFileSync, existsSync as existsSync46, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname24, join as join48 } from "path";
 
+// src/commands/sessions/daemon/worktree/runInstall.ts
+import { spawn as spawn5 } from "child_process";
+
 // src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
 import { existsSync as existsSync45 } from "fs";
 import { join as join47 } from "path";
@@ -18861,6 +18863,90 @@ function resolveInstallCommand(repoRoot, install) {
   return detectInstallCommand(repoRoot);
 }
 
+// src/commands/sessions/daemon/worktree/stopInstall.ts
+import { execFile as execFile8 } from "child_process";
+var running2 = /* @__PURE__ */ new Map();
+function trackInstall(worktreePath, child) {
+  running2.set(worktreePath, child);
+}
+function untrackInstall(worktreePath, child) {
+  if (running2.get(worktreePath) === child) running2.delete(worktreePath);
+}
+function stopInstall(worktreePath) {
+  const child = running2.get(worktreePath);
+  running2.delete(worktreePath);
+  if (!child?.pid) return;
+  daemonLog(
+    `worktree ${worktreePath} install still running at teardown; killing pid ${child.pid} so removal is not racing it`
+  );
+  killTree(child.pid);
+}
+function killTree(pid) {
+  if (process.platform === "win32") {
+    execFile8("taskkill", ["/T", "/F", "/PID", String(pid)], () => {
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+
+// src/commands/sessions/daemon/worktree/installInvocation.ts
+function installInvocation(worktreePath, command) {
+  const windows = /^[A-Za-z]:[\\/]/.test(worktreePath);
+  const shell = windows ? "cmd.exe" : process.env.SHELL ?? "bash";
+  const args = windows ? ["/c", `cd /d ${quoteForCmd(worktreePath)} && ${command}`] : ["-l", "-c", `cd ${quoteForPosixShell(worktreePath)} && ${command}`];
+  return [
+    shell,
+    args,
+    { cwd: worktreePath, detached: true, stdio: ["ignore", "ignore", "pipe"] }
+  ];
+}
+function quoteForCmd(value) {
+  return `"${value.replaceAll('"', "")}"`;
+}
+function quoteForPosixShell(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+// src/commands/sessions/daemon/worktree/runInstall.ts
+var STDERR_TAIL = 2e3;
+function runInstall(worktreePath, clone, install, onSeeded) {
+  const command = resolveInstallCommand(clone, install);
+  if (!command) {
+    onSeeded();
+    return;
+  }
+  daemonLog(`worktree ${worktreePath} installing deps: ${command}`);
+  const child = spawn5(...installInvocation(worktreePath, command));
+  trackInstall(worktreePath, child);
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr = (stderr + chunk.toString()).slice(-STDERR_TAIL);
+  });
+  let settled = false;
+  const settle = (outcome) => {
+    if (settled) return;
+    settled = true;
+    untrackInstall(worktreePath, child);
+    daemonLog(`worktree ${worktreePath} install ${outcome}`);
+    onSeeded();
+  };
+  child.on("error", (error) => settle(`failed to start: ${error.message}`));
+  child.on(
+    "close",
+    (code, signal) => settle(
+      code === 0 ? "complete" : `failed (${signal ? `signal ${signal}` : `exit ${code}`}): ${stderr.trim() || "no output"}`
+    )
+  );
+}
+
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
 function seedWorktree(worktreePath, clone, onSeeded = () => {
 }) {
@@ -18884,29 +18970,6 @@ function copyConfigFiles(worktreePath, clone, copy) {
     }
   }
 }
-function runInstall(worktreePath, clone, install, onSeeded) {
-  const command = resolveInstallCommand(clone, install);
-  if (!command) {
-    onSeeded();
-    return;
-  }
-  const windows = /^[A-Za-z]:[\\/]/.test(worktreePath);
-  const shell = windows ? "cmd.exe" : process.env.SHELL ?? "bash";
-  const shellArgs = windows ? ["/c", `cd /d ${quoteForCmd(worktreePath)} && ${command}`] : ["-l", "-c", `cd ${quoteForPosixShell(worktreePath)} && ${command}`];
-  daemonLog(`worktree ${worktreePath} installing deps: ${command}`);
-  execFile8(shell, shellArgs, { cwd: worktreePath }, (error) => {
-    daemonLog(
-      error ? `worktree ${worktreePath} install failed: ${error.message}` : `worktree ${worktreePath} install complete`
-    );
-    onSeeded();
-  });
-}
-function quoteForPosixShell(value) {
-  return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function quoteForCmd(value) {
-  return `"${value.replaceAll('"', "")}"`;
-}
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -20881,16 +20944,16 @@ function reply(commentId, body) {
 
 // src/commands/prs/wontfix.ts
 import { execSync as execSync50 } from "child_process";
-function validateReason(reason2) {
-  const lowerReason = reason2.toLowerCase();
+function validateReason(reason4) {
+  const lowerReason = reason4.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
     console.error('Error: Reason must not contain "claude" or "opus"');
     process.exit(1);
   }
 }
-function validateShaReferences(reason2) {
+function validateShaReferences(reason4) {
   const commitLinkPattern = /\[[0-9a-f]{7}\]\(https:\/\/github\.com\/[^/]+\/[^/]+\/commit\/([0-9a-f]{40})\)/gi;
-  const shas = Array.from(reason2.matchAll(commitLinkPattern), (m) => m[1]);
+  const shas = Array.from(reason4.matchAll(commitLinkPattern), (m) => m[1]);
   if (shas.length === 0) {
     return;
   }
@@ -20909,11 +20972,11 @@ function validateShaReferences(reason2) {
     process.exit(1);
   }
 }
-function wontfix(commentId, reason2) {
-  validateReason(reason2);
-  validateShaReferences(reason2);
+function wontfix(commentId, reason4) {
+  validateReason(reason4);
+  validateShaReferences(reason4);
   try {
-    resolveCommentWithReply(commentId, reason2);
+    resolveCommentWithReply(commentId, reason4);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -21092,8 +21155,8 @@ function registerPrs(program2) {
   prsCommand.command("fixed <comment-id> <sha>").description("Reply with commit link and resolve thread").action((commentId, sha) => {
     fixed(Number.parseInt(commentId, 10), sha);
   });
-  prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason2) => {
-    wontfix(Number.parseInt(commentId, 10), reason2);
+  prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason4) => {
+    wontfix(Number.parseInt(commentId, 10), reason4);
   });
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
@@ -21542,7 +21605,7 @@ function registerRavendb(program2) {
 }
 
 // src/commands/refactor/check/index.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import * as path36 from "path";
 
 // src/commands/refactor/logViolations.ts
@@ -21690,7 +21753,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
   return new Promise((resolve20) => {
-    const child = spawn5("npm", ["run", script], {
+    const child = spawn6("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
       cwd
@@ -23074,10 +23137,10 @@ function listFilesRecursive(dir) {
   }
   return results;
 }
-function addDirectoryFileMoves(moves, childDir, newLocation, reason2) {
+function addDirectoryFileMoves(moves, childDir, newLocation, reason4) {
   for (const file of listFilesRecursive(childDir)) {
     const rel = path55.relative(childDir, file);
-    moves.push({ from: file, to: path55.join(newLocation, rel), reason: reason2 });
+    moves.push({ from: file, to: path55.join(newLocation, rel), reason: reason4 });
   }
 }
 function resolveChildDest(parentDir, childDir) {
@@ -23088,8 +23151,8 @@ function childMoveReason(parentDir) {
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
-  const reason2 = childMoveReason(parentDir);
-  addDirectoryFileMoves(result.moves, childDir, dest, reason2);
+  const reason4 = childMoveReason(parentDir);
+  addDirectoryFileMoves(result.moves, childDir, dest, reason4);
 }
 function planChildDirectoryMove(result, parentDir, childDir) {
   const dest = resolveChildDest(parentDir, childDir);
@@ -24384,7 +24447,7 @@ function reportReviewerToolUse(name, use, spinner) {
 }
 
 // src/commands/review/runStreamingChild.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 
 // src/commands/review/attachLineParser.ts
 function flushBuffer(buffer, onLine) {
@@ -24535,7 +24598,7 @@ function writeStdinSafely(child, payload) {
   }
 }
 function startChild(spec) {
-  const child = spawn6(spec.command, spec.args, {
+  const child = spawn7(spec.command, spec.args, {
     stdio: ["pipe", "pipe", "pipe"],
     shell: process.platform === "win32"
   });
@@ -26192,7 +26255,7 @@ function setup() {
 }
 
 // src/commands/voice/start.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync40 } from "fs";
 import { join as join65 } from "path";
 
@@ -26207,11 +26270,11 @@ function buildDaemonEnv(options2) {
 // src/commands/voice/start.ts
 function spawnForeground(python, script, env) {
   console.log("Starting voice daemon in foreground...");
-  const child = spawn7(python, [script], { stdio: "inherit", env });
+  const child = spawn8(python, [script], { stdio: "inherit", env });
   child.on("exit", (code) => process.exit(code ?? 0));
 }
 function spawnBackground(python, script, env) {
-  const child = spawn7(python, [script], {
+  const child = spawn8(python, [script], {
     detached: true,
     stdio: "ignore",
     env
@@ -27012,7 +27075,7 @@ function runPreCommands(pre, cwd) {
 }
 
 // src/commands/run/spawnRunCommand.ts
-import { execFileSync as execFileSync12, spawn as spawn8 } from "child_process";
+import { execFileSync as execFileSync12, spawn as spawn9 } from "child_process";
 import { existsSync as existsSync58 } from "fs";
 import { dirname as dirname29, join as join67, resolve as resolve15 } from "path";
 function resolveCommand2(command) {
@@ -27028,7 +27091,7 @@ function resolveCommand2(command) {
 }
 function spawnRunCommand(command, args, env, cwd, quiet) {
   const start3 = Date.now();
-  const child = spawn8(resolveCommand2(command), args, {
+  const child = spawn9(resolveCommand2(command), args, {
     stdio: quiet ? "pipe" : "inherit",
     env: env ? { ...process.env, ...expandEnv(env) } : void 0,
     cwd
@@ -28104,9 +28167,89 @@ function otherTreeHolders(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync62 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import { basename as basename16 } from "path";
 
+// src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
+import { existsSync as existsSync62 } from "fs";
+import { join as join73 } from "path";
+
+// src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
+import { statSync as statSync11 } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { join as join72 } from "path";
+async function deleteTreeDirectly(clone, worktreePath, why) {
+  if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
+    daemonLog(
+      `worktree ${worktreePath} not deleted directly (${why}): it is a clone of its own, not a linked worktree`
+    );
+    return false;
+  }
+  daemonLog(`worktree ${worktreePath} deleting its directory directly: ${why}`);
+  try {
+    await rm2(worktreePath, {
+      recursive: true,
+      force: true,
+      maxRetries: 3,
+      retryDelay: 200
+    });
+  } catch (error) {
+    daemonLog(
+      `worktree ${worktreePath} directory delete failed, left in place for the next reconcile: ${reason(error)}`
+    );
+    return false;
+  }
+  daemonLog(`worktree ${worktreePath} directory deleted directly`);
+  await pruneBookkeeping(clone, worktreePath);
+  return true;
+}
+function holdsAGitDirectoryRatherThanALink(worktreePath) {
+  return statSync11(join72(worktreePath, ".git"), {
+    throwIfNoEntry: false
+  })?.isDirectory() === true;
+}
+async function pruneBookkeeping(clone, worktreePath) {
+  try {
+    await git2(clone, ["worktree", "prune"]);
+    daemonLog(
+      `worktree bookkeeping pruned in clone ${clone} after deleting ${worktreePath} directly`
+    );
+  } catch (error) {
+    daemonLog(
+      `worktree bookkeeping prune failed in clone ${clone} after deleting ${worktreePath}: ${reason(error)}`
+    );
+  }
+}
+function reason(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
+async function deleteStrandedTree(clone, worktreePath, cause) {
+  const stranded = strandedReason(worktreePath, cause);
+  if (!stranded) {
+    daemonLog(
+      `worktree ${worktreePath} left in place for the next reconcile: ${reason2(cause)}`
+    );
+    return false;
+  }
+  return await deleteTreeDirectly(
+    clone,
+    worktreePath,
+    `git can no longer remove it, ${stranded}`
+  );
+}
+function strandedReason(worktreePath, cause) {
+  if (!existsSync62(join73(worktreePath, ".git")))
+    return "its .git link is already gone";
+  if (/not a working tree|not a git repository/i.test(reason2(cause)))
+    return "git no longer recognises it as a working tree";
+  return null;
+}
+function reason2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/commands/sessions/daemon/worktree/removeTree.ts
 async function removeTree(clone, worktreePath, force) {
   const remove2 = (forced) => git2(clone, [
@@ -28119,12 +28262,17 @@ async function removeTree(clone, worktreePath, force) {
     await remove2(force);
     return true;
   } catch (error) {
-    daemonLog(`worktree ${worktreePath} removal failed: ${reason(error)}`);
+    daemonLog(`worktree ${worktreePath} removal failed: ${reason3(error)}`);
+    if (force)
+      return await deleteTreeDirectly(
+        clone,
+        worktreePath,
+        `its work was discarded and git could not remove it: ${reason3(error)}`
+      );
   }
-  if (force) return false;
-  return await removeIgnoringLeftovers(remove2, worktreePath);
+  return await removeIgnoringLeftovers(clone, remove2, worktreePath);
 }
-async function removeIgnoringLeftovers(remove2, worktreePath) {
+async function removeIgnoringLeftovers(clone, remove2, worktreePath) {
   try {
     await remove2(true);
     daemonLog(
@@ -28133,18 +28281,18 @@ async function removeIgnoringLeftovers(remove2, worktreePath) {
     return true;
   } catch (error) {
     daemonLog(
-      `worktree ${worktreePath} left in place for the next reconcile: ${reason(error)}`
+      `worktree ${worktreePath} forced removal failed: ${reason3(error)}`
     );
-    return false;
+    return await deleteStrandedTree(clone, worktreePath, error);
   }
 }
-function reason(error) {
+function reason3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync62(worktreePath)) {
+  if (!existsSync63(worktreePath)) {
     daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
     return false;
   }
@@ -28155,13 +28303,24 @@ async function reapWorktree(worktreePath, force = false) {
       return false;
     }
   }
-  const clone = mainWorktree(worktreePath) ?? worktreePath;
+  stopInstall(worktreePath);
+  const clone = owningClone(worktreePath);
   if (!await removeTree(clone, worktreePath, force)) return false;
   await deleteWorktreeBranch(clone, basename16(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return true;
 }
+function owningClone(worktreePath) {
+  const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
+  if (recorded && existsSync63(recorded)) return recorded;
+  const detected = mainWorktree(worktreePath);
+  if (detected) return detected;
+  daemonLog(
+    `worktree ${worktreePath} has no resolvable clone; tearing it down on its own`
+  );
+  return worktreePath;
+}
 async function deleteWorktreeBranch(clone, branch2) {
   if (!listLocalBranches(clone).includes(branch2)) return;
   const current = await gitOrNull2(clone, ["symbolic-ref", "--short", "HEAD"]);
@@ -28241,12 +28400,12 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync63, watch } from "fs";
+import { existsSync as existsSync64, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync63(common)) return void 0;
+  if (!common || !existsSync64(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -28300,12 +28459,12 @@ async function resolveCloseDurability(session, finalize, notify2) {
   session.gitWatcher = void 0;
   finalize();
 }
-function holdStopped(session, tree, reason2, finalize, notify2) {
-  if (session.undurable?.reason !== reason2)
+function holdStopped(session, tree, reason4, finalize, notify2) {
+  if (session.undurable?.reason !== reason4)
     daemonLog(
-      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason2}`
+      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason4}`
     );
-  session.undurable = { reason: reason2, removesTree: tree.removable };
+  session.undurable = { reason: reason4, removesTree: tree.removable };
   session.closing = void 0;
   setStatus2(session, "stopped");
   if (!session.gitWatcher) {
@@ -28650,10 +28809,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 function exitReason(session, exitCode) {
   const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync64(session.cwd))
+  if (session.cwd && !existsSync65(session.cwd))
     return `${base}: working directory ${session.cwd} no longer exists`;
   return base;
 }
@@ -28671,7 +28830,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync65, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
+import { existsSync as existsSync66, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
 import { dirname as dirname31 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -28752,7 +28911,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync65(path71)) read();
+  if (existsSync66(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -29767,14 +29926,14 @@ function restoreSession(id, persisted) {
 }
 
 // src/commands/sessions/daemon/restoreOne.ts
-function restoreOne(persisted, spawn12, sessions) {
+function restoreOne(persisted, spawn13, sessions) {
   try {
-    const id = spawn12((sid) => restoreSession(sid, persisted));
+    const id = spawn13((sid) => restoreSession(sid, persisted));
     logUnresumable(persisted.name, id, sessions.get(id));
   } catch (error) {
-    const reason2 = logRestoreError(persisted.name, error);
+    const reason4 = logRestoreError(persisted.name, error);
     try {
-      spawn12((id) => errorSession(id, persisted, reason2));
+      spawn13((id) => errorSession(id, persisted, reason4));
     } catch {
     }
   }
@@ -29786,9 +29945,9 @@ function logUnresumable(name, id, session) {
     );
 }
 function logRestoreError(name, error) {
-  const reason2 = error instanceof Error ? error.message : String(error);
-  daemonLog(`failed to restore session "${name}": ${reason2}`);
-  return reason2;
+  const reason4 = error instanceof Error ? error.message : String(error);
+  daemonLog(`failed to restore session "${name}": ${reason4}`);
+  return reason4;
 }
 
 // src/commands/sessions/daemon/sessionLimits.ts
@@ -29809,7 +29968,7 @@ var sessionLimits = {
 };
 
 // src/commands/sessions/daemon/restoreAll.ts
-function restoreAll(spawn12, sessions) {
+function restoreAll(spawn13, sessions) {
   const persisted = loadPersistedSessions();
   const toRestore = persisted.slice(0, sessionLimits.maxRestore);
   const skipped = persisted.length - toRestore.length;
@@ -29818,7 +29977,7 @@ function restoreAll(spawn12, sessions) {
       `restore capped at ${sessionLimits.maxRestore}; skipping ${skipped} persisted session(s)`
     );
   return toRestore.map((persisted2) => {
-    restoreOne(persisted2, spawn12, sessions);
+    restoreOne(persisted2, spawn13, sessions);
     return persisted2.name;
   });
 }
@@ -29841,7 +30000,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -29897,10 +30056,10 @@ function bindResumedWorktree(session, cwd, notify2) {
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path71, reason2) {
-  if (reason2.startsWith("uncommitted")) return await changedFiles(path71);
-  if (reason2.startsWith("unpushed")) return await unpushedCommits(path71, reason2);
-  return { summary: reason2, items: [] };
+async function describeHeldWork(path71, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path71);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path71, reason4);
+  return { summary: reason4, items: [] };
 }
 async function changedFiles(path71) {
   const status3 = await gitResult(path71, ["status", "--porcelain"]);
@@ -29910,9 +30069,9 @@ async function changedFiles(path71) {
     items: capped(lines)
   };
 }
-async function unpushedCommits(path71, reason2) {
+async function unpushedCommits(path71, reason4) {
   const log = await gitResult(path71, ["log", "--oneline", "@{upstream}..HEAD"]);
-  if (!log.ok) return { summary: reason2, items: [] };
+  if (!log.ok) return { summary: reason4, items: [] };
   const lines = nonEmptyLines(log.out);
   return {
     summary: `${lines.length} unpushed ${lines.length === 1 ? "commit" : "commits"}`,
@@ -29931,20 +30090,20 @@ function capped(lines) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync67(clone)) {
+  if (!existsSync68(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
-  await pruneBookkeeping(clone);
+  await pruneBookkeeping2(clone);
   for (const { path: path71, branch: branch2 } of paths)
     if (await reclaimBranch(clone, branch2)) forgetWorktree(path71);
 }
-async function pruneBookkeeping(clone) {
+async function pruneBookkeeping2(clone) {
   try {
     await git2(clone, ["worktree", "prune"]);
     daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
@@ -29971,7 +30130,7 @@ async function reclaimBranch(clone, branch2) {
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
 import { basename as basename17 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
-  const { orphan, reason: reason2, held } = recovered;
+  const { orphan, reason: reason4, held } = recovered;
   let id;
   try {
     id = spawnWith((sid) => orphanedSession(sid, recovered));
@@ -29982,14 +30141,14 @@ function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
     return;
   }
   daemonLog(
-    `orphaned worktree ${orphan.path} resurfaced as stopped session ${id}: ${reason2} (${held.summary})`
+    `orphaned worktree ${orphan.path} resurfaced as stopped session ${id}: ${reason4} (${held.summary})`
   );
   const session = sessions.get(id);
   if (session) armStoppedSession(sessions, session, notify2);
   notify2();
 }
 function orphanedSession(id, recovered) {
-  const { orphan, reason: reason2, held } = recovered;
+  const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
     name: `recovered ${basename17(orphan.path)}`,
@@ -29998,7 +30157,7 @@ function orphanedSession(id, recovered) {
     pty: null,
     cwd: orphan.path,
     worktree: { path: orphan.path, clone: orphan.clone },
-    undurable: { reason: reason2, removesTree: true },
+    undurable: { reason: reason4, removesTree: true },
     scrollback: recoveryNotice(recovered)
   };
 }
@@ -30026,7 +30185,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
     if (accounted.has(path71)) continue;
-    if (!existsSync68(path71)) {
+    if (!existsSync69(path71)) {
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
         { path: path71, branch: basename18(path71) }
@@ -30239,6 +30398,12 @@ function startHeldSession(session, sessions, clients, onStatusChange, notify2) {
     );
     return;
   }
+  if (session.closing) {
+    daemonLog(
+      `session ${session.id} not started after seeding: card is closing (${session.worktree?.path ?? "no worktree"})`
+    );
+    return;
+  }
   session.startedAt = Date.now();
   if (session.status === "running") session.runningSince = session.startedAt;
   session.pty = start3();
@@ -30315,7 +30480,7 @@ async function isWindowsDaemonRunning() {
 }
 
 // src/commands/sessions/daemon/ensureWindowsDaemonRunning.ts
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 
 // src/commands/sessions/daemon/logChildStream.ts
 import { createInterface as createInterface7 } from "readline";
@@ -30340,7 +30505,7 @@ async function ensureWindowsDaemonRunning() {
   await waitForWindowsDaemon();
 }
 function launchWindowsDaemon() {
-  const child = spawn10("pwsh.exe", ["-Command", "assist daemon run"], {
+  const child = spawn11("pwsh.exe", ["-Command", "assist daemon run"], {
     detached: true,
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -30388,13 +30553,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync69, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync70, readFileSync as readFileSync50 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync69(sessionsFile)) return false;
+    if (!existsSync70(sessionsFile)) return false;
     const data = JSON.parse(readFileSync50(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -30643,7 +30808,7 @@ function handleWindowsClose(state) {
 }
 
 // src/commands/sessions/daemon/healWindowsDaemon.ts
-import { spawn as spawn11 } from "child_process";
+import { spawn as spawn12 } from "child_process";
 var UPDATE_TIMEOUT_MS = 5 * 6e4;
 var STOP_TIMEOUT_MS2 = 3e4;
 async function healWindowsDaemon() {
@@ -30663,7 +30828,7 @@ async function healWindowsDaemon() {
 }
 function runOnWindowsHost(command, timeoutMs) {
   return new Promise((resolve20, reject) => {
-    const child = spawn11("pwsh.exe", ["-Command", command], {
+    const child = spawn12("pwsh.exe", ["-Command", command], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     logChildStream(child.stdout, `windows ${command}`);
@@ -31285,10 +31450,10 @@ import * as net3 from "net";
 import { createInterface as createInterface9 } from "readline";
 
 // src/commands/sessions/daemon/creator.ts
-function creator(isNew, spawn12) {
+function creator(isNew, spawn13) {
   return (client, m, d) => {
     if (m.windowsProxy.route(client, d)) return;
-    sendTo(client, { type: "created", sessionId: spawn12(m, d), isNew });
+    sendTo(client, { type: "created", sessionId: spawn13(m, d), isNew });
   };
 }
 
@@ -32018,13 +32183,13 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync53, statSync as statSync12 } from "fs";
-import { isAbsolute as isAbsolute3, join as join73, resolve as resolve18 } from "path";
+import { readFileSync as readFileSync53, statSync as statSync13 } from "fs";
+import { isAbsolute as isAbsolute3, join as join75, resolve as resolve18 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join73(cwd, ".git");
+  const dotGit = join75(cwd, ".git");
   let stat3;
   try {
-    stat3 = statSync12(dotGit);
+    stat3 = statSync13(dotGit);
   } catch {
     return null;
   }
@@ -32051,7 +32216,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync53(join73(gitDir, "HEAD"), "utf8");
+    head = readFileSync53(join75(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }