@staff0rd/assist 0.273.1 → 0.274.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.273.1",
+  version: "0.274.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3034,22 +3034,6 @@ function buildArgs(prompt, options2) {
   return [prompt];
 }
 
-// src/commands/backlog/prepareRun.ts
-import chalk32 from "chalk";
-
-// src/commands/backlog/resolvePlan.ts
-function resolvePlan(item) {
-  if (item.plan && item.plan.length > 0) {
-    return item.plan;
-  }
-  return [
-    {
-      name: "Implement",
-      tasks: item.acceptanceCriteria.map((ac) => ({ task: ac }))
-    }
-  ];
-}
-
 // src/commands/backlog/shared.ts
 import chalk31 from "chalk";
 
@@ -3589,6 +3573,43 @@ async function removeItem(id) {
   return name;
 }
 
+// src/commands/backlog/handleReviewResult.ts
+async function handleReviewResult(id, review2) {
+  if (review2.kind === "fail" || review2.kind === "abort")
+    return { kind: "stop", success: false };
+  if (review2.kind === "paused") return { kind: "stop", success: true };
+  if (review2.kind === "rewind")
+    return {
+      kind: "resume",
+      startPhase: review2.targetPhase,
+      plan: review2.plan
+    };
+  await ensureDone(id);
+  return { kind: "stop", success: true };
+}
+async function ensureDone(id) {
+  try {
+    await setStatus(id, "done");
+  } catch {
+  }
+}
+
+// src/commands/backlog/prepareRun.ts
+import chalk32 from "chalk";
+
+// src/commands/backlog/resolvePlan.ts
+function resolvePlan(item) {
+  if (item.plan && item.plan.length > 0) {
+    return item.plan;
+  }
+  return [
+    {
+      name: "Implement",
+      tasks: item.acceptanceCriteria.map((ac) => ({ task: ac }))
+    }
+  ];
+}
+
 // src/commands/backlog/prepareRun.ts
 async function prepareRun(id) {
   const found = await findOneItem(id);
@@ -3610,14 +3631,47 @@ async function prepareRun(id) {
   return { item, plan: plan2, startPhase };
 }
 
+// src/commands/backlog/consumePause.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join14 } from "path";
+function getControlsDir() {
+  return join14(homedir4(), ".assist", "controls");
+}
+function getPausePath(itemId) {
+  return join14(getControlsDir(), `pause-${itemId}.json`);
+}
+function requestPause(itemId) {
+  mkdirSync5(getControlsDir(), { recursive: true });
+  writeFileSync12(
+    getPausePath(itemId),
+    JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+}
+function clearPause(itemId) {
+  try {
+    unlinkSync3(getPausePath(itemId));
+  } catch {
+  }
+}
+function consumePause(itemId) {
+  const pausePath = getPausePath(itemId);
+  if (!existsSync18(pausePath)) return false;
+  try {
+    unlinkSync3(pausePath);
+  } catch {
+  }
+  return true;
+}
+
 // src/commands/backlog/executePhase.ts
 import { randomUUID } from "crypto";
 import chalk34 from "chalk";
 
 // src/shared/emitActivity.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync12 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname14, join as join14 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname14, join as join15 } from "path";
 import { z as z4 } from "zod";
 var activitySchema = z4.object({
   kind: z4.enum(["command", "backlog"]),
@@ -3630,14 +3684,14 @@ var activitySchema = z4.object({
   startedAt: z4.number()
 });
 function activityPath(sessionId) {
-  return join14(homedir4(), ".assist", "activity", `activity-${sessionId}.json`);
+  return join15(homedir5(), ".assist", "activity", `activity-${sessionId}.json`);
 }
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
   const path53 = activityPath(sessionId);
-  mkdirSync5(dirname14(path53), { recursive: true });
-  writeFileSync12(path53, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  mkdirSync6(dirname14(path53), { recursive: true });
+  writeFileSync13(path53, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
 function readActivity(path53) {
   try {
@@ -3763,7 +3817,7 @@ function buildResumePrompt() {
 }
 
 // src/commands/backlog/resolvePhaseResult.ts
-import { existsSync as existsSync19, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync20, unlinkSync as unlinkSync4 } from "fs";
 import chalk33 from "chalk";
 
 // src/commands/backlog/handleIncompletePhase.ts
@@ -3783,26 +3837,26 @@ async function handleIncompletePhase() {
 }
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
 
 // src/commands/backlog/writeSignal.ts
-import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join15 } from "path";
+import { writeFileSync as writeFileSync14 } from "fs";
+import { join as join16 } from "path";
 function getSignalPath() {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const filename = sessionId ? `.assist-signal-${sessionId}.json` : ".assist-signal.json";
-  return join15(getBacklogDir(), filename);
+  return join16(getBacklogDir(), filename);
 }
 function writeSignal(event, data) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const signal = { event, ...sessionId && { sessionId }, ...data };
-  writeFileSync13(getSignalPath(), JSON.stringify(signal));
+  writeFileSync14(getSignalPath(), JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
   const path53 = getSignalPath();
-  if (!existsSync18(path53)) return void 0;
+  if (!existsSync19(path53)) return void 0;
   try {
     return JSON.parse(readFileSync12(path53, "utf-8"));
   } catch {
@@ -3813,8 +3867,8 @@ function readSignal() {
 // src/commands/backlog/resolvePhaseResult.ts
 function cleanupSignal() {
   const statusPath = getSignalPath();
-  if (existsSync19(statusPath)) {
-    unlinkSync3(statusPath);
+  if (existsSync20(statusPath)) {
+    unlinkSync4(statusPath);
   }
 }
 async function isTerminalStatus(itemId) {
@@ -3823,7 +3877,7 @@ async function isTerminalStatus(itemId) {
   return item?.status === "done" || item?.status === "wontdo";
 }
 async function resolvePhaseResult(phaseIndex, itemId) {
-  if (!existsSync19(getSignalPath())) {
+  if (!existsSync20(getSignalPath())) {
     if (await isTerminalStatus(itemId)) return -1;
     const action = await handleIncompletePhase();
     if (action === "abort") return -1;
@@ -3845,11 +3899,11 @@ Phase ${phaseNumber} completed.`));
 }
 
 // src/commands/backlog/watchForMarker.ts
-import { existsSync as existsSync20, unwatchFile, watchFile } from "fs";
+import { existsSync as existsSync21, unwatchFile, watchFile } from "fs";
 function watchForMarker(child, options2) {
   const statusPath = getSignalPath();
   watchFile(statusPath, { interval: 1e3 }, () => {
-    if (!existsSync20(statusPath)) return;
+    if (!existsSync21(statusPath)) return;
     const signal = readSignal();
     if (!signal) return;
     if (signal.event === "done" && !options2?.actOnDone) return;
@@ -3915,10 +3969,11 @@ async function runPhases(item, startPhase, plan2, spawnOptions) {
       currentPlan.length + 1
     );
     phaseOptions = withoutResumeSession(phaseOptions);
-    if (phaseIndex < 0) return false;
+    if (phaseIndex < 0) return { kind: "fail" };
+    if (consumePause(item.id)) return { kind: "paused" };
     currentPlan = await reloadPlan(item.id) ?? currentPlan;
   }
-  return true;
+  return { kind: "completed" };
 }
 
 // src/commands/backlog/buildReviewPhase.ts
@@ -3954,8 +4009,9 @@ async function runReview(item, fallbackPlan, spawnOptions) {
 // src/commands/backlog/runOnce.ts
 async function runOnce(item, startPhase, plan2, spawnOptions) {
   const reviewOptions = startPhase >= plan2.length ? spawnOptions : withoutResumeSession(spawnOptions);
-  if (!await runPhases(item, startPhase, plan2, spawnOptions))
-    return { kind: "fail" };
+  const phases = await runPhases(item, startPhase, plan2, spawnOptions);
+  if (phases.kind === "fail") return { kind: "fail" };
+  if (phases.kind === "paused") return { kind: "paused" };
   return runReview(item, plan2, reviewOptions);
 }
 
@@ -3976,15 +4032,10 @@ async function runPrepared(id, prepared, spawnOptions) {
     while (true) {
       const review2 = await runOnce(item, startPhase, plan2, spawnOptions);
       spawnOptions = withoutResumeSession(spawnOptions);
-      if (review2.kind === "fail") return false;
-      if (review2.kind === "abort") return false;
-      if (review2.kind === "rewind") {
-        startPhase = review2.targetPhase;
-        plan2 = review2.plan;
-        continue;
-      }
-      await ensureDone(id);
-      return true;
+      const outcome = await handleReviewResult(id, review2);
+      if (outcome.kind === "stop") return outcome.success;
+      startPhase = outcome.startPhase;
+      plan2 = outcome.plan;
     }
   } finally {
     releaseLock(item.id);
@@ -4004,12 +4055,6 @@ function logProgress(id, { plan: plan2, startPhase, item }) {
 `));
   }
 }
-async function ensureDone(id) {
-  try {
-    await setStatus(id, "done");
-  } catch {
-  }
-}
 
 // src/commands/backlog/next.ts
 function toChoice(item, items2) {
@@ -4351,10 +4396,10 @@ function startWebServer(label2, port, handler, initialPath) {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync,
   statSync,
-  unlinkSync as unlinkSync4,
+  unlinkSync as unlinkSync5,
   writeSync
 } from "fs";
 
@@ -4362,15 +4407,15 @@ import {
 import * as net from "net";
 
 // src/commands/sessions/daemon/daemonPaths.ts
-import { homedir as homedir5 } from "os";
-import { join as join16 } from "path";
-var DAEMON_DIR = join16(homedir5(), ".assist", "daemon");
+import { homedir as homedir6 } from "os";
+import { join as join17 } from "path";
+var DAEMON_DIR = join17(homedir6(), ".assist", "daemon");
 var daemonPaths = {
   dir: DAEMON_DIR,
-  socket: process.platform === "win32" ? "\\\\.\\pipe\\assist-sessions-daemon" : join16(DAEMON_DIR, "daemon.sock"),
-  log: join16(DAEMON_DIR, "daemon.log"),
-  pid: join16(DAEMON_DIR, "daemon.pid"),
-  spawnLock: join16(DAEMON_DIR, "spawn.lock")
+  socket: process.platform === "win32" ? "\\\\.\\pipe\\assist-sessions-daemon" : join17(DAEMON_DIR, "daemon.sock"),
+  log: join17(DAEMON_DIR, "daemon.log"),
+  pid: join17(DAEMON_DIR, "daemon.pid"),
+  spawnLock: join17(DAEMON_DIR, "spawn.lock")
 };
 
 // src/commands/sessions/daemon/connectToDaemon.ts
@@ -4396,7 +4441,7 @@ var RETRY_DELAY_MS = 200;
 var STALE_LOCK_MS = SPAWN_TIMEOUT_MS + 5e3;
 async function ensureDaemonRunning(reason = "unspecified") {
   if (await isDaemonRunning()) return;
-  mkdirSync6(daemonPaths.dir, { recursive: true });
+  mkdirSync7(daemonPaths.dir, { recursive: true });
   const holdsLock = acquireSpawnLock();
   if (holdsLock) spawnDaemon(reason);
   try {
@@ -4419,7 +4464,7 @@ function acquireSpawnLock() {
   if (tryCreateLock()) return true;
   if (!isLockStale()) return false;
   try {
-    unlinkSync4(daemonPaths.spawnLock);
+    unlinkSync5(daemonPaths.spawnLock);
   } catch {
   }
   return tryCreateLock();
@@ -4443,7 +4488,7 @@ function isLockStale() {
 }
 function releaseSpawnLock() {
   try {
-    unlinkSync4(daemonPaths.spawnLock);
+    unlinkSync5(daemonPaths.spawnLock);
   } catch {
   }
 }
@@ -4466,14 +4511,14 @@ import { createRequire as createRequire2 } from "module";
 
 // src/shared/createBundleHandler.ts
 import { readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname16, join as join17 } from "path";
+import { dirname as dirname16, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath) {
   const dir = dirname16(fileURLToPath4(importMetaUrl));
   let cache;
   return (_req, res) => {
     if (!cache) {
-      cache = readFileSync13(join17(dir, bundlePath), "utf-8");
+      cache = readFileSync13(join18(dir, bundlePath), "utf-8");
     }
     res.writeHead(200, { "Content-Type": "application/javascript" });
     res.end(cache);
@@ -5416,9 +5461,9 @@ import chalk51 from "chalk";
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync14 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync15, unlinkSync as unlinkSync6, writeFileSync as writeFileSync15 } from "fs";
 import { tmpdir } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -5458,16 +5503,16 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join18(tmpdir(), "assist-"));
-  const filePath = join18(dir, "description.md");
-  writeFileSync14(filePath, "");
+  const dir = mkdtempSync(join19(tmpdir(), "assist-"));
+  const filePath = join19(dir, "description.md");
+  writeFileSync15(filePath, "");
   const result = spawnSync(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
-    unlinkSync5(filePath);
+    unlinkSync6(filePath);
     return void 0;
   }
   const content = readFileSync15(filePath, "utf-8").trim();
-  unlinkSync5(filePath);
+  unlinkSync6(filePath);
   return content || void 0;
 }
 async function promptAcceptanceCriteria() {
@@ -6724,13 +6769,13 @@ function stripEnvPrefix(parts) {
 }
 
 // src/commands/cliHook/logDeniedToolCall.ts
-import { mkdirSync as mkdirSync7 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join19 } from "path";
+import { mkdirSync as mkdirSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join20 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join19(homedir6(), ".assist");
+  return join20(homedir7(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -6748,8 +6793,8 @@ function initSchema(db) {
 function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
-  mkdirSync7(dbDir, { recursive: true });
-  const db = new Database(join19(dbDir, "assist.db"));
+  mkdirSync8(dbDir, { recursive: true });
+  const db = new Database(join20(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -6851,7 +6896,7 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync16, writeFileSync as writeFileSync16 } from "fs";
 import { dirname as dirname17, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
@@ -6860,7 +6905,7 @@ function packageRoot() {
   return __dirname5;
 }
 function readLines(path53) {
-  if (!existsSync21(path53)) return [];
+  if (!existsSync22(path53)) return [];
   return readFileSync16(path53, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
@@ -6881,7 +6926,7 @@ function loadCliReads() {
   return getCliReadsLines();
 }
 function saveCliReads(commands) {
-  writeFileSync15(
+  writeFileSync16(
     resolve7(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
@@ -6907,14 +6952,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join20 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join21 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join20(homedir7(), ".claude", "settings.json"),
-    join20(process.cwd(), ".claude", "settings.json"),
-    join20(process.cwd(), ".claude", "settings.local.json")
+    join21(homedir8(), ".claude", "settings.json"),
+    join21(process.cwd(), ".claude", "settings.json"),
+    join21(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -6923,7 +6968,7 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync22(filePath)) return [];
+  if (!existsSync23(filePath)) return [];
   try {
     const data = JSON.parse(readFileSync17(filePath, "utf-8"));
     const arr = data?.permissions?.[key];
@@ -7205,9 +7250,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join21 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join22 } from "path";
 
 // src/shared/checkCliAvailable.ts
 import { execSync as execSync22 } from "child_process";
@@ -7496,17 +7541,17 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join21(homedir8(), ".assist", `cli-discover-${safeName}.log`);
+  return join22(homedir9(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path53 = logPath(cli);
-  if (!existsSync23(path53)) return void 0;
+  if (!existsSync24(path53)) return void 0;
   return readFileSync18(path53, "utf-8");
 }
 function writeCache(cli, output) {
-  const dir = join21(homedir8(), ".assist");
-  mkdirSync8(dir, { recursive: true });
-  writeFileSync16(logPath(cli), output);
+  const dir = join22(homedir9(), ".assist");
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync17(logPath(cli), output);
 }
 async function permitCliReads(cli, options2 = { noCache: false }) {
   if (!cli) {
@@ -8307,7 +8352,7 @@ function registerConfig(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync18 } from "fs";
 import chalk88 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -8316,7 +8361,7 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync24(indexPath)) {
+  if (!existsSync25(indexPath)) {
     console.log(chalk88.yellow("No index.html found"));
     return;
   }
@@ -8331,7 +8376,7 @@ function redirect() {
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
-  writeFileSync17(indexPath, newContent);
+  writeFileSync18(indexPath, newContent);
   console.log(chalk88.green("Added trailing slash redirect to index.html"));
 }
 
@@ -8347,11 +8392,11 @@ import { execFileSync } from "child_process";
 import { basename as basename4 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
-import { homedir as homedir9 } from "os";
-import { join as join22 } from "path";
-var BLOG_REPO_ROOT = join22(homedir9(), "git/blog");
+import { homedir as homedir10 } from "os";
+import { join as join23 } from "path";
+var BLOG_REPO_ROOT = join23(homedir10(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join22(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join23(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName] ?? []);
@@ -8362,15 +8407,15 @@ import { execSync as execSync23 } from "child_process";
 import chalk89 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20 } from "fs";
-import { basename as basename3, join as join23 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
+import { basename as basename3, join as join24 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join23(process.cwd(), "package.json");
-  if (existsSync25(packageJsonPath)) {
+  const packageJsonPath = join24(process.cwd(), "package.json");
+  if (existsSync26(packageJsonPath)) {
     try {
       const content = readFileSync20(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -8385,8 +8430,8 @@ function getRepoName() {
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync, readFileSync as readFileSync21 } from "fs";
-import { join as join24 } from "path";
-var DEVLOG_DIR = join24(BLOG_REPO_ROOT, "src/content/devlog");
+import { join as join25 } from "path";
+var DEVLOG_DIR = join25(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -8414,7 +8459,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync21(join24(DEVLOG_DIR, file), "utf-8");
+      const content = readFileSync21(join25(DEVLOG_DIR, file), "utf-8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -8801,12 +8846,12 @@ function repos(options2) {
 }
 
 // src/commands/devlog/skip.ts
-import { writeFileSync as writeFileSync18 } from "fs";
-import { join as join25 } from "path";
+import { writeFileSync as writeFileSync19 } from "fs";
+import { join as join26 } from "path";
 import chalk94 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join25(BLOG_REPO_ROOT, "assist.yml");
+  return join26(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -8830,7 +8875,7 @@ function skip(date) {
   skip2[repoName] = skipDays;
   devlog.skip = skip2;
   config.devlog = devlog;
-  writeFileSync18(configPath, stringifyYaml3(config, { lineWidth: 0 }));
+  writeFileSync19(configPath, stringifyYaml3(config, { lineWidth: 0 }));
   console.log(chalk94.green(`Added ${date} to skip list for ${repoName}`));
 }
 
@@ -8867,16 +8912,16 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import chalk96 from "chalk";
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import path20 from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path20.dirname(current)) {
-    if (existsSync26(path20.join(current, ".git"))) {
+    if (existsSync27(path20.join(current, ".git"))) {
       return current;
     }
     current = path20.dirname(current);
@@ -8895,7 +8940,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join26(debugDir, file);
+    const dllPath = join27(debugDir, file);
     try {
       const fd = openSync2(dllPath, "r+");
       closeSync2(fd);
@@ -8913,13 +8958,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join26(dir, "bin", "Debug"));
+    const locked = isLockedDll(join27(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(join26(dir, entry));
+    const found = findFirstLockedDll(join27(dir, entry));
     if (found) return found;
   }
   return null;
@@ -9087,12 +9132,12 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import path23 from "path";
 import chalk98 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path23.resolve(csprojPath);
-  if (!existsSync27(resolved)) {
+  if (!existsSync28(resolved)) {
     console.error(chalk98.red(`File not found: ${resolved}`));
     process.exit(1);
   }
@@ -9260,17 +9305,17 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import path24 from "path";
 import chalk102 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync4 } from "fs";
-import { dirname as dirname18, join as join27 } from "path";
+import { dirname as dirname18, join as join28 } from "path";
 import chalk101 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join27(dir, f));
+    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join28(dir, f));
   } catch {
     return [];
   }
@@ -9301,7 +9346,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path24.resolve(sln);
-    if (!existsSync28(resolved)) {
+    if (!existsSync29(resolved)) {
       console.error(chalk102.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -9341,7 +9386,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync27 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync24, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync24, unlinkSync as unlinkSync7 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path25 from "path";
 import chalk103 from "chalk";
@@ -9372,12 +9417,12 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk103.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync29(reportPath)) {
+  if (!existsSync30(reportPath)) {
     console.error(chalk103.red("Report file not generated"));
     process.exit(1);
   }
   const xml = readFileSync24(reportPath, "utf-8");
-  unlinkSync6(reportPath);
+  unlinkSync7(reportPath);
   return xml;
 }
 
@@ -9503,9 +9548,9 @@ function aggregateCommitters(authorLists) {
 
 // src/shared/runGhGraphql.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
+import { unlinkSync as unlinkSync8, writeFileSync as writeFileSync20 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -9530,8 +9575,8 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join28(tmpdir4(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync19(queryFile, mutation);
+  const queryFile = join29(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync20(queryFile, mutation);
   try {
     const result = spawnSync2("gh", buildArgs2(queryFile, vars), {
       encoding: "utf-8"
@@ -9540,7 +9585,7 @@ function runGhGraphql(mutation, vars) {
     throwOnGraphqlErrors(result.stdout);
     return result.stdout;
   } finally {
-    unlinkSync7(queryFile);
+    unlinkSync8(queryFile);
   }
 }
 
@@ -9709,8 +9754,8 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/archive.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync9, renameSync as renameSync2 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync10, renameSync as renameSync2 } from "fs";
+import { join as join31 } from "path";
 
 // src/commands/handover/formatArchiveTimestamp.ts
 function formatArchiveTimestamp(date = /* @__PURE__ */ new Date()) {
@@ -9725,9 +9770,9 @@ function formatArchiveTimestamp(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/commands/handover/getHandoverArchiveDir.ts
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function getHandoverArchiveDir(cwd = process.cwd()) {
-  return join29(cwd, ".assist", "handovers", "archive");
+  return join30(cwd, ".assist", "handovers", "archive");
 }
 
 // src/commands/handover/archive.ts
@@ -9737,15 +9782,15 @@ function buildArchiveFilename(timestamp, suffix) {
   return `${base}.md`;
 }
 function resolveCollisionPath(archiveDir, timestamp, suffix) {
-  const initial = join30(archiveDir, buildArchiveFilename(timestamp, suffix));
-  if (!existsSync30(initial)) return initial;
+  const initial = join31(archiveDir, buildArchiveFilename(timestamp, suffix));
+  if (!existsSync31(initial)) return initial;
   for (let i = 1; i <= MAX_COLLISION_SUFFIX; i++) {
     const collisionSuffix = suffix ? `${suffix}-${i}` : `${i}`;
-    const candidate = join30(
+    const candidate = join31(
       archiveDir,
       buildArchiveFilename(timestamp, collisionSuffix)
     );
-    if (!existsSync30(candidate)) return candidate;
+    if (!existsSync31(candidate)) return candidate;
   }
   throw new Error(
     `Exhausted collision suffixes (1-${MAX_COLLISION_SUFFIX}) for ${timestamp}`
@@ -9754,9 +9799,9 @@ function resolveCollisionPath(archiveDir, timestamp, suffix) {
 function archive(options2 = {}) {
   const cwd = options2.cwd ?? process.cwd();
   const handoverPath = getHandoverPath(cwd);
-  if (!existsSync30(handoverPath)) return void 0;
+  if (!existsSync31(handoverPath)) return void 0;
   const archiveDir = getHandoverArchiveDir(cwd);
-  mkdirSync9(archiveDir, { recursive: true });
+  mkdirSync10(archiveDir, { recursive: true });
   const timestamp = formatArchiveTimestamp(options2.now);
   const destination = resolveCollisionPath(
     archiveDir,
@@ -9768,7 +9813,7 @@ function archive(options2 = {}) {
 }
 
 // src/commands/handover/load.ts
-import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
 
 // src/commands/handover/parseLoadInput.ts
 async function parseLoadInput(stdin) {
@@ -9883,7 +9928,7 @@ function normaliseOutput(raw) {
 // src/commands/handover/load.ts
 function loadFromHandover(cwd) {
   const handoverPath = getHandoverPath(cwd);
-  if (!existsSync31(handoverPath)) return void 0;
+  if (!existsSync32(handoverPath)) return void 0;
   const content = readFileSync26(handoverPath, "utf-8");
   archive({ cwd });
   return {
@@ -10051,18 +10096,18 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync30 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync10, readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync11, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join32 } from "path";
 function getStoreDir() {
-  return join31(homedir10(), ".assist");
+  return join32(homedir11(), ".assist");
 }
 function getStorePath(filename) {
-  return join31(getStoreDir(), filename);
+  return join32(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path53 = getStorePath(filename);
-  if (existsSync32(path53)) {
+  if (existsSync33(path53)) {
     try {
       return JSON.parse(readFileSync27(path53, "utf-8"));
     } catch {
@@ -10073,10 +10118,10 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync32(dir)) {
-    mkdirSync10(dir, { recursive: true });
+  if (!existsSync33(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
-  writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
+  writeFileSync21(getStorePath(filename), JSON.stringify(data, null, 2));
 }
 
 // src/shared/promptInput.ts
@@ -10211,12 +10256,12 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync11, readdirSync as readdirSync5 } from "fs";
+import { mkdirSync as mkdirSync12, readdirSync as readdirSync5 } from "fs";
 import { resolve as resolve10 } from "path";
 import chalk114 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
 import { basename as basename5, extname, resolve as resolve9 } from "path";
 import chalk113 from "chalk";
 
@@ -10267,7 +10312,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
     const outPath = resolve9(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
-    writeFileSync21(outPath, svg, "utf8");
+    writeFileSync22(outPath, svg, "utf8");
     console.log(chalk113.green(`  \u2192 ${outPath}`));
   }
 }
@@ -10280,7 +10325,7 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve10(process.cwd(), options2.out ?? ".");
-  mkdirSync11(outDir, { recursive: true });
+  mkdirSync12(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
@@ -10786,20 +10831,20 @@ import { execSync as execSync34 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
 import { execSync as execSync33 } from "child_process";
-import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
+import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync33, readFileSync as readFileSync29, unlinkSync as unlinkSync8 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync29, unlinkSync as unlinkSync9 } from "fs";
+import { join as join33 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join32(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join33(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync33(cachePath)) {
+  if (!existsSync34(cachePath)) {
     return null;
   }
   const content = readFileSync29(cachePath, "utf-8");
@@ -10807,8 +10852,8 @@ function loadCommentsCache(prNumber) {
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync33(cachePath)) {
-    unlinkSync8(cachePath);
+  if (existsSync34(cachePath)) {
+    unlinkSync9(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
 }
@@ -10822,15 +10867,15 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join33(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync22(queryFile, mutation);
+  const queryFile = join34(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync23(queryFile, mutation);
   try {
     execSync33(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
   } finally {
-    unlinkSync9(queryFile);
+    unlinkSync10(queryFile);
   }
 }
 function requireCache(prNumber) {
@@ -10904,19 +10949,19 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync12, writeFileSync as writeFileSync24 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync13, writeFileSync as writeFileSync25 } from "fs";
+import { join as join36 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync35 } from "child_process";
-import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
+import { unlinkSync as unlinkSync11, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } 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 = join34(tmpdir6(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync23(queryFile, THREAD_QUERY);
+  const queryFile = join35(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync24(queryFile, THREAD_QUERY);
   try {
     const result = execSync35(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -10935,7 +10980,7 @@ function fetchThreadIds(org, repo, prNumber) {
     }
     return { threadMap, resolvedThreadIds };
   } finally {
-    unlinkSync10(queryFile);
+    unlinkSync11(queryFile);
   }
 }
 
@@ -11029,17 +11074,17 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join35(process.cwd(), ".assist");
-  if (!existsSync34(assistDir)) {
-    mkdirSync12(assistDir, { recursive: true });
+  const assistDir = join36(process.cwd(), ".assist");
+  if (!existsSync35(assistDir)) {
+    mkdirSync13(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join35(assistDir, `pr-${prNumber}-comments.yaml`);
-  writeFileSync24(cachePath, stringify(cacheData));
+  const cachePath = join36(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync25(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -11071,7 +11116,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join35(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join36(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -13389,11 +13434,11 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir11 } from "os";
-import { basename as basename6, join as join36 } from "path";
+import { homedir as homedir12 } from "os";
+import { basename as basename6, join as join37 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join36(
-    homedir11(),
+  const reviewDir = join37(
+    homedir12(),
     ".assist",
     "reviews",
     basename6(repoRoot),
@@ -13401,10 +13446,10 @@ function buildReviewPaths(repoRoot, key) {
   );
   return {
     reviewDir,
-    requestPath: join36(reviewDir, "request.md"),
-    claudePath: join36(reviewDir, "claude.md"),
-    codexPath: join36(reviewDir, "codex.md"),
-    synthesisPath: join36(reviewDir, "synthesis.md")
+    requestPath: join37(reviewDir, "request.md"),
+    claudePath: join37(reviewDir, "claude.md"),
+    codexPath: join37(reviewDir, "codex.md"),
+    synthesisPath: join37(reviewDir, "synthesis.md")
   };
 }
 
@@ -13939,16 +13984,16 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync13, unlinkSync as unlinkSync11, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync26 } from "fs";
 function clearReviewFiles(paths) {
   for (const path53 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync35(path53)) unlinkSync11(path53);
+    if (existsSync36(path53)) unlinkSync12(path53);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync13(paths.reviewDir, { recursive: true });
+  mkdirSync14(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync25(paths.requestPath, requestBody);
+  writeFileSync26(paths.requestPath, requestBody);
 }
 
 // src/commands/review/runApplySession.ts
@@ -14227,7 +14272,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync37, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync38, unlinkSync as unlinkSync14 } 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 request.md in the current working directory.
@@ -14291,7 +14336,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync26 } from "fs";
+import { writeFileSync as writeFileSync27 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -14627,7 +14672,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync26(spec.outputPath, finalText);
+    writeFileSync27(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -14645,7 +14690,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync36, unlinkSync as unlinkSync12 } from "fs";
+import { existsSync as existsSync37, unlinkSync as unlinkSync13 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -14699,8 +14744,8 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync36(spec.outputPath)) {
-    unlinkSync12(spec.outputPath);
+  if (result.exitCode !== 0 && existsSync37(spec.outputPath)) {
+    unlinkSync13(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
@@ -14847,8 +14892,8 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync37(paths.synthesisPath)) {
-    unlinkSync13(paths.synthesisPath);
+  if (anyFresh && existsSync38(paths.synthesisPath)) {
+    unlinkSync14(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
   if (synthesisResult.exitCode !== 0) failures.push(synthesisResult);
@@ -15622,8 +15667,8 @@ function registerSql(program2) {
 }
 
 // src/commands/transcript/shared.ts
-import { existsSync as existsSync38, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { basename as basename7, join as join37, relative as relative2 } from "path";
+import { existsSync as existsSync39, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { basename as basename7, join as join38, relative as relative2 } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -15638,10 +15683,10 @@ function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
 function collectFiles(dir, extension) {
-  if (!existsSync38(dir)) return [];
+  if (!existsSync39(dir)) return [];
   const results = [];
   for (const entry of readdirSync6(dir)) {
-    const fullPath = join37(dir, entry);
+    const fullPath = join38(dir, entry);
     if (statSync4(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -15735,14 +15780,14 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname20, join as join39 } from "path";
+import { dirname as dirname20, join as join40 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync as renameSync3 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -15757,7 +15802,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync3(join38(vttDir, vttFile), join38(vttDir, newFilename));
+  renameSync3(join39(vttDir, vttFile), join39(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -15791,12 +15836,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname20(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join39(
+        const newRelativePath = join40(
           dirname20(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join39(vttFileDir, newFilename),
+          absolutePath: join40(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -15809,8 +15854,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync14, readFileSync as readFileSync32, writeFileSync as writeFileSync27 } from "fs";
-import { basename as basename8, dirname as dirname21, join as join40 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync15, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
+import { basename as basename8, dirname as dirname21, join as join41 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text2) {
@@ -16020,22 +16065,22 @@ function toMdFilename(vttFilename) {
   return `${basename8(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join40(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join41(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname21(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join40(outputDir, mdFile);
+  const outputPath = join41(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join40(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join41(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
-  if (!existsSync39(dir)) {
-    mkdirSync14(dir, { recursive: true });
+  if (!existsSync40(dir)) {
+    mkdirSync15(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -16060,7 +16105,7 @@ function readAndParseCues(inputPath) {
   return processCues(readFileSync32(inputPath, "utf-8"));
 }
 function writeFormatted(outputPath, content) {
-  writeFileSync27(outputPath, content, "utf-8");
+  writeFileSync28(outputPath, content, "utf-8");
   console.log(`Written: ${outputPath}`);
 }
 function convertVttToMarkdown(inputPath, outputPath) {
@@ -16070,7 +16115,7 @@ function convertVttToMarkdown(inputPath, outputPath) {
   logReduction(cues.length, chatMessages.length);
 }
 function tryProcessVtt(vttFile, paths) {
-  if (existsSync39(paths.outputPath))
+  if (existsSync40(paths.outputPath))
     return logSkipped(paths.relativeDir, paths.mdFile);
   convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
   return "processed";
@@ -16096,7 +16141,7 @@ function processAllFiles(vttFiles, transcriptsDir) {
   logSummary(counts);
 }
 function requireVttDir(vttDir) {
-  if (!existsSync40(vttDir)) {
+  if (!existsSync41(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
@@ -16128,18 +16173,18 @@ async function format() {
 }
 
 // src/commands/transcript/summarise/index.ts
-import { existsSync as existsSync42 } from "fs";
-import { basename as basename9, dirname as dirname23, join as join42, relative as relative3 } from "path";
+import { existsSync as existsSync43 } from "fs";
+import { basename as basename9, dirname as dirname23, join as join43, relative as relative3 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync42,
+  mkdirSync as mkdirSync16,
   readFileSync as readFileSync33,
   renameSync as renameSync4,
   rmSync as rmSync2
 } from "fs";
-import { dirname as dirname22, join as join41 } from "path";
+import { dirname as dirname22, join as join42 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
 import chalk156 from "chalk";
@@ -16168,9 +16213,9 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join41(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join42(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync41(STAGING_DIR)) {
+  if (!existsSync42(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -16192,10 +16237,10 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join41(summaryDir, matchingTranscript.relativePath);
+  const destPath = join42(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname22(destPath);
-  if (!existsSync41(destDir)) {
-    mkdirSync15(destDir, { recursive: true });
+  if (!existsSync42(destDir)) {
+    mkdirSync16(destDir, { recursive: true });
   }
   renameSync4(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
@@ -16208,7 +16253,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname23(relativePath);
-  return relDir === "." ? baseName : join42(relDir, baseName);
+  return relDir === "." ? baseName : join43(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -16221,7 +16266,7 @@ function buildSummaryIndex(summaryDir) {
 function summarise3() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync42(transcriptsDir)) {
+  if (!existsSync43(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -16242,8 +16287,8 @@ function summarise3() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join42(STAGING_DIR, outputFilename);
-  const summaryFileDir = join42(summaryDir, dirname23(next3.relativePath));
+  const outputPath = join43(STAGING_DIR, outputFilename);
+  const summaryFileDir = join43(summaryDir, dirname23(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -16293,45 +16338,45 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir12 } from "os";
-import { dirname as dirname24, join as join43 } from "path";
+import { homedir as homedir13 } from "os";
+import { dirname as dirname24, join as join44 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname6 = dirname24(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join43(homedir12(), ".assist", "voice");
+var VOICE_DIR = join44(homedir13(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join43(VOICE_DIR, "voice.pid"),
-  log: join43(VOICE_DIR, "voice.log"),
-  venv: join43(VOICE_DIR, ".venv"),
-  lock: join43(VOICE_DIR, "voice.lock")
+  pid: join44(VOICE_DIR, "voice.pid"),
+  log: join44(VOICE_DIR, "voice.log"),
+  venv: join44(VOICE_DIR, ".venv"),
+  lock: join44(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join43(__dirname6, "commands", "voice", "python");
+  return join44(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join43(voicePaths.venv, "Scripts", "python.exe") : join43(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join44(voicePaths.venv, "Scripts", "python.exe") : join44(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join43(getLockDir(), "voice.lock");
+  return join44(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join44(getPythonDir(), "list_devices.py");
+  const script = join45(getPythonDir(), "list_devices.py");
   spawnSync4(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync43, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync34 } from "fs";
 function logs(options2) {
-  if (!existsSync43(voicePaths.log)) {
+  if (!existsSync44(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -16358,13 +16403,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { mkdirSync as mkdirSync17 } from "fs";
-import { join as join46 } from "path";
+import { mkdirSync as mkdirSync18 } from "fs";
+import { join as join47 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync46 } from "child_process";
-import { existsSync as existsSync44, mkdirSync as mkdirSync16, readFileSync as readFileSync35, writeFileSync as writeFileSync28 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync17, readFileSync as readFileSync35, writeFileSync as writeFileSync29 } from "fs";
+import { join as join46 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -16375,7 +16420,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync44(lockFile)) return;
+  if (!existsSync45(lockFile)) return;
   try {
     const lock = JSON.parse(readFileSync35(lockFile, "utf-8"));
     if (lock.pid && isProcessAlive2(lock.pid)) {
@@ -16388,7 +16433,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync44(getVenvPython())) return;
+  if (existsSync45(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync46(
@@ -16401,8 +16446,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync16(join45(lockFile, ".."), { recursive: true });
-  writeFileSync28(
+  mkdirSync17(join46(lockFile, ".."), { recursive: true });
+  writeFileSync29(
     lockFile,
     JSON.stringify({
       pid,
@@ -16414,10 +16459,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync17(voicePaths.dir, { recursive: true });
+  mkdirSync18(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join46(getPythonDir(), "setup_models.py");
+  const script = join47(getPythonDir(), "setup_models.py");
   const result = spawnSync5(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -16430,8 +16475,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync29 } from "fs";
-import { join as join47 } from "path";
+import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync30 } from "fs";
+import { join as join48 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -16459,17 +16504,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync29(voicePaths.pid, String(pid));
+  writeFileSync30(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync18(voicePaths.dir, { recursive: true });
+  mkdirSync19(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join47(getPythonDir(), "voice_daemon.py");
+  const script = join48(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -16479,7 +16524,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync45, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync36 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -16489,12 +16534,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count6) {
-  if (!existsSync45(voicePaths.log)) return [];
+  if (!existsSync46(voicePaths.log)) return [];
   const lines = readFileSync36(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count6);
 }
 function status() {
-  if (!existsSync45(voicePaths.pid)) {
+  if (!existsSync46(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -16517,9 +16562,9 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync46, readFileSync as readFileSync37, unlinkSync as unlinkSync14 } from "fs";
+import { existsSync as existsSync47, readFileSync as readFileSync37, unlinkSync as unlinkSync15 } from "fs";
 function stop2() {
-  if (!existsSync46(voicePaths.pid)) {
+  if (!existsSync47(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -16531,12 +16576,12 @@ function stop2() {
     console.log(`Voice daemon (PID ${pid}) is not running`);
   }
   try {
-    unlinkSync14(voicePaths.pid);
+    unlinkSync15(voicePaths.pid);
   } catch {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync46(lockFile)) unlinkSync14(lockFile);
+    if (existsSync47(lockFile)) unlinkSync15(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -16759,7 +16804,7 @@ async function auth() {
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync7 } from "child_process";
 import { readdirSync as readdirSync7, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -16768,7 +16813,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path53 = join48(roamDir, name);
+    const path53 = join49(roamDir, name);
     try {
       return { path: path53, mtimeMs: statSync5(path53).mtimeMs };
     } catch {
@@ -16780,7 +16825,7 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join48(appData, "Roam"));
+  const portFile = findPortFile(join49(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -16926,15 +16971,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 dirname25, join as join49, resolve as resolve11 } from "path";
+import { existsSync as existsSync48 } from "fs";
+import { dirname as dirname25, join as join50, resolve as resolve11 } 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 = resolve11(dirname25(gitPath), "..");
-    const gitBash = join49(gitRoot, "bin", "bash.exe");
-    if (existsSync47(gitBash)) return gitBash;
+    const gitBash = join50(gitRoot, "bin", "bash.exe");
+    if (existsSync48(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -17019,8 +17064,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync30 } from "fs";
-import { join as join50 } from "path";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync31 } from "fs";
+import { join as join51 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -17081,16 +17126,16 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join50(".claude", "commands");
-  mkdirSync19(dir, { recursive: true });
+  const dir = join51(".claude", "commands");
+  mkdirSync20(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join50(dir, `${name}.md`);
-  writeFileSync30(filePath, content);
+  const filePath = join51(dir, `${name}.md`);
+  writeFileSync31(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -17145,8 +17190,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync48, unlinkSync as unlinkSync15 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync49, unlinkSync as unlinkSync16 } from "fs";
+import { join as join52 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -17161,9 +17206,9 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join51(".claude", "commands", `${name}.md`);
-  if (existsSync48(filePath)) {
-    unlinkSync15(filePath);
+  const filePath = join52(".claude", "commands", `${name}.md`);
+  if (existsSync49(filePath)) {
+    unlinkSync16(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
 }
@@ -17201,9 +17246,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync49 } from "child_process";
-import { existsSync as existsSync49, mkdirSync as mkdirSync20, unlinkSync as unlinkSync16, writeFileSync as writeFileSync31 } from "fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join52, resolve as resolve13 } from "path";
+import { join as join53, resolve as resolve13 } from "path";
 import chalk158 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -17333,22 +17378,22 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync49(outputDir)) {
-    mkdirSync20(outputDir, { recursive: true });
+  if (!existsSync50(outputDir)) {
+    mkdirSync21(outputDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve13(outputDir, `${processName}-${timestamp}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join52(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync31(scriptPath, captureWindowPs1, "utf-8");
+  const scriptPath = join53(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync32(scriptPath, captureWindowPs1, "utf-8");
   try {
     execSync49(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }
     );
   } finally {
-    unlinkSync16(scriptPath);
+    unlinkSync17(scriptPath);
   }
 }
 function screenshot(processName) {
@@ -17516,7 +17561,7 @@ async function restartDaemon() {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync22 } from "fs";
+import { mkdirSync as mkdirSync23 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -17720,7 +17765,8 @@ function toSessionInfo({
   cwd,
   restored,
   activity: activity2,
-  autoRun
+  autoRun,
+  autoAdvance
 }) {
   return {
     id,
@@ -17734,7 +17780,8 @@ function toSessionInfo({
     cwd,
     restored,
     activity: activity2,
-    autoRun
+    autoRun,
+    autoAdvance
   };
 }
 
@@ -17751,7 +17798,7 @@ function broadcastSessions(sessions, clients) {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync50, statSync as statSync6 } from "fs";
+import { chmodSync, existsSync as existsSync51, statSync as statSync6 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path47 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -17766,7 +17813,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync50(helper)) return;
+  if (!existsSync51(helper)) return;
   const mode = statSync6(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -17884,7 +17931,7 @@ function shouldAutoRun(session, exitCode) {
   if (session.status !== "done" || exitCode !== 0) return false;
   if (session.commandType !== "assist") return false;
   const cmd = session.assistArgs?.[0];
-  if (cmd !== "draft" && cmd !== "bug") return false;
+  if (cmd !== "draft" && cmd !== "bug" && cmd !== "refine") return false;
   return session.activity?.itemId != null;
 }
 
@@ -17996,7 +18043,7 @@ function clearIdle(session) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync51, mkdirSync as mkdirSync21, watch } from "fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync22, watch } from "fs";
 import { dirname as dirname27 } from "path";
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
@@ -18004,7 +18051,7 @@ function watchActivity(session, notify2) {
   const path53 = activityPath(session.id);
   const dir = dirname27(path53);
   try {
-    mkdirSync21(dir, { recursive: true });
+    mkdirSync22(dir, { recursive: true });
   } catch {
     return;
   }
@@ -18023,7 +18070,7 @@ function watchActivity(session, notify2) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync51(path53)) read();
+  if (existsSync52(path53)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -18192,6 +18239,17 @@ function setAutoRun(sessions, id, enabled) {
   s.autoRun = enabled;
   return true;
 }
+function setAutoAdvance(sessions, id, enabled) {
+  const s = sessions.get(id);
+  if (!s) return false;
+  s.autoAdvance = enabled;
+  const itemId = s.activity?.itemId;
+  if (itemId != null) {
+    if (enabled) clearPause(itemId);
+    else requestPause(itemId);
+  }
+  return true;
+}
 function dismissSession(sessions, id) {
   const s = sessions.get(id);
   if (!s) return false;
@@ -18231,7 +18289,7 @@ var SessionManager = class {
   }
   restore() {
     return loadPersistedSessions().map((persisted) => {
-      this.add(restoreSession(String(this.nextId++), persisted));
+      this.spawnWith((id) => restoreSession(id, persisted));
       return persisted.name;
     });
   }
@@ -18241,21 +18299,20 @@ var SessionManager = class {
     watchActivity(session, this.notify);
     return session.id;
   }
+  spawnWith(create2) {
+    return this.add(create2(String(this.nextId++)));
+  }
   spawn(prompt, cwd) {
-    return this.add(createSession(String(this.nextId++), prompt, cwd));
+    return this.spawnWith((id) => createSession(id, prompt, cwd));
   }
   spawnRun(runName, runArgs, cwd) {
-    return this.add(
-      createRunSession(String(this.nextId++), runName, runArgs, cwd)
-    );
+    return this.spawnWith((id) => createRunSession(id, runName, runArgs, cwd));
   }
   spawnAssist(assistArgs, cwd) {
-    return this.add(
-      createAssistSession(String(this.nextId++), assistArgs, cwd)
-    );
+    return this.spawnWith((id) => createAssistSession(id, assistArgs, cwd));
   }
   resume(sessionId, cwd, name) {
-    return this.add(resumeSession(String(this.nextId++), sessionId, cwd, name));
+    return this.spawnWith((id) => resumeSession(id, sessionId, cwd, name));
   }
   onStatusChange = makeStatusChangeHandler(
     (id) => this.dismissSession(id),
@@ -18283,6 +18340,9 @@ var SessionManager = class {
   setAutoRun(id, enabled) {
     if (setAutoRun(this.sessions, id, enabled)) this.notify();
   }
+  setAutoAdvance(id, enabled) {
+    if (setAutoAdvance(this.sessions, id, enabled)) this.notify();
+  }
   listSessions() {
     return [...this.sessions.values()].map(toSessionInfo);
   }
@@ -18297,7 +18357,7 @@ var SessionManager = class {
 };
 
 // src/commands/sessions/daemon/startDaemonServer.ts
-import { unlinkSync as unlinkSync18 } from "fs";
+import { unlinkSync as unlinkSync19 } from "fs";
 import * as net2 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
@@ -18367,7 +18427,8 @@ var handlers = {
   resize: (_client, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows),
   retry: (_client, m, d) => m.retrySession(d.sessionId),
   dismiss: (_client, m, d) => m.dismissSession(d.sessionId),
-  "set-autorun": (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled)
+  "set-autorun": (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled),
+  "set-autoadvance": (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
 };
 function dispatchMessage(client, manager, data) {
   handlers[data.type]?.(client, manager, data);
@@ -18407,7 +18468,7 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
+import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync33 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
 import { readFileSync as readFileSync40 } from "fs";
@@ -18429,7 +18490,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync32(daemonPaths.pid, String(process.pid));
+  writeFileSync33(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     manager.shutdown();
@@ -18446,12 +18507,12 @@ function onListening(manager, checkAutoExit) {
 function cleanupOwnedFiles() {
   if (!ownsPidFile()) return;
   try {
-    unlinkSync17(daemonPaths.pid);
+    unlinkSync18(daemonPaths.pid);
   } catch {
   }
   if (process.platform !== "win32") {
     try {
-      unlinkSync17(daemonPaths.socket);
+      unlinkSync18(daemonPaths.socket);
     } catch {
     }
   }
@@ -18481,7 +18542,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
   daemonLog("removing stale socket left by a crashed daemon");
   if (process.platform !== "win32") {
     try {
-      unlinkSync18(daemonPaths.socket);
+      unlinkSync19(daemonPaths.socket);
     } catch {
     }
   }
@@ -18490,7 +18551,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync22(daemonPaths.dir, { recursive: true });
+  mkdirSync23(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );