@staff0rd/assist 0.437.0 → 0.438.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.437.0",
+  version: "0.438.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -98,6 +98,7 @@ var package_default = {
     "@types/pg-copy-streams": "^1.2.5",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
+    "@types/react-file-icon": "^1.0.5",
     "@types/semver": "^7.7.1",
     "@types/shell-quote": "^1.7.5",
     "@types/ws": "^8.18.1",
@@ -110,6 +111,7 @@ var package_default = {
     oxlint: "^1.69.0",
     react: "^19.2.4",
     "react-dom": "^19.2.4",
+    "react-file-icon": "^1.6.0",
     "react-router": "^7.14.0",
     "semantic-release": "^25.0.2",
     skott: "^0.35.11",
@@ -4101,12 +4103,12 @@ function getChangedFiles() {
 function filterByChangedFiles(entries) {
   const hasFilters = entries.some((e) => e.filter);
   if (!hasFilters) return entries;
-  const changedFiles = getChangedFiles();
+  const changedFiles2 = getChangedFiles();
   return entries.filter((entry) => {
     const { filter } = entry;
     if (!filter) return true;
-    if (changedFiles.length === 0) return false;
-    return changedFiles.some((file) => minimatch4(file, filter));
+    if (changedFiles2.length === 0) return false;
+    return changedFiles2.some((file) => minimatch4(file, filter));
   });
 }
 
@@ -6380,10 +6382,10 @@ async function prepareRun(id, resumeSessionId) {
 import chalk39 from "chalk";
 function reportDuplicateRun(itemId2, holder) {
   const since = holder.timestamp ? `, started ${holder.timestamp}` : "";
-  const reason = `another session is already running it (pid ${holder.pid}${since}); close that session before running it again`;
+  const reason2 = `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 ${reason}.`));
-  appendDaemonLog(`backlog run ${itemId2}: refused \u2014 ${reason}`);
+  console.log(chalk39.dim(`Refusing to start a second run \u2014 ${reason2}.`));
+  appendDaemonLog(`backlog run ${itemId2}: refused \u2014 ${reason2}`);
 }
 
 // src/commands/backlog/consumePause.ts
@@ -8030,11 +8032,11 @@ import {
 var SPAWN_TIMEOUT_MS = 1e4;
 var RETRY_DELAY_MS2 = 200;
 var STALE_LOCK_MS = SPAWN_TIMEOUT_MS + 5e3;
-async function ensureDaemonRunning(reason = "unspecified") {
+async function ensureDaemonRunning(reason2 = "unspecified") {
   if (await isDaemonRunning()) return;
   mkdirSync10(daemonPaths.dir, { recursive: true });
   const holdsLock = acquireSpawnLock();
-  if (holdsLock) spawnDaemon(reason);
+  if (holdsLock) spawnDaemon(reason2);
   try {
     await waitForDaemon();
   } finally {
@@ -8083,12 +8085,12 @@ function releaseSpawnLock() {
   } catch {
   }
 }
-function spawnDaemon(reason) {
+function spawnDaemon(reason2) {
   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: reason }
+    env: { ...process.env, ASSIST_DAEMON_SPAWN_REASON: reason2 }
   });
   child.unref();
 }
@@ -8485,7 +8487,7 @@ async function patchSubtaskStatus(req, res, id, idx) {
 }
 
 // src/commands/backlog/rewindItemToPhase.ts
-async function rewindItemToPhase(orm, item, phaseNumber, reason) {
+async function rewindItemToPhase(orm, item, phaseNumber, reason2) {
   const plan2 = resolveRewindPlan(item);
   if (phaseNumber < 1 || phaseNumber > plan2.length) {
     return {
@@ -8504,7 +8506,7 @@ async function rewindItemToPhase(orm, item, phaseNumber, reason) {
   await appendComment(
     orm,
     item.id,
-    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason}`,
+    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason2}`,
     { phase: phaseNumber }
   );
   await updateCurrentPhase(orm, item.id, phaseNumber);
@@ -8515,11 +8517,11 @@ async function rewindItemToPhase(orm, item, phaseNumber, reason) {
 
 // src/commands/backlog/web/rewindItemPhase.ts
 async function rewindItemPhase(req, res, id) {
-  const { phase, reason } = await parseRewindBody(req);
+  const { phase, reason: reason2 } = await parseRewindBody(req);
   const result = await findItemOr404(res, id);
   if (!result) return;
   const { orm, item } = result;
-  const outcome = await rewindItemToPhase(orm, item, phase, reason);
+  const outcome = await rewindItemToPhase(orm, item, phase, reason2);
   if (!outcome.ok) {
     respondJson(res, 400, { error: outcome.error });
     return;
@@ -8977,6 +8979,85 @@ function jiraSite(_req, res) {
   respondJson(res, 200, { site: config.site ?? null });
 }
 
+// src/commands/sessions/web/scoreFilePath.ts
+var BASENAME_WEIGHT = 1e3;
+var START_BONUS = 15;
+var BOUNDARY_BONUS = 10;
+var CONSECUTIVE_BONUS = 8;
+var MAX_GAP_PENALTY = 6;
+var MAX_LENGTH_PENALTY = 100;
+function isBoundary(text17, index3) {
+  if (index3 === 0) return true;
+  const previous = text17[index3 - 1] ?? "";
+  if (!/[A-Za-z0-9]/.test(previous)) return true;
+  return /[a-z0-9]/.test(previous) && /[A-Z]/.test(text17[index3] ?? "");
+}
+function subsequenceScore(text17, query) {
+  const lower = text17.toLowerCase();
+  let score = 0;
+  let cursor = 0;
+  let previous = -1;
+  for (const char of query) {
+    const at2 = lower.indexOf(char, cursor);
+    if (at2 === -1) return null;
+    if (at2 === previous + 1) score += CONSECUTIVE_BONUS;
+    if (isBoundary(text17, at2)) score += BOUNDARY_BONUS;
+    if (at2 === 0) score += START_BONUS;
+    score -= Math.min(at2 - cursor, MAX_GAP_PENALTY);
+    previous = at2;
+    cursor = at2 + 1;
+  }
+  return score - Math.min(text17.length, MAX_LENGTH_PENALTY);
+}
+function scoreFilePath(path71, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return 0;
+  const basename18 = path71.slice(path71.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename18, needle);
+  if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
+  return subsequenceScore(path71, needle);
+}
+
+// src/commands/sessions/web/rankFilePaths.ts
+function rankFilePaths(paths, query, limit) {
+  const scored = [];
+  for (const path71 of paths) {
+    const score = scoreFilePath(path71, query);
+    if (score !== null) scored.push({ path: path71, score });
+  }
+  scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  return scored.slice(0, limit).map((entry) => entry.path);
+}
+
+// src/commands/sessions/web/listFiles.ts
+var MAX_RESULTS = 20;
+var CACHE_TTL_MS = 5e3;
+var LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
+var fileListCache = /* @__PURE__ */ new Map();
+async function repoFiles(cwd) {
+  const cached = fileListCache.get(cwd);
+  if (cached && cached.expires > Date.now()) return cached.files;
+  const output = await execGit(
+    cwd,
+    ["ls-files", "--cached", "--others", "--exclude-standard"],
+    { maxBuffer: LS_FILES_MAX_BUFFER }
+  );
+  const files = [...new Set(output.split(/\r?\n/).filter(Boolean))];
+  fileListCache.set(cwd, { files, expires: Date.now() + CACHE_TTL_MS });
+  return files;
+}
+async function listFiles(req, res) {
+  const cwd = getCwdParam(req, res);
+  if (!cwd) return;
+  const query = new URL(req.url ?? "/", "http://localhost").searchParams.get("q") ?? "";
+  try {
+    const files = await repoFiles(cwd);
+    respondJson(res, 200, { files: rankFilePaths(files, query, MAX_RESULTS) });
+  } catch {
+    respondJson(res, 500, { error: "Failed to list files" });
+  }
+}
+
 // src/commands/news/shared.ts
 import { decodeHTML } from "entities";
 function extractText(xml, tag) {
@@ -9173,7 +9254,7 @@ async function openInCode(req, res) {
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify5 } from "util";
 var execFileAsync4 = promisify5(execFile4);
-var CACHE_TTL_MS = 3e4;
+var CACHE_TTL_MS2 = 3e4;
 function createCachedGhJson(args, parse3, fallback, options2 = {}) {
   const { cacheFallback = true } = options2;
   const cache2 = /* @__PURE__ */ new Map();
@@ -9193,7 +9274,7 @@ function createCachedGhJson(args, parse3, fallback, options2 = {}) {
       value = fallback;
     }
     if (cacheFallback || value !== fallback)
-      cache2.set(key, { value, expires: now + CACHE_TTL_MS });
+      cache2.set(key, { value, expires: now + CACHE_TTL_MS2 });
     return value;
   };
 }
@@ -9561,6 +9642,7 @@ var routes2 = {
   "GET /api/git-status": gitStatus,
   "GET /api/diff": diff2,
   "GET /api/file": fileContent,
+  "GET /api/files": listFiles,
   "GET /api/jira-site": jiraSite,
   "GET /api/harness": harnessCapabilities,
   "GET /api/pr-status": prStatus,
@@ -10364,8 +10446,8 @@ function countCopyRows(data) {
 
 // src/commands/backlog/dump/parseDump.ts
 var NEWLINE = 10;
-function invalid(reason) {
-  throw new Error(`Invalid dump: ${reason}`);
+function invalid(reason2) {
+  throw new Error(`Invalid dump: ${reason2}`);
 }
 function readLine(dump, start3) {
   const eol = dump.indexOf(NEWLINE, start3);
@@ -11462,14 +11544,14 @@ async function unstar(id) {
 
 // src/commands/backlog/wontdo/index.ts
 import chalk96 from "chalk";
-async function wontdo(id, reason) {
+async function wontdo(id, reason2) {
   const found = await findOneItem(id);
   if (!found) return;
   const { orm, item } = found;
   await updateStatus(orm, item.id, "wontdo");
-  if (reason) {
+  if (reason2) {
     const phase = item.currentPhase ?? 1;
-    await appendComment(orm, item.id, reason, { phase, type: "summary" });
+    await appendComment(orm, item.id, reason2, { phase, type: "summary" });
   }
   console.log(
     chalk96.red(`Won't do item ${formatItemId(item.id)}: ${item.name}`)
@@ -12795,9 +12877,9 @@ function resolvePermission(toolName, parts) {
   if (denied) return denied;
   const reasons = [];
   for (const part of parts) {
-    const reason = isApprovedRead(part, toolName);
-    if (!reason) return void 0;
-    reasons.push(reason);
+    const reason2 = isApprovedRead(part, toolName);
+    if (!reason2) return void 0;
+    reasons.push(reason2);
   }
   return {
     permissionDecision: "allow",
@@ -12921,13 +13003,13 @@ function cliHookCheck(command, toolName = "Bash") {
   if (reportDeny(toolName, parts)) return;
   const reasons = [];
   for (const part of parts) {
-    const reason = isApprovedRead(part, toolName);
-    if (!reason) {
+    const reason2 = isApprovedRead(part, toolName);
+    if (!reason2) {
       console.log(`not approved (unrecognised: ${part})`);
       process.exitCode = 1;
       return;
     }
-    reasons.push(`  ${part} -> ${reason}`);
+    reasons.push(`  ${part} -> ${reason2}`);
   }
   console.log(`approved
 ${reasons.join("\n")}`);
@@ -15665,9 +15747,9 @@ function resolveSolution(sln) {
 }
 
 // src/commands/dotnet/filterToChangedFiles.ts
-function filterToChangedFiles(issues, changedFiles) {
+function filterToChangedFiles(issues, changedFiles2) {
   const normalize = (f) => f.replace(/\\/g, "/").replace(/^file:\/\/\//, "");
-  const changed = changedFiles.map(normalize);
+  const changed = changedFiles2.map(normalize);
   return issues.filter((i) => {
     const file = normalize(i.file);
     return changed.some((c) => file === c || file.endsWith(`/${c}`));
@@ -15785,23 +15867,23 @@ function runRoslynInspect(slnPath) {
 }
 
 // src/commands/dotnet/runEngine.ts
-function runEngine(resolved, changedFiles, options2) {
+function runEngine(resolved, changedFiles2, options2) {
   if (options2.roslyn) {
     const issues = runRoslynInspect(resolved);
-    return changedFiles ? filterToChangedFiles(issues, changedFiles) : issues;
+    return changedFiles2 ? filterToChangedFiles(issues, changedFiles2) : issues;
   }
   return parseInspectReport(
-    runInspectCode(resolved, changedFiles?.join(";") ?? null, !!options2.swea)
+    runInspectCode(resolved, changedFiles2?.join(";") ?? null, !!options2.swea)
   );
 }
 
 // src/commands/dotnet/inspect.ts
-function logScope(changedFiles) {
-  if (changedFiles === null) {
+function logScope(changedFiles2) {
+  if (changedFiles2 === null) {
     console.log(chalk149.dim("Inspecting full solution..."));
   } else {
     console.log(
-      chalk149.dim(`Inspecting ${changedFiles.length} changed file(s)...`)
+      chalk149.dim(`Inspecting ${changedFiles2.length} changed file(s)...`)
     );
   }
 }
@@ -15817,14 +15899,14 @@ async function inspect(sln, options2) {
   if (options2.roslyn) assertMsbuildInstalled();
   else assertJbInstalled();
   const scope = parseScope(options2.scope);
-  const changedFiles = getChangedCsFiles(scope);
-  if (changedFiles !== null && changedFiles.length === 0) {
+  const changedFiles2 = getChangedCsFiles(scope);
+  if (changedFiles2 !== null && changedFiles2.length === 0) {
     console.log(chalk149.green("No changed .cs files found"));
     return;
   }
-  logScope(changedFiles);
+  logScope(changedFiles2);
   const start3 = Date.now();
-  const issues = runEngine(resolved, changedFiles, options2);
+  const issues = runEngine(resolved, changedFiles2, options2);
   const elapsed = Date.now() - start3;
   const { all = false, only = [], suppress = [] } = options2;
   reportResults(filterIssues(issues, all, only, suppress), elapsed);
@@ -16076,14 +16158,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 reason = decideOverrideGuard(input, existing) ?? decideCommentGuard(input, existing) ?? decideMigrationGuard(input, existing);
-  if (!reason) return;
+  const reason2 = decideOverrideGuard(input, existing) ?? decideCommentGuard(input, existing) ?? decideMigrationGuard(input, existing);
+  if (!reason2) return;
   console.log(
     JSON.stringify({
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
         permissionDecision: "deny",
-        permissionDecisionReason: reason
+        permissionDecisionReason: reason2
       }
     })
   );
@@ -18775,16 +18857,16 @@ function reply(commentId, body) {
 
 // src/commands/prs/wontfix.ts
 import { execSync as execSync48 } from "child_process";
-function validateReason(reason) {
-  const lowerReason = reason.toLowerCase();
+function validateReason(reason2) {
+  const lowerReason = reason2.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
     console.error('Error: Reason must not contain "claude" or "opus"');
     process.exit(1);
   }
 }
-function validateShaReferences(reason) {
+function validateShaReferences(reason2) {
   const commitLinkPattern = /\[[0-9a-f]{7}\]\(https:\/\/github\.com\/[^/]+\/[^/]+\/commit\/([0-9a-f]{40})\)/gi;
-  const shas = Array.from(reason.matchAll(commitLinkPattern), (m) => m[1]);
+  const shas = Array.from(reason2.matchAll(commitLinkPattern), (m) => m[1]);
   if (shas.length === 0) {
     return;
   }
@@ -18803,11 +18885,11 @@ function validateShaReferences(reason) {
     process.exit(1);
   }
 }
-function wontfix(commentId, reason) {
-  validateReason(reason);
-  validateShaReferences(reason);
+function wontfix(commentId, reason2) {
+  validateReason(reason2);
+  validateShaReferences(reason2);
   try {
-    resolveCommentWithReply(commentId, reason);
+    resolveCommentWithReply(commentId, reason2);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -18986,8 +19068,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, reason) => {
-    wontfix(Number.parseInt(commentId, 10), reason);
+  prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason2) => {
+    wontfix(Number.parseInt(commentId, 10), reason2);
   });
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
@@ -20820,8 +20902,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename17 = path52.basename(file, path52.extname(file));
-    if (basename17 === "index") continue;
+    const basename18 = path52.basename(file, path52.extname(file));
+    if (basename18 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -20968,10 +21050,10 @@ function listFilesRecursive(dir) {
   }
   return results;
 }
-function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
+function addDirectoryFileMoves(moves, childDir, newLocation, reason2) {
   for (const file of listFilesRecursive(childDir)) {
     const rel = path55.relative(childDir, file);
-    moves.push({ from: file, to: path55.join(newLocation, rel), reason });
+    moves.push({ from: file, to: path55.join(newLocation, rel), reason: reason2 });
   }
 }
 function resolveChildDest(parentDir, childDir) {
@@ -20982,8 +21064,8 @@ function childMoveReason(parentDir) {
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
-  const reason = childMoveReason(parentDir);
-  addDirectoryFileMoves(result.moves, childDir, dest, reason);
+  const reason2 = childMoveReason(parentDir);
+  addDirectoryFileMoves(result.moves, childDir, dest, reason2);
 }
 function planChildDirectoryMove(result, parentDir, childDir) {
   const dest = resolveChildDest(parentDir, childDir);
@@ -21383,7 +21465,7 @@ function gatherContext() {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
-  const changedFiles = fetchPrChangedFiles(prInfo.prNumber);
+  const changedFiles2 = fetchPrChangedFiles(prInfo.prNumber);
   const diff3 = fetchPrDiff(prInfo.prNumber, prInfo.baseSha, prInfo.headSha);
   return {
     branch: branch2,
@@ -21394,7 +21476,7 @@ function gatherContext() {
     baseSha: prInfo.baseSha,
     headRef: prInfo.headRef,
     headSha: prInfo.headSha,
-    changedFiles,
+    changedFiles: changedFiles2,
     diff: diff3
   };
 }
@@ -25904,6 +25986,16 @@ async function gitResult(cwd, args) {
     };
   }
 }
+function gitSyncResult(cwd, args) {
+  try {
+    return { ok: true, out: gitSync(cwd, args).trim() };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function gitSync(cwd, args) {
   const { file, argv, options: options2 } = gitInvocation(cwd, args);
   return execFileSync12(file, argv, {
@@ -25918,6 +26010,8 @@ function gitSyncOrNull(cwd, args) {
     return null;
   }
 }
+
+// src/commands/sessions/daemon/worktree/listWorktreePaths.ts
 function listWorktreePaths(cwd) {
   const out = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
   if (!out) return [];
@@ -25942,6 +26036,59 @@ function gitCommonDir(cwd) {
   ]);
 }
 
+// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
+var REGISTRY_FILE = "worktrees.json";
+function readWorktreeRegistry() {
+  const data = loadJson(REGISTRY_FILE);
+  return Object.entries(data).map(([path71, record]) => ({ path: path71, ...record }));
+}
+function recordWorktree(path71, clone, origin) {
+  const data = loadJson(REGISTRY_FILE);
+  data[path71] = { clone, origin };
+  saveJson(REGISTRY_FILE, data);
+}
+function forgetWorktree(path71) {
+  const data = loadJson(REGISTRY_FILE);
+  if (!(path71 in data)) return;
+  delete data[path71];
+  saveJson(REGISTRY_FILE, data);
+}
+
+// src/commands/sessions/daemon/worktree/removeTree.ts
+async function removeTree(clone, worktreePath, force) {
+  const remove2 = (forced) => git3(clone, [
+    "worktree",
+    "remove",
+    ...forced ? ["--force"] : [],
+    worktreePath
+  ]);
+  try {
+    await remove2(force);
+    return true;
+  } catch (error) {
+    daemonLog(`worktree ${worktreePath} removal failed: ${reason(error)}`);
+  }
+  if (force) return false;
+  return await removeIgnoringLeftovers(remove2, worktreePath);
+}
+async function removeIgnoringLeftovers(remove2, worktreePath) {
+  try {
+    await remove2(true);
+    daemonLog(
+      `worktree ${worktreePath} removed on retry; only ignored files remained, its work is landed`
+    );
+    return true;
+  } catch (error) {
+    daemonLog(
+      `worktree ${worktreePath} left in place for the next reconcile: ${reason(error)}`
+    );
+    return false;
+  }
+}
+function reason(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/commands/sessions/daemon/worktree/treeDurability.ts
 import { existsSync as existsSync58 } from "fs";
 function treeDurability(state) {
@@ -25950,28 +26097,29 @@ function treeDurability(state) {
     return { durable: false, reason: "unpushed commits" };
   return { durable: true };
 }
-async function hasLocalOnlyCommits(cwd) {
-  const upstream = await gitResult(cwd, [
+function* durabilityProbes(cwd) {
+  const status3 = yield ["status", "--porcelain"];
+  if (!status3.ok)
+    return { durable: false, reason: `tree state unreadable: ${status3.error}` };
+  const upstream = yield [
     "rev-parse",
     "--abbrev-ref",
     "--symbolic-full-name",
     "@{upstream}"
-  ]);
+  ];
+  let localOnlyCommits;
   if (upstream.ok && upstream.out) {
-    const ahead = await gitResult(cwd, [
-      "rev-list",
-      "--count",
-      "@{upstream}..HEAD"
-    ]);
-    return !ahead.ok || Number(ahead.out) > 0;
+    const ahead = yield ["rev-list", "--count", "@{upstream}..HEAD"];
+    localOnlyCommits = !ahead.ok || Number(ahead.out) > 0;
+  } else {
+    const remoteBranches = yield ["branch", "-r", "--contains", "HEAD"];
+    localOnlyCommits = !remoteBranches.ok || remoteBranches.out === "";
   }
-  const remoteBranches = await gitResult(cwd, [
-    "branch",
-    "-r",
-    "--contains",
-    "HEAD"
-  ]);
-  return !remoteBranches.ok || remoteBranches.out === "";
+  return treeDurability({
+    dirty: status3.out !== "",
+    push: pushOnCommit(cwd),
+    localOnlyCommits
+  });
 }
 function pushOnCommit(cwd) {
   try {
@@ -25982,14 +26130,17 @@ function pushOnCommit(cwd) {
 }
 async function checkDurability(cwd) {
   if (!existsSync58(cwd)) return { durable: true };
-  const status3 = await gitResult(cwd, ["status", "--porcelain"]);
-  if (!status3.ok)
-    return { durable: false, reason: `tree state unreadable: ${status3.error}` };
-  return treeDurability({
-    dirty: status3.out !== "",
-    push: pushOnCommit(cwd),
-    localOnlyCommits: await hasLocalOnlyCommits(cwd)
-  });
+  const probes = durabilityProbes(cwd);
+  let step = probes.next();
+  while (!step.done) step = probes.next(await gitResult(cwd, step.value));
+  return step.value;
+}
+function checkDurabilitySync(cwd) {
+  if (!existsSync58(cwd)) return { durable: true };
+  const probes = durabilityProbes(cwd);
+  let step = probes.next();
+  while (!step.done) step = probes.next(gitSyncResult(cwd, step.value));
+  return step.value;
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
@@ -26011,22 +26162,11 @@ async function reapWorktree(worktreePath, force = false) {
     "--short",
     "HEAD"
   ]);
-  try {
-    await git3(clone, [
-      "worktree",
-      "remove",
-      ...force ? ["--force"] : [],
-      worktreePath
-    ]);
-    if (branch2) await deleteBranch(clone, branch2);
-    daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
-    return true;
-  } catch (error) {
-    daemonLog(
-      `worktree ${worktreePath} reap failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return false;
-  }
+  if (!await removeTree(clone, worktreePath, force)) return false;
+  if (branch2) await deleteBranch(clone, branch2);
+  forgetWorktree(worktreePath);
+  daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
+  return true;
 }
 async function deleteBranch(clone, branch2) {
   const current = await gitOrNull(clone, ["symbolic-ref", "--short", "HEAD"]);
@@ -26096,22 +26236,42 @@ function setStatus2(session, newStatus) {
 // src/commands/sessions/daemon/worktree/watchGitState.ts
 import { existsSync as existsSync60, watch } from "fs";
 var DEBOUNCE_MS = 500;
+var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
   if (!common || !existsSync60(common)) return void 0;
+  const watchers = [
+    watchGitDir(common, onChange),
+    pollGitState(cwd, onChange)
+  ].filter((w) => w !== void 0);
+  return { close: () => watchers.forEach((w) => w.close()) };
+}
+function watchGitDir(common, onChange) {
   let timer = null;
   try {
-    return watch(common, { recursive: true }, () => {
+    const watcher = watch(common, { recursive: true }, () => {
       if (timer) clearTimeout(timer);
       timer = setTimeout(onChange, DEBOUNCE_MS);
     });
+    return {
+      close: () => {
+        if (timer) clearTimeout(timer);
+        watcher.close();
+      }
+    };
   } catch (error) {
     daemonLog(
-      `git-state watch failed for ${cwd}: ${error instanceof Error ? error.message : String(error)}`
+      `git-state watch unavailable for ${common}, polling only: ${error instanceof Error ? error.message : String(error)}`
     );
     return void 0;
   }
 }
+function pollGitState(cwd, onChange) {
+  const timer = setInterval(onChange, POLL_MS);
+  timer.unref?.();
+  daemonLog(`git-state polled every ${POLL_MS / 1e3}s for ${cwd}`);
+  return { close: () => clearInterval(timer) };
+}
 
 // src/commands/sessions/daemon/worktree/resolveCloseDurability.ts
 async function resolveCloseDurability(session, finalize, notify2) {
@@ -26133,19 +26293,24 @@ async function resolveCloseDurability(session, finalize, notify2) {
   session.gitWatcher = void 0;
   finalize();
 }
-function holdStopped(session, tree, reason, finalize, notify2) {
-  if (session.undurable?.reason !== reason)
+function holdStopped(session, tree, reason2, finalize, notify2) {
+  if (session.undurable?.reason !== reason2)
     daemonLog(
-      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason}`
+      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason2}`
     );
-  session.undurable = { reason, removesTree: tree.removable };
+  session.undurable = { reason: reason2, removesTree: tree.removable };
   session.closing = void 0;
   setStatus2(session, "stopped");
-  if (!session.gitWatcher)
+  if (!session.gitWatcher) {
+    let rechecking = false;
     session.gitWatcher = watchGitState(tree.path, () => {
-      if (session.status !== "stopped") return;
-      void resolveCloseDurability(session, finalize, notify2);
+      if (session.status !== "stopped" || rechecking) return;
+      rechecking = true;
+      void resolveCloseDurability(session, finalize, notify2).finally(() => {
+        rechecking = false;
+      });
     });
+  }
   notify2();
 }
 
@@ -26893,6 +27058,8 @@ function respawnPlan(session) {
         status: "waiting"
       };
     if (initialPrompt) return freshClaudePlan(session, initialPrompt, cwd);
+    if (cwd && session.harness !== "pi")
+      return freshClaudePlan(session, void 0, cwd);
     return null;
   }
   if (commandType === "assist" && assistArgs) {
@@ -26921,7 +27088,7 @@ function freshClaudePlan(session, prompt, cwd) {
         claudeSessionId
       });
     },
-    status: "running"
+    status: prompt ? "running" : "waiting"
   };
 }
 
@@ -27346,9 +27513,9 @@ function restoreOne(persisted, spawn12, sessions) {
     const id = spawn12((sid) => restoreSession(sid, persisted));
     logUnresumable(persisted.name, id, sessions.get(id));
   } catch (error) {
-    const reason = logRestoreError(persisted.name, error);
+    const reason2 = logRestoreError(persisted.name, error);
     try {
-      spawn12((id) => errorSession(id, persisted, reason));
+      spawn12((id) => errorSession(id, persisted, reason2));
     } catch {
     }
   }
@@ -27360,9 +27527,9 @@ function logUnresumable(name, id, session) {
     );
 }
 function logRestoreError(name, error) {
-  const reason = error instanceof Error ? error.message : String(error);
-  daemonLog(`failed to restore session "${name}": ${reason}`);
-  return reason;
+  const reason2 = error instanceof Error ? error.message : String(error);
+  daemonLog(`failed to restore session "${name}": ${reason2}`);
+  return reason2;
 }
 
 // src/commands/sessions/daemon/sessionLimits.ts
@@ -27398,22 +27565,42 @@ function restoreAll(spawn12, sessions) {
 }
 
 // src/commands/sessions/daemon/worktree/rearmStoppedSessions.ts
+function armStoppedSession(sessions, session, notify2) {
+  void resolveCloseDurability(
+    session,
+    () => {
+      if (dismissSession(sessions, session.id)) notify2();
+    },
+    notify2
+  );
+}
 function rearmStoppedSessions(sessions, notify2) {
   for (const s of sessions.values()) {
     if (s.status !== "stopped" || !treeUnderClose(s)) continue;
-    void resolveCloseDurability(
-      s,
-      () => {
-        if (dismissSession(sessions, s.id)) notify2();
-      },
-      notify2
-    );
+    armStoppedSession(sessions, s, notify2);
   }
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync66 } from "fs";
-import { basename as basename14 } from "path";
+import { existsSync as existsSync67 } from "fs";
+import { basename as basename15 } from "path";
+
+// src/commands/sessions/daemon/worktree/accountedTrees.ts
+function accountedTrees(sessions) {
+  const accounted = /* @__PURE__ */ new Set();
+  const account = (cwd) => {
+    if (!cwd) return;
+    accounted.add(cwd);
+    const root = findRepoRoot(cwd);
+    if (root) accounted.add(root);
+  };
+  for (const s of sessions.values()) {
+    account(s.cwd);
+    account(s.worktree?.path);
+  }
+  for (const s of loadPersistedSessions()) account(s.cwd);
+  return accounted;
+}
 
 // src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
 function detectExistingWorktree(cwd) {
@@ -27490,12 +27677,6 @@ function message(error) {
 }
 
 // src/commands/sessions/daemon/worktree/bindNewWorktree.ts
-function boundTreeRoots(sessions) {
-  const roots = /* @__PURE__ */ new Set();
-  for (const session of sessions.values())
-    if (session.cwd) roots.add(findRepoRoot(session.cwd) ?? session.cwd);
-  return roots;
-}
 function bindNewWorktree(session, alloc, notify2, startHeld = () => {
 }) {
   if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
@@ -27520,66 +27701,169 @@ function bindResumedWorktree(session, cwd, notify2) {
   notify2();
 }
 
-// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
-var REGISTRY_FILE = "worktrees.json";
-function readWorktreeRegistry() {
-  const data = loadJson(REGISTRY_FILE);
-  return Object.entries(data).map(([path71, record]) => ({ path: path71, ...record }));
+// 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: [] };
 }
-function recordWorktree(path71, clone, origin) {
-  const data = loadJson(REGISTRY_FILE);
-  data[path71] = { clone, origin };
-  saveJson(REGISTRY_FILE, data);
+async function changedFiles(path71) {
+  const status3 = await gitResult(path71, ["status", "--porcelain"]);
+  const lines = status3.ok ? nonEmptyLines(status3.out) : [];
+  return {
+    summary: `${lines.length} uncommitted ${lines.length === 1 ? "file" : "files"}`,
+    items: capped(lines)
+  };
 }
-
-// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-function reconcileWorktreesOnRestore(sessions) {
-  bindRestoredWorktrees(sessions);
-  void pruneWorktrees([...sessions.values()].map((s) => s.cwd));
+async function unpushedCommits(path71, reason2) {
+  const log = await gitResult(path71, ["log", "--oneline", "@{upstream}..HEAD"]);
+  if (!log.ok) return { summary: reason2, items: [] };
+  const lines = nonEmptyLines(log.out);
+  return {
+    summary: `${lines.length} unpushed ${lines.length === 1 ? "commit" : "commits"}`,
+    items: capped(lines)
+  };
 }
-async function pruneWorktrees(liveCwds) {
-  const accounted = /* @__PURE__ */ new Set();
-  for (const cwd of liveCwds) if (cwd) accounted.add(cwd);
-  for (const s of loadPersistedSessions()) accounted.add(s.cwd);
-  const clonesToPrune = /* @__PURE__ */ new Set();
-  const orphanBranches = [];
-  for (const { path: path71, clone } of readWorktreeRegistry()) {
-    if (accounted.has(path71)) continue;
-    if (!existsSync66(path71)) {
-      clonesToPrune.add(clone);
-      orphanBranches.push({ clone, branch: basename14(path71) });
-      continue;
-    }
-    daemonLog(`worktree ${path71} orphaned across restart; reconciling`);
-    await reapWorktree(path71);
+function nonEmptyLines(out) {
+  return out.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+function capped(lines) {
+  if (lines.length <= MAX_ITEMS) return lines;
+  return [
+    ...lines.slice(0, MAX_ITEMS),
+    `\u2026 and ${lines.length - MAX_ITEMS} more`
+  ];
+}
+
+// src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
+import { existsSync as existsSync66 } from "fs";
+async function reclaimVanishedWorktrees(clone, paths) {
+  if (!existsSync66(clone)) {
+    for (const { path: path71 } of paths) forgetWorktree(path71);
+    daemonLog(
+      `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
+    );
+    return;
   }
-  for (const clone of clonesToPrune) {
-    if (!existsSync66(clone)) continue;
-    try {
-      await git3(clone, ["worktree", "prune"]);
-      daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
-    } catch {
-    }
+  await pruneBookkeeping(clone);
+  for (const { path: path71, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path71);
+}
+async function pruneBookkeeping(clone) {
+  try {
+    await git3(clone, ["worktree", "prune"]);
+    daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
+  } catch (error) {
+    daemonLog(
+      `worktree bookkeeping prune failed for clone ${clone}: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  for (const { clone, branch: branch2 } of orphanBranches)
-    if (existsSync66(clone)) await pruneStaleWorktreeBranch(clone, branch2);
 }
-async function pruneStaleWorktreeBranch(clone, branch2) {
-  if (!listLocalBranches(clone).includes(branch2)) return;
+async function reclaimBranch(clone, branch2) {
+  if (!listLocalBranches(clone).includes(branch2)) return true;
   try {
     await git3(clone, ["branch", "-d", branch2]);
     daemonLog(`stale worktree branch ${branch2} pruned from clone ${clone}`);
+    return true;
   } catch {
     daemonLog(
       `stale worktree branch ${branch2} retained (unmerged; surfaced not destroyed) in clone ${clone}`
     );
+    return false;
+  }
+}
+
+// src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
+import { basename as basename14 } from "path";
+function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
+  const { orphan, reason: reason2, held } = recovered;
+  let id;
+  try {
+    id = spawnWith((sid) => orphanedSession(sid, recovered));
+  } catch (error) {
+    daemonLog(
+      `orphaned worktree ${orphan.path} left in place, no card available: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  daemonLog(
+    `orphaned worktree ${orphan.path} resurfaced as stopped session ${id}: ${reason2} (${held.summary})`
+  );
+  const session = sessions.get(id);
+  if (session) armStoppedSession(sessions, session, notify2);
+  notify2();
+}
+function orphanedSession(id, recovered) {
+  const { orphan, reason: reason2, held } = recovered;
+  return {
+    ...sessionBase(id, "stopped"),
+    name: `recovered ${basename14(orphan.path)}`,
+    subtitle: `${held.summary} in ${orphan.path}`,
+    commandType: "claude",
+    pty: null,
+    cwd: orphan.path,
+    worktree: { path: orphan.path, clone: orphan.clone },
+    undurable: { reason: reason2, removesTree: true },
+    scrollback: recoveryNotice(recovered)
+  };
+}
+function recoveryNotice({ orphan, held }) {
+  return [
+    `\r
+\x1B[33mRecovered workspace ${orphan.path}\x1B[0m\r
+`,
+    `Its session is gone, but the workspace still holds ${held.summary}:\r
+`,
+    ...held.items.map((item) => `  ${item}\r
+`),
+    "\r\nThis card is the handle for it: land the work and the workspace is removed on its own,\r\n",
+    "restart to put an agent back in it, or discard to delete it and the work it holds.\r\n"
+  ].join("");
+}
+
+// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
+function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
+  bindRestoredWorktrees(sessions);
+  void recoverOrphanedWorktrees(sessions, spawnWith, notify2);
+}
+async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
+  const accounted = accountedTrees(sessions);
+  const vanished = /* @__PURE__ */ new Map();
+  for (const { path: path71, clone } of readWorktreeRegistry()) {
+    if (accounted.has(path71)) continue;
+    if (!existsSync67(path71)) {
+      vanished.set(clone, [
+        ...vanished.get(clone) ?? [],
+        { path: path71, branch: basename15(path71) }
+      ]);
+      continue;
+    }
+    await recoverOrphan(sessions, spawnWith, { path: path71, clone }, notify2);
   }
+  for (const [clone, paths] of vanished)
+    await reclaimVanishedWorktrees(clone, paths);
+}
+async function recoverOrphan(sessions, spawnWith, orphan, notify2) {
+  daemonLog(`worktree ${orphan.path} orphaned across restart; reconciling`);
+  const durability = await checkDurability(orphan.path);
+  if (durability.durable) {
+    await reapWorktree(orphan.path);
+    return;
+  }
+  const held = await describeHeldWork(orphan.path, durability.reason);
+  resurfaceOrphanedWorktree(
+    sessions,
+    spawnWith,
+    { orphan, reason: durability.reason, held },
+    notify2
+  );
 }
 
 // src/commands/sessions/daemon/restoreAllSessions.ts
 function restoreAllSessions(spawnWith, sessions, notify2) {
   const names = restoreAll(spawnWith, sessions);
-  reconcileWorktreesOnRestore(sessions);
+  reconcileWorktreesOnRestore(sessions, spawnWith, notify2);
   rearmStoppedSessions(sessions, notify2);
   return names;
 }
@@ -27727,7 +28011,7 @@ function treeSpawnContext(sessions, spawnWith, notify2, clients, onStatusChange)
 }
 
 // src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync67, watch as watch3 } from "fs";
+import { existsSync as existsSync68, watch as watch3 } from "fs";
 
 // src/commands/sessions/daemon/reconcileTranscriptStatus.ts
 async function resolveTranscriptPath(session) {
@@ -27762,7 +28046,7 @@ function watchTranscript(session, onStatusChange) {
   if (!session.cwd || !session.claudeSessionId) return;
   if (session.watchedTranscriptId === session.claudeSessionId) return;
   const dir = projectDirForCwd(session.cwd);
-  if (!existsSync67(dir)) return;
+  if (!existsSync68(dir)) return;
   if (session.transcriptWatcher) {
     session.transcriptWatcher.close();
     session.transcriptWatcher = void 0;
@@ -27913,13 +28197,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync68, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync69, readFileSync as readFileSync49 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync68(sessionsFile)) return false;
+    if (!existsSync69(sessionsFile)) return false;
     const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -28507,16 +28791,16 @@ function resumeSession(id, sessionId, cwd, name) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync69 } from "fs";
-import { basename as basename16, dirname as dirname31 } from "path";
+import { existsSync as existsSync70 } from "fs";
+import { basename as basename17, dirname as dirname31 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename15, join as join72 } from "path";
+import { basename as basename16, join as join72 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
-  const name = basename15(clone);
+  const name = basename16(clone);
   for (let n = 2; n < 1e3; n++) {
     const candidate = join72(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
@@ -28532,7 +28816,7 @@ function createWorktree(clone, root, boundTreeRoots2) {
   const path71 = nextWorktreePath(
     clone,
     base,
-    (candidate) => registered.has(candidate) || existsSync69(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
+    (candidate) => registered.has(candidate) || existsSync70(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename17(candidate))
   );
   const trunk = cloneTrunkBranch(clone);
   gitSync(clone, ["config", "push.default", "upstream"]);
@@ -28541,13 +28825,13 @@ function createWorktree(clone, root, boundTreeRoots2) {
     "add",
     "--track",
     "-b",
-    basename16(path71),
+    basename17(path71),
     path71,
     `origin/${trunk}`
   ]);
   recordWorktree(path71, clone, getCurrentOrigin(clone));
   daemonLog(
-    `worktree allocated ${path71} (branch ${basename16(path71)} tracking origin/${trunk}) for clone ${clone}`
+    `worktree allocated ${path71} (branch ${basename17(path71)} tracking origin/${trunk}) for clone ${clone}`
   );
   return path71;
 }
@@ -28581,6 +28865,30 @@ function allocateTree(requestedCwd, boundTreeRoots2) {
   return { cwd: path71, kind: "worktree", created: true, clone };
 }
 
+// src/commands/sessions/daemon/worktree/boundTreeRoots.ts
+function boundTreeRoots(sessions) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const session of sessions.values()) {
+    const root = treeRootOf(session);
+    if (root && !roots.has(root) && holdsTree(session, root)) roots.add(root);
+  }
+  return roots;
+}
+function treeRootOf(session) {
+  if (!session.cwd) return void 0;
+  return findRepoRoot(session.cwd) ?? session.cwd;
+}
+function holdsTree(session, root) {
+  if (session.closing) return true;
+  if (session.status !== "done" && session.status !== "error") return true;
+  if (!worktreeConfigFor(root).enabled) return true;
+  const durability = checkDurabilitySync(root);
+  daemonLog(
+    durability.durable ? `tree ${root} free for allocation: session ${session.id} finished and its work is landed` : `tree ${root} still held by finished session ${session.id}: ${durability.reason}`
+  );
+  return !durability.durable;
+}
+
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
 function allocateAndBind(ctx, cwd, create) {
   const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions));