runcastle 1.4.1 → 1.4.2

package/bin/runcastle.js

@@ -909,14 +909,32 @@ var init_src = __esm(() => {
 });
 
 // ../core/src/paths.ts
-import { homedir } from "os";
+import { homedir, userInfo } from "os";
 import { join, resolve } from "path";
 function prodDataDir() {
   return join(homedir(), ".runcastle");
 }
 function dataDir() {
   const override = process.env.RUNCASTLE_DATA_DIR;
-  return override ? resolve(override) : prodDataDir();
+  const dir = override ? resolve(override) : prodDataDir();
+  if (process.env.VITEST && sameDataDir(dir, join(realHomeDir(), ".runcastle"))) {
+    throw new Error(`dataDir() resolved to the real ${dir} under Vitest; a test must run against a temp data dir (useDataDir / withTempDataDir)`);
+  }
+  return dir;
+}
+function realHomeDir() {
+  try {
+    return userInfo().homedir;
+  } catch {
+    return homedir();
+  }
+}
+function sameDataDir(a, b) {
+  const canon = (p) => {
+    const abs = resolve(p).replace(/[\\/]+$/, "");
+    return process.platform === "win32" ? abs.toLowerCase().replace(/\//g, "\\") : abs;
+  };
+  return canon(a) === canon(b);
 }
 function dbPath() {
   return join(dataDir(), "runcastle.db");
@@ -957,8 +975,11 @@ function projectNotePath(noteId) {
 function attachmentRelPath(noteId) {
   return `${ATTACHMENTS_DIR}/${noteId}.png`;
 }
+function worktreesRoot() {
+  return join(dataDir(), "worktrees");
+}
 function projectWorktreesDir(projectId) {
-  return join(dataDir(), "worktrees", projectId);
+  return join(worktreesRoot(), projectId);
 }
 function worktreeDir(projectId, slug) {
   return join(projectWorktreesDir(projectId), slug);
@@ -3032,6 +3053,7 @@ import {
   mkdtempSync,
   readFileSync as readFileSync3,
   realpathSync,
+  rmdirSync,
   rmSync,
   writeFileSync
 } from "fs";
@@ -3269,7 +3291,21 @@ async function reclaimTalkBranch(g, repoPath, worktreePath, branch) {
   throw new InvalidInputError(`${branch} is checked out at ${strays[0] ?? repoPath}; end the test drive or remove that worktree`);
 }
 async function addWorktree(g, worktreePath, branch, label) {
-  mkdirSync2(dirname2(worktreePath), { recursive: true });
+  const parent = dirname2(worktreePath);
+  mkdirSync2(parent, { recursive: true });
+  try {
+    return await addWorktreeOrRepair(g, worktreePath, branch, label);
+  } catch (e) {
+    removeIfEmpty(parent);
+    throw e;
+  }
+}
+function removeIfEmpty(dir) {
+  try {
+    rmdirSync(dir);
+  } catch {}
+}
+async function addWorktreeOrRepair(g, worktreePath, branch, label) {
   try {
     await g.raw(["worktree", "add", worktreePath, branch]);
     return worktreePath;
@@ -3524,14 +3560,18 @@ async function unexcludePath(repoPath, pattern) {
     writeFileSync(file, next);
 }
 async function cleanupBurnWorktree(repoPath, branch, opts = {}) {
-  const path = burnWorktreePath(repoPath, branch);
+  return discardWorktree(repoPath, burnWorktreePath(repoPath, branch), opts);
+}
+async function discardWorktree(repoPath, path, opts = {}) {
   const attempts = Math.max(1, opts.attempts ?? 3);
   const delayMs = opts.delayMs ?? 750;
-  const g = git(repoPath);
-  for (let attempt = 1;attempt <= attempts && existsSync6(path); attempt++) {
+  const gitQuietly = async (args) => {
     try {
-      await g.raw(["worktree", "remove", "--force", path]);
+      await git(repoPath).raw(args);
     } catch {}
+  };
+  for (let attempt = 1;attempt <= attempts && existsSync6(path); attempt++) {
+    await gitQuietly(["worktree", "remove", "--force", path]);
     if (existsSync6(path) && attempt < attempts)
       await sleep2(delayMs);
   }
@@ -3540,9 +3580,7 @@ async function cleanupBurnWorktree(repoPath, branch, opts = {}) {
       rmSync(path, { recursive: true, force: true });
     } catch {}
   }
-  try {
-    await g.raw(["worktree", "prune"]);
-  } catch {}
+  await gitQuietly(["worktree", "prune"]);
   return !existsSync6(path);
 }
 function sleep2(ms) {
@@ -3813,19 +3851,19 @@ async function cleanupTempBranches(repoPath) {
   return { deleted, kept };
 }
 async function removeTalkWorktree(repoPath, worktreePath) {
-  const g = git(repoPath);
-  try {
-    await g.raw(["worktree", "remove", "--force", worktreePath]);
-  } catch {
-    try {
-      rmSync(worktreePath, { recursive: true, force: true });
-    } catch {}
+  if (!await discardWorktree(repoPath, worktreePath, { attempts: 1 })) {
+    throw new InvalidInputError(`could not remove talk worktree at ${worktreePath} \u2014 a file may be locked; ` + "close anything using it and retry the delete");
   }
+}
+async function worktreeState(path) {
+  if (!existsSync6(path))
+    return "missing";
+  if (!existsSync6(join6(path, ".git")))
+    return "not-a-checkout";
   try {
-    await g.raw(["worktree", "prune"]);
-  } catch {}
-  if (existsSync6(worktreePath)) {
-    throw new InvalidInputError(`could not remove talk worktree at ${worktreePath} \u2014 a file may be locked; ` + "close anything using it and retry the delete");
+    return (await git(path).raw(["status", "--porcelain"])).trim() === "" ? "clean" : "dirty";
+  } catch {
+    return "unreadable";
   }
 }
 async function deleteFeatureBranches(repoPath, slug) {
@@ -4042,6 +4080,7 @@ async function testDrive(ctx, project, feature, action, purpose = "human") {
   testDriveState = {
     kind: "feature",
     purpose,
+    projectId: project.id,
     featureId: feature.id,
     branch,
     previousBranch,
@@ -4445,7 +4484,7 @@ async function detectDbDrift(ctx, project, feature, previousBranch, driveBranch)
 }
 async function mergeFeature(project, feature) {
   const target = featureBase(feature);
-  if (testDriveState) {
+  if (testDriveState?.projectId === project.id) {
     throw new GateError("Cannot merge while a test drive is active \u2014 stop it first");
   }
   const g = git(project.repoPath);
@@ -6949,6 +6988,15 @@ function staleImage(detail, unchecked = "") {
     fix: "Open Settings \u2192 Burns (Rebuild image)."
   };
 }
+function imageUncheckable() {
+  return {
+    ...IMAGE_ROW,
+    status: "unhealthy",
+    severity: "error",
+    detail: "cannot inspect the image while the container runtime is not responding",
+    fix: "Get the container runtime answering first (see the container runtime row), then re-run doctor."
+  };
+}
 async function runDoctor(env) {
   const { exec } = env;
   const processEnv = env.env ?? process.env;
@@ -6969,7 +7017,8 @@ async function runDoctor(env) {
       severity: required.has(runtime) ? "error" : "info"
     }));
   }
-  results.push(await gitIdentityProbe(exec, env.cwd), await containerRuntimeProbe(exec), await sandcastleImageProbe({
+  const containerRuntime = await containerRuntimeProbe(exec);
+  results.push(await gitIdentityProbe(exec, env.cwd), containerRuntime, RUNTIME_DOWN.has(containerRuntime.status) ? imageUncheckable() : await sandcastleImageProbe({
     exec,
     imageName,
     burnerDockerfile,
@@ -6990,7 +7039,7 @@ function exitCodeFor(report, mode) {
     return report.tier1Ok ? 0 : 1;
   return report.ok ? 0 : 1;
 }
-var RUNTIME_SPECS, IMAGE_ROW;
+var RUNTIME_SPECS, IMAGE_ROW, RUNTIME_DOWN;
 var init_doctor = __esm(() => {
   init_src();
   init_asset_paths();
@@ -7029,6 +7078,7 @@ var init_doctor = __esm(() => {
     }
   };
   IMAGE_ROW = { id: "sandcastle-image", label: "Sandcastle container image", tier: 2 };
+  RUNTIME_DOWN = new Set(["daemon-dead", "machine-stopped"]);
 });
 
 // src/launcher/runtimes/codex.ts
@@ -7605,9 +7655,111 @@ var init_runtime = __esm(() => {
   init_paths();
 });
 
+// src/services/feature-worktrees.ts
+import { readdirSync as readdirSync3, rmSync as rmSync2 } from "fs";
+import { join as join14 } from "path";
+async function retireShippedWorktree(ctx, project, feature) {
+  await retireWorktree(ctx, project, feature, { requireClean: false });
+}
+async function retireArchivedWorktree(ctx, project, feature) {
+  await retireWorktree(ctx, project, feature, { requireClean: true });
+}
+async function retireWorktree(ctx, project, feature, opts) {
+  const path = worktreeDir(project.id, feature.slug);
+  const state = await worktreeState(path);
+  if (state === "missing")
+    return;
+  const kept = keptReason(ctx, feature, state, opts);
+  if (kept) {
+    emit(ctx, feature.id, {
+      type: "feature.worktree_kept",
+      message: `talk worktree kept \u2014 ${kept}`,
+      data: { path, reason: kept }
+    });
+    return;
+  }
+  if (await discardWorktree(project.repoPath, path)) {
+    emit(ctx, feature.id, {
+      type: "feature.worktree_removed",
+      message: "talk worktree removed",
+      data: { path }
+    });
+  } else {
+    emit(ctx, feature.id, {
+      type: "feature.worktree_remove_failed",
+      message: `could not remove the talk worktree at ${path} \u2014 a file may be locked`,
+      data: { path }
+    });
+  }
+}
+function keptReason(ctx, feature, state, opts) {
+  if (activeSessionsForFeature(ctx, feature.id).length > 0)
+    return "a session is live on it";
+  if (hasActiveRun(ctx, feature.id))
+    return "a run is in progress";
+  if (opts.requireClean && state !== "clean")
+    return "uncommitted changes";
+  return;
+}
+async function sweepFeatureWorktrees(ctx) {
+  const sweep = { removed: 0, kept: 0, failed: 0, orphanProjects: 0 };
+  const root = worktreesRoot();
+  const projectsById = new Map(allProjects(ctx).map((p) => [p.id, p]));
+  const statusBySlug = new Map(ctx.db.select({ projectId: features.projectId, slug: features.slug, status: features.status }).from(features).all().map((f) => [`${f.projectId}/${f.slug}`, f.status]));
+  for (const projectId of subdirs(root)) {
+    const project = projectsById.get(projectId);
+    if (!project) {
+      try {
+        rmSync2(join14(root, projectId), { recursive: true, force: true });
+        sweep.orphanProjects++;
+      } catch {
+        sweep.failed++;
+      }
+      continue;
+    }
+    for (const slug of subdirs(join14(root, projectId))) {
+      if (slug.startsWith("_"))
+        continue;
+      const status = statusBySlug.get(`${projectId}/${slug}`);
+      if (status === "active" || status === "draft")
+        continue;
+      const path = worktreeDir(projectId, slug);
+      const state = await worktreeState(path);
+      if (!sweepable(status, state)) {
+        sweep.kept++;
+      } else if (await discardWorktree(project.repoPath, path, { attempts: 1 })) {
+        sweep.removed++;
+      } else {
+        sweep.failed++;
+      }
+    }
+  }
+  return sweep;
+}
+function sweepable(status, state) {
+  if (status === "shipped")
+    return true;
+  return state === "clean" || state === "not-a-checkout";
+}
+function subdirs(dir) {
+  try {
+    return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+var init_feature_worktrees = __esm(() => {
+  init_paths();
+  init_schema();
+  init_sessions();
+  init_events();
+  init_git();
+  init_repo();
+});
+
 // src/services/knowledge.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join14, relative as relative2, resolve as resolve8, sep } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join15, relative as relative2, resolve as resolve8, sep } from "path";
 function scaffoldDocs(ctx, feature, opts = {}) {
   const project = projectForFeature(ctx, feature);
   const dir = featureDocsDir(project, feature);
@@ -7660,7 +7812,7 @@ function mapDocBody(feature, seed) {
 `);
 }
 function readCharter(repoRoot) {
-  const path = join14(repoRoot, CHARTER_FILE);
+  const path = join15(repoRoot, CHARTER_FILE);
   if (!existsSync12(path))
     return;
   try {
@@ -7670,16 +7822,16 @@ function readCharter(repoRoot) {
   }
 }
 function listLiveAdrs(repoRoot) {
-  const dir = join14(repoRoot, ADR_DIR_REL);
+  const dir = join15(repoRoot, ADR_DIR_REL);
   if (!existsSync12(dir))
     return [];
   const docs2 = [];
-  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".md"))
       continue;
     let content;
     try {
-      content = readFileSync8(join14(dir, entry.name), "utf8");
+      content = readFileSync8(join15(dir, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -7694,8 +7846,8 @@ function listDocs(ctx, feature) {
   const dir = featureDocsDir(project, feature);
   if (!existsSync12(dir))
     return [];
-  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => {
-    const path = join14(dir, e.name);
+  return readdirSync4(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => {
+    const path = join15(dir, e.name);
     return { relPath: e.name, title: readTitle(path, e.name), ...writtenAt(path) };
   }).sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
@@ -9175,7 +9327,7 @@ var Effect_exports, isFunction = (input) => typeof input === "function", dual =
     next4 = b2;
   }
   return out;
-}, getEquivalence2, dedupeWith, dedupe = (self) => dedupeWith(self, equivalence()), join15, TypeId4, emptyArray, getEquivalence3 = (isEquivalent) => make((self, that) => self.length === that.length && toReadonlyArray(self).every((value5, i) => isEquivalent(value5, unsafeGet2(that, i)))), _equivalence3, ChunkProto, makeChunk = (backing) => {
+}, getEquivalence2, dedupeWith, dedupe = (self) => dedupeWith(self, equivalence()), join16, TypeId4, emptyArray, getEquivalence3 = (isEquivalent) => make((self, that) => self.length === that.length && toReadonlyArray(self).every((value5, i) => isEquivalent(value5, unsafeGet2(that, i)))), _equivalence3, ChunkProto, makeChunk = (backing) => {
   const chunk4 = Object.create(ChunkProto);
   chunk4.backing = backing;
   switch (backing._tag) {
@@ -10874,7 +11026,7 @@ ${prefix}}`;
   Object.defineProperty(error3, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join15(options.pathDelim));
+      const path2 = pipe(this.path, join16(options.pathDelim));
       return `(Invalid data at ${path2}: "${this.message}")`;
     }
   });
@@ -10889,7 +11041,7 @@ ${prefix}}`;
   Object.defineProperty(error3, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join15(options.pathDelim));
+      const path2 = pipe(this.path, join16(options.pathDelim));
       return `(Missing data at ${path2}: "${this.message}")`;
     }
   });
@@ -10905,7 +11057,7 @@ ${prefix}}`;
   Object.defineProperty(error3, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join15(options.pathDelim));
+      const path2 = pipe(this.path, join16(options.pathDelim));
       return `(Source unavailable at ${path2}: "${this.message}")`;
     }
   });
@@ -10920,7 +11072,7 @@ ${prefix}}`;
   Object.defineProperty(error3, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join15(options.pathDelim));
+      const path2 = pipe(this.path, join16(options.pathDelim));
       return `(Unsupported operation at ${path2}: "${this.message}")`;
     }
   });
@@ -10950,7 +11102,7 @@ ${prefix}}`;
     pathDelim: "_",
     seqDelim: ","
   }, options);
-  const makePathString = (path) => pipe(path, join15(pathDelim));
+  const makePathString = (path) => pipe(path, join16(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && ("env" in process) && typeof process.env === "object" ? process.env : {};
   const load = (path, primitive2, split2 = true) => {
@@ -11071,7 +11223,7 @@ ${prefix}}`;
           return fail2(right3.left);
         }
         if (isRight2(left3) && isRight2(right3)) {
-          const path = pipe(prefix, join15("."));
+          const path = pipe(prefix, join16("."));
           const fail19 = fromFlatLoopFail(prefix, path);
           const [lefts, rights] = extend(fail19, fail19, pipe(left3.right, map3(right2)), pipe(right3.right, map3(right2)));
           return pipe(lefts, zip(rights), forEachSequential(([left4, right4]) => pipe(zip2(left4, right4), map10(([left5, right5]) => op.zip(left5, right5)))));
@@ -20909,7 +21061,7 @@ var init_chunk_VOG34SRF = __esm(() => {
     }
     return [];
   });
-  join15 = /* @__PURE__ */ dual(2, (self, sep2) => fromIterable2(self).join(sep2));
+  join16 = /* @__PURE__ */ dual(2, (self, sep2) => fromIterable2(self).join(sep2));
   TypeId4 = /* @__PURE__ */ Symbol.for("effect/Chunk");
   emptyArray = [];
   _equivalence3 = /* @__PURE__ */ getEquivalence3(equals);
@@ -54663,7 +54815,7 @@ var init_chunk_62WN33RK = __esm(() => {
 // ../../node_modules/.bun/@ai-hero+sandcastle@0.12.0/node_modules/@ai-hero/sandcastle/dist/index.js
 import { createRequire as createRequire8 } from "module";
 import { mkdirSync as mkdirSync7, appendFileSync } from "fs";
-import path, { join as join17, posix as posix4, dirname as dirname8, relative as relative3 } from "path";
+import path, { join as join18, posix as posix4, dirname as dirname8, relative as relative3 } from "path";
 import { styleText as styleText2 } from "util";
 import * as clack2 from "@clack/prompts";
 import { readdir as readdir2, access as access3, readFile as readFile4, mkdir as mkdir3, writeFile as writeFile3, rm as rm3 } from "fs/promises";
@@ -54732,7 +54884,7 @@ async function run6(options) {
   const targetBranch = effectiveBranchType === "merge-to-head" ? currentHostBranch : undefined;
   const resolvedLogging = options.logging ?? {
     type: "file",
-    path: join17(hostRepoDir, ".sandcastle", "logs", buildLogFilename(resolvedBranch, targetBranch, options.name))
+    path: join18(hostRepoDir, ".sandcastle", "logs", buildLogFilename(resolvedBranch, targetBranch, options.name))
   };
   const displayLayer = resolvedLogging.type === "file" ? (() => {
     printFileDisplayStartup({
@@ -55366,7 +55518,7 @@ ${errorDetail}`
   }
   return vars;
 }), resolveEnv = (repoDir) => Effect_exports.gen(function* () {
-  const sandcastleEnv = yield* parseEnvFile2(join17(repoDir, ".sandcastle", ".env"));
+  const sandcastleEnv = yield* parseEnvFile2(join18(repoDir, ".sandcastle", ".env"));
   const result = {};
   for (const key of Object.keys(sandcastleEnv)) {
     const value = sandcastleEnv[key] || process.env[key];
@@ -55588,11 +55740,11 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
   const normalized = isRoot ? cwd : cwd.replace(/[\\/]+$/, "");
   return normalized.replace(/^([A-Za-z]):/, "$1").replace(/[\\/]/g, "-");
 }, claudeHostSessionPath = (cwd, id3, projectsDir) => {
-  const base = projectsDir ?? join17(process.env.HOME ?? "~", ".claude", "projects");
-  return join17(base, encodeProjectPath(cwd), `${id3}.jsonl`);
+  const base = projectsDir ?? join18(process.env.HOME ?? "~", ".claude", "projects");
+  return join18(base, encodeProjectPath(cwd), `${id3}.jsonl`);
 }, claudeSandboxSessionPath = (cwd, id3, projectsDir) => posix4.join(projectsDir, encodeProjectPath(cwd), `${id3}.jsonl`), claudeSubagentsDirInSandbox = (cwd, id3, projectsDir) => posix4.join(projectsDir, encodeProjectPath(cwd), id3, "subagents"), claudeSubagentsDirOnHost = (cwd, id3, projectsDir) => {
-  const base = projectsDir ?? join17(process.env.HOME ?? "~", ".claude", "projects");
-  return join17(base, encodeProjectPath(cwd), id3, "subagents");
+  const base = projectsDir ?? join18(process.env.HOME ?? "~", ".claude", "projects");
+  return join18(base, encodeProjectPath(cwd), id3, "subagents");
 }, listClaudeSubagentSessionsInSandbox = async (cwd, id3, handle, sandboxProjectsDir) => {
   const dir = claudeSubagentsDirInSandbox(cwd, id3, sandboxProjectsDir);
   const result = await handle.exec(`find ${JSON.stringify(dir)} -type f -name ${JSON.stringify("agent-*.jsonl")} 2>/dev/null`);
@@ -55604,7 +55756,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
   return stdout.split(`
 `).filter((line) => line !== "");
 }, findClaudeSessionOnHost = async (id3, projectsDir) => {
-  const root = projectsDir ?? join17(process.env.HOME ?? "~", ".claude", "projects");
+  const root = projectsDir ?? join18(process.env.HOME ?? "~", ".claude", "projects");
   let entries;
   try {
     entries = await readdir2(root, { withFileTypes: true });
@@ -55614,7 +55766,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const candidate = join17(root, entry.name, `${id3}.jsonl`);
+    const candidate = join18(root, entry.name, `${id3}.jsonl`);
     if (await pathExists(candidate)) {
       return { path: candidate, searchedRoot: root };
     }
@@ -55650,7 +55802,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
       return;
     }
     for (const entry of entries) {
-      const child = join17(dir, entry.name);
+      const child = join18(dir, entry.name);
       if (entry.isFile() && isCodexSessionFilename(entry.name, id3)) {
         return child;
       }
@@ -55664,11 +55816,11 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
   };
   return visit(rootDir);
 }, findCodexSessionOnHost = async (id3, sessionsDir) => {
-  const root = sessionsDir ?? join17(process.env.HOME ?? "~", ".codex", "sessions");
+  const root = sessionsDir ?? join18(process.env.HOME ?? "~", ".codex", "sessions");
   const path2 = await findCodexSessionPath(root, id3);
   return { path: path2, searchedRoot: root };
 }, locateCodexHostSession = async (id3, sessionsDir) => {
-  const root = sessionsDir ?? join17(process.env.HOME ?? "~", ".codex", "sessions");
+  const root = sessionsDir ?? join18(process.env.HOME ?? "~", ".codex", "sessions");
   const path2 = await findCodexSessionPath(root, id3);
   if (!path2)
     throw new Error(`session ${id3} not found in ${root}`);
@@ -55744,7 +55896,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
   } catch {}
   return [];
 }, CURSOR_PRINT_PROMPT_MAX_BYTES, readSandboxFile = async (handle, sandboxPath, tag) => {
-  const tmpPath = join17(tmpdir4(), `sandcastle-${tag}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
+  const tmpPath = join18(tmpdir4(), `sandcastle-${tag}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
   await handle.copyFileOut(sandboxPath, tmpPath);
   try {
     return await readFile4(tmpPath, "utf-8");
@@ -55752,7 +55904,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
     await rm3(tmpPath, { force: true }).catch(() => {});
   }
 }, writeSandboxFile = async (handle, sandboxPath, content, tag) => {
-  const tmpPath = join17(tmpdir4(), `sandcastle-${tag}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
+  const tmpPath = join18(tmpdir4(), `sandcastle-${tag}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`);
   await writeFile3(tmpPath, content);
   try {
     await handle.exec(`mkdir -p ${JSON.stringify(posix4.dirname(sandboxPath))}`);
@@ -55802,7 +55954,7 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
             sourcePath: sandboxSubagentPath,
             fromCwd: sandboxCwd,
             toCwd: hostCwd,
-            destPath: join17(hostSubagentsDir, posix4.basename(sandboxSubagentPath)),
+            destPath: join18(hostSubagentsDir, posix4.basename(sandboxSubagentPath)),
             tag: "claude-sub"
           });
         } catch (err) {
@@ -55839,8 +55991,8 @@ Emit only a corrected <${error.tag}> block. Do not change files or run commands.
       const located = await locateCodexSandboxSession(sessionId, handle, sandboxSessionsDir);
       const jsonl = await readSandboxFile(handle, located.path, "codex-cap");
       const rewritten = transferCodexSession(jsonl, sandboxCwd, hostCwd);
-      const root = hostSessionsDir ?? join17(process.env.HOME ?? "~", ".codex", "sessions");
-      const target = join17(root, located.relativePath);
+      const root = hostSessionsDir ?? join18(process.env.HOME ?? "~", ".codex", "sessions");
+      const target = join18(root, located.relativePath);
       await mkdir3(dirname8(target), { recursive: true });
       await writeFile3(target, rewritten);
       capturedPaths.set(sessionId, target);
@@ -56479,8 +56631,8 @@ var init_settings = __esm(() => {
 });
 
 // src/services/setup.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync10, readdirSync as readdirSync4, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname10, join as join18 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync10, readdirSync as readdirSync5, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname10, join as join19 } from "path";
 async function writeGitIdentity(exec3, identity4) {
   const name = identity4.name.trim();
   const email = identity4.email.trim();
@@ -56590,10 +56742,10 @@ function terminalSpec(kind) {
   throw new InvalidInputError(`no terminal command for ${kind}`);
 }
 function refreshSandcastleConfig(templateDir, targetDir) {
-  const dir = join18(targetDir, ".sandcastle");
+  const dir = join19(targetDir, ".sandcastle");
   mkdirSync9(dir, { recursive: true });
-  for (const name of readdirSync4(templateDir)) {
-    copyFileSync2(join18(templateDir, name), join18(dir, name));
+  for (const name of readdirSync5(templateDir)) {
+    copyFileSync2(join19(templateDir, name), join19(dir, name));
   }
   return dir;
 }
@@ -56669,11 +56821,33 @@ var init_setup = __esm(() => {
 // src/doctor/system-exec.ts
 import { spawn as spawn7 } from "child_process";
 function createSystemExec(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS;
   return (command, args2) => new Promise((resolve10) => {
     const { file, args: spawnArgs } = resolveSpawnTarget(command, args2);
     let stdout = "";
     let stderr = "";
+    let settled = false;
+    const settle = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve10(outcome);
+    };
     const child = spawn7(file, spawnArgs, { cwd: opts.cwd, windowsHide: true });
+    const timer = setTimeout(() => {
+      if (child.pid !== undefined)
+        killProcessTree(child.pid);
+      const note2 = `${command} ${args2.join(" ")} timed out after ${Math.round(timeoutMs / 1000)}s`;
+      settle({
+        ok: true,
+        code: null,
+        stdout,
+        stderr: stderr ? `${stderr}
+${note2}` : note2,
+        timedOut: true
+      });
+    }, timeoutMs);
     child.stdout?.on("data", (d) => {
       stdout += d.toString();
     });
@@ -56681,14 +56855,16 @@ function createSystemExec(opts = {}) {
       stderr += d.toString();
     });
     child.on("error", (err) => {
-      resolve10({ ok: false, code: null, stdout, stderr: stderr || String(err) });
+      settle({ ok: false, code: null, stdout, stderr: stderr || String(err) });
     });
     child.on("close", (code) => {
-      resolve10({ ok: true, code: code ?? 0, stdout, stderr });
+      settle({ ok: true, code: code ?? 0, stdout, stderr });
     });
   });
 }
+var DEFAULT_EXEC_TIMEOUT_MS = 60000;
 var init_system_exec = __esm(() => {
+  init_kill_tree();
   init_resolve_executable();
 });
 
@@ -56880,13 +57056,13 @@ var init_no_sandbox = __esm(() => {
 // src/workflows/recorder-reap.ts
 import { spawn as spawn8 } from "child_process";
 import { closeSync, existsSync as existsSync16, openSync } from "fs";
-import { delimiter, join as join19 } from "path";
+import { delimiter, join as join20 } from "path";
 function findOnPath(bin, env = process.env, platform = process.platform) {
   const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
   const suffixes = platform === "win32" ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
   for (const dir of dirs) {
     for (const suffix of suffixes) {
-      const candidate = join19(dir, `${bin}${suffix}`);
+      const candidate = join20(dir, `${bin}${suffix}`);
       if (existsSync16(candidate))
         return candidate;
     }
@@ -56984,9 +57160,9 @@ var init_recorder_reap = __esm(() => {
 });
 
 // src/workflows/review-ticket.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync6, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
 import { spawnSync } from "child_process";
-import { basename as basename3, dirname as dirname11, join as join20 } from "path";
+import { basename as basename3, dirname as dirname11, join as join21 } from "path";
 function reviewTemplatePath(ticket) {
   return burnerAssetPath(ticket?.passKind === "verification" ? "verify-fixes.md" : "review-ticket.md");
 }
@@ -56994,18 +57170,34 @@ function renderReviewPrompt(templateOrTicket, values) {
   const template = typeof templateOrTicket === "string" ? templateOrTicket : readFileSync11(reviewTemplatePath(templateOrTicket), "utf8");
   return renderTemplate(template, values);
 }
-function executableIsHealthy(path2) {
-  if (!path2)
-    return false;
-  const result = spawnSync(path2, ["--version"], { timeout: 3000, stdio: "ignore" });
-  return result.status === 0 && !result.error;
+function probeExecutable(path2, spawn9) {
+  const started = performance.now();
+  const result = spawn9(path2);
+  const elapsedMs = Math.round(performance.now() - started);
+  const error = result.error ? result.error.code ?? result.error.message : undefined;
+  return {
+    ok: result.status === 0 && !result.error,
+    path: path2,
+    status: result.status,
+    signal: result.signal,
+    ...error ? { error } : {},
+    elapsedMs
+  };
 }
-function missingDrivePieces(browserPath, devCommand, browserHealthy, ffmpegPath) {
+function checkExecutableHealth(path2, spawn9 = spawnVersion) {
+  const first = probeExecutable(path2, spawn9);
+  return first.ok ? first : probeExecutable(path2, spawn9);
+}
+function describeHealthFailure(health) {
+  const cause3 = health.error ?? (health.signal ? `killed by ${health.signal}` : `exited with status ${health.status}`);
+  return `${health.path} --version: ${cause3} after ${health.elapsedMs}ms`;
+}
+function missingDrivePieces(browserPath, devCommand, browserFailure, ffmpegPath) {
   const missing = [];
   if (!browserPath) {
     missing.push(`\`${AGENT_BROWSER_BIN}\` is not on this machine's PATH, so there is no browser to walk the app with`);
-  } else if (!browserHealthy) {
-    missing.push(`\`${AGENT_BROWSER_BIN}\` is on PATH but failed its health check`);
+  } else if (browserFailure) {
+    missing.push(`\`${AGENT_BROWSER_BIN}\` is on PATH but failed its health check (${browserFailure})`);
   }
   if (!ffmpegPath)
     missing.push(`\`${FFMPEG_BIN}\` is not on this machine's PATH, so a drive cannot be recorded`);
@@ -57014,17 +57206,17 @@ function missingDrivePieces(browserPath, devCommand, browserHealthy, ffmpegPath)
   }
   return missing;
 }
-function driveWithheldReason(browserPath, devCommand, browserHealthy, ffmpegPath) {
-  const missing = missingDrivePieces(browserPath, devCommand, browserHealthy, ffmpegPath);
+function driveWithheldReason(browserPath, devCommand, browserFailure, ffmpegPath) {
+  const missing = missingDrivePieces(browserPath, devCommand, browserFailure, ffmpegPath);
   if (missing.length === 0)
     return;
   return `Drive was unavailable: ${missing.join(", and ")}.`;
 }
-function buildDriveAvailability(browserPath, devCommand, inheritedMode, browserHealthy = true, ffmpegPath = browserPath) {
+function buildDriveAvailability(browserPath, devCommand, inheritedMode, browserFailure, ffmpegPath = browserPath) {
   if (inheritedMode === "gates") {
     return "Inherited mode: **Gates**. The pass being verified recorded Gates mode, so run Gates mode; do not choose Drive mode or call `review_drive`.";
   }
-  const missing = missingDrivePieces(browserPath, devCommand, browserHealthy, ffmpegPath);
+  const missing = missingDrivePieces(browserPath, devCommand, browserFailure, ffmpegPath);
   if (inheritedMode === "drive" && missing.length === 0) {
     return "Inherited mode: **Drive**. The pass being verified recorded Drive mode, so run Drive mode and record the full tour; do not choose Gates mode.";
   }
@@ -57089,9 +57281,10 @@ function buildDriveInstructions(instructions) {
   ].join(`
 `);
 }
-function buildGateNotes(config2) {
-  const commands = config2.verifyCommands?.trim();
-  const failures2 = config2.knownFailures?.trim();
+function buildGateNotes(config2, project3) {
+  const prepared = resolvePreparedSettings(config2, project3);
+  const commands = prepared.verifyCommands;
+  const failures2 = prepared.knownFailures;
   const out = [];
   if (commands) {
     out.push("Run exactly these, once each \u2014 they are this project's own verify commands, so do not go looking for alternatives, add concurrency flags, or re-run one to re-read its output (redirect to a file and read that instead):", "", "```", commands, "```");
@@ -57116,7 +57309,7 @@ function prepareReviewDirectory(dir, options = {}) {
       if (!sibling.startsWith(stalePrefix))
         continue;
       try {
-        fs.remove(join20(parent, sibling), { recursive: true, force: true });
+        fs.remove(join21(parent, sibling), { recursive: true, force: true });
       } catch {}
     }
   } catch {}
@@ -57139,14 +57332,14 @@ async function prepareReviewArtifactsDirectory(ticketId, dir = reviewDir(ticketI
 async function writeReviewArtifacts(ticket, runId, config2, recorderReap = reapRecorder) {
   const dir = reviewDir(ticket.id);
   await prepareReviewArtifactsDirectory(ticket.id, dir, { recorderReap });
-  const mcpConfigPath = join20(dir, "mcp.json");
+  const mcpConfigPath = join21(dir, "mcp.json");
   const mcpConfig = renderRunMcpConfig(runId, config2);
   writeFileSync8(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   return {
     dir,
     mcp: { path: mcpConfigPath, config: mcpConfig },
-    digestPath: join20(dir, "DIGEST.md"),
-    blockedPath: join20(dir, "BLOCKED.md"),
+    digestPath: join21(dir, "DIGEST.md"),
+    blockedPath: join21(dir, "BLOCKED.md"),
     walkthroughPath: reviewWalkthroughPath(ticket.id)
   };
 }
@@ -57178,8 +57371,11 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
   const inheritedMode = ticket.passKind === "verification" ? inheritedReviewMode(verifies?.reviewMode) : undefined;
   const browserPath = findOnPath(AGENT_BROWSER_BIN);
   const ffmpegPath = findOnPath(FFMPEG_BIN);
-  const browserHealthy = executableIsHealthy(browserPath);
-  const withheldReason = driveWithheldReason(browserPath, project3.devCommand, browserHealthy, ffmpegPath);
+  const browserHealth = browserPath ? checkExecutableHealth(browserPath) : undefined;
+  const browserFailure = browserHealth && !browserHealth.ok ? describeHealthFailure(browserHealth) : undefined;
+  if (browserFailure)
+    console.error(`[review] ${AGENT_BROWSER_BIN} failed its health check: ${browserFailure}`);
+  const withheldReason = driveWithheldReason(browserPath, project3.devCommand, browserFailure, ffmpegPath);
   const offeredMode = inheritedMode === "gates" || withheldReason ? "gates" : "drive";
   const prompt = renderReviewPrompt(ticket, {
     TICKET_JSON: buildTicketJson(ticket),
@@ -57188,9 +57384,9 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
     LAP_DIGESTS: buildLapDigestsBlock(deps.lapDigests),
     FEATURE_BRANCH: feature.branch,
     BASE_BRANCH: feature.baseBranch,
-    DRIVE_AVAILABILITY: buildDriveAvailability(browserPath, project3.devCommand, inheritedMode, browserHealthy, ffmpegPath),
+    DRIVE_AVAILABILITY: buildDriveAvailability(browserPath, project3.devCommand, inheritedMode, browserFailure, ffmpegPath),
     DRIVE_INSTRUCTIONS: buildDriveInstructions(project3.driveInstructions),
-    GATE_NOTES: buildGateNotes(deps.config),
+    GATE_NOTES: buildGateNotes(deps.config, project3),
     DIGEST_PATH: artifacts.digestPath,
     BLOCKED_PATH: artifacts.blockedPath,
     WALKTHROUGH_PATH: artifacts.walkthroughPath,
@@ -57237,7 +57433,7 @@ async function reviewTicketOutcome(ctx, ticket, deps, timer) {
     maxIterations: deps.config.burnMaxIterations,
     logging: {
       type: "file",
-      path: join20(logsDir(), `review-${feature.id}-${ticket.seq}.log`),
+      path: join21(logsDir(), `review-${feature.id}-${ticket.seq}.log`),
       onAgentStreamEvent: onStreamEvent
     }
   };
@@ -57308,8 +57504,9 @@ function couldNotReview(ticket, reason, digest) {
 **${headline}**` : `**${headline}**`
   };
 }
-var FFMPEG_BIN = "ffmpeg", DECLARATION, REVIEW_DIRECTORY_FS;
+var FFMPEG_BIN = "ffmpeg", spawnVersion = (path2) => spawnSync(path2, ["--version"], { timeout: 3000, stdio: "ignore" }), DECLARATION, REVIEW_DIRECTORY_FS;
 var init_review_ticket = __esm(() => {
+  init_src();
   init_paths();
   init_dist();
   init_no_sandbox();
@@ -57324,9 +57521,9 @@ var init_review_ticket = __esm(() => {
   DECLARATION = /(?:^|\n)REVIEW-MODE:\s*(drive|gates)\s*\nREVIEW-VERDICT:\s*(verified|unverified)\s*\nREVIEW-REASON:\s*([^\r\n]*)/i;
   REVIEW_DIRECTORY_FS = {
     mkdir: mkdirSync10,
-    readDir: readdirSync5,
+    readDir: readdirSync6,
     rename: renameSync,
-    remove: rmSync2
+    remove: rmSync3
   };
 });
 
@@ -57884,8 +58081,8 @@ var init_podman = __esm(() => {
 });
 
 // src/workflows/ticket-burner.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync12, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
-import { dirname as dirname12, join as join21, posix as posixPath, win32 as winPath } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync12, readdirSync as readdirSync7, rmSync as rmSync4 } from "fs";
+import { dirname as dirname12, join as join23, posix as posixPath, win32 as winPath } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function missingImageRuntimeMessage(runtime5, image) {
   const binary = RUNTIME_BINARY[runtime5];
@@ -58146,10 +58343,10 @@ _(The "${DROPPED_MAP_SECTIONS.join('" and "')}" sections are omitted here: they
 }
 function buildProjectStandards(repoPath) {
   const present = [];
-  if (existsSync18(join21(repoPath, AGENT_CONVENTIONS_FILE))) {
+  if (existsSync18(join23(repoPath, AGENT_CONVENTIONS_FILE))) {
     present.push("`CLAUDE.md` \u2014 this repo's agent-facing conventions, and the highest authority on them");
   }
-  if (existsSync18(join21(repoPath, CHARTER_FILE))) {
+  if (existsSync18(join23(repoPath, CHARTER_FILE))) {
     present.push(`\`${CHARTER_FILE}\` \u2014 the project charter: what this codebase is for`);
   }
   const adrs = listLiveAdrs(repoPath).map((a) => a.relPath);
@@ -58180,7 +58377,7 @@ function buildDriveNotes(settings) {
   add5("stop", settings.driveStopCommand);
   add5("dev server", settings.devCommand);
   add5("db reset", settings.dbResetCommand);
-  const hasDir = existsSync18(join21(settings.repoPath, ".runcastle"));
+  const hasDir = existsSync18(join23(settings.repoPath, ".runcastle"));
   if (configured.length === 0 && !hasDir) {
     return [
       "This project has no test-drive machinery configured, so there is nothing here for you to keep in step \u2014 do not invent any.",
@@ -58400,14 +58597,14 @@ function parseSetupMarker(text3) {
   return { cold: m[1] === "1", syncMs: Number(m[2]), installMs: Number(m[3]) };
 }
 function takeSetupMarker(worktreePath) {
-  const file = join21(worktreePath, SETUP_MARKER_FILE);
+  const file = join23(worktreePath, SETUP_MARKER_FILE);
   let text3;
   try {
     text3 = readFileSync12(file, "utf8");
   } catch {
     return;
   }
-  rmSync3(file, { force: true });
+  rmSync4(file, { force: true });
   return parseSetupMarker(text3);
 }
 function fmtSeconds(ms) {
@@ -58500,7 +58697,7 @@ function buildAttachmentCopyCommands(sources, platform = process.platform) {
   ];
 }
 async function clearAttachments(workspacePath, repoPath) {
-  rmSync3(join21(workspacePath, ATTACHMENTS_DIR), { recursive: true, force: true });
+  rmSync4(join23(workspacePath, ATTACHMENTS_DIR), { recursive: true, force: true });
   await unexcludePath(repoPath, ATTACHMENTS_PREFIX);
 }
 function buildVerifyNotes(config2) {
@@ -58522,7 +58719,7 @@ function buildVerifyNotes(config2) {
 `);
 }
 function readRepoToolchain(repoPath) {
-  const pkgPath = join21(repoPath, "package.json");
+  const pkgPath = join23(repoPath, "package.json");
   const hasPackageJson = existsSync18(pkgPath);
   let packageManagerField;
   if (hasPackageJson) {
@@ -58536,10 +58733,10 @@ function readRepoToolchain(repoPath) {
     hasPackageJson,
     ...packageManagerField !== undefined ? { packageManagerField } : {},
     lockfiles: {
-      bun: existsSync18(join21(repoPath, "bun.lock")) || existsSync18(join21(repoPath, "bun.lockb")),
-      pnpm: existsSync18(join21(repoPath, "pnpm-lock.yaml")),
-      yarn: existsSync18(join21(repoPath, "yarn.lock")),
-      npm: existsSync18(join21(repoPath, "package-lock.json"))
+      bun: existsSync18(join23(repoPath, "bun.lock")) || existsSync18(join23(repoPath, "bun.lockb")),
+      pnpm: existsSync18(join23(repoPath, "pnpm-lock.yaml")),
+      yarn: existsSync18(join23(repoPath, "yarn.lock")),
+      npm: existsSync18(join23(repoPath, "package-lock.json"))
     }
   };
 }
@@ -59293,16 +59490,16 @@ function resolverTemplatePath() {
 }
 function burnerAssetPath(file) {
   const here = dirname12(fileURLToPath6(import.meta.url));
-  return join21(resolveSkillsRoot(here), "burner", file);
+  return join23(resolveSkillsRoot(here), "burner", file);
 }
 function listFeatureDocs(docsDir, prefix = "") {
   const out = [];
-  for (const e of readdirSync6(docsDir, { withFileTypes: true })) {
+  for (const e of readdirSync7(docsDir, { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${e.name}` : e.name;
     if (e.isFile() && e.name.endsWith(".md"))
       out.push(rel);
     else if (e.isDirectory() && !prefix)
-      out.push(...listFeatureDocs(join21(docsDir, e.name), rel));
+      out.push(...listFeatureDocs(join23(docsDir, e.name), rel));
   }
   return out;
 }
@@ -59319,7 +59516,7 @@ function readDocsDigest(projectId, slug) {
   if (!existsSync18(worktree)) {
     return done10("_No talk worktree on disk \u2014 docs digest skipped._", "no-worktree");
   }
-  const docsDir = join21(worktree, ...docsRel.split("/"));
+  const docsDir = join23(worktree, ...docsRel.split("/"));
   if (!existsSync18(docsDir)) {
     return done10("_No docs/features dir in the talk worktree \u2014 docs digest skipped._", "no-docs-dir");
   }
@@ -59336,7 +59533,7 @@ function readDocsDigest(projectId, slug) {
     }
     let content;
     try {
-      content = readFileSync12(join21(docsDir, ...name.split("/")), "utf8");
+      content = readFileSync12(join23(docsDir, ...name.split("/")), "utf8");
     } catch {
       continue;
     }
@@ -59383,7 +59580,7 @@ function readAgentFile(dirs, file) {
   for (const dir of dirs) {
     if (!dir)
       continue;
-    const p = join21(dir, file);
+    const p = join23(dir, file);
     if (existsSync18(p)) {
       try {
         return readFileSync12(p, "utf8");
@@ -59563,7 +59760,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land2, ensureIsola
   const slotStamp = buildSlotStamp(resolveSandboxImage(config2, project3), toolchain.packageManagerField);
   const setupHookFor = (branch) => withPrelude(slot !== undefined ? buildSlotSetupCommand(slot, branch, setupCommand, pm, slotStamp) : workspaceMode === "isolated" ? buildIsolatedSetupCommand(branch, setupCommand, pm) : setupCommand);
   mkdirSync11(logsDir(), { recursive: true });
-  const logFilePath = join21(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
+  const logFilePath = join23(logsDir(), `burn-${feature.id}-${ticket.seq}.log`);
   const throttle = createStreamThrottle((e) => ctx.emitEvent({ ...e, ticketId: ticket.id }));
   beginTranscript(ticket.id);
   const timer = createToolTimer(model.runtime);
@@ -59647,7 +59844,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land2, ensureIsola
     };
   };
   const discards = new Map;
-  const discardWorktree = (branch) => {
+  const discardWorktree2 = (branch) => {
     const pending3 = discards.get(branch) ?? cleanupBurnWorktree(project3.repoPath, branch);
     discards.set(branch, pending3);
     return pending3;
@@ -59702,7 +59899,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land2, ensureIsola
         logging: { type: "file", path: logFilePath, onAgentStreamEvent: onStreamEvent }
       });
     } catch (err) {
-      await discardWorktree(resolveBranch);
+      await discardWorktree2(resolveBranch);
       if (ctx.signal.aborted)
         throw err;
       const tip = await bestTip();
@@ -59716,7 +59913,7 @@ async function burnTicket(ctx, ticket, config2, token, model, land2, ensureIsola
       }
     }
     const blocked3 = readAgentFile([result?.preservedWorktreePath, project3.repoPath], "BLOCKED.md");
-    await discardWorktree(resolveBranch);
+    await discardWorktree2(resolveBranch);
     if (blocked3 !== undefined && blocked3.trim().length > 0) {
       return {
         ok: false,
@@ -59850,7 +60047,7 @@ ${retryNotes}` : basePrompt,
         break;
       } catch (err) {
         await clearAttachmentsFor(tempBranch);
-        await discardWorktree(tempBranch);
+        await discardWorktree2(tempBranch);
         if (ctx.signal.aborted)
           throw err;
         const msg = err instanceof Error ? err.message : String(err);
@@ -59865,7 +60062,7 @@ ${retryNotes}` : basePrompt,
           return stoppedOutcome(salvaged.length);
         }
         if (isWorktreeTeardownError(err)) {
-          const removed = await discardWorktree(tempBranch);
+          const removed = await discardWorktree2(tempBranch);
           if (salvaged.length > 0) {
             ctx.emitEvent({
               type: "burn.worktree.teardown-failed",
@@ -59938,7 +60135,7 @@ ${retryNotes}` : basePrompt,
     const blocked3 = readAgentFile(agentFileDirs, "BLOCKED.md");
     emitUnrunnableGates(ctx, ticket, readAgentFile(agentFileDirs, "GATE_UNRUNNABLE.md"));
     harvestedDigest = harvestDigest(agentFileDirs);
-    await discardWorktree(tempBranch);
+    await discardWorktree2(tempBranch);
     const chain = await branchCommitsAhead(project3.repoPath, feature.branch, tempBranch);
     let outcome;
     if (result.commits.length === 0 && blocked3 !== undefined && blocked3.trim().length > 0) {
@@ -60236,7 +60433,7 @@ var init_ticket_burner = __esm(() => {
 
 // src/workflows/research.ts
 import { mkdirSync as mkdirSync12, readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname13, join as join23 } from "path";
+import { dirname as dirname13, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function waypointSlug(waypoint) {
   const base = waypoint.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -60305,7 +60502,7 @@ function interpretResearchResult(result, docRelPath) {
 }
 function researchTemplatePath() {
   const here = dirname13(fileURLToPath7(import.meta.url));
-  return join23(resolveSkillsRoot(here), "burner", "research-waypoint.md");
+  return join25(resolveSkillsRoot(here), "burner", "research-waypoint.md");
 }
 function researchContainerName(runId, seq2) {
   return `runcastle-${runId}-w${seq2}`;
@@ -60329,7 +60526,7 @@ async function realExecuteResearchRun(ctx, waypoint, config2, token, model) {
     RESEARCH_DOC_PATH: docRelPath
   });
   mkdirSync12(logsDir(), { recursive: true });
-  const logFilePath = join23(logsDir(), `research-${feature.id}-${waypoint.seq}.log`);
+  const logFilePath = join25(logsDir(), `research-${feature.id}-${waypoint.seq}.log`);
   const throttle = createResearchStreamThrottle((e) => ctx.emitEvent(e));
   const codexAuthMount = codexAuthMountFor(model.runtime, config2.sandbox);
   const runOptions = {
@@ -60592,29 +60789,43 @@ var init_runner = __esm(() => {
 
 // src/services/features.ts
 import { desc as desc4, eq as eq11 } from "drizzle-orm";
-import { rmSync as rmSync4 } from "fs";
+import { rmSync as rmSync5 } from "fs";
 async function createFeature(ctx, input) {
   const project3 = requireProjectById(ctx, input.projectId);
   const slug = uniqueSlug(ctx, project3.id, input.title);
   const branch = `feature/${slug}`;
-  const cut = input.draft ? null : await ensureFeatureBranch(ctx, project3, slug, await requestedBase(ctx, project3, input.baseBranch));
+  const { cut, baseBranch, status: status3 } = await parkOrCut(ctx, project3, slug, input);
   const row = {
     id: newId("feat"),
     projectId: project3.id,
     slug,
     title: input.title,
     oneLiner: input.oneLiner,
-    brief: input.draft ? input.brief ?? null : null,
+    brief: cut ? null : input.brief ?? null,
     mapped: false,
     lap: 1,
     phase: "planning",
     branch,
-    baseBranch: cut?.baseBranch ?? null,
-    status: cut ? "active" : "draft",
+    baseBranch,
+    status: status3,
     createdAt: Date.now()
   };
   const inserted = ctx.db.insert(features).values(row).returning().get();
   const feature = rowToFeature(inserted);
+  emitFeatureCreated(ctx, feature, cut);
+  if (!cut)
+    return feature;
+  await scaffoldDocsOnFeatureBranch(ctx, project3, feature, { brief: input.brief });
+  return feature;
+}
+async function parkOrCut(ctx, project3, slug, input) {
+  if (input.draft)
+    return { cut: null, baseBranch: null, status: "draft" };
+  const cut = await ensureFeatureBranch(ctx, project3, slug, await requestedBase(ctx, project3, input.baseBranch));
+  return { cut, baseBranch: cut.baseBranch, status: "active" };
+}
+function emitFeatureCreated(ctx, feature, cut) {
+  const { slug, branch } = feature;
   emit(ctx, feature.id, {
     type: "feature.created",
     message: !cut ? `feature.created (draft \u2014 ${branch} not cut yet)` : cut.branchReady ? `feature.created (${branch} \u2190 ${cut.baseBranch})` : "feature.created (branch pending)",
@@ -60626,10 +60837,6 @@ async function createFeature(ctx, input) {
       draft: !cut
     }
   });
-  if (!cut)
-    return feature;
-  await scaffoldDocsOnFeatureBranch(ctx, project3, feature, { brief: input.brief });
-  return feature;
 }
 function requireNotDraft(feature) {
   if (feature.status === "draft") {
@@ -60698,8 +60905,8 @@ async function quickChange(ctx, input) {
     throw new InvalidInputError("a quick change needs a sentence describing the change");
   const slug = uniqueSlug(ctx, project3.id, title);
   const branch = `feature/${slug}`;
-  const base = await requestedBase(ctx, project3, input.baseBranch);
-  const { branchReady, baseBranch } = await ensureFeatureBranch(ctx, project3, slug, base);
+  const brief = quickBrief(title, proses);
+  const { cut, baseBranch, status: status3 } = await parkOrCut(ctx, project3, slug, input);
   const inserted = ctx.db.insert(features).values({
     id: newId("feat"),
     projectId: project3.id,
@@ -60707,22 +60914,20 @@ async function quickChange(ctx, input) {
     title,
     oneLiner: proses[0].split(`
 `)[0].trim(),
+    brief: cut ? null : brief,
     mapped: false,
     lap: 1,
     ticketsReadyLap: 1,
     phase: "planning",
     branch,
     baseBranch,
-    status: "active",
+    status: status3,
     createdAt: Date.now()
   }).returning().get();
   const feature = rowToFeature(inserted);
-  emit(ctx, feature.id, {
-    type: "feature.created",
-    message: branchReady ? `feature.created (${branch} \u2190 ${baseBranch})` : "feature.created (branch pending)",
-    data: { slug, branch, baseBranch, branchReady }
-  });
-  await scaffoldDocsOnFeatureBranch(ctx, project3, feature, { brief: quickBrief(title, proses) });
+  emitFeatureCreated(ctx, feature, cut);
+  if (cut)
+    await scaffoldDocsOnFeatureBranch(ctx, project3, feature, { brief });
   const stored = storeTickets(ctx, feature.id, [
     ...proses.map((prose) => ({
       title: quickTicketTitle(prose),
@@ -61013,7 +61218,7 @@ function escalateToMap(ctx, featureId, input) {
   });
   return { ok: true };
 }
-function archiveFeature(ctx, featureId) {
+async function archiveFeature(ctx, featureId) {
   const feature = getFeatureRow(ctx, featureId);
   requireNotDraft(feature);
   if (feature.status === "archived") {
@@ -61028,6 +61233,7 @@ function archiveFeature(ctx, featureId) {
     message: `feature ${feature.slug} archived`,
     data: { from: feature.status }
   });
+  await retireArchivedWorktree(ctx, projectForFeature(ctx, feature), feature);
   return { ...feature, status: "archived" };
 }
 function unarchiveFeature(ctx, featureId) {
@@ -61069,7 +61275,7 @@ async function deleteFeature(ctx, featureId) {
   });
   for (const s of listSessionsByFeature(ctx, featureId)) {
     try {
-      rmSync4(sessionDir(s.id), { recursive: true, force: true });
+      rmSync5(sessionDir(s.id), { recursive: true, force: true });
     } catch {}
   }
   deleteFeatureRows(ctx, featureId);
@@ -61104,6 +61310,7 @@ var init_features = __esm(() => {
   init_schema();
   init_errors();
   init_events();
+  init_feature_worktrees();
   init_git();
   init_knowledge();
   init_repo();
@@ -61164,7 +61371,7 @@ var init_burn_warnings = __esm(() => {
 });
 
 // src/services/project-notes.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
 import { and as and9, count as count3, desc as desc5, eq as eq12, inArray as inArray4 } from "drizzle-orm";
 function rowToNote(row) {
   return ProjectNote.parse({
@@ -61229,7 +61436,7 @@ function deleteNote(ctx, noteId) {
   const note2 = getNote(ctx, noteId);
   requireOpen(note2, "delete");
   ctx.db.delete(projectNotes).where(eq12(projectNotes.id, noteId)).run();
-  rmSync5(projectNotePath(noteId), { force: true });
+  rmSync6(projectNotePath(noteId), { force: true });
   emitProject(ctx, note2.projectId, { type: "project_note.deleted", message: "project note deleted", data: { noteId } });
 }
 function triage(ctx, noteIds, outcome, featureId, verb = "triaged") {
@@ -61354,7 +61561,7 @@ var init_runs = __esm(() => {
 });
 
 // src/services/test-notes.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname14 } from "path";
 import { and as and11, asc as asc6, eq as eq14, lt } from "drizzle-orm";
 function rowToNote2(row) {
@@ -61443,7 +61650,7 @@ function deleteNote2(ctx, noteId) {
   const current2 = getNote2(ctx, noteId);
   assertOpen(current2, "delete");
   ctx.db.delete(testNotes).where(eq14(testNotes.id, noteId)).run();
-  rmSync6(annotationPath(noteId), { force: true });
+  rmSync7(annotationPath(noteId), { force: true });
   emit(ctx, current2.featureId, {
     type: "note.deleted",
     message: "note deleted",
@@ -61644,7 +61851,7 @@ var MCP_READ_CEILING_CHARS = 60000;
 
 // src/mcp/server.ts
 import { existsSync as existsSync23, readFileSync as readFileSync14 } from "fs";
-import { join as join25, relative as relative4, resolve as resolve10, sep as sep2 } from "path";
+import { join as join26, relative as relative4, resolve as resolve10, sep as sep2 } from "path";
 import { StreamableHTTPTransport } from "@hono/mcp";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Hono } from "hono";
@@ -61727,7 +61934,7 @@ function featureContext(ctx, reader) {
         doc: { relPath: summary.relPath, content },
         ref: {
           relPath: summary.relPath,
-          absPath: join25(docsDir, summary.relPath),
+          absPath: join26(docsDir, summary.relPath),
           bytes: Buffer.byteLength(content, "utf8"),
           reason: notInlinedReason(summary.relPath)
         }
@@ -62141,7 +62348,8 @@ async function toolCreateFeature(ctx, session, input) {
     projectId: project3.id,
     title: input.title,
     tickets: input.tickets,
-    baseBranch: input.baseBranch
+    baseBranch: input.baseBranch,
+    draft: input.draft
   }) : await createFeature(ctx, {
     projectId: project3.id,
     title: input.title,
@@ -62219,7 +62427,7 @@ function adrRef(adr) {
 }
 function toolReadAdr(ctx, session, input) {
   requireProject(ctx, session);
-  const root = resolve10(join25(session.worktreePath, ADR_DIR_REL));
+  const root = resolve10(join26(session.worktreePath, ADR_DIR_REL));
   const name = input.relPath.replace(/\\/g, "/").replace(/^\.?\/*docs\/adr\//i, "");
   const target = resolve10(root, name);
   const rel = relative4(root, target);
@@ -62248,7 +62456,7 @@ function toolReadFeatureBrief(ctx, session, input) {
   const feature = list(ctx, project3.id).find((f) => f.slug === input.slug);
   if (!feature)
     throw new NotFoundError(`feature not found: ${input.slug}`);
-  const onDisk = join25(session.worktreePath, featureDocsRel(feature.slug), "brief.md");
+  const onDisk = join26(session.worktreePath, featureDocsRel(feature.slug), "brief.md");
   const brief = feature.status === "shipped" && existsSync23(onDisk) ? readFileSync14(onDisk, "utf8") : feature.brief;
   return {
     slug: feature.slug,
@@ -62474,7 +62682,7 @@ function buildMcpServer(audience) {
         oneLiner: z5.string().optional().describe("One line saying what this feature is. Required for every shape EXCEPT `tickets`, " + "where the first ticket\u2019s prose becomes the one-liner and anything sent here is " + "ignored."),
         baseBranch: z5.string().optional().describe("Branch to cut from \u2014 always pass it explicitly, naming the base you told the " + "human you would use (see `get_project_context`\u2019s `baseBranches`). Omitted, it " + "falls back to whatever the project checkout happens to be on. Drafts pass none: " + "a parked feature picks its base at Start."),
         brief: z5.string().optional().describe("The reasoning you just worked out with the human \u2014 why this feature exists and " + "what it must NOT swallow. Becomes brief.md verbatim, and without it that " + "reasoning is lost. Unused by the `tickets` shape, whose brief IS the proses."),
-        draft: z5.boolean().optional().describe("PARK it instead of starting it: a row and its brief, no branch and no files, " + "until the human clicks Start. Ask them per feature whether to start or park."),
+        draft: z5.boolean().optional().describe("PARK it instead of starting it: a row and its brief, no branch and no files, " + "until the human clicks Start. With `tickets`, the draft keeps them and Start lands " + "it ready to Burn. Ask them per feature whether to start or park."),
         tickets: z5.array(z5.string().min(1)).min(1).optional().describe("The quick-change shape: work too small to deserve a grill. Creates ONE feature at " + "the implementation phase carrying a ticket per prose (plus the review ticket " + "every batch closes with). Send every sentence of one quick change in a SINGLE " + "call \u2014 calling this once per ticket makes one feature per ticket.")
       }
     }, async (args2, extra) => {
@@ -62996,7 +63204,7 @@ var init_ws = __esm(() => {
 // src/services/prep.ts
 import { and as and12, desc as desc6, eq as eq15, inArray as inArray6 } from "drizzle-orm";
 import { readdir as readdir3 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function keysToPrepare(ctx, project3) {
   return unsetPreparedKeys(project3).filter((key) => isOverwritable(ctx, project3.id, key));
 }
@@ -63023,7 +63231,7 @@ async function isEmptyRepo(repoPath) {
     return false;
   if (!rootEntries.includes("docs"))
     return true;
-  const docsEntries = await readdir3(join26(repoPath, "docs"));
+  const docsEntries = await readdir3(join27(repoPath, "docs"));
   return docsEntries.every((entry) => SCAFFOLDED_DOCS_DIRS.includes(entry));
 }
 async function prepView(ctx, project3) {
@@ -63509,7 +63717,7 @@ var init_stream = __esm(() => {
 // src/routes/web.ts
 import { existsSync as existsSync24, statSync as statSync6 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
-import { extname, join as join27, normalize as normalize2, resolve as resolve11, sep as sep3 } from "path";
+import { extname, join as join28, normalize as normalize2, resolve as resolve11, sep as sep3 } from "path";
 function contentType(path2) {
   return MIME[extname(path2).toLowerCase()] ?? "application/octet-stream";
 }
@@ -63527,7 +63735,7 @@ function safeJoin(root, pathname) {
   } catch {
     return null;
   }
-  const joined = normalize2(join27(root, decoded));
+  const joined = normalize2(join28(root, decoded));
   if (joined !== root && !joined.startsWith(root + sep3))
     return null;
   return joined;
@@ -63540,7 +63748,7 @@ function resolveWebDist() {
 }
 function mountWebApp(app, distDir) {
   const root = resolve11(distDir);
-  const indexHtml = join27(root, "index.html");
+  const indexHtml = join28(root, "index.html");
   app.get("*", async (c, next4) => {
     const { pathname } = new URL(c.req.url);
     if (/^\/(api|mcp|ws|health)(\/|$)/.test(pathname))
@@ -63560,7 +63768,7 @@ function mountWebApp(app, distDir) {
 }
 function mountWebAppIfBuilt(app) {
   const dist = resolveWebDist();
-  if (existsSync24(join27(dist, "index.html")))
+  if (existsSync24(join28(dist, "index.html")))
     mountWebApp(app, dist);
 }
 var MIME;
@@ -63588,13 +63796,13 @@ var init_web = __esm(() => {
 
 // src/version.ts
 import { readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname15, join as join28 } from "path";
+import { dirname as dirname15, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 function runcastleVersion() {
   if (cached4)
     return cached4;
   const here = dirname15(fileURLToPath8(import.meta.url));
-  for (const pkgPath of [join28(here, "..", "package.json"), join28(here, "package.json")]) {
+  for (const pkgPath of [join29(here, "..", "package.json"), join29(here, "package.json")]) {
     try {
       const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
       if (typeof pkg.version === "string") {
@@ -63652,6 +63860,10 @@ function compareSemver(a, b) {
     if (diff8 !== 0)
       return diff8;
   }
+  const la = pa.pre[0] === LOCAL_BUILD_PRERELEASE;
+  const lb = pb.pre[0] === LOCAL_BUILD_PRERELEASE;
+  if (la !== lb)
+    return la ? 1 : -1;
   if (pa.pre.length === 0 && pb.pre.length === 0)
     return 0;
   if (pa.pre.length === 0)
@@ -63733,7 +63945,7 @@ async function getUpdateInfo(current2, fetchImpl) {
     cache = info;
   return info;
 }
-var PACKAGE_NAME = "runcastle", UPDATE_COMMAND, PING_URL = "https://ping.runcastle.dev/ping", NPM_LATEST_URL, NO_UPDATE = (current2) => ({
+var PACKAGE_NAME = "runcastle", UPDATE_COMMAND, PING_URL = "https://ping.runcastle.dev/ping", NPM_LATEST_URL, LOCAL_BUILD_PRERELEASE = "local", NO_UPDATE = (current2) => ({
   current: current2,
   latest: null,
   updateAvailable: false,
@@ -63822,7 +64034,7 @@ var init_events2 = __esm(() => {
 
 // src/launcher/launcher.ts
 import { existsSync as existsSync26 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { and as and13, eq as eq16 } from "drizzle-orm";
 function ptyExitMessage(exitCode) {
   const label = typeof exitCode === "number" ? String(exitCode) : "unknown";
@@ -64437,7 +64649,7 @@ async function buildPrepareBrief(ctx, project3) {
   };
 }
 function probePrepareHost(repoPath) {
-  const has4 = (rel) => existsSync26(join29(repoPath, rel));
+  const has4 = (rel) => existsSync26(join30(repoPath, rel));
   const lock = LOCKFILES.find(([file]) => has4(file));
   return {
     platform: process.platform,
@@ -64590,7 +64802,7 @@ var init_launcher = __esm(() => {
 
 // src/services/outcome.ts
 import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync12 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function digestHasSubstance(text3) {
   return text3.split(`
 `).some((line) => {
@@ -64690,9 +64902,9 @@ async function promoteOutcomeDoc(ctx, project3, feature, target, delta) {
       delta: { commits: delta.commits ?? 0, files: delta.files ?? 0 }
     });
     await onBranch(project3.repoPath, target, async () => {
-      const docsDir = join30(project3.repoPath, ...featureDocsRel(feature.slug).split("/"));
+      const docsDir = join31(project3.repoPath, ...featureDocsRel(feature.slug).split("/"));
       mkdirSync16(docsDir, { recursive: true });
-      writeFileSync12(join30(docsDir, "outcome.md"), doc, "utf8");
+      writeFileSync12(join31(docsDir, "outcome.md"), doc, "utf8");
       await commitDocs(project3.repoPath, docsCommitMessage(`outcome for ${feature.slug}`, project3.docsCommitPrefix));
     });
   } catch (error) {
@@ -64721,6 +64933,7 @@ var init_feature = __esm(() => {
   init_launcher();
   init_burn_warnings();
   init_events();
+  init_feature_worktrees();
   init_features();
   init_git();
   init_outcome();
@@ -64800,6 +65013,7 @@ var init_feature = __esm(() => {
         await promoteOutcomeDoc(ctx, project3, feature, res.target, delta);
         setPhase(ctx, input.featureId, "shipped", "feature.shipped", `merged to ${res.target}`);
         setFeatureStatus(ctx, input.featureId, "shipped");
+        await retireShippedWorktree(ctx, project3, feature);
       } else {
         emit(ctx, input.featureId, {
           type: "merge.conflict",
@@ -64813,9 +65027,9 @@ var init_feature = __esm(() => {
 });
 
 // src/services/fsbrowse.ts
-import { existsSync as existsSync27, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync8, statSync as statSync7 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename4, dirname as dirname17, isAbsolute as isAbsolute3, join as join31, resolve as resolve12, sep as sep4 } from "path";
+import { basename as basename4, dirname as dirname17, isAbsolute as isAbsolute3, join as join33, resolve as resolve12, sep as sep4 } from "path";
 function expandPath(input, home = homedir4()) {
   const trimmed = input.trim();
   if (trimmed === "")
@@ -64824,12 +65038,12 @@ function expandPath(input, home = homedir4()) {
   if (out === "~")
     out = home;
   else if (out.startsWith("~/") || out.startsWith("~\\"))
-    out = join31(home, out.slice(2));
+    out = join33(home, out.slice(2));
   return resolve12(out);
 }
 function looksLikeRepo(dir) {
   try {
-    return existsSync27(join31(dir, ".git"));
+    return existsSync27(join33(dir, ".git"));
   } catch {
     return false;
   }
@@ -64851,7 +65065,7 @@ function listRoots(home = homedir4()) {
     roots3.push({ label: "Home", path: home, kind: "home" });
   const seen = new Set(roots3.map(pathKey));
   for (const name of COMMON_DIRS) {
-    const candidate = join31(home, name);
+    const candidate = join33(home, name);
     const key = pathKey({ path: candidate });
     if (seen.has(key) || !existsSync27(candidate))
       continue;
@@ -64896,7 +65110,7 @@ function browseDir(input, showHidden = false, home = homedir4()) {
   }
   let dirents;
   try {
-    dirents = readdirSync7(dir, { withFileTypes: true, encoding: "utf8" });
+    dirents = readdirSync8(dir, { withFileTypes: true, encoding: "utf8" });
   } catch (e) {
     throw new InvalidInputError(`cannot read directory: ${dir} (${errMsg2(e)})`);
   }
@@ -64912,7 +65126,7 @@ function browseDir(input, showHidden = false, home = homedir4()) {
       continue;
     if (!showHidden && name.startsWith("."))
       continue;
-    const path2 = join31(dir, name);
+    const path2 = join33(dir, name);
     const isSymlink = dirent.isSymbolicLink();
     if (isSymlink && !showHidden)
       continue;
@@ -65154,7 +65368,7 @@ var init_conversations = __esm(() => {
 
 // src/services/projects.ts
 import { existsSync as existsSync28 } from "fs";
-import { basename as basename5, join as join33 } from "path";
+import { basename as basename5, join as join35 } from "path";
 import { eq as eq17, isNull } from "drizzle-orm";
 function listProjects(ctx) {
   return ctx.db.select().from(projects).where(isNull(projects.closedAt)).all().map(rowToProject);
@@ -65238,7 +65452,7 @@ async function assertRepoTolerant(ctx, repoPath) {
   } catch (e) {
     if (!isNotImplemented(e))
       throw e;
-    if (!existsSync28(join33(repoPath, ".git"))) {
+    if (!existsSync28(join35(repoPath, ".git"))) {
       throw new InvalidInputError(`not a git repository: ${repoPath}`);
     }
   }
@@ -65442,7 +65656,7 @@ var init_project_image = __esm(() => {
 });
 
 // src/trpc/routers/setup.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { isNotNull as isNotNull4 } from "drizzle-orm";
 import * as z14 from "zod";
 function projectImageEnv(ctx, project3) {
@@ -65463,7 +65677,7 @@ async function buildImageTerminal(ctx, projectId) {
   const notices = Object.values(host.problems);
   const stockFresh = imageFreshness({
     image: await inspectBuiltImage(exec3, runtime5, DEFAULT_SANDBOX_IMAGE),
-    expectedHash: hashDockerfile(join35(stockContext, "Dockerfile")),
+    expectedHash: hashDockerfile(join36(stockContext, "Dockerfile")),
     host: host.versions
   }).fresh;
   const plan = planImageBuild({
@@ -65495,7 +65709,7 @@ async function buildImageTerminal(ctx, projectId) {
     }
   };
 }
-var setupRouter;
+var DOCTOR_PROBE_TIMEOUT_MS = 1e4, setupRouter;
 var init_setup2 = __esm(() => {
   init_src();
   init_schema();
@@ -65521,7 +65735,7 @@ var init_setup2 = __esm(() => {
       const projectModels = ctx.db.select({ model: projects.model }).from(projects).where(isNotNull4(projects.model)).all().map((p) => p.model);
       const project3 = input?.projectId ? requireProjectById(ctx, input.projectId) : null;
       return runDoctor({
-        exec: createSystemExec(),
+        exec: createSystemExec({ timeoutMs: DOCTOR_PROBE_TIMEOUT_MS }),
         burnerDockerfile: burnerDockerfilePath(),
         env: envWithAfkCredentials(),
         runtimes: configuredRuntimes(rosterConfig(ctx), projectModels),
@@ -65842,6 +66056,11 @@ async function startServer() {
   if (staleRuns.length > 0) {
     console.log(`reconciled ${staleRuns.length} stale run(s) from a previous server run`);
   }
+  sweepFeatureWorktrees(ctx).then((s) => {
+    if (s.removed + s.orphanProjects + s.failed > 0) {
+      console.log(`worktree sweep: removed ${s.removed} feature worktree(s) and ` + `${s.orphanProjects} orphaned project dir(s); kept ${s.kept} dirty, ${s.failed} failed`);
+    }
+  });
   const server = Bun.serve({
     port: config2.serverPort,
     hostname: SERVE_HOSTNAME,
@@ -65884,6 +66103,7 @@ var init_src2 = __esm(() => {
   init_reviews();
   init_stream();
   init_web();
+  init_feature_worktrees();
   init_model_discovery();
   init_settings();
   init_update_check();