@staff0rd/assist 0.482.0 → 0.483.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.482.0",
+  version: "0.483.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -399,7 +399,7 @@ var DEFAULT_WAKE_WORDS = ["computer"];
 var DEFAULT_MODELS_DIR = "~/.assist/voice/models";
 var DEFAULT_BACKUP_DIR = "~/.assist/backups";
 var DEFAULT_CLONE_DIR = "~/git";
-var assistConfigSchema = z2.strictObject({
+var assistConfigShape = {
   backup: z2.strictObject({
     dir: z2.string().default(DEFAULT_BACKUP_DIR)
   }).default({ dir: DEFAULT_BACKUP_DIR }),
@@ -451,7 +451,6 @@ var assistConfigSchema = z2.strictObject({
     required: z2.boolean().default(false),
     promptJira: z2.boolean().default(false)
   }).optional(),
-  repos: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional(),
   worktree: z2.strictObject({
     enabled: z2.boolean().default(false),
     trunk: z2.boolean().default(false),
@@ -571,6 +570,11 @@ var assistConfigSchema = z2.strictObject({
     modelsDir: DEFAULT_MODELS_DIR,
     models: {}
   })
+};
+var repoConfigSchema = z2.strictObject(assistConfigShape).partial();
+var assistConfigSchema = z2.strictObject({
+  ...assistConfigShape,
+  repos: z2.record(z2.string(), repoConfigSchema).optional()
 });
 
 // src/shared/loadConfigFrom.ts
@@ -6665,10 +6669,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 +8336,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 +8389,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 +8975,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 +8994,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 +9005,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;
@@ -9568,7 +9572,7 @@ function readConfigEntries(cwd) {
       value: getNestedValue(config, leaf.key),
       source,
       sources,
-      ...source === "repo" && layers.repoKey ? { repoKey: layers.repoKey } : {},
+      ...layers.repoKey ? { repoKey: layers.repoKey } : {},
       globalOnly: isGlobalOnlyConfigKey(leaf.key),
       node: configEntryNode(schema2, leaf.key)
     };
@@ -10402,90 +10406,6 @@ function sessionView(_req, res) {
   respondJson(res, 200, { floatWaiting });
 }
 
-// src/commands/config/setNestedValue.ts
-function isPlainObject2(val) {
-  return val !== null && typeof val === "object" && !Array.isArray(val);
-}
-function isNumericKey(key) {
-  return /^\d+$/.test(key);
-}
-function resolveKey(key) {
-  return isNumericKey(key) ? Number.parseInt(key, 10) : key;
-}
-function getItem(container, key) {
-  if (Array.isArray(container)) return container[key];
-  return container[key];
-}
-function setItem(container, key, value) {
-  if (Array.isArray(container)) container[key] = value;
-  else container[key] = value;
-}
-function ensureArray(container, key) {
-  const existing = getItem(container, key);
-  const arr = Array.isArray(existing) ? [...existing] : [];
-  setItem(container, key, arr);
-  return arr;
-}
-function ensureObject(container, key) {
-  const existing = getItem(container, key);
-  const obj = isPlainObject2(existing) ? { ...existing } : {};
-  setItem(container, key, obj);
-  return obj;
-}
-function stepIntoNested(container, key, nextKey) {
-  const resolved = resolveKey(key);
-  if (nextKey !== void 0 && isNumericKey(nextKey)) {
-    return ensureArray(container, resolved);
-  }
-  return ensureObject(container, resolved);
-}
-function setNestedValue(obj, path71, value) {
-  const keys = path71.split(".");
-  const result = { ...obj };
-  let current = result;
-  for (let i = 0; i < keys.length - 1; i++) {
-    current = stepIntoNested(current, keys[i], keys[i + 1]);
-  }
-  setItem(current, resolveKey(keys[keys.length - 1]), value);
-  return result;
-}
-
-// src/commands/config/validateConfig.ts
-function validateConfig(updated, key) {
-  const result = assistConfigSchema.safeParse(updated);
-  if (result.success) return { ok: true };
-  return {
-    ok: false,
-    errors: result.error.issues.map((issue) => formatIssue(issue, key))
-  };
-}
-function formatIssue(issue, key) {
-  const path71 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return `${path71}: ${issue.message}`;
-}
-
-// src/commands/config/applyConfigSet.ts
-function applyConfigSet(key, coerced, global, cwd = process.cwd()) {
-  if (!global && isGlobalOnlyConfigKey(key)) {
-    return {
-      ok: false,
-      errors: [
-        `"${key}" is a global-only key. Use --global to set it in ~/.assist.yml`
-      ]
-    };
-  }
-  const raw = global ? loadGlobalConfigRaw() : loadProjectConfig(cwd);
-  const updated = setNestedValue(raw, key, coerced);
-  const validation = validateConfig(updated, key);
-  if (!validation.ok) return validation;
-  if (global) {
-    saveGlobalConfig(updated);
-    return { ok: true, target: "global" };
-  }
-  saveConfig(updated, cwd);
-  return { ok: true, target: "project" };
-}
-
 // src/commands/config/coerceConfigScalar.ts
 function coerceConfigScalar(key, raw, type) {
   if (type === "boolean") return coerceBoolean(key, raw);
@@ -10534,10 +10454,10 @@ function coerceStructuredConfigValue(key, raw) {
     return { ok: true, value: parsed.data };
   return {
     ok: false,
-    error: parsed.error.issues.map((issue) => formatIssue2(key, issue)).join("\n")
+    error: parsed.error.issues.map((issue) => formatIssue(key, issue)).join("\n")
   };
 }
-function formatIssue2(key, issue) {
+function formatIssue(key, issue) {
   const path71 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
@@ -10591,6 +10511,152 @@ function coerceUnion(key, raw, types) {
   return { ok: false, error: `${key}: expected ${types.join(" or ")}` };
 }
 
+// src/commands/config/setNestedValue.ts
+function isPlainObject2(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function isNumericKey(key) {
+  return /^\d+$/.test(key);
+}
+function resolveKey(key) {
+  return isNumericKey(key) ? Number.parseInt(key, 10) : key;
+}
+function getItem(container, key) {
+  if (Array.isArray(container)) return container[key];
+  return container[key];
+}
+function setItem(container, key, value) {
+  if (Array.isArray(container)) container[key] = value;
+  else container[key] = value;
+}
+function ensureArray(container, key) {
+  const existing = getItem(container, key);
+  const arr = Array.isArray(existing) ? [...existing] : [];
+  setItem(container, key, arr);
+  return arr;
+}
+function ensureObject(container, key) {
+  const existing = getItem(container, key);
+  const obj = isPlainObject2(existing) ? { ...existing } : {};
+  setItem(container, key, obj);
+  return obj;
+}
+function stepIntoNested(container, key, nextKey) {
+  const resolved = resolveKey(key);
+  if (nextKey !== void 0 && isNumericKey(nextKey)) {
+    return ensureArray(container, resolved);
+  }
+  return ensureObject(container, resolved);
+}
+function setNestedValue(obj, path71, value) {
+  const keys = path71.split(".");
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    current = stepIntoNested(current, keys[i], keys[i + 1]);
+  }
+  setItem(current, resolveKey(keys[keys.length - 1]), value);
+  return result;
+}
+
+// src/commands/config/validateConfig.ts
+function validateConfig(updated, key, schema2 = assistConfigSchema) {
+  const result = schema2.safeParse(updated);
+  if (result.success) return { ok: true };
+  return {
+    ok: false,
+    errors: result.error.issues.map((issue) => formatIssue2(issue, key))
+  };
+}
+function formatIssue2(issue, key) {
+  const path71 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return `${path71}: ${issue.message}`;
+}
+
+// src/commands/config/applyConfigSet.ts
+function applyConfigSet(key, coerced, global, cwd = process.cwd()) {
+  if (!global && isGlobalOnlyConfigKey(key)) {
+    return {
+      ok: false,
+      errors: [
+        `"${key}" is a global-only key. Use --global to set it in ~/.assist.yml`
+      ]
+    };
+  }
+  const raw = global ? loadGlobalConfigRaw() : loadProjectConfig(cwd);
+  const updated = setNestedValue(raw, key, coerced);
+  const validation = validateConfig(updated, key);
+  if (!validation.ok) return validation;
+  if (global) {
+    saveGlobalConfig(updated);
+    return { ok: true, target: "global" };
+  }
+  saveConfig(updated, cwd);
+  return { ok: true, target: "project" };
+}
+
+// src/shared/resolveNamedRepoWriteLabel.ts
+var UnknownRepoConfigError = class extends Error {
+  name = "UnknownRepoConfigError";
+};
+function resolveNamedRepoWriteLabel(globalRaw, name) {
+  const repos2 = globalRaw.repos;
+  const entries = repos2 && typeof repos2 === "object" && !Array.isArray(repos2) ? repos2 : {};
+  const candidates = originKeyCandidates(name);
+  const matches = Object.keys(entries).filter((key) => candidates.has(key));
+  if (matches.length === 0) {
+    throw new UnknownRepoConfigError(
+      `No repo in ~/.assist.yml matches "${name}". Use an existing repos key (full origin, org/repo, or bare repo name).`
+    );
+  }
+  if (matches.length > 1) {
+    throw new AmbiguousRepoConfigError(
+      `Ambiguous repos config in ~/.assist.yml: keys ${matches.map((m) => `"${m}"`).join(", ")} all match "${name}". Keep a single key per repository.`
+    );
+  }
+  return matches[0];
+}
+
+// src/commands/config/applyRepoConfigSet.ts
+function applyRepoConfigSet(key, coerced, repoName, cwd = process.cwd()) {
+  if (isGlobalOnlyConfigKey(key)) {
+    return {
+      ok: false,
+      errors: [
+        `"${key}" is a global-only key. Set it in ~/.assist.yml rather than under repos:`
+      ]
+    };
+  }
+  const globalRaw = loadGlobalConfigRaw();
+  const label2 = repoName === void 0 ? resolveRepoWriteLabel(globalRaw, getCurrentOrigin(cwd)) : resolveNamedRepoWriteLabel(globalRaw, repoName);
+  const repos2 = isPlainObject3(globalRaw.repos) ? { ...globalRaw.repos } : {};
+  const existingBlock = isPlainObject3(repos2[label2]) ? repos2[label2] : {};
+  const updatedBlock = setNestedValue(existingBlock, key, coerced);
+  const validation = validateConfig(updatedBlock, key, repoConfigSchema);
+  if (!validation.ok) return validation;
+  repos2[label2] = updatedBlock;
+  saveGlobalConfig({ ...globalRaw, repos: repos2 });
+  return { ok: true, target: "repo", label: label2 };
+}
+function isPlainObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/commands/sessions/web/applyScopedConfigSet.ts
+function applyScopedConfigSet(key, value, cwd, scope) {
+  if (scope === "repo") {
+    const result2 = applyRepoConfigSet(key, value, void 0, cwd);
+    return result2.ok ? { ok: true, payload: { target: result2.target, repoKey: result2.label } } : result2;
+  }
+  const result = applyConfigSet(key, value, scope === "global", cwd);
+  return result.ok ? { ok: true, payload: { target: result.target } } : result;
+}
+
+// src/commands/config/ConfigWriteScope.ts
+function isConfigWriteScope(value) {
+  return value === "project" || value === "global" || value === "repo";
+}
+
 // src/commands/sessions/web/readJsonBody.ts
 async function readJsonBody(req) {
   const chunks = [];
@@ -10611,9 +10677,9 @@ async function parseConfigWriteRequest(req) {
     return { ok: false, error: "Missing key" };
   if (typeof cwd !== "string" || cwd === "")
     return { ok: false, error: "Missing cwd" };
-  if (scope !== "project" && scope !== "global")
-    return { ok: false, error: 'scope must be "project" or "global"' };
-  return { ok: true, key, value: body.value, cwd, global: scope === "global" };
+  if (!isConfigWriteScope(scope))
+    return { ok: false, error: 'scope must be "project", "global" or "repo"' };
+  return { ok: true, key, value: body.value, cwd, scope };
 }
 
 // src/commands/sessions/web/handleConfigWrite.ts
@@ -10645,22 +10711,21 @@ function setConfig(req, res) {
   return handleConfigWrite(req, res, (request) => {
     const coerced = coerceConfigValue(request.key, request.value);
     if (!coerced.ok) return { ok: false, errors: [coerced.error] };
-    const result = applyConfigSet(
+    return applyScopedConfigSet(
       request.key,
       coerced.value,
-      request.global,
-      request.cwd
+      request.cwd,
+      request.scope
     );
-    return result.ok ? { ok: true, payload: { target: result.target } } : result;
   });
 }
 
 // src/commands/config/unsetNestedValue.ts
-function isPlainObject3(val) {
+function isPlainObject4(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
 }
 function isContainer(val) {
-  return Array.isArray(val) || isPlainObject3(val);
+  return Array.isArray(val) || isPlainObject4(val);
 }
 function isNumericKey2(key) {
   return /^\d+$/.test(key);
@@ -10696,7 +10761,7 @@ function withChild(container, key, child) {
   return { ...container, [key]: child };
 }
 function isPrunable(container) {
-  return isPlainObject3(container) && Object.keys(container).length === 0;
+  return isPlainObject4(container) && Object.keys(container).length === 0;
 }
 function replaceOrPrune(container, key, child) {
   return isPrunable(child) ? withoutKey(container, key) : withChild(container, key, child);
@@ -10755,7 +10820,18 @@ function unsetConfig(req, res) {
   return handleConfigWrite(req, res, (request) => {
     if (!isKnownConfigKey(request.key))
       return { ok: false, errors: [`Unknown config key "${request.key}"`] };
-    const result = applyConfigUnset(request.key, request.global, request.cwd);
+    if (request.scope === "repo")
+      return {
+        ok: false,
+        errors: [
+          "Clearing a repos override is not supported \u2014 remove the key from repos: in ~/.assist.yml"
+        ]
+      };
+    const result = applyConfigUnset(
+      request.key,
+      request.scope === "global",
+      request.cwd
+    );
     return result.ok ? {
       ok: true,
       payload: { target: result.target, removed: result.removed }
@@ -11750,8 +11826,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 +13199,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 +14773,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 +14899,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")}`);
@@ -16166,28 +16242,6 @@ function exitKeyNotSet(key) {
 // src/commands/config/configSet.ts
 import chalk131 from "chalk";
 
-// src/shared/resolveNamedRepoWriteLabel.ts
-var UnknownRepoConfigError = class extends Error {
-  name = "UnknownRepoConfigError";
-};
-function resolveNamedRepoWriteLabel(globalRaw, name) {
-  const repos2 = globalRaw.repos;
-  const entries = repos2 && typeof repos2 === "object" && !Array.isArray(repos2) ? repos2 : {};
-  const candidates = originKeyCandidates(name);
-  const matches = Object.keys(entries).filter((key) => candidates.has(key));
-  if (matches.length === 0) {
-    throw new UnknownRepoConfigError(
-      `No repo in ~/.assist.yml matches "${name}". Use an existing repos key (full origin, org/repo, or bare repo name).`
-    );
-  }
-  if (matches.length > 1) {
-    throw new AmbiguousRepoConfigError(
-      `Ambiguous repos config in ~/.assist.yml: keys ${matches.map((m) => `"${m}"`).join(", ")} all match "${name}". Keep a single key per repository.`
-    );
-  }
-  return matches[0];
-}
-
 // src/commands/config/exitWithConfigErrors.ts
 import chalk130 from "chalk";
 function exitWithConfigErrors(errors) {
@@ -16195,23 +16249,6 @@ function exitWithConfigErrors(errors) {
   process.exit(1);
 }
 
-// src/commands/config/applyRepoConfigSet.ts
-function applyRepoConfigSet(key, coerced, repoName) {
-  const globalRaw = loadGlobalConfigRaw();
-  const label2 = repoName === void 0 ? resolveRepoWriteLabel(globalRaw, getCurrentOrigin(process.cwd())) : resolveNamedRepoWriteLabel(globalRaw, repoName);
-  const repos2 = isPlainObject4(globalRaw.repos) ? { ...globalRaw.repos } : {};
-  const existingBlock = isPlainObject4(repos2[label2]) ? repos2[label2] : {};
-  const updatedBlock = setNestedValue(existingBlock, key, coerced);
-  const validation = validateConfig(updatedBlock, key);
-  if (!validation.ok) exitWithConfigErrors(validation.errors);
-  repos2[label2] = updatedBlock;
-  saveGlobalConfig({ ...globalRaw, repos: repos2 });
-  return label2;
-}
-function isPlainObject4(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
 // src/commands/config/resolveRepoTarget.ts
 function resolveRepoTarget(key, value, repo) {
   if (typeof repo === "string") {
@@ -16237,7 +16274,7 @@ function configSet(key, value, options2 = {}) {
     process.exit(1);
   }
   const coerced = coerceValue(resolved.value);
-  const target = resolved.useRepo ? `repo: ${applyRepoConfigSet(resolved.key, coerced, resolved.repoName)}` : applyOrExit(resolved.key, coerced, options2.global ?? false);
+  const target = resolved.useRepo ? `repo: ${applyRepoOrExit(resolved.key, coerced, resolved.repoName)}` : applyOrExit(resolved.key, coerced, options2.global ?? false);
   console.log(
     chalk131.green(`Set ${resolved.key} = ${JSON.stringify(coerced)} (${target})`)
   );
@@ -16247,6 +16284,11 @@ function applyOrExit(key, coerced, global) {
   if (!result.ok) exitWithConfigErrors(result.errors);
   return result.target;
 }
+function applyRepoOrExit(key, coerced, repoName) {
+  const result = applyRepoConfigSet(key, coerced, repoName);
+  if (!result.ok) exitWithConfigErrors(result.errors);
+  return result.label;
+}
 function coerceValue(value) {
   if (value === "true") return true;
   if (value === "false") return false;
@@ -17888,14 +17930,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 +18883,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 +18905,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 +19012,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 +20986,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 +21014,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 +21197,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 +21647,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 +21795,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 +23179,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 +23193,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 +24489,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 +24640,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 +26297,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 +26312,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 +27117,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 +27133,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 +28209,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 +28304,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 +28323,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 +28345,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 +28442,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 +28501,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 +28851,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 +28872,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 +28953,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 +29968,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 +29987,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 +30010,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 +30019,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 +30042,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 +30098,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 +30111,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 +30132,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 +30172,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 +30183,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 +30199,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 +30227,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 +30440,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 +30522,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 +30547,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 +30595,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 +30850,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 +30870,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 +31492,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 +32225,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 +32258,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync53(join73(gitDir, "HEAD"), "utf8");
+    head = readFileSync53(join75(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }