@staff0rd/assist 0.341.1 → 0.342.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.341.1",
+  version: "0.342.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -5579,7 +5579,7 @@ function delay(ms) {
 
 // src/commands/sessions/web/handleRequest.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 import { createRequire as createRequire2 } from "module";
 
 // src/shared/createBundleHandler.ts
@@ -5940,6 +5940,81 @@ function getHtml() {
 </html>`;
 }
 
+// src/commands/sessions/web/getReviewSynthesis.ts
+import { execFile } from "child_process";
+import { readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir9 } from "os";
+import { basename as basename3, join as join22 } from "path";
+import { promisify } from "util";
+
+// src/commands/sessions/web/findSynthesisForBranch.ts
+import { existsSync as existsSync24, readdirSync, statSync as statSync2 } from "fs";
+import { basename as basename2, dirname as dirname18, join as join21 } from "path";
+function findSynthesisForBranch(repoReviewsDir, branch) {
+  const branchKeyPath = join21(repoReviewsDir, `${branch}-`);
+  const parent = dirname18(branchKeyPath);
+  const branchPrefix = basename2(branchKeyPath);
+  if (!existsSync24(parent)) return null;
+  const synthesisFiles = readdirSync(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join21(parent, name, "synthesis.md")).filter((path57) => existsSync24(path57)).map((path57) => ({ path: path57, mtime: statSync2(path57).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  return synthesisFiles[0]?.path ?? null;
+}
+
+// src/commands/sessions/web/getCwdParam.ts
+function getCwdParam(req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const cwd = url.searchParams.get("cwd");
+  if (!cwd) {
+    respondJson(res, 400, { error: "Missing cwd" });
+    return null;
+  }
+  return cwd;
+}
+
+// src/commands/sessions/web/windowsCwdToWslPath.ts
+function windowsCwdToWslPath(cwd) {
+  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
+  if (!match) return cwd;
+  const drive = match[1].toLowerCase();
+  const rest = match[2].replace(/\\/g, "/");
+  return `/mnt/${drive}/${rest}`;
+}
+
+// src/commands/sessions/web/getReviewSynthesis.ts
+var execFileAsync = promisify(execFile);
+function runGit(cwd, args) {
+  return execFileAsync("git", args, {
+    encoding: "utf8",
+    cwd: windowsCwdToWslPath(cwd)
+  }).then((r) => r.stdout.trim());
+}
+async function resolveSynthesisPath(cwd) {
+  const [repoRoot, branch] = await Promise.all([
+    runGit(cwd, ["rev-parse", "--show-toplevel"]),
+    runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
+  ]);
+  const repoReviewsDir = join22(
+    homedir9(),
+    ".assist",
+    "reviews",
+    basename3(repoRoot)
+  );
+  return findSynthesisForBranch(repoReviewsDir, branch);
+}
+async function getReviewSynthesis(req, res) {
+  const cwd = getCwdParam(req, res);
+  if (!cwd) return;
+  try {
+    const path57 = await resolveSynthesisPath(cwd);
+    if (!path57) {
+      respondJson(res, 404, { error: "No synthesis found" });
+      return;
+    }
+    respondJson(res, 200, { synthesis: readFileSync17(path57, "utf8") });
+  } catch {
+    respondJson(res, 404, { error: "No synthesis found" });
+  }
+}
+
 // src/commands/prs/getPreferredRemoteRepo.ts
 import { execSync as execSync21 } from "child_process";
 var GITHUB_URL_PATTERN = /(?:git@github\.com:|https:\/\/github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?\/?$/;
@@ -6001,26 +6076,6 @@ function getPreferredRemoteRepo(cwd) {
   return null;
 }
 
-// src/commands/sessions/web/getCwdParam.ts
-function getCwdParam(req, res) {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  const cwd = url.searchParams.get("cwd");
-  if (!cwd) {
-    respondJson(res, 400, { error: "Missing cwd" });
-    return null;
-  }
-  return cwd;
-}
-
-// src/commands/sessions/web/windowsCwdToWslPath.ts
-function windowsCwdToWslPath(cwd) {
-  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
-  if (!match) return cwd;
-  const drive = match[1].toLowerCase();
-  const rest = match[2].replace(/\\/g, "/");
-  return `/mnt/${drive}/${rest}`;
-}
-
 // src/commands/sessions/web/githubUrl.ts
 function githubUrl(req, res) {
   const cwd = getCwdParam(req, res);
@@ -6032,8 +6087,8 @@ function githubUrl(req, res) {
 }
 
 // src/commands/sessions/web/gitStatus.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 
 // src/commands/sessions/web/parseGitStatus.ts
 function extractPath(rest) {
@@ -6063,7 +6118,7 @@ function parseGitStatus(output) {
 }
 
 // src/commands/sessions/web/gitStatus.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify2(execFile2);
 async function gitStatus(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
@@ -6076,7 +6131,7 @@ async function gitStatus(req, res) {
 function runGitStatus(cwd) {
   const args = ["status", "--porcelain"];
   const { file, argv } = /^[A-Za-z]:[\\/]/.test(cwd) ? { file: "git.exe", argv: ["-C", cwd, ...args] } : { file: "git", argv: args };
-  return execFileAsync(file, argv, {
+  return execFileAsync2(file, argv, {
     encoding: "utf8",
     ...file === "git" ? { cwd } : {}
   }).then((r) => r.stdout);
@@ -6240,8 +6295,8 @@ async function listUsageHistory(req, res) {
 
 // src/commands/sessions/web/openInCode.ts
 import { exec } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync = promisify2(exec);
+import { promisify as promisify3 } from "util";
+var execAsync = promisify3(exec);
 async function openInCode(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
@@ -6257,9 +6312,9 @@ async function openInCode(req, res) {
 }
 
 // src/commands/sessions/web/createCachedGhJson.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync2 = promisify3(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync3 = promisify4(execFile3);
 var CACHE_TTL_MS = 3e4;
 function createCachedGhJson(args, parse3, fallback) {
   const cache = /* @__PURE__ */ new Map();
@@ -6269,7 +6324,7 @@ function createCachedGhJson(args, parse3, fallback) {
     if (cached && cached.expires > now) return cached.value;
     let value = fallback;
     try {
-      const { stdout } = await execFileAsync2("gh", args, {
+      const { stdout } = await execFileAsync3("gh", args, {
         encoding: "utf8",
         cwd: windowsCwdToWslPath(cwd)
       });
@@ -6435,7 +6490,7 @@ function createCssHandler(packageEntry) {
   return (req, res) => {
     if (!cache) {
       const resolved = require3.resolve(packageEntry);
-      const body = readFileSync17(resolved, "utf8");
+      const body = readFileSync18(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache = { body, etag };
     }
@@ -6468,7 +6523,8 @@ var routes2 = {
   "GET /api/pr-list": prList,
   "GET /api/news/items": listNewsItems,
   "GET /api/usage/history": listUsageHistory,
-  "GET /api/backups/list": getBackups
+  "GET /api/backups/list": getBackups,
+  "GET /api/review/synthesis": getReviewSynthesis
 };
 var handleRequest = createFallbackHandler(
   routes2,
@@ -7245,9 +7301,9 @@ async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, c
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync18, unlinkSync as unlinkSync6, writeFileSync as writeFileSync19 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync19 } from "fs";
 import { tmpdir } from "os";
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -7287,15 +7343,15 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join21(tmpdir(), "assist-"));
-  const filePath = join21(dir, "description.md");
+  const dir = mkdtempSync(join23(tmpdir(), "assist-"));
+  const filePath = join23(dir, "description.md");
   writeFileSync19(filePath, "");
   const result = spawnSync2(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
     unlinkSync6(filePath);
     return void 0;
   }
-  const content = readFileSync18(filePath, "utf8").trim();
+  const content = readFileSync19(filePath, "utf8").trim();
   unlinkSync6(filePath);
   return content || void 0;
 }
@@ -8444,7 +8500,7 @@ function registerBacklog(program2) {
 }
 
 // src/commands/cliHook/index.ts
-import { basename as basename2 } from "path";
+import { basename as basename4 } from "path";
 
 // src/shared/splitCompound.ts
 import { parse } from "shell-quote";
@@ -8614,12 +8670,12 @@ function findBuiltinDenyRaw(rawCommand) {
 
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync10 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join24 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join22(homedir9(), ".assist");
+  return join24(homedir10(), ".assist");
 }
 function initSchema2(db) {
   db.exec(`
@@ -8638,7 +8694,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync10(dbDir, { recursive: true });
-  const db = new Database(join22(dbDir, "assist.db"));
+  const db = new Database(join24(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema2(db);
   _db = db;
@@ -8740,17 +8796,17 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname18, resolve as resolve8 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname19, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname18(__filename3);
+var __dirname4 = dirname19(__filename3);
 function packageRoot() {
   return __dirname4;
 }
 function readLines(path57) {
-  if (!existsSync24(path57)) return [];
-  return readFileSync19(path57, "utf8").split("\n").filter((line) => line.trim() !== "");
+  if (!existsSync25(path57)) return [];
+  return readFileSync20(path57, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -8796,14 +8852,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join25 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join23(homedir10(), ".claude", "settings.json"),
-    join23(process.cwd(), ".claude", "settings.json"),
-    join23(process.cwd(), ".claude", "settings.local.json")
+    join25(homedir11(), ".claude", "settings.json"),
+    join25(process.cwd(), ".claude", "settings.json"),
+    join25(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -8812,9 +8868,9 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync25(filePath)) return [];
+  if (!existsSync26(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync20(filePath, "utf8"));
+    const data = JSON.parse(readFileSync21(filePath, "utf8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -9030,7 +9086,7 @@ async function cliHook() {
       logDeniedToolCall({
         tool: input.toolName,
         command: input.command,
-        repo: basename2(process.cwd()),
+        repo: basename4(process.cwd()),
         sessionId: process.env.CLAUDE_SESSION_ID,
         denyReason: decision.permissionDecisionReason
       });
@@ -9076,9 +9132,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync21 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join24 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync21 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join26 } from "path";
 
 // src/shared/checkCliAvailable.ts
 import { execSync as execSync23 } from "child_process";
@@ -9367,15 +9423,15 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join24(homedir11(), ".assist", `cli-discover-${safeName}.log`);
+  return join26(homedir12(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path57 = logPath(cli);
-  if (!existsSync26(path57)) return void 0;
-  return readFileSync21(path57, "utf8");
+  if (!existsSync27(path57)) return void 0;
+  return readFileSync22(path57, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join24(homedir11(), ".assist");
+  const dir = join26(homedir12(), ".assist");
   mkdirSync11(dir, { recursive: true });
   writeFileSync21(logPath(cli), output);
 }
@@ -9504,35 +9560,35 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync27, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync23, unlinkSync as unlinkSync8, writeFileSync as writeFileSync22 } from "fs";
 import chalk94 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
-import { homedir as homedir12 } from "os";
-import { join as join25 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join27 } from "path";
 function getRestrictedDir() {
-  return join25(homedir12(), ".assist", "restricted");
+  return join27(homedir13(), ".assist", "restricted");
 }
 function getPinStatePath(pin) {
-  return join25(getRestrictedDir(), `code-comment-${pin}.json`);
+  return join27(getRestrictedDir(), `code-comment-${pin}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync, statSync as statSync2, unlinkSync as unlinkSync7 } from "fs";
-import { join as join26 } from "path";
+import { readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync7 } from "fs";
+import { join as join28 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return;
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path57 = join26(dir, entry);
+    const path57 = join28(dir, entry);
     try {
-      if (statSync2(path57).mtimeMs < cutoff) unlinkSync7(path57);
+      if (statSync3(path57).mtimeMs < cutoff) unlinkSync7(path57);
     } catch {
       continue;
     }
@@ -9542,9 +9598,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/codeCommentConfirm.ts
 function readPinState(pin) {
   const path57 = getPinStatePath(pin);
-  if (!existsSync27(path57)) return void 0;
+  if (!existsSync28(path57)) return void 0;
   try {
-    const state = JSON.parse(readFileSync22(path57, "utf8"));
+    const state = JSON.parse(readFileSync23(path57, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -9559,12 +9615,12 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync27(state.file)) {
+  if (!existsSync28(state.file)) {
     console.error(chalk94.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
   }
-  const original = readFileSync22(state.file, "utf8");
+  const original = readFileSync23(state.file, "utf8");
   const lines = original.split("\n");
   const index3 = state.line - 1;
   if (index3 > lines.length) {
@@ -10410,7 +10466,7 @@ function registerConfig(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync28, readFileSync as readFileSync23, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24, writeFileSync as writeFileSync24 } from "fs";
 import chalk107 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -10419,11 +10475,11 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync28(indexPath)) {
+  if (!existsSync29(indexPath)) {
     console.log(chalk107.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync23(indexPath, "utf8");
+  const content = readFileSync24(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk107.dim("Trailing slash script already present"));
     return;
@@ -10448,14 +10504,14 @@ function registerDeploy(program2) {
 
 // src/commands/devlog/list/index.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { basename as basename4 } from "path";
+import { basename as basename6 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
-import { homedir as homedir13 } from "os";
-import { join as join27 } from "path";
-var BLOG_REPO_ROOT = join27(homedir13(), "git/blog");
+import { homedir as homedir14 } from "os";
+import { join as join29 } from "path";
+var BLOG_REPO_ROOT = join29(homedir14(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join27(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join29(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -10466,17 +10522,17 @@ import { execSync as execSync24 } from "child_process";
 import chalk108 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
-import { basename as basename3, join as join28 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
+import { basename as basename5, join as join30 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join28(process.cwd(), "package.json");
-  if (existsSync29(packageJsonPath)) {
+  const packageJsonPath = join30(process.cwd(), "package.json");
+  if (existsSync30(packageJsonPath)) {
     try {
-      const content = readFileSync24(packageJsonPath, "utf8");
+      const content = readFileSync25(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -10484,13 +10540,13 @@ function getRepoName() {
     } catch {
     }
   }
-  return basename3(process.cwd());
+  return basename5(process.cwd());
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync25 } from "fs";
-import { join as join29 } from "path";
-var DEVLOG_DIR = join29(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync as readdirSync3, readFileSync as readFileSync26 } from "fs";
+import { join as join31 } from "path";
+var DEVLOG_DIR = join31(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -10516,9 +10572,9 @@ function parseFrontmatter(content, filename) {
 }
 function readDevlogFiles(callback) {
   try {
-    const files = readdirSync2(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
+    const files = readdirSync3(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync25(join29(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync26(join31(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -10620,7 +10676,7 @@ function list3(options2) {
   const config = loadConfig();
   const days = options2.days ?? 30;
   const ignore2 = options2.ignore ?? config.devlog?.ignore ?? [];
-  const repoName = basename4(process.cwd());
+  const repoName = basename6(process.cwd());
   const skipDays = loadBlogSkipDays(repoName);
   const devlogEntries = loadDevlogEntries(repoName);
   const args = ["log"];
@@ -10906,11 +10962,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync25 } from "fs";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 import chalk113 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join30(BLOG_REPO_ROOT, "assist.yml");
+  return join32(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -10970,17 +11026,17 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync3 } from "fs";
-import { join as join31 } from "path";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync4 } from "fs";
+import { join as join33 } from "path";
 import chalk115 from "chalk";
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import path22 from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path22.dirname(current)) {
-    if (existsSync30(path22.join(current, ".git"))) {
+    if (existsSync31(path22.join(current, ".git"))) {
       return current;
     }
     current = path22.dirname(current);
@@ -10993,13 +11049,13 @@ var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
 function isLockedDll(debugDir) {
   let files;
   try {
-    files = readdirSync3(debugDir, { recursive: true });
+    files = readdirSync4(debugDir, { recursive: true });
   } catch {
     return null;
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join31(debugDir, file);
+    const dllPath = join33(debugDir, file);
     try {
       const fd = openSync2(dllPath, "r+");
       closeSync2(fd);
@@ -11012,18 +11068,18 @@ function isLockedDll(debugDir) {
 function findFirstLockedDll(dir) {
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join31(dir, "bin", "Debug"));
+    const locked = isLockedDll(join33(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(join31(dir, entry));
+    const found = findFirstLockedDll(join33(dir, entry));
     if (found) return found;
   }
   return null;
@@ -11046,11 +11102,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync27 } from "fs";
 import path23 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync26(csprojPath, "utf8");
+  const content = readFileSync27(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -11067,7 +11123,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path23.resolve(dir, ref);
     try {
-      readFileSync26(childAbs);
+      readFileSync27(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -11092,14 +11148,14 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync27, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync28, statSync as statSync4 } from "fs";
 import path24 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return results;
   }
@@ -11108,7 +11164,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path24.join(dir, entry);
     try {
-      const stat2 = statSync3(full);
+      const stat2 = statSync4(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat2.isDirectory()) {
@@ -11127,7 +11183,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync27(sln, "utf8");
+      const content = readFileSync28(sln, "utf8");
       if (pattern2.test(content)) {
         matches.push(path24.relative(repoRoot, sln));
       }
@@ -11191,12 +11247,12 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import path25 from "path";
 import chalk117 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path25.resolve(csprojPath);
-  if (!existsSync31(resolved)) {
+  if (!existsSync32(resolved)) {
     console.error(chalk117.red(`File not found: ${resolved}`));
     process.exit(1);
   }
@@ -11364,17 +11420,17 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import path26 from "path";
 import chalk121 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
-import { readdirSync as readdirSync5 } from "fs";
-import { dirname as dirname19, join as join32 } from "path";
+import { readdirSync as readdirSync6 } from "fs";
+import { dirname as dirname20, join as join34 } from "path";
 import chalk120 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync5(dir).filter((f) => f.endsWith(".sln")).map((f) => join32(dir, f));
+    return readdirSync6(dir).filter((f) => f.endsWith(".sln")).map((f) => join34(dir, f));
   } catch {
     return [];
   }
@@ -11395,7 +11451,7 @@ function findSolution() {
       process.exit(1);
     }
     if (current === ceiling) break;
-    current = dirname19(current);
+    current = dirname20(current);
   }
   console.error(chalk120.red("No .sln file found between cwd and repo root"));
   process.exit(1);
@@ -11405,7 +11461,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path26.resolve(sln);
-    if (!existsSync32(resolved)) {
+    if (!existsSync33(resolved)) {
       console.error(chalk121.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -11445,7 +11501,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync28 } from "child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync28, unlinkSync as unlinkSync9 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync29, unlinkSync as unlinkSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path27 from "path";
 import chalk122 from "chalk";
@@ -11476,11 +11532,11 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk122.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync33(reportPath)) {
+  if (!existsSync34(reportPath)) {
     console.error(chalk122.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync28(reportPath, "utf8");
+  const xml = readFileSync29(reportPath, "utf8");
   unlinkSync9(reportPath);
   return xml;
 }
@@ -11783,7 +11839,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync3 } from "child_process";
 import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync26 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -11808,7 +11864,7 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join33(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join35(tmpdir4(), `gh-query-${Date.now()}.graphql`);
   writeFileSync26(queryFile, mutation);
   try {
     const result = spawnSync3("gh", buildArgs2(queryFile, vars), {
@@ -11995,24 +12051,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync34,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync29,
+  existsSync as existsSync35,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync30,
   rmSync as rmSync2,
-  statSync as statSync4
+  statSync as statSync5
 } from "fs";
-import { basename as basename5, join as join36 } from "path";
+import { basename as basename7, join as join38 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join34(cwd, ".assist", "HANDOVER.md");
+  return join36(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join35(cwd, ".assist", "handovers");
+  return join37(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -12050,17 +12106,17 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync34(dir)) return [];
+  if (!existsSync35(dir)) return [];
   const out = [];
-  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-    const full = join36(dir, entry.name);
+  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
+    const full = join38(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
   return out;
 }
 async function migrateFile(orm, origin, file, createdAt) {
-  const content = readFileSync29(file, "utf8");
+  const content = readFileSync30(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -12072,13 +12128,13 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename5(file)) ?? statSync4(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename7(file)) ?? statSync5(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync34(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync4(handoverPath).mtime);
+  if (existsSync35(handoverPath)) {
+    await migrateFile(orm, origin, handoverPath, statSync5(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -12293,20 +12349,20 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync30 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync13, readFileSync as readFileSync30, writeFileSync as writeFileSync27 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join37 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync13, readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join39 } from "path";
 function getStoreDir() {
-  return join37(homedir14(), ".assist");
+  return join39(homedir15(), ".assist");
 }
 function getStorePath(filename) {
-  return join37(getStoreDir(), filename);
+  return join39(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path57 = getStorePath(filename);
-  if (existsSync35(path57)) {
+  if (existsSync36(path57)) {
     try {
-      return JSON.parse(readFileSync30(path57, "utf8"));
+      return JSON.parse(readFileSync31(path57, "utf8"));
     } catch {
       return {};
     }
@@ -12315,7 +12371,7 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync35(dir)) {
+  if (!existsSync36(dir)) {
     mkdirSync13(dir, { recursive: true });
   }
   writeFileSync27(getStorePath(filename), JSON.stringify(data, null, 2));
@@ -12485,13 +12541,13 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync14, readdirSync as readdirSync7 } from "fs";
+import { mkdirSync as mkdirSync14, readdirSync as readdirSync8 } from "fs";
 import { resolve as resolve11 } from "path";
 import chalk132 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
-import { basename as basename6, extname, resolve as resolve10 } from "path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
+import { basename as basename8, extname, resolve as resolve10 } from "path";
 import chalk131 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -12516,9 +12572,9 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync31(file, "utf8");
+  const content = readFileSync32(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename6(file, extname(file));
+  const stem = basename8(file, extname(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -12567,7 +12623,7 @@ async function mermaidExport(file, options2 = {}) {
       process.exit(1);
     }
   }
-  const files = file ? [file] : readdirSync7(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
+  const files = file ? [file] : readdirSync8(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
     console.log(chalk132.gray("No markdown files found in current directory."));
     return;
@@ -12594,7 +12650,7 @@ function registerMermaid(program2) {
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir3 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname21 } from "path";
+import { dirname as dirname22 } from "path";
 import chalk134 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
@@ -12673,15 +12729,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 import chalk133 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname20, join as join38 } from "path";
+import { dirname as dirname21, join as join40 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-var moduleDir = dirname20(fileURLToPath5(import.meta.url));
+var moduleDir = dirname21(fileURLToPath5(import.meta.url));
 function netcapExtensionDir() {
-  return join38(moduleDir, "commands", "netcap", "netcap-extension");
+  return join40(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -12696,7 +12752,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join39(dir, "background.js");
+  const file = join41(dir, "background.js");
   const source = await readFile2(file, "utf8");
   await writeFile2(
     file,
@@ -12736,20 +12792,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute, join as join41, resolve as resolve12 } from "path";
+import { isAbsolute, join as join43, resolve as resolve12 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
-import { homedir as homedir15 } from "os";
-import { join as join40 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join42 } from "path";
 function defaultCapturePath() {
-  return join40(homedir15(), ".assist", "netcap", "capture.jsonl");
+  return join42(homedir16(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute(out) ? out : resolve12(process.cwd(), out);
-  return join41(dir, "capture.jsonl");
+  return join43(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -12757,7 +12813,7 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir3(dirname21(outPath), { recursive: true });
+  await mkdir3(dirname22(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count7 = 0;
   const handler = createNetcapHandler({
@@ -12796,11 +12852,11 @@ netcap stopped \u2014 captured ${count7} ${count7 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync29 } from "fs";
-import { join as join42 } from "path";
+import { join as join44 } from "path";
 import chalk135 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -13196,7 +13252,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines = readFileSync32(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync33(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines) {
     let entry;
@@ -13241,7 +13297,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join42(captureFile, "..", "posts.json");
+  const outFile = join44(captureFile, "..", "posts.json");
   writeFileSync29(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -13677,26 +13733,26 @@ import { execSync as execSync35 } from "child_process";
 import { execSync as execSync34 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync36, readFileSync as readFileSync33, unlinkSync as unlinkSync11 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync34, unlinkSync as unlinkSync11 } from "fs";
+import { join as join45 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join43(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join45(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync36(cachePath)) {
+  if (!existsSync37(cachePath)) {
     return null;
   }
-  const content = readFileSync33(cachePath, "utf8");
+  const content = readFileSync34(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync36(cachePath)) {
+  if (existsSync37(cachePath)) {
     unlinkSync11(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -13714,7 +13770,7 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join44(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join46(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync30(queryFile, mutation);
   try {
     execSync34(
@@ -13796,18 +13852,18 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync15, writeFileSync as writeFileSync32 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync38, mkdirSync as mkdirSync15, writeFileSync as writeFileSync32 } from "fs";
+import { join as join48 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync36 } from "child_process";
 import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join45 } from "path";
+import { join as join47 } 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 = join45(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join47(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync31(queryFile, THREAD_QUERY);
   try {
     const result = execSync36(
@@ -13921,8 +13977,8 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join46(process.cwd(), ".assist");
-  if (!existsSync37(assistDir)) {
+  const assistDir = join48(process.cwd(), ".assist");
+  if (!existsSync38(assistDir)) {
     mkdirSync15(assistDir, { recursive: true });
   }
   const cacheData = {
@@ -13930,7 +13986,7 @@ function writeCommentsCache(prNumber, comments3) {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join46(assistDir, `pr-${prNumber}-comments.yaml`);
+  const cachePath = join48(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync32(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
@@ -13963,7 +14019,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join46(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join48(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -16055,8 +16111,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename11 = path43.basename(file, path43.extname(file));
-    if (basename11 === "index") continue;
+    const basename13 = path43.basename(file, path43.extname(file));
+    if (basename13 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -16468,22 +16524,22 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir16 } from "os";
-import { basename as basename7, join as join47 } from "path";
+import { homedir as homedir17 } from "os";
+import { basename as basename9, join as join49 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join47(
-    homedir16(),
+  const reviewDir = join49(
+    homedir17(),
     ".assist",
     "reviews",
-    basename7(repoRoot),
+    basename9(repoRoot),
     key
   );
   return {
     reviewDir,
-    requestPath: join47(reviewDir, "request.md"),
-    claudePath: join47(reviewDir, "claude.md"),
-    codexPath: join47(reviewDir, "codex.md"),
-    synthesisPath: join47(reviewDir, "synthesis.md")
+    requestPath: join49(reviewDir, "request.md"),
+    claudePath: join49(reviewDir, "claude.md"),
+    codexPath: join49(reviewDir, "codex.md"),
+    synthesisPath: join49(reviewDir, "synthesis.md")
   };
 }
 
@@ -16626,7 +16682,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -16941,7 +16997,7 @@ async function confirmPost(prNumber, count7, options2) {
 async function postReviewToPr(synthesisPath, options2) {
   const prInfo = fetchPrDiffInfo();
   const prNumber = prInfo.prNumber;
-  const markdown = readFileSync34(synthesisPath, "utf8");
+  const markdown = readFileSync35(synthesisPath, "utf8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -17023,10 +17079,10 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync16, unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync16, unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 function clearReviewFiles(paths) {
   for (const path57 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync38(path57)) unlinkSync14(path57);
+    if (existsSync39(path57)) unlinkSync14(path57);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -17094,11 +17150,11 @@ async function runBacklogSession(synthesisPath) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync6 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync5(outputPath).size;
+    size = statSync6(outputPath).size;
   } catch {
     return null;
   }
@@ -17311,7 +17367,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync40, unlinkSync as unlinkSync16 } from "fs";
+import { existsSync as existsSync41, unlinkSync as unlinkSync16 } 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.
@@ -17731,7 +17787,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync39, unlinkSync as unlinkSync15 } from "fs";
+import { existsSync as existsSync40, unlinkSync as unlinkSync15 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -17783,7 +17839,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync39(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync40(spec.outputPath)) {
     unlinkSync15(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -17825,7 +17881,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync35 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -17881,7 +17937,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync35(synthesisPath, "utf8");
+  const markdown = readFileSync36(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -17929,7 +17985,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync40(paths.synthesisPath)) {
+  if (anyFresh && existsSync41(paths.synthesisPath)) {
     unlinkSync16(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -18779,27 +18835,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync41, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
-import { join as join48 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync9, statSync as statSync7 } from "fs";
+import { join as join50 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync41(vttDir)) return;
-  for (const entry of readdirSync8(vttDir)) {
+  if (!existsSync42(vttDir)) return;
+  for (const entry of readdirSync9(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync6(join48(vttDir, entry)).isDirectory()) continue;
+    if (statSync7(join50(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   mkdirSync as mkdirSync17,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   renameSync as renameSync2,
   writeFileSync as writeFileSync35
 } from "fs";
-import { basename as basename8, join as join49 } from "path";
+import { basename as basename10, join as join51 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text6) {
@@ -19007,14 +19063,14 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync36(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync37(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join49(vttDir, "processed");
+  const processedDir = join51(vttDir, "processed");
   mkdirSync17(processedDir, { recursive: true });
-  renameSync2(sourcePath, join49(processedDir, filename));
+  renameSync2(sourcePath, join51(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -19023,20 +19079,20 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename8(file);
-  const sourcePath = join49(vttDir, filename);
-  if (!existsSync42(sourcePath)) {
+  const filename = basename10(file);
+  const sourcePath = join51(vttDir, filename);
+  if (!existsSync43(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename8(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename10(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join49(transcriptsDir, client);
+  const formattedDir = join51(transcriptsDir, client);
   mkdirSync17(formattedDir, { recursive: true });
-  const formattedPath = join49(formattedDir, outputName);
+  const formattedPath = join51(formattedDir, outputName);
   writeFileSync35(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join49(summaryDir, client, outputName);
+  const summaryPath = join51(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -19084,50 +19140,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir17 } from "os";
-import { dirname as dirname23, join as join50 } from "path";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname24, join as join52 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var __dirname5 = dirname23(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join50(homedir17(), ".assist", "voice");
+var __dirname5 = dirname24(fileURLToPath6(import.meta.url));
+var VOICE_DIR = join52(homedir18(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join50(VOICE_DIR, "voice.pid"),
-  log: join50(VOICE_DIR, "voice.log"),
-  venv: join50(VOICE_DIR, ".venv"),
-  lock: join50(VOICE_DIR, "voice.lock")
+  pid: join52(VOICE_DIR, "voice.pid"),
+  log: join52(VOICE_DIR, "voice.log"),
+  venv: join52(VOICE_DIR, ".venv"),
+  lock: join52(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join50(__dirname5, "commands", "voice", "python");
+  return join52(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join50(voicePaths.venv, "Scripts", "python.exe") : join50(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join52(voicePaths.venv, "Scripts", "python.exe") : join52(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join50(getLockDir(), "voice.lock");
+  return join52(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join51(getPythonDir(), "list_devices.py");
+  const script = join53(getPythonDir(), "list_devices.py");
   spawnSync5(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync43, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync38 } from "fs";
 function logs(options2) {
-  if (!existsSync43(voicePaths.log)) {
+  if (!existsSync44(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count7 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync37(voicePaths.log, "utf8").trim();
+  const content = readFileSync38(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -19150,12 +19206,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync6 } from "child_process";
 import { mkdirSync as mkdirSync19 } from "fs";
-import { join as join53 } from "path";
+import { join as join55 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync48 } from "child_process";
-import { existsSync as existsSync44, mkdirSync as mkdirSync18, readFileSync as readFileSync38, writeFileSync as writeFileSync36 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync18, readFileSync as readFileSync39, writeFileSync as writeFileSync36 } from "fs";
+import { join as join54 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -19166,9 +19222,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync44(lockFile)) return;
+  if (!existsSync45(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync38(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync39(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -19179,7 +19235,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync44(getVenvPython())) return;
+  if (existsSync45(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync48(
@@ -19192,7 +19248,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync18(join52(lockFile, ".."), { recursive: true });
+  mkdirSync18(join54(lockFile, ".."), { recursive: true });
   writeFileSync36(
     lockFile,
     JSON.stringify({
@@ -19208,7 +19264,7 @@ function setup() {
   mkdirSync19(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join53(getPythonDir(), "setup_models.py");
+  const script = join55(getPythonDir(), "setup_models.py");
   const result = spawnSync6(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -19222,7 +19278,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
 import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync37 } from "fs";
-import { join as join54 } from "path";
+import { join as join56 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -19260,7 +19316,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join54(getPythonDir(), "voice_daemon.py");
+  const script = join56(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -19270,7 +19326,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync45, readFileSync as readFileSync39 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync40 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -19280,16 +19336,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count7) {
-  if (!existsSync45(voicePaths.log)) return [];
-  const lines = readFileSync39(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync46(voicePaths.log)) return [];
+  const lines = readFileSync40(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count7);
 }
 function status() {
-  if (!existsSync45(voicePaths.pid)) {
+  if (!existsSync46(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync39(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync40(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -19308,13 +19364,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync46, readFileSync as readFileSync40, unlinkSync as unlinkSync17 } from "fs";
+import { existsSync as existsSync47, readFileSync as readFileSync41, unlinkSync as unlinkSync17 } from "fs";
 function stop2() {
-  if (!existsSync46(voicePaths.pid)) {
+  if (!existsSync47(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync40(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync41(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -19327,7 +19383,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync46(lockFile)) unlinkSync17(lockFile);
+    if (existsSync47(lockFile)) unlinkSync17(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -19505,19 +19561,19 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { readdirSync as readdirSync9, readFileSync as readFileSync41, statSync as statSync7 } from "fs";
-import { join as join55 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync42, statSync as statSync8 } from "fs";
+import { join as join57 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
-    entries = readdirSync9(roamDir);
+    entries = readdirSync10(roamDir);
   } catch {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path57 = join55(roamDir, name);
+    const path57 = join57(roamDir, name);
     try {
-      return { path: path57, mtimeMs: statSync7(path57).mtimeMs };
+      return { path: path57, mtimeMs: statSync8(path57).mtimeMs };
     } catch {
       return void 0;
     }
@@ -19527,11 +19583,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join55(appData, "Roam"));
+  const portFile = findPortFile(join57(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync41(portFile, "utf8").trim();
+    port = readFileSync42(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -19673,15 +19729,15 @@ function runPreCommands(pre, cwd) {
 
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
-import { existsSync as existsSync47 } from "fs";
-import { dirname as dirname24, join as join56, resolve as resolve13 } from "path";
+import { existsSync as existsSync48 } from "fs";
+import { dirname as dirname25, join as join58, resolve as resolve13 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync8("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve13(dirname24(gitPath), "..");
-    const gitBash = join56(gitRoot, "bin", "bash.exe");
-    if (existsSync47(gitBash)) return gitBash;
+    const gitRoot = resolve13(dirname25(gitPath), "..");
+    const gitBash = join58(gitRoot, "bin", "bash.exe");
+    if (existsSync48(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -19767,7 +19823,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync21, writeFileSync as writeFileSync38 } from "fs";
-import { join as join57 } from "path";
+import { join as join59 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -19828,7 +19884,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join57(".claude", "commands");
+  const dir = join59(".claude", "commands");
   mkdirSync21(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -19836,7 +19892,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join57(dir, `${name}.md`);
+  const filePath = join59(dir, `${name}.md`);
   writeFileSync38(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -19892,8 +19948,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync48, unlinkSync as unlinkSync18 } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync49, unlinkSync as unlinkSync18 } from "fs";
+import { join as join60 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -19908,8 +19964,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join58(".claude", "commands", `${name}.md`);
-  if (existsSync48(filePath)) {
+  const filePath = join60(".claude", "commands", `${name}.md`);
+  if (existsSync49(filePath)) {
     unlinkSync18(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -19948,9 +20004,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync50 } from "child_process";
-import { existsSync as existsSync49, mkdirSync as mkdirSync22, unlinkSync as unlinkSync19, writeFileSync as writeFileSync39 } from "fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync22, unlinkSync as unlinkSync19, writeFileSync as writeFileSync39 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join59, resolve as resolve15 } from "path";
+import { join as join61, resolve as resolve15 } from "path";
 import chalk179 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -20080,14 +20136,14 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync49(outputDir)) {
+  if (!existsSync50(outputDir)) {
     mkdirSync22(outputDir, { recursive: true });
   }
   const timestamp4 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve15(outputDir, `${processName}-${timestamp4}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join59(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join61(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync39(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync50(
@@ -20164,7 +20220,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -20176,7 +20232,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync42(daemonPaths.pid, "utf8").trim(),
+      readFileSync43(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -20249,6 +20305,8 @@ function recentDaemonLogLines() {
 var SESSIONS_FILE = "sessions.json";
 var persistedSessionSchema = z5.object({
   name: z5.string(),
+  title: z5.string().optional(),
+  subtitle: z5.string().optional(),
   commandType: z5.enum(["claude", "run", "assist"]),
   cwd: z5.string(),
   startedAt: z5.number(),
@@ -20289,6 +20347,8 @@ function logPersist(live) {
 function toPersistedSession(session) {
   return {
     name: session.name,
+    title: session.title,
+    subtitle: session.subtitle,
     commandType: session.commandType,
     cwd: session.cwd ?? process.cwd(),
     startedAt: session.startedAt,
@@ -20524,7 +20584,7 @@ var ClientHub = class extends Set {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync50, statSync as statSync8 } from "fs";
+import { chmodSync, existsSync as existsSync51, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path49 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -20539,8 +20599,8 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync50(helper)) return;
-  const mode = statSync8(helper).mode;
+  if (!existsSync51(helper)) return;
+  const mode = statSync9(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -20782,6 +20842,8 @@ function restoreBase(id2, persisted) {
   return {
     id: id2,
     name: persisted.name,
+    title: persisted.title,
+    subtitle: persisted.subtitle,
     commandType: persisted.commandType,
     scrollback: "",
     cwd: persisted.cwd,
@@ -20982,8 +21044,8 @@ function resumeSession(id2, sessionId, cwd, name) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync51, mkdirSync as mkdirSync23, watch } from "fs";
-import { dirname as dirname25 } from "path";
+import { existsSync as existsSync52, mkdirSync as mkdirSync23, watch } from "fs";
+import { dirname as dirname26 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
 function applyReviewPause(session, activity2) {
@@ -21001,7 +21063,7 @@ var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path57 = activityPath(session.id);
-  const dir = dirname25(path57);
+  const dir = dirname26(path57);
   try {
     mkdirSync23(dir, { recursive: true });
   } catch {
@@ -21024,7 +21086,7 @@ function watchActivity(session, notify2) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync51(path57)) read();
+  if (existsSync52(path57)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -22301,7 +22363,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync20, writeFileSync as writeFileSync40 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -22312,7 +22374,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync43(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync44(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }