@staff0rd/assist 0.517.0 → 0.519.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.517.0",
+  version: "0.519.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -10274,32 +10274,46 @@ async function diffScopes(req, res) {
 
 // src/commands/sessions/web/fileContent.ts
 import { readFile, stat as stat2 } from "fs/promises";
+
+// src/commands/sessions/web/resolveWithinCwd.ts
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10 } from "path";
-var MAX_FILE_BYTES = 2 * 1024 * 1024;
+function repoRoot(cwd) {
+  return resolve10(toGitCwd(cwd));
+}
 function resolveWithinCwd(cwd, path71) {
-  const root = resolve10(toGitCwd(cwd));
+  const root = repoRoot(cwd);
   const target = resolve10(root, path71);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
 }
-async function fileContent(req, res) {
+
+// src/commands/sessions/web/getFileTarget.ts
+function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
-  if (!cwd) return;
+  if (!cwd) return null;
   const path71 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
   if (!path71) {
     respondJson(res, 400, { error: "Missing path" });
-    return;
+    return null;
   }
   const target = resolveWithinCwd(cwd, path71);
   if (!target) {
     respondJson(res, 400, { error: "Path outside cwd" });
-    return;
+    return null;
   }
+  return { cwd, target };
+}
+
+// src/commands/sessions/web/fileContent.ts
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+async function fileContent(req, res) {
+  const resolved = getFileTarget(req, res);
+  if (!resolved) return;
   try {
-    const info = await stat2(target);
+    const info = await stat2(resolved.target);
     if (!info.isFile()) {
       respondJson(res, 404, { error: "File not found" });
       return;
@@ -10308,7 +10322,10 @@ async function fileContent(req, res) {
       respondJson(res, 413, { error: "File too large" });
       return;
     }
-    respondJson(res, 200, { content: await readFile(target, "utf8") });
+    respondJson(res, 200, {
+      content: await readFile(resolved.target, "utf8"),
+      mtimeMs: info.mtimeMs
+    });
   } catch {
     respondJson(res, 404, { error: "File not found" });
   }
@@ -10647,7 +10664,7 @@ function runGit(cwd, args) {
   }).then((r) => r.stdout.trim());
 }
 async function resolveSynthesisPath(cwd) {
-  const [repoRoot, branch2] = await Promise.all([
+  const [repoRoot2, branch2] = await Promise.all([
     runGit(cwd, ["rev-parse", "--show-toplevel"]),
     runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
@@ -10655,7 +10672,7 @@ async function resolveSynthesisPath(cwd) {
     homedir13(),
     ".assist",
     "reviews",
-    basename8(repoRoot)
+    basename8(repoRoot2)
   );
   return findSynthesisForBranch(repoReviewsDir, branch2);
 }
@@ -12063,6 +12080,89 @@ async function uploadPrImage(req, res) {
   }
 }
 
+// src/commands/sessions/web/writeFileContent.ts
+import { readFile as readFile2, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+
+// src/commands/sessions/web/formatWithOxfmt.ts
+import { execFile as execFile8 } from "child_process";
+import { existsSync as existsSync30 } from "fs";
+import { dirname as dirname22, join as join30 } from "path";
+import { promisify as promisify8 } from "util";
+var execFileAsync7 = promisify8(execFile8);
+var TIMEOUT_MS = 15e3;
+function findOxfmtScript(root) {
+  let dir = root;
+  for (; ; ) {
+    const candidate = join30(dir, "node_modules", "oxfmt", "bin", "oxfmt");
+    if (existsSync30(candidate)) return candidate;
+    const parent = dirname22(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+async function formatWithOxfmt(target, root) {
+  const script = findOxfmtScript(root);
+  if (!script) return;
+  await execFileAsync7(process.execPath, [script, target], {
+    cwd: root,
+    windowsHide: true,
+    timeout: TIMEOUT_MS
+  }).catch(() => {
+  });
+}
+
+// src/commands/sessions/web/getFileWriteBody.ts
+async function getFileWriteBody(req, res) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch {
+    respondJson(res, 400, { error: "Invalid JSON body" });
+    return null;
+  }
+  if (typeof body.content !== "string") {
+    respondJson(res, 400, { error: "Missing content" });
+    return null;
+  }
+  if (typeof body.mtimeMs !== "number") {
+    respondJson(res, 400, { error: "Missing mtimeMs" });
+    return null;
+  }
+  return { content: body.content, mtimeMs: body.mtimeMs };
+}
+
+// src/commands/sessions/web/writeFileContent.ts
+var STALE_MESSAGE = "The file changed on disk since it was opened";
+async function currentMtimeMs(target) {
+  try {
+    return (await stat3(target)).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function writeFileContent(req, res) {
+  const resolved = getFileTarget(req, res);
+  if (!resolved) return;
+  const body = await getFileWriteBody(req, res);
+  if (!body) return;
+  if (await currentMtimeMs(resolved.target) !== body.mtimeMs) {
+    respondJson(res, 409, { error: STALE_MESSAGE });
+    return;
+  }
+  try {
+    await writeFile3(resolved.target, body.content, "utf8");
+    await formatWithOxfmt(resolved.target, repoRoot(resolved.cwd));
+    respondJson(res, 200, {
+      content: await readFile2(resolved.target, "utf8"),
+      mtimeMs: await currentMtimeMs(resolved.target)
+    });
+  } catch (error) {
+    respondJson(res, 500, {
+      error: error instanceof Error ? error.message : "Failed to write file"
+    });
+  }
+}
+
 // src/commands/sessions/web/createCssHandler.ts
 import { createHash as createHash2 } from "crypto";
 import { readFileSync as readFileSync22 } from "fs";
@@ -12125,6 +12225,7 @@ var routes2 = {
   "GET /api/diff": diff2,
   "GET /api/diff-scopes": diffScopes,
   "GET /api/file": fileContent,
+  "POST /api/file": writeFileContent,
   "GET /api/files": listFiles,
   "GET /api/jira-site": jiraSite,
   "GET /api/harness": harnessCapabilities,
@@ -12755,7 +12856,7 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/cloneRepo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import chalk69 from "chalk";
 
@@ -12791,7 +12892,7 @@ async function cloneRepo(originRaw) {
   if (!target) {
     return fail2(`Could not derive a repository name from "${origin}".`);
   }
-  if (existsSync30(target)) {
+  if (existsSync31(target)) {
     return fail2(`Clone target already exists: ${target}`);
   }
   await mkdir3(baseDir, { recursive: true });
@@ -12902,7 +13003,7 @@ function registerExportCommand(cmd) {
 }
 
 // src/commands/backlog/import/index.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import chalk74 from "chalk";
 
 // src/commands/backlog/dump/countCopyRows.ts
@@ -13079,7 +13180,7 @@ async function restore(client, parsed) {
 
 // src/commands/backlog/import/index.ts
 async function importBacklog(file, options2 = {}) {
-  const raw = file ? await readFile2(file) : await readStdinBuffer();
+  const raw = file ? await readFile3(file) : await readStdinBuffer();
   const parsed = parseDump(raw);
   validateDump(parsed);
   const { tables } = parsed.header;
@@ -13216,7 +13317,7 @@ function ensureRemoteOrigin() {
 import { spawnSync as spawnSync3 } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync23, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -13256,8 +13357,8 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join30(tmpdir2(), "assist-"));
-  const filePath = join30(dir, "description.md");
+  const dir = mkdtempSync(join31(tmpdir2(), "assist-"));
+  const filePath = join31(dir, "description.md");
   writeFileSync21(filePath, "");
   const result = spawnSync3(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
@@ -15731,16 +15832,16 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname22, resolve as resolve12 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname23, resolve as resolve12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname4 = dirname22(__filename3);
+var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
 function readLines(path71) {
-  if (!existsSync31(path71)) return [];
+  if (!existsSync32(path71)) return [];
   return readFileSync25(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
@@ -15787,14 +15888,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join31(homedir14(), ".claude", "settings.json"),
-    join31(process.cwd(), ".claude", "settings.json"),
-    join31(process.cwd(), ".claude", "settings.local.json")
+    join32(homedir14(), ".claude", "settings.json"),
+    join32(process.cwd(), ".claude", "settings.json"),
+    join32(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -15803,7 +15904,7 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync32(filePath)) return [];
+  if (!existsSync33(filePath)) return [];
   try {
     const data = JSON.parse(readFileSync26(filePath, "utf8"));
     const arr = data?.permissions?.[key];
@@ -16003,11 +16104,11 @@ function decideCommand(toolName, rawCommand) {
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync12 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join32(homedir15(), ".assist");
+  return join33(homedir15(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -16026,7 +16127,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync12(dbDir, { recursive: true });
-  const db = new Database(join32(dbDir, "assist.db"));
+  const db = new Database(join33(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -16122,9 +16223,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // src/commands/permitCliReads/assertCliExists.ts
 function assertCliExists(cli) {
@@ -16387,15 +16488,15 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join33(homedir16(), ".assist", `cli-discover-${safeName}.log`);
+  return join34(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path71 = logPath(cli);
-  if (!existsSync33(path71)) return void 0;
+  if (!existsSync34(path71)) return void 0;
   return readFileSync27(path71, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join33(homedir16(), ".assist");
+  const dir = join34(homedir16(), ".assist");
   mkdirSync13(dir, { recursive: true });
   writeFileSync23(logPath(cli), output);
 }
@@ -16526,22 +16627,22 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync35, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
 import chalk121 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
 import { homedir as homedir17 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function getRestrictedDir() {
-  return join34(homedir17(), ".assist", "restricted");
+  return join35(homedir17(), ".assist", "restricted");
 }
 function getPinStatePath(pin) {
-  return join34(getRestrictedDir(), `code-comment-${pin}.json`);
+  return join35(getRestrictedDir(), `code-comment-${pin}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
 import { readdirSync as readdirSync3, statSync as statSync5, unlinkSync as unlinkSync7 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
@@ -16552,7 +16653,7 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path71 = join35(dir, entry);
+    const path71 = join36(dir, entry);
     try {
       if (statSync5(path71).mtimeMs < cutoff) unlinkSync7(path71);
     } catch {
@@ -16562,10 +16663,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync28 } from "fs";
 function readPinState(pin) {
   const path71 = getPinStatePath(pin);
-  if (!existsSync34(path71)) return void 0;
+  if (!existsSync35(path71)) return void 0;
   try {
     const state = JSON.parse(readFileSync28(path71, "utf8"));
     if (state.pin !== pin) return void 0;
@@ -16584,7 +16685,7 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync35(state.file)) {
+  if (!existsSync36(state.file)) {
     console.error(chalk121.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
@@ -17641,19 +17742,19 @@ import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync26 } from "fs"
 import chalk137 from "chalk";
 
 // src/commands/dbMigration/getMigrationPinPath.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function getMigrationPinPath(pin) {
-  return join36(getRestrictedDir(), `db-migration-pin-${pin}.json`);
+  return join37(getRestrictedDir(), `db-migration-pin-${pin}.json`);
 }
 function getMigrationApprovalPath(migrationId) {
-  return join36(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
+  return join37(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync36, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync30 } from "fs";
 function readMigrationPinState(pin) {
   const path71 = getMigrationPinPath(pin);
-  if (!existsSync36(path71)) return void 0;
+  if (!existsSync37(path71)) return void 0;
   try {
     const state = JSON.parse(readFileSync30(path71, "utf8"));
     if (state.pin !== pin) return void 0;
@@ -17742,7 +17843,7 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync37, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
 import chalk139 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -17751,7 +17852,7 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync37(indexPath)) {
+  if (!existsSync38(indexPath)) {
     console.log(chalk139.yellow("No index.html found"));
     return;
   }
@@ -17784,10 +17885,10 @@ import { basename as basename11 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir18 } from "os";
-import { join as join37 } from "path";
-var BLOG_REPO_ROOT = join37(homedir18(), "git/blog");
+import { join as join38 } from "path";
+var BLOG_REPO_ROOT = join38(homedir18(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join37(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join38(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -17798,15 +17899,15 @@ import { execSync as execSync36 } from "child_process";
 import chalk140 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync38, readFileSync as readFileSync32 } from "fs";
-import { basename as basename10, join as join38 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync32 } from "fs";
+import { basename as basename10, join as join39 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join38(process.cwd(), "package.json");
-  if (existsSync38(packageJsonPath)) {
+  const packageJsonPath = join39(process.cwd(), "package.json");
+  if (existsSync39(packageJsonPath)) {
     try {
       const content = readFileSync32(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
@@ -17821,8 +17922,8 @@ function getRepoName() {
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync33 } from "fs";
-import { join as join39 } from "path";
-var DEVLOG_DIR = join39(BLOG_REPO_ROOT, "src/content/devlog");
+import { join as join40 } from "path";
+var DEVLOG_DIR = join40(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -17850,7 +17951,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync4(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync33(join39(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync33(join40(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -18238,11 +18339,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync29 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import chalk145 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join40(BLOG_REPO_ROOT, "assist.yml");
+  return join41(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -18304,7 +18405,7 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync5 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 import chalk147 from "chalk";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
 function isLockedDll(debugDir) {
@@ -18316,7 +18417,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join41(debugDir, file);
+    const dllPath = join42(debugDir, file);
     try {
       const fd = openSync3(dllPath, "r+");
       closeSync3(fd);
@@ -18334,13 +18435,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join41(dir, "bin", "Debug"));
+    const locked = isLockedDll(join42(dir, "bin", "Debug"));
     if (locked) return locked;
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry) || entry === "bin" || entry.startsWith("."))
       continue;
-    const found = findFirstLockedDll(join41(dir, entry));
+    const found = findFirstLockedDll(join42(dir, entry));
     if (found) return found;
   }
   return null;
@@ -18374,9 +18475,9 @@ function getProjectRefs(csprojPath) {
   }
   return refs;
 }
-function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
+function buildTree(csprojPath, repoRoot2, visited = /* @__PURE__ */ new Set()) {
   const abs = path31.resolve(csprojPath);
-  const rel = path31.relative(repoRoot, abs);
+  const rel = path31.relative(repoRoot2, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
@@ -18385,7 +18486,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
     const childAbs = path31.resolve(dir, ref);
     try {
       readFileSync34(childAbs);
-      node.children.push(buildTree(childAbs, repoRoot, visited));
+      node.children.push(buildTree(childAbs, repoRoot2, visited));
     } catch {
       node.children.push({
         path: childAbs,
@@ -18425,10 +18526,10 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path32.join(dir, entry);
     try {
-      const stat3 = statSync6(full);
-      if (stat3.isFile() && entry.endsWith(".sln")) {
+      const stat4 = statSync6(full);
+      if (stat4.isFile() && entry.endsWith(".sln")) {
         results.push(full);
-      } else if (stat3.isDirectory()) {
+      } else if (stat4.isDirectory()) {
         results.push(...findSlnFiles(full, maxDepth, depth + 1));
       }
     } catch {
@@ -18436,17 +18537,17 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   }
   return results;
 }
-function findContainingSolutions(csprojPath, repoRoot) {
+function findContainingSolutions(csprojPath, repoRoot2) {
   const csprojAbs = path32.resolve(csprojPath);
   const csprojBasename = path32.basename(csprojAbs);
-  const slnFiles = findSlnFiles(repoRoot, 3);
+  const slnFiles = findSlnFiles(repoRoot2, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
       const content = readFileSync35(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path32.relative(repoRoot, sln));
+        matches.push(path32.relative(repoRoot2, sln));
       }
     } catch {
     }
@@ -18508,29 +18609,29 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import path33 from "path";
 import chalk149 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path33.resolve(csprojPath);
-  if (!existsSync39(resolved)) {
+  if (!existsSync40(resolved)) {
     console.error(chalk149.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot = findRepoRoot(path33.dirname(resolved));
-  if (!repoRoot) {
+  const repoRoot2 = findRepoRoot(path33.dirname(resolved));
+  if (!repoRoot2) {
     console.error(chalk149.red("Could not find git repository root"));
     process.exit(1);
   }
-  return { resolved, repoRoot };
+  return { resolved, repoRoot: repoRoot2 };
 }
 
 // src/commands/dotnet/deps.ts
 async function deps(csprojPath, options2) {
-  const { resolved, repoRoot } = resolveCsproj(csprojPath);
-  const tree = buildTree(resolved, repoRoot);
+  const { resolved, repoRoot: repoRoot2 } = resolveCsproj(csprojPath);
+  const tree = buildTree(resolved, repoRoot2);
   const totalCount = collectAllDeps(tree).size + 1;
-  const solutions = findContainingSolutions(resolved, repoRoot);
+  const solutions = findContainingSolutions(resolved, repoRoot2);
   if (options2.json) {
     printJson(tree, totalCount, solutions);
   } else {
@@ -18571,8 +18672,8 @@ function getChangedCsFiles(scope) {
 // src/commands/dotnet/inSln.ts
 import chalk150 from "chalk";
 async function inSln(csprojPath) {
-  const { resolved, repoRoot } = resolveCsproj(csprojPath);
-  const solutions = findContainingSolutions(resolved, repoRoot);
+  const { resolved, repoRoot: repoRoot2 } = resolveCsproj(csprojPath);
+  const solutions = findContainingSolutions(resolved, repoRoot2);
   if (solutions.length === 0) {
     console.log(chalk150.yellow("Not found in any .sln file"));
     process.exit(1);
@@ -18681,24 +18782,24 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path34 from "path";
 import chalk153 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync7 } from "fs";
-import { dirname as dirname23, join as join42 } from "path";
+import { dirname as dirname24, join as join43 } from "path";
 import chalk152 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join42(dir, f));
+    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join43(dir, f));
   } catch {
     return [];
   }
 }
 function findSolution() {
-  const repoRoot = findRepoRoot(process.cwd());
-  const ceiling = repoRoot ?? process.cwd();
+  const repoRoot2 = findRepoRoot(process.cwd());
+  const ceiling = repoRoot2 ?? process.cwd();
   let current = process.cwd();
   while (true) {
     const slnFiles = findSlnInDir(current);
@@ -18712,7 +18813,7 @@ function findSolution() {
       process.exit(1);
     }
     if (current === ceiling) break;
-    current = dirname23(current);
+    current = dirname24(current);
   }
   console.error(chalk152.red("No .sln file found between cwd and repo root"));
   process.exit(1);
@@ -18722,7 +18823,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path34.resolve(sln);
-    if (!existsSync40(resolved)) {
+    if (!existsSync41(resolved)) {
       console.error(chalk153.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -18762,7 +18863,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync40 } from "child_process";
-import { existsSync as existsSync41, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import path35 from "path";
 import chalk154 from "chalk";
@@ -18793,7 +18894,7 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk154.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync41(reportPath)) {
+  if (!existsSync42(reportPath)) {
     console.error(chalk154.red("Report file not generated"));
     process.exit(1);
   }
@@ -19050,11 +19151,11 @@ function decideCommentGuard(input, existingContent) {
 }
 
 // src/commands/dbMigration/consumeMigrationApproval.ts
-import { existsSync as existsSync42, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync43, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
   const path71 = getMigrationApprovalPath(migrationId);
-  if (!existsSync42(path71)) return false;
+  if (!existsSync43(path71)) return false;
   try {
     unlinkSync11(path71);
     return true;
@@ -19174,7 +19275,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync4 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -19199,7 +19300,7 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join43(tmpdir5(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join44(tmpdir5(), `gh-query-${Date.now()}.graphql`);
   writeFileSync30(queryFile, mutation);
   try {
     const result = spawnSync4("gh", buildArgs2(queryFile, vars), {
@@ -19387,24 +19488,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync43,
+  existsSync as existsSync44,
   readdirSync as readdirSync8,
   readFileSync as readFileSync37,
   rmSync as rmSync3,
   statSync as statSync7
 } from "fs";
-import { basename as basename12, join as join46 } from "path";
+import { basename as basename12, join as join47 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join44(cwd, ".assist", "HANDOVER.md");
+  return join45(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join45(cwd, ".assist", "handovers");
+  return join46(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -19442,10 +19543,10 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync43(dir)) return [];
+  if (!existsSync44(dir)) return [];
   const out = [];
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-    const full = join46(dir, entry.name);
+    const full = join47(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
@@ -19469,7 +19570,7 @@ async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync43(handoverPath)) {
+  if (existsSync44(handoverPath)) {
     await migrateFile(orm, origin, handoverPath, statSync7(handoverPath).mtime);
     migrated++;
   }
@@ -19815,18 +19916,18 @@ function recentDaemonLogLines() {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync44 } from "fs";
-import { basename as basename14, dirname as dirname24 } from "path";
+import { existsSync as existsSync45 } from "fs";
+import { basename as basename14, dirname as dirname25 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename13, join as join47 } from "path";
+import { basename as basename13, join as join48 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
   const name = basename13(clone);
   for (let n = 2; n < 1e3; n++) {
-    const candidate = join47(base, `${name}-${n}`);
+    const candidate = join48(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
   }
   throw new Error(`no free worktree suffix for ${clone}`);
@@ -19859,13 +19960,13 @@ function cloneHead(clone) {
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
 function createWorktree(clone, strategy, boundTreeRoots2) {
-  const base = strategy.root ? expandTilde2(strategy.root) : dirname24(clone);
+  const base = strategy.root ? expandTilde2(strategy.root) : dirname25(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
   const path71 = nextWorktreePath(
     clone,
     base,
-    (candidate) => registered.has(candidate) || existsSync44(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate))
+    (candidate) => registered.has(candidate) || existsSync45(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate))
   );
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
@@ -19885,7 +19986,7 @@ function createWorktree(clone, strategy, boundTreeRoots2) {
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 var treeIsGone = { durable: true, gone: true };
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
@@ -19916,14 +20017,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync45(cwd)) return treeIsGone;
+  if (!existsSync46(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
   return step2.value;
 }
 function checkDurabilitySync(cwd) {
-  if (!existsSync45(cwd)) return treeIsGone;
+  if (!existsSync46(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -19973,11 +20074,11 @@ function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
   if (!requestedCwd)
     return { cwd: requestedCwd, kind: "primary", created: false };
   if (options2.inPlace === true) return keptInPlace(requestedCwd);
-  const repoRoot = findRepoRoot(requestedCwd) ?? requestedCwd;
-  const cfg = worktreeConfigFor(repoRoot);
+  const repoRoot2 = findRepoRoot(requestedCwd) ?? requestedCwd;
+  const cfg = worktreeConfigFor(repoRoot2);
   if (!cfg.enabled)
     return { cwd: requestedCwd, kind: "primary", created: false };
-  const clone = mainWorktree(repoRoot) ?? repoRoot;
+  const clone = mainWorktree(repoRoot2) ?? repoRoot2;
   const reuse = { ...options2, includeDrafts: cfg.includeDrafts };
   if (mustLeaveTrunk(cfg.trunk, options2))
     daemonLog(
@@ -20133,30 +20234,30 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { copyFileSync, existsSync as existsSync47, mkdirSync as mkdirSync16 } from "fs";
-import { dirname as dirname25, join as join49 } from "path";
+import { copyFileSync, existsSync as existsSync48, mkdirSync as mkdirSync16 } from "fs";
+import { dirname as dirname26, join as join50 } 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 existsSync46 } from "fs";
-import { join as join48 } from "path";
-function detectInstallCommand(repoRoot) {
-  if (!existsSync46(join48(repoRoot, "package.json"))) return null;
-  if (existsSync46(join48(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync46(join48(repoRoot, "yarn.lock"))) return "yarn install";
-  if (existsSync46(join48(repoRoot, "bun.lockb"))) return "bun install";
+import { existsSync as existsSync47 } from "fs";
+import { join as join49 } from "path";
+function detectInstallCommand(repoRoot2) {
+  if (!existsSync47(join49(repoRoot2, "package.json"))) return null;
+  if (existsSync47(join49(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync47(join49(repoRoot2, "yarn.lock"))) return "yarn install";
+  if (existsSync47(join49(repoRoot2, "bun.lockb"))) return "bun install";
   return "npm install";
 }
-function resolveInstallCommand(repoRoot, install) {
+function resolveInstallCommand(repoRoot2, install) {
   if (install === false) return null;
   if (typeof install === "string") return install;
-  return detectInstallCommand(repoRoot);
+  return detectInstallCommand(repoRoot2);
 }
 
 // src/commands/sessions/daemon/worktree/stopInstall.ts
-import { execFile as execFile8 } from "child_process";
+import { execFile as execFile9 } from "child_process";
 var running2 = /* @__PURE__ */ new Map();
 function trackInstall(worktreePath, child) {
   running2.set(worktreePath, child);
@@ -20175,7 +20276,7 @@ function stopInstall(worktreePath) {
 }
 function killTree(pid) {
   if (process.platform === "win32") {
-    execFile8(
+    execFile9(
       "taskkill",
       ["/T", "/F", "/PID", String(pid)],
       { windowsHide: true },
@@ -20258,11 +20359,11 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 }
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
-    const src = join49(clone, rel);
-    if (!existsSync47(src)) continue;
-    const dest = join49(worktreePath, rel);
+    const src = join50(clone, rel);
+    if (!existsSync48(src)) continue;
+    const dest = join50(worktreePath, rel);
     try {
-      mkdirSync16(dirname25(dest), { recursive: true });
+      mkdirSync16(dirname26(dest), { recursive: true });
       copyFileSync(src, dest);
       daemonLog(`worktree ${worktreePath} seeded ${rel}`);
     } catch (error) {
@@ -20555,7 +20656,7 @@ function registerMermaid(program2) {
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname27 } from "path";
+import { dirname as dirname28 } from "path";
 import chalk166 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
@@ -20632,17 +20733,17 @@ function createNetcapHandler(options2) {
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
-import { cp, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { cp, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 import chalk165 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname26, join as join50 } from "path";
+import { dirname as dirname27, join as join51 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var moduleDir = dirname26(fileURLToPath6(import.meta.url));
+var moduleDir = dirname27(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
-  return join50(moduleDir, "commands", "netcap", "netcap-extension");
+  return join51(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -20657,9 +20758,9 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join51(dir, "background.js");
-  const source = await readFile3(file, "utf8");
-  await writeFile3(
+  const file = join52(dir, "background.js");
+  const source = await readFile4(file, "utf8");
+  await writeFile4(
     file,
     source.replace(
       /const RECEIVER = "[^"]*";/,
@@ -20697,20 +20798,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute3, join as join53, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute3, join as join54, resolve as resolve16 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir19 } from "os";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 function defaultCapturePath() {
-  return join52(homedir19(), ".assist", "netcap", "capture.jsonl");
+  return join53(homedir19(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute3(out) ? out : resolve16(process.cwd(), out);
-  return join53(dir, "capture.jsonl");
+  return join54(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -20718,7 +20819,7 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir4(dirname27(outPath), { recursive: true });
+  await mkdir4(dirname28(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count8 = 0;
   const handler = createNetcapHandler({
@@ -20757,7 +20858,7 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync32 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 import chalk167 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
@@ -21202,7 +21303,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join54(captureFile, "..", "posts.json");
+  const outFile = join55(captureFile, "..", "posts.json");
   writeFileSync32(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -21727,17 +21828,17 @@ import { execSync as execSync46 } from "child_process";
 import { execSync as execSync45 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync48, readFileSync as readFileSync40, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync40, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse2 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
 import { homedir as homedir20 } from "os";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 function commentsCachePath(org, repo, prNumber) {
-  return join55(
+  return join56(
     homedir20(),
     ".assist",
     "pr-comments",
@@ -21750,7 +21851,7 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync48(cachePath)) {
+  if (!existsSync49(cachePath)) {
     return null;
   }
   const content = readFileSync40(cachePath, "utf8");
@@ -21758,7 +21859,7 @@ function loadCommentsCache(org, repo, prNumber) {
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync48(cachePath)) {
+  if (existsSync49(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -21776,7 +21877,7 @@ function replyToComment(org, repo, prNumber, commentId, message3) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join56(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join57(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync33(queryFile, mutation);
   try {
     execSync45(
@@ -21861,10 +21962,10 @@ function fixed(commentId, sha) {
 import { execSync as execSync47 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync34 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join57(tmpdir7(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join58(tmpdir7(), `gh-query-${Date.now()}.graphql`);
   writeFileSync34(queryFile, THREAD_QUERY);
   try {
     const result = execSync47(
@@ -21934,15 +22035,15 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync35 } from "fs";
-import { dirname as dirname28 } from "path";
+import { dirname as dirname29 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
 import { readdirSync as readdirSync10, unlinkSync as unlinkSync16 } from "fs";
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 var STALE_PATTERN = /^pr-\d+-comments\.yaml$/;
 function removeStaleCommentsCaches(cwd = process.cwd()) {
-  const dir = join58(cwd, ".assist");
+  const dir = join59(cwd, ".assist");
   let entries;
   try {
     entries = readdirSync10(dir);
@@ -21950,14 +22051,14 @@ function removeStaleCommentsCaches(cwd = process.cwd()) {
     return;
   }
   for (const entry of entries.filter((e) => STALE_PATTERN.test(e))) {
-    unlinkSync16(join58(dir, entry));
+    unlinkSync16(join59(dir, entry));
   }
 }
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 function writeCommentsCache(org, repo, prNumber, comments3) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  mkdirSync18(dirname28(cachePath), { recursive: true });
+  mkdirSync18(dirname29(cachePath), { recursive: true });
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24910,21 +25011,21 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir21 } from "os";
-import { basename as basename16, join as join59 } from "path";
-function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join59(
+import { basename as basename16, join as join60 } from "path";
+function buildReviewPaths(repoRoot2, key) {
+  const reviewDir = join60(
     homedir21(),
     ".assist",
     "reviews",
-    basename16(repoRoot),
+    basename16(repoRoot2),
     key
   );
   return {
     reviewDir,
-    requestPath: join59(reviewDir, "request.md"),
-    claudePath: join59(reviewDir, "claude.md"),
-    codexPath: join59(reviewDir, "codex.md"),
-    synthesisPath: join59(reviewDir, "synthesis.md")
+    requestPath: join60(reviewDir, "request.md"),
+    claudePath: join60(reviewDir, "claude.md"),
+    codexPath: join60(reviewDir, "codex.md"),
+    synthesisPath: join60(reviewDir, "synthesis.md")
   };
 }
 
@@ -25581,10 +25682,10 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync49, mkdirSync as mkdirSync19, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync19, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
   for (const path71 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync49(path71)) unlinkSync17(path71);
+    if (existsSync50(path71)) unlinkSync17(path71);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -25811,7 +25912,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync51, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync52, unlinkSync as unlinkSync19 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -26231,7 +26332,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync50, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync51, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -26283,7 +26384,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync50(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync51(spec.outputPath)) {
     unlinkSync18(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -26429,7 +26530,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync51(paths.synthesisPath)) {
+  if (anyFresh && existsSync52(paths.synthesisPath)) {
     unlinkSync19(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -26495,9 +26596,9 @@ function gatherChangedContext() {
   );
   process.exit(1);
 }
-function setupReviewDir(repoRoot, context, force) {
+function setupReviewDir(repoRoot2, context, force) {
   const paths = buildReviewPaths(
-    repoRoot,
+    repoRoot2,
     `${context.branch}-${context.shortSha}`
   );
   const priorComments = fetchExistingComments();
@@ -26517,9 +26618,9 @@ function runPostSynthesis(synthesisPath, prInfo, options2) {
     announce: options2.announce ?? false
   });
 }
-async function reviewPr(repoRoot, options2) {
+async function reviewPr(repoRoot2, options2) {
   const context = gatherChangedContext();
-  const paths = setupReviewDir(repoRoot, context, options2.force ?? false);
+  const paths = setupReviewDir(repoRoot2, context, options2.force ?? false);
   const synthesisOk = await runReviewPipeline(paths, {
     verbose: options2.verbose ?? false
   });
@@ -26530,8 +26631,8 @@ async function reviewPr(repoRoot, options2) {
 
 // src/commands/review/review.ts
 function resolveRepoRoot() {
-  const repoRoot = findRepoRoot(process.cwd());
-  if (repoRoot) return repoRoot;
+  const repoRoot2 = findRepoRoot(process.cwd());
+  if (repoRoot2) return repoRoot2;
   console.error("Error: not inside a git repository.");
   process.exit(1);
 }
@@ -27277,27 +27378,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync52, readdirSync as readdirSync11, statSync as statSync9 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync53, readdirSync as readdirSync11, statSync as statSync9 } from "fs";
+import { join as join61 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync52(vttDir)) return;
+  if (!existsSync53(vttDir)) return;
   for (const entry of readdirSync11(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync9(join60(vttDir, entry)).isDirectory()) continue;
+    if (statSync9(join61(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync53,
+  existsSync as existsSync54,
   mkdirSync as mkdirSync20,
   readFileSync as readFileSync43,
   renameSync as renameSync2,
   writeFileSync as writeFileSync38
 } from "fs";
-import { basename as basename17, join as join61 } from "path";
+import { basename as basename17, join as join62 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text17) {
@@ -27510,9 +27611,9 @@ function convertVttToMarkdown(inputPath) {
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join61(vttDir, "processed");
+  const processedDir = join62(vttDir, "processed");
   mkdirSync20(processedDir, { recursive: true });
-  renameSync2(sourcePath, join61(processedDir, filename));
+  renameSync2(sourcePath, join62(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -27522,19 +27623,19 @@ function move(file, options2) {
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename17(file);
-  const sourcePath = join61(vttDir, filename);
-  if (!existsSync53(sourcePath)) {
+  const sourcePath = join62(vttDir, filename);
+  if (!existsSync54(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
   const base = basename17(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join61(transcriptsDir, client);
+  const formattedDir = join62(transcriptsDir, client);
   mkdirSync20(formattedDir, { recursive: true });
-  const formattedPath = join61(formattedDir, outputName);
+  const formattedPath = join62(formattedDir, outputName);
   writeFileSync38(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join61(summaryDir, client, outputName);
+  const summaryPath = join62(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -27616,45 +27717,45 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { join as join63 } from "path";
+import { join as join64 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir22 } from "os";
-import { dirname as dirname30, join as join62 } from "path";
+import { dirname as dirname31, join as join63 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
-var __dirname5 = dirname30(fileURLToPath7(import.meta.url));
-var VOICE_DIR = join62(homedir22(), ".assist", "voice");
+var __dirname5 = dirname31(fileURLToPath7(import.meta.url));
+var VOICE_DIR = join63(homedir22(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join62(VOICE_DIR, "voice.pid"),
-  log: join62(VOICE_DIR, "voice.log"),
-  venv: join62(VOICE_DIR, ".venv"),
-  lock: join62(VOICE_DIR, "voice.lock")
+  pid: join63(VOICE_DIR, "voice.pid"),
+  log: join63(VOICE_DIR, "voice.log"),
+  venv: join63(VOICE_DIR, ".venv"),
+  lock: join63(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join62(__dirname5, "commands", "voice", "python");
+  return join63(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join62(voicePaths.venv, "Scripts", "python.exe") : join62(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join63(voicePaths.venv, "Scripts", "python.exe") : join63(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join62(getLockDir(), "voice.lock");
+  return join63(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join63(getPythonDir(), "list_devices.py");
+  const script = join64(getPythonDir(), "list_devices.py");
   spawnSync6(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync54, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync55, readFileSync as readFileSync44 } from "fs";
 function logs(options2) {
-  if (!existsSync54(voicePaths.log)) {
+  if (!existsSync55(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -27682,12 +27783,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync7 } from "child_process";
 import { mkdirSync as mkdirSync22 } from "fs";
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync59 } from "child_process";
-import { existsSync as existsSync55, mkdirSync as mkdirSync21, readFileSync as readFileSync45, writeFileSync as writeFileSync39 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync56, mkdirSync as mkdirSync21, readFileSync as readFileSync45, writeFileSync as writeFileSync39 } from "fs";
+import { join as join65 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -27698,7 +27799,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync55(lockFile)) return;
+  if (!existsSync56(lockFile)) return;
   try {
     const lock2 = JSON.parse(readFileSync45(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
@@ -27711,7 +27812,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync55(getVenvPython())) return;
+  if (existsSync56(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync59(
@@ -27724,7 +27825,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync21(join64(lockFile, ".."), { recursive: true });
+  mkdirSync21(join65(lockFile, ".."), { recursive: true });
   writeFileSync39(
     lockFile,
     JSON.stringify({
@@ -27740,7 +27841,7 @@ function setup() {
   mkdirSync22(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join65(getPythonDir(), "setup_models.py");
+  const script = join66(getPythonDir(), "setup_models.py");
   const result = spawnSync7(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -27754,7 +27855,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
 import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync40 } from "fs";
-import { join as join66 } from "path";
+import { join as join67 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -27792,7 +27893,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join66(getPythonDir(), "voice_daemon.py");
+  const script = join67(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -27802,7 +27903,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync56, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync46 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -27812,12 +27913,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync56(voicePaths.log)) return [];
+  if (!existsSync57(voicePaths.log)) return [];
   const lines2 = readFileSync46(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync56(voicePaths.pid)) {
+  if (!existsSync57(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -27840,9 +27941,9 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync57, readFileSync as readFileSync47, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync58, readFileSync as readFileSync47, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync57(voicePaths.pid)) {
+  if (!existsSync58(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -27859,7 +27960,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync57(lockFile)) unlinkSync20(lockFile);
+    if (existsSync58(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -27878,7 +27979,7 @@ function registerVoice(program2) {
 }
 
 // src/commands/watch/readBuiltVersion.ts
-import { join as join67 } from "path";
+import { join as join68 } from "path";
 
 // src/commands/watch/resolveUpstream.ts
 import { execFileSync as execFileSync10 } from "child_process";
@@ -27924,7 +28025,7 @@ function resolveUpstream(cwd) {
 function readBuiltVersion(cwd) {
   try {
     const root = runGit2(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join67(root, "package.json")).version ?? "unknown";
+    return readPackageJson(join68(root, "package.json")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -28222,7 +28323,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { resolve as resolve17 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -28235,25 +28336,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve17(baseDir, config.cwd);
-  if (!existsSync58(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync59(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import { existsSync as existsSync59 } from "fs";
-import { dirname as dirname31, join as join68, resolve as resolve18 } from "path";
+import { existsSync as existsSync60 } from "fs";
+import { dirname as dirname32, join as join69, resolve as resolve18 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync11("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve18(dirname31(gitPath), "..");
-    const gitBash = join68(gitRoot, "bin", "bash.exe");
-    if (existsSync59(gitBash)) return gitBash;
+    const gitRoot = resolve18(dirname32(gitPath), "..");
+    const gitBash = join69(gitRoot, "bin", "bash.exe");
+    if (existsSync60(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -28263,7 +28364,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync60(cwd)) {
+    if (cwd && !existsSync61(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -28653,7 +28754,7 @@ async function auth() {
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync13 } from "child_process";
 import { readdirSync as readdirSync12, readFileSync as readFileSync48, statSync as statSync10 } from "fs";
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -28662,7 +28763,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path71 = join69(roamDir, name);
+    const path71 = join70(roamDir, name);
     try {
       return { path: path71, mtimeMs: statSync10(path71).mtimeMs };
     } catch {
@@ -28674,7 +28775,7 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join69(appData, "Roam"));
+  const portFile = findPortFile(join70(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -28807,7 +28908,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync41 } from "fs";
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -28868,7 +28969,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join70(".claude", "commands");
+  const dir = join71(".claude", "commands");
   mkdirSync24(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -28876,7 +28977,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join70(dir, `${name}.md`);
+  const filePath = join71(dir, `${name}.md`);
   writeFileSync41(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -28932,8 +29033,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync61, unlinkSync as unlinkSync21 } from "fs";
-import { join as join71 } from "path";
+import { existsSync as existsSync62, unlinkSync as unlinkSync21 } from "fs";
+import { join as join72 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -28948,8 +29049,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join71(".claude", "commands", `${name}.md`);
-  if (existsSync61(filePath)) {
+  const filePath = join72(".claude", "commands", `${name}.md`);
+  if (existsSync62(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -28994,9 +29095,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync61 } from "child_process";
-import { existsSync as existsSync62, mkdirSync as mkdirSync25, unlinkSync as unlinkSync22, writeFileSync as writeFileSync42 } from "fs";
+import { existsSync as existsSync63, mkdirSync as mkdirSync25, unlinkSync as unlinkSync22, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join72, resolve as resolve19 } from "path";
+import { join as join73, resolve as resolve19 } from "path";
 import chalk211 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -29126,14 +29227,14 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync62(outputDir)) {
+  if (!existsSync63(outputDir)) {
     mkdirSync25(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve19(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join72(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join73(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync42(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync61(
@@ -29615,11 +29716,11 @@ function readDesignSystemPrompt() {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync63, statSync as statSync11 } from "fs";
+import { chmodSync, existsSync as existsSync64, statSync as statSync11 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path59 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -29634,7 +29735,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync63(helper)) return;
+  if (!existsSync64(helper)) return;
   const mode = statSync11(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -29670,7 +29771,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync64(cwd)) return;
+  if (!cwd || existsSync65(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -29793,17 +29894,17 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync66 } from "fs";
+import { existsSync as existsSync67 } from "fs";
 import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync65 } from "fs";
-import { join as join75 } from "path";
+import { existsSync as existsSync66 } from "fs";
+import { join as join76 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync12 } from "fs";
 import { rm as rm2 } from "fs/promises";
-import { join as join74 } from "path";
+import { join as join75 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -29831,7 +29932,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync12(join74(worktreePath, ".git"), {
+  return statSync12(join75(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -29867,7 +29968,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync65(join75(worktreePath, ".git")))
+  if (!existsSync66(join76(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";
@@ -29919,7 +30020,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync66(worktreePath)) {
+  if (!existsSync67(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -29944,7 +30045,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync66(recorded)) return recorded;
+  if (recorded && existsSync67(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -30072,12 +30173,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync67, watch } from "fs";
+import { existsSync as existsSync68, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync67(common)) return void 0;
+  if (!common || !existsSync68(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -30436,13 +30537,13 @@ function isBacklogItemId(text17) {
 }
 
 // src/commands/sessions/daemon/generateSessionTitle.ts
-import { execFile as execFile9 } from "child_process";
-import { promisify as promisify8 } from "util";
-var execFileAsync7 = promisify8(execFile9);
+import { execFile as execFile10 } from "child_process";
+import { promisify as promisify9 } from "util";
+var execFileAsync8 = promisify9(execFile10);
 var SESSION_TITLE_MAX_LENGTH = 48;
 async function generateSessionTitle(prompt) {
   try {
-    const { stdout } = await execFileAsync7(
+    const { stdout } = await execFileAsync8(
       "claude",
       ["-p", "--model", "haiku", buildPrompt4(prompt)],
       { encoding: "utf8", windowsHide: true, timeout: 3e4 }
@@ -30521,10 +30622,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import { resolve as resolve20 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync68(session.cwd))
+  if (session.cwd && !existsSync69(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -30538,7 +30639,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve20(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync68(configured)) return void 0;
+  if (existsSync69(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -30555,8 +30656,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync69, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
-import { dirname as dirname33 } from "path";
+import { existsSync as existsSync70, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
+import { dirname as dirname34 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
 function applyReviewPause(session, activity2) {
@@ -30610,7 +30711,7 @@ var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path71 = activityPath(session.id);
-  const dir = dirname33(path71);
+  const dir = dirname34(path71);
   try {
     mkdirSync26(dir, { recursive: true });
   } catch {
@@ -30636,7 +30737,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync69(path71)) read();
+  if (existsSync70(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -31962,7 +32063,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import { basename as basename20 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -31984,10 +32085,10 @@ function accountedTrees(sessions) {
 
 // src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
 function detectExistingWorktree(cwd) {
-  const repoRoot = findRepoRoot(cwd) ?? cwd;
-  if (!worktreeConfigFor(repoRoot).enabled) return void 0;
-  const clone = mainWorktree(repoRoot);
-  if (clone && clone !== repoRoot) return { path: repoRoot, clone };
+  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
+  if (!worktreeConfigFor(repoRoot2).enabled) return void 0;
+  const clone = mainWorktree(repoRoot2);
+  if (clone && clone !== repoRoot2) return { path: repoRoot2, clone };
   return void 0;
 }
 
@@ -32052,9 +32153,9 @@ function capped(lines2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync72 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync71(clone)) {
+  if (!existsSync72(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -32161,7 +32262,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
-    if (!existsSync72(path71)) {
+    if (!existsSync73(path71)) {
       logVanishedTree(sessions, path71);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
@@ -32626,13 +32727,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync73, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync74, readFileSync as readFileSync51 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync73(sessionsFile)) return false;
+    if (!existsSync74(sessionsFile)) return false;
     const data = JSON.parse(readFileSync51(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -33607,9 +33708,9 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync74 } from "fs";
+import { existsSync as existsSync75 } from "fs";
 function repoDirExists(cwd) {
-  return existsSync74(toGitCwd(cwd));
+  return existsSync75(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/withRepoGroups.ts
@@ -34169,16 +34270,16 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync54, statSync as statSync14 } from "fs";
-import { isAbsolute as isAbsolute4, join as join77, resolve as resolve21 } from "path";
+import { isAbsolute as isAbsolute4, join as join78, resolve as resolve21 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join77(cwd, ".git");
-  let stat3;
+  const dotGit = join78(cwd, ".git");
+  let stat4;
   try {
-    stat3 = statSync14(dotGit);
+    stat4 = statSync14(dotGit);
   } catch {
     return null;
   }
-  if (stat3.isDirectory()) {
+  if (stat4.isDirectory()) {
     return dotGit;
   }
   let contents;
@@ -34201,7 +34302,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync54(join77(gitDir, "HEAD"), "utf8");
+    head = readFileSync54(join78(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }