@staff0rd/assist 0.573.2 → 0.574.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.573.2",
+  version: "0.574.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -147,8 +147,45 @@ import { existsSync as existsSync3 } from "fs";
 import { homedir } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 
-// src/commands/backlog/getCurrentOrigin.ts
+// src/commands/backlog/remoteUrl.ts
 import { execFileSync } from "child_process";
+function runGit(cwd, args) {
+  const windows = /^[A-Za-z]:[\\/]/.test(cwd);
+  const file = windows ? "git.exe" : "git";
+  const argv = windows ? ["-C", cwd, ...args] : args;
+  try {
+    const out = execFileSync(file, argv, {
+      encoding: "utf8",
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      ...windows ? {} : { cwd }
+    }).trim();
+    return { ok: true, out };
+  } catch {
+    return { ok: false, out: "" };
+  }
+}
+function tryGit(cwd, args) {
+  return runGit(cwd, args).out || null;
+}
+function remoteUrl(cwd) {
+  const origin = runGit(cwd, ["remote", "get-url", "origin"]);
+  if (origin.out) return { url: origin.out, ok: true };
+  const remotes = runGit(cwd, ["remote"]);
+  if (!remotes.ok) return { url: null, ok: false };
+  let failed2 = false;
+  for (const remote of remotes.out.split("\n").map((r) => r.trim()).filter(Boolean)) {
+    const url = runGit(cwd, ["remote", "get-url", remote]);
+    if (url.out) return { url: url.out, ok: true };
+    if (!url.ok) failed2 = true;
+  }
+  return { url: null, ok: !failed2 };
+}
+function getRemoteOriginUrl(cwd) {
+  return remoteUrl(cwd).url;
+}
+
+// src/commands/backlog/getCurrentOrigin.ts
 function stripLeadingSlashes(path80) {
   return path80.replace(/^\/+/, "");
 }
@@ -168,39 +205,14 @@ function normalizeOrigin(raw) {
   }
   return trimmed.toLowerCase();
 }
-function tryGit(cwd, args) {
-  const windows = /^[A-Za-z]:[\\/]/.test(cwd);
-  const file = windows ? "git.exe" : "git";
-  const argv = windows ? ["-C", cwd, ...args] : args;
-  try {
-    const out = execFileSync(file, argv, {
-      encoding: "utf8",
-      windowsHide: true,
-      stdio: ["pipe", "pipe", "pipe"],
-      ...windows ? {} : { cwd }
-    }).trim();
-    return out || null;
-  } catch {
-    return null;
-  }
-}
-function firstRemoteUrl(cwd) {
-  const remotes = tryGit(cwd, ["remote"]);
-  if (!remotes) return null;
-  for (const remote of remotes.split("\n").map((r) => r.trim()).filter(Boolean)) {
-    const url = tryGit(cwd, ["remote", "get-url", remote]);
-    if (url) return url;
-  }
-  return null;
-}
-function getRemoteOriginUrl(cwd) {
-  return tryGit(cwd, ["remote", "get-url", "origin"]) ?? firstRemoteUrl(cwd);
+function resolveCurrentOrigin(cwd) {
+  const remote = remoteUrl(cwd);
+  if (remote.url) return { origin: normalizeOrigin(remote.url), stable: true };
+  const root = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
+  return { origin: `local:${root ?? cwd}`, stable: remote.ok };
 }
 function getCurrentOrigin(cwd) {
-  const url = getRemoteOriginUrl(cwd);
-  if (url) return normalizeOrigin(url);
-  const root = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
-  return `local:${root ?? cwd}`;
+  return resolveCurrentOrigin(cwd).origin;
 }
 
 // src/shared/linkedWorktree.ts
@@ -9900,13 +9912,38 @@ function shouldProxyToWindows(cwd) {
 
 // src/commands/sessions/daemon/originForCwd.ts
 var cache = /* @__PURE__ */ new Map();
-function originForCwd(cwd) {
+function originResolutionForCwd(cwd) {
   if (!cwd) return void 0;
   const cached = cache.get(cwd);
-  if (cached !== void 0) return cached;
-  const origin = getCurrentOrigin(cwd);
-  cache.set(cwd, origin);
-  return origin;
+  if (cached !== void 0) return { origin: cached, stable: true };
+  const resolved = resolveCurrentOrigin(cwd);
+  if (resolved.stable) cache.set(cwd, resolved.origin);
+  return resolved;
+}
+function originForCwd(cwd) {
+  return originResolutionForCwd(cwd)?.origin;
+}
+
+// src/commands/sessions/daemon/repoDirExists.ts
+import { existsSync as existsSync28 } from "fs";
+
+// 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/toGitCwd.ts
+function toGitCwd(cwd) {
+  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
+}
+
+// src/commands/sessions/daemon/repoDirExists.ts
+function repoDirExists(cwd) {
+  return existsSync28(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/worktree/git.ts
@@ -10003,7 +10040,7 @@ function gitCommonDir(cwd) {
 }
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join26 } from "path";
 function getStoreDir() {
@@ -10014,7 +10051,7 @@ function getStorePath(filename) {
 }
 function loadJson(filename) {
   const path80 = getStorePath(filename);
-  if (existsSync28(path80)) {
+  if (existsSync29(path80)) {
     try {
       return JSON.parse(readFileSync19(path80, "utf8"));
     } catch {
@@ -10025,7 +10062,7 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync28(dir)) {
+  if (!existsSync29(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
@@ -10059,26 +10096,29 @@ var cache2 = /* @__PURE__ */ new Map();
 function repoGroupForCwd(cwd) {
   if (!cwd) return void 0;
   if (cache2.has(cwd)) return cache2.get(cwd);
-  const group = resolveRepoGroup(cwd);
-  cache2.set(cwd, group);
+  const { group, stable } = resolveRepoGroup(cwd);
+  if (stable) cache2.set(cwd, group);
   return group;
 }
 function resolveRepoGroup(cwd) {
-  const live = groupFromLiveTree(cwd);
-  if (live) return live;
-  const reaped = worktreeAttributionIncludingReaped(cwd);
-  if (!reaped) return void 0;
-  const origin = currentOriginOfClone(reaped.clone) ?? reaped.origin;
-  return hostedGroup(cwd, origin, reaped.clone);
-}
-function groupFromLiveTree(cwd) {
   const clone = mainWorktree(cwd);
-  const origin = clone ? originForCwd(clone) : void 0;
-  return clone && origin ? hostedGroup(cwd, origin, clone) : void 0;
+  const origin = clone ? originResolutionForCwd(clone) : void 0;
+  if (clone && origin)
+    return {
+      group: hostedGroup(cwd, origin.origin, clone),
+      stable: origin.stable
+    };
+  const reaped = worktreeAttributionIncludingReaped(cwd);
+  if (!reaped) return { group: void 0, stable: repoDirExists(cwd) };
+  const current = currentOriginOfClone(reaped.clone);
+  return {
+    group: hostedGroup(cwd, current?.origin ?? reaped.origin, reaped.clone),
+    stable: current?.stable === true
+  };
 }
 function currentOriginOfClone(clone) {
   const main = mainWorktree(clone);
-  return main ? originForCwd(main) : void 0;
+  return main ? originResolutionForCwd(main) : void 0;
 }
 function hostedGroup(cwd, origin, clone) {
   return { origin: isWindowsCwd(cwd) ? `windows:${origin}` : origin, clone };
@@ -10224,7 +10264,7 @@ async function loadItemSummaries(orm, origin) {
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 
 // src/commands/backlog/cloneTargetDir.ts
 import { join as join28, resolve as resolve9 } from "path";
@@ -10240,7 +10280,7 @@ function resolveRepoLocation(origin, knownCwd, baseDir) {
   if (knownCwd) return { cwd: knownCwd };
   const target = cloneTargetDir(origin, baseDir);
   if (!target) return {};
-  if (existsSync29(target) && getCurrentOrigin(target) === origin)
+  if (existsSync30(target) && getCurrentOrigin(target) === origin)
     return { cwd: target };
   return { cloneTarget: target };
 }
@@ -10607,20 +10647,6 @@ async function execGit(cwd, args, opts = {}) {
   }
 }
 
-// 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/toGitCwd.ts
-function toGitCwd(cwd) {
-  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
-}
-
 // src/commands/sessions/web/defaultBranchRef.ts
 var ORIGIN_HEAD_REF = "refs/remotes/origin/HEAD";
 var ORIGIN_REF_PREFIX = "refs/remotes/origin/";
@@ -11019,7 +11045,7 @@ async function getBackups(_req, res) {
 }
 
 // src/shared/globalConfigTargetFor.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { posix as posix2 } from "path";
 
 // src/shared/windowsHomeFromWsl.ts
@@ -11040,7 +11066,7 @@ function globalConfigTargetFor(cwd) {
       ok: false,
       error: `${cwd} runs on the Windows host, whose ~/.assist.yml cannot be located because sessions.windowsProjectsRoot is unset. Set it with: assist config set sessions.windowsProjectsRoot /mnt/c/Users/<you>/.claude/projects`
     };
-  if (!existsSync30(winHome))
+  if (!existsSync31(winHome))
     return {
       ok: false,
       error: `${cwd} runs on the Windows host, whose home ${winHome} is not reachable from here. Check that the Windows drive is mounted and sessions.windowsProjectsRoot points at it.`
@@ -11390,20 +11416,20 @@ import { basename as basename9, join as join30 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync31, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
 import { basename as basename8, dirname as dirname21, join as join29 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
   const branchKeyPath = join29(repoReviewsDir, `${branch2}-`);
   const parent = dirname21(branchKeyPath);
   const branchPrefix = basename8(branchKeyPath);
-  if (!existsSync31(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path80) => existsSync31(path80)).map((path80) => ({ path: path80, mtime: statSync4(path80).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (!existsSync32(parent)) return null;
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path80) => existsSync32(path80)).map((path80) => ({ path: path80, mtime: statSync4(path80).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
 // src/commands/sessions/web/getReviewSynthesis.ts
 var execFileAsync3 = promisify3(execFile4);
-function runGit(cwd, args) {
+function runGit2(cwd, args) {
   return execFileAsync3("git", args, {
     encoding: "utf8",
     windowsHide: true,
@@ -11412,8 +11438,8 @@ function runGit(cwd, args) {
 }
 async function resolveSynthesisPath(cwd) {
   const [repoRoot2, branch2] = await Promise.all([
-    runGit(cwd, ["rev-parse", "--show-toplevel"]),
-    runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
+    runGit2(cwd, ["rev-parse", "--show-toplevel"]),
+    runGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
   const repoReviewsDir = join30(
     homedir13(),
@@ -12972,7 +12998,7 @@ import { readFile as readFile2, stat as stat3, writeFile as writeFile3 } from "f
 
 // src/commands/sessions/web/formatWithOxfmt.ts
 import { execFile as execFile8 } from "child_process";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { dirname as dirname22, join as join32 } from "path";
 import { promisify as promisify8 } from "util";
 var execFileAsync7 = promisify8(execFile8);
@@ -12981,7 +13007,7 @@ function findOxfmtScript(root) {
   let dir = root;
   for (; ; ) {
     const candidate = join32(dir, "node_modules", "oxfmt", "bin", "oxfmt");
-    if (existsSync32(candidate)) return candidate;
+    if (existsSync33(candidate)) return candidate;
     const parent = dirname22(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -13854,7 +13880,7 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/cloneRepo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import chalk70 from "chalk";
 
@@ -13890,7 +13916,7 @@ async function cloneRepo(originRaw) {
   if (!target) {
     return fail2(`Could not derive a repository name from "${origin}".`);
   }
-  if (existsSync34(target)) {
+  if (existsSync35(target)) {
     return fail2(`Clone target already exists: ${target}`);
   }
   await mkdir3(baseDir, { recursive: true });
@@ -16869,7 +16895,7 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync35, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname23, resolve as resolve12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
@@ -16878,7 +16904,7 @@ function packageRoot() {
   return __dirname4;
 }
 function readLines(path80) {
-  if (!existsSync35(path80)) return [];
+  if (!existsSync36(path80)) return [];
   return readFileSync25(path80, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
@@ -16925,7 +16951,7 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync36, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir15 } from "os";
 import { join as join37 } from "path";
 function readSettingsPerms(key) {
@@ -16941,7 +16967,7 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync36(filePath)) return [];
+  if (!existsSync37(filePath)) return [];
   try {
     const data = JSON.parse(readFileSync26(filePath, "utf8"));
     const arr = data?.permissions?.[key];
@@ -17286,7 +17312,7 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir17 } from "os";
 import { join as join39 } from "path";
 
@@ -17555,7 +17581,7 @@ function logPath(cli) {
 }
 function readCache(cli) {
   const path80 = logPath(cli);
-  if (!existsSync37(path80)) return void 0;
+  if (!existsSync38(path80)) return void 0;
   return readFileSync27(path80, "utf8");
 }
 function writeCache(cli, output) {
@@ -17690,7 +17716,7 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync39, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
 import chalk122 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
@@ -17726,10 +17752,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync38, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync28 } from "fs";
 function readPinState(pin) {
   const path80 = getPinStatePath(pin);
-  if (!existsSync38(path80)) return void 0;
+  if (!existsSync39(path80)) return void 0;
   try {
     const state = JSON.parse(readFileSync28(path80, "utf8"));
     if (state.pin !== pin) return void 0;
@@ -17748,7 +17774,7 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync39(state.file)) {
+  if (!existsSync40(state.file)) {
     console.error(chalk122.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
@@ -18915,10 +18941,10 @@ function getMigrationApprovalPath(migrationId) {
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync40, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync30 } from "fs";
 function readMigrationPinState(pin) {
   const path80 = getMigrationPinPath(pin);
-  if (!existsSync40(path80)) return void 0;
+  if (!existsSync41(path80)) return void 0;
   try {
     const state = JSON.parse(readFileSync30(path80, "utf8"));
     if (state.pin !== pin) return void 0;
@@ -19007,7 +19033,7 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync41, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
 import chalk142 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -19016,7 +19042,7 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync41(indexPath)) {
+  if (!existsSync42(indexPath)) {
     console.log(chalk142.yellow("No index.html found"));
     return;
   }
@@ -19063,7 +19089,7 @@ import { execSync as execSync36 } from "child_process";
 import chalk143 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync42, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync32 } from "fs";
 import { basename as basename12, join as join44 } from "path";
 function getRepoName() {
   const config = loadConfig();
@@ -19071,7 +19097,7 @@ function getRepoName() {
     return config.devlog.name;
   }
   const packageJsonPath = join44(process.cwd(), "package.json");
-  if (existsSync42(packageJsonPath)) {
+  if (existsSync43(packageJsonPath)) {
     try {
       const content = readFileSync32(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
@@ -19773,12 +19799,12 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import path39 from "path";
 import chalk152 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path39.resolve(csprojPath);
-  if (!existsSync43(resolved)) {
+  if (!existsSync44(resolved)) {
     console.error(chalk152.red(`File not found: ${resolved}`));
     process.exit(1);
   }
@@ -19946,7 +19972,7 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import path40 from "path";
 import chalk156 from "chalk";
 
@@ -19987,7 +20013,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path40.resolve(sln);
-    if (!existsSync44(resolved)) {
+    if (!existsSync45(resolved)) {
       console.error(chalk156.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -20027,7 +20053,7 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync40 } from "child_process";
-import { existsSync as existsSync45, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import path41 from "path";
 import chalk157 from "chalk";
@@ -20058,7 +20084,7 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk157.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync45(reportPath)) {
+  if (!existsSync46(reportPath)) {
     console.error(chalk157.red("Report file not generated"));
     process.exit(1);
   }
@@ -20347,11 +20373,11 @@ function decideCommentGuard(input, existingContent) {
 }
 
 // src/commands/dbMigration/consumeMigrationApproval.ts
-import { existsSync as existsSync46, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync47, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
   const path80 = getMigrationApprovalPath(migrationId);
-  if (!existsSync46(path80)) return false;
+  if (!existsSync47(path80)) return false;
   try {
     unlinkSync11(path80);
     return true;
@@ -20771,6 +20797,136 @@ async function createIssue(options2) {
   }
 }
 
+// src/commands/github/issue/fetchIssue.ts
+import { execFileSync as execFileSync8 } from "child_process";
+function fetchIssue2(number, repo) {
+  const args = [
+    "issue",
+    "view",
+    String(number),
+    "--json",
+    "title,body,updatedAt,url"
+  ];
+  if (repo) args.push("--repo", repo);
+  let raw;
+  try {
+    raw = execFileSync8("gh", args, { encoding: "utf8" });
+  } catch {
+    console.error(`Could not fetch issue #${number} with gh issue view`);
+    process.exit(1);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    console.error(`Could not parse the gh issue view output for #${number}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/pushIssueBody.ts
+import { execFileSync as execFileSync9 } from "child_process";
+function pushIssueBody(number, repo, bodyPath) {
+  const args = ["issue", "edit", String(number), "--body-file", bodyPath];
+  if (repo) args.push("--repo", repo);
+  try {
+    execFileSync9("gh", args, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/reviewProposedIssueEdit.ts
+import { randomUUID as randomUUID9 } from "crypto";
+async function reviewProposedIssueEdit(title, body) {
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return false;
+  await awaitPreviewApproval("GitHub issue edit preview", {
+    sessionId,
+    requestId: randomUUID9(),
+    title,
+    body,
+    prNumber: null,
+    kind: "github-issue-edit"
+  });
+  return true;
+}
+
+// src/commands/github/issue/writeIssueWorkingFile.ts
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync31 } from "fs";
+
+// src/commands/github/issue/issueWorkingFile.ts
+import { join as join50 } from "path";
+function issueWorkingFile(slug, number) {
+  const [owner = "unknown", repo = "unknown"] = slug.split("/");
+  const dir = join50(getStoreDir(), "github-issues", owner, repo);
+  return {
+    dir,
+    bodyPath: join50(dir, `${number}.md`),
+    metaPath: join50(dir, `${number}.json`)
+  };
+}
+
+// src/commands/github/issue/writeIssueWorkingFile.ts
+function writeIssueWorkingFile(slug, number, target, updatedAt, body) {
+  const { dir, bodyPath, metaPath } = issueWorkingFile(slug, number);
+  mkdirSync16(dir, { recursive: true });
+  writeFileSync31(bodyPath, body);
+  writeFileSync31(
+    metaPath,
+    `${JSON.stringify({ target, updatedAt }, null, 2)}
+`
+  );
+  return bodyPath;
+}
+
+// src/commands/github/issue/editIssue.ts
+var USAGE3 = "Usage: assist github issue edit <number> [-R <owner>/<repo>]";
+function slugFromUrl(url) {
+  const match = /github\.com\/([^/]+\/[^/]+)\//.exec(url ?? "");
+  return match ? match[1] : "unknown/unknown";
+}
+function abandon(reason4, bodyPath) {
+  console.error(
+    `${reason4}. Nothing was pushed; the markdown is at ${bodyPath}`
+  );
+  process.exit(1);
+}
+async function editIssue(numberArg, options2) {
+  const number = Number.parseInt(numberArg, 10);
+  if (!Number.isInteger(number) || number <= 0) {
+    console.error(USAGE3);
+    process.exit(1);
+  }
+  const issue = fetchIssue2(number, options2.repo);
+  const slug = options2.repo ?? slugFromUrl(issue.url);
+  const target = `${slug}#${number}`;
+  validateProposedContent(
+    { subject: "Issue", context: "GitHub issues" },
+    issue.title,
+    issue.body
+  );
+  const bodyPath = writeIssueWorkingFile(
+    slug,
+    number,
+    target,
+    issue.updatedAt,
+    issue.body
+  );
+  const reviewed = await reviewProposedIssueEdit(
+    `Edit ${target}: ${issue.title}`,
+    issue.body
+  );
+  if (!reviewed)
+    abandon(
+      `${target} can only be edited through the assist web preview pane`,
+      bodyPath
+    );
+  if (fetchIssue2(number, options2.repo).updatedAt !== issue.updatedAt)
+    abandon(`${target} was updated on GitHub after it was fetched`, bodyPath);
+  pushIssueBody(number, options2.repo, bodyPath);
+  console.log(`Issue body updated on ${target}`);
+}
+
 // src/commands/prs/readBodyArgument.ts
 async function readBodyArgument(value) {
   if (value !== "-") return value;
@@ -20792,6 +20948,13 @@ function registerGithubIssue(githubCommand) {
     "after",
     "\nThere is no What/Why/How template: an issue reports a problem, and the target repo's own issue template is unknowable from here. Write the body as the repo's maintainers would expect.\nIn an assist web session the title and body are previewed for approve/reject first (with inline comments); nothing is created until it is approved."
   ).action(createIssue);
+  issueCommand.command("edit <number>").description("Edit an existing GitHub issue's body in the preview pane").option(
+    "-R, --repo <owner/repo>",
+    "Target repository (defaults to the current repo)"
+  ).addHelpText(
+    "after",
+    "\nFetches the issue's current body and opens it in the assist web preview pane, where it can be reworked before it is pushed back. Approving pushes the pane's markdown to the issue; nothing is pushed if the issue moved on GitHub after it was fetched, or outside a web session.\nOnly the body is touched \u2014 the title, labels, assignees and state are left alone."
+  ).action(editIssue);
   issueCommand.command("comment <number>").description("Comment on a GitHub issue (body of - reads it from stdin)").option("--body <body>", "Comment body (- reads it from stdin)").option(
     "-R, --repo <owner/repo>",
     "Target repository (defaults to the current repo)"
@@ -20832,24 +20995,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync47,
+  existsSync as existsSync48,
   readdirSync as readdirSync10,
   readFileSync as readFileSync37,
   rmSync as rmSync3,
   statSync as statSync8
 } from "fs";
-import { basename as basename14, join as join52 } from "path";
+import { basename as basename14, join as join53 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join50(cwd, ".assist", "HANDOVER.md");
+  return join51(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join51(cwd, ".assist", "handovers");
+  return join52(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -20887,10 +21050,10 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync47(dir)) return [];
+  if (!existsSync48(dir)) return [];
   const out = [];
   for (const entry of readdirSync10(dir, { withFileTypes: true })) {
-    const full = join52(dir, entry.name);
+    const full = join53(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
@@ -20914,7 +21077,7 @@ async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync47(handoverPath)) {
+  if (existsSync48(handoverPath)) {
     await migrateFile(orm, origin, handoverPath, statSync8(handoverPath).mtime);
     migrated++;
   }
@@ -21230,10 +21393,10 @@ function registerRefineLaunch(program2, resumeFlag) {
 }
 
 // src/commands/reviewPrComments.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 
 // src/commands/review/checkoutPr.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import chalk164 from "chalk";
 
 // src/commands/sessions/daemon/daemonLog.ts
@@ -21271,18 +21434,18 @@ function canonicalTreePath(path80) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { basename as basename16, dirname as dirname25 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename15, join as join53 } from "path";
+import { basename as basename15, join as join54 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
   const name = basename15(clone);
   for (let n = 2; n < 1e3; n++) {
-    const candidate = join53(base, `${name}-${n}`);
+    const candidate = join54(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
   }
   throw new Error(`no free worktree suffix for ${clone}`);
@@ -21318,7 +21481,7 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const base = strategy.root ? expandTilde2(strategy.root) : dirname25(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const isTaken = (candidate) => registered.has(candidate) || existsSync48(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
+  const isTaken = (candidate) => registered.has(candidate) || existsSync49(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
   const path80 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
@@ -21344,7 +21507,7 @@ function keptInTree(cwd, reason4) {
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 var treeIsGone = { durable: true, gone: true };
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
@@ -21375,14 +21538,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync49(cwd)) return treeIsGone;
+  if (!existsSync50(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
   return step2.value;
 }
 function checkDurabilitySync(cwd) {
-  if (!existsSync49(cwd)) return treeIsGone;
+  if (!existsSync50(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -21625,20 +21788,20 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { copyFileSync, existsSync as existsSync51, mkdirSync as mkdirSync16 } from "fs";
-import { dirname as dirname26, join as join55 } from "path";
+import { copyFileSync, existsSync as existsSync52, mkdirSync as mkdirSync17 } from "fs";
+import { dirname as dirname26, join as join56 } from "path";
 
 // src/commands/sessions/daemon/worktree/runInstall.ts
 import { spawn as spawn5 } from "child_process";
 
 // src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
-import { existsSync as existsSync50 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync51 } from "fs";
+import { join as join55 } from "path";
 function detectInstallCommand(repoRoot2) {
-  if (!existsSync50(join54(repoRoot2, "package.json"))) return null;
-  if (existsSync50(join54(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync50(join54(repoRoot2, "yarn.lock"))) return "yarn install";
-  if (existsSync50(join54(repoRoot2, "bun.lockb"))) return "bun install";
+  if (!existsSync51(join55(repoRoot2, "package.json"))) return null;
+  if (existsSync51(join55(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync51(join55(repoRoot2, "yarn.lock"))) return "yarn install";
+  if (existsSync51(join55(repoRoot2, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 function resolveInstallCommand(repoRoot2, install) {
@@ -21750,11 +21913,11 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 }
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
-    const src = join55(clone, rel);
-    if (!existsSync51(src)) continue;
-    const dest = join55(worktreePath, rel);
+    const src = join56(clone, rel);
+    if (!existsSync52(src)) continue;
+    const dest = join56(worktreePath, rel);
     try {
-      mkdirSync16(dirname26(dest), { recursive: true });
+      mkdirSync17(dirname26(dest), { recursive: true });
       copyFileSync(src, dest);
       daemonLog(`worktree ${worktreePath} seeded ${rel}`);
     } catch (error) {
@@ -21793,10 +21956,10 @@ async function moveToPrCheckoutTree() {
 }
 
 // src/commands/review/prHeadBranch.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 function prHeadBranch(number) {
   try {
-    const out = execFileSync8(
+    const out = execFileSync10(
       "gh",
       ["pr", "view", number, "--json", "headRefName", "-q", ".headRefName"],
       { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
@@ -21844,7 +22007,7 @@ async function checkoutPr(number) {
   if (headRef && moveToExistingCheckout(number, headRef)) return;
   await moveToPrCheckoutTree();
   try {
-    execFileSync9("gh", ["pr", "checkout", number], { stdio: "inherit" });
+    execFileSync11("gh", ["pr", "checkout", number], { stdio: "inherit" });
   } catch {
     console.error(chalk164.red(`gh pr checkout ${number} failed; aborting.`));
     process.exit(1);
@@ -21866,7 +22029,7 @@ async function reviewPrComments(number, options2 = {}) {
   const resumeSessionId = options2.resumeSessionId;
   validateAnnounce(number, announce);
   if (number && !resumeSessionId) await checkoutPr(number);
-  const claudeSessionId = resumeSessionId ?? randomUUID9();
+  const claudeSessionId = resumeSessionId ?? randomUUID10();
   emitActivity({
     kind: "command",
     name: "review-pr-comments",
@@ -21884,14 +22047,14 @@ async function reviewPrComments(number, options2 = {}) {
 }
 
 // src/commands/fixConflict.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function buildPrompt3(rebase) {
   return rebase ? "/fix-conflict --rebase" : "/fix-conflict";
 }
 async function fixConflict(number, options2 = {}) {
   const { resumeSessionId } = options2;
   if (number && !resumeSessionId) await checkoutPr(number);
-  const claudeSessionId = resumeSessionId ?? randomUUID10();
+  const claudeSessionId = resumeSessionId ?? randomUUID11();
   emitActivity({
     kind: "command",
     name: "fix-conflict",
@@ -21981,12 +22144,12 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync17, readdirSync as readdirSync11 } from "fs";
+import { mkdirSync as mkdirSync18, readdirSync as readdirSync11 } from "fs";
 import { resolve as resolve16 } from "path";
 import chalk167 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync38, writeFileSync as writeFileSync31 } from "fs";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync32 } from "fs";
 import { basename as basename17, extname as extname2, resolve as resolve15 } from "path";
 import chalk166 from "chalk";
 
@@ -22037,7 +22200,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
     const outPath = resolve15(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
-    writeFileSync31(outPath, svg, "utf8");
+    writeFileSync32(outPath, svg, "utf8");
     console.log(chalk166.green(`  \u2192 ${outPath}`));
   }
 }
@@ -22050,7 +22213,7 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve16(process.cwd(), options2.out ?? ".");
-  mkdirSync17(outDir, { recursive: true });
+  mkdirSync18(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
@@ -22170,15 +22333,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 import chalk168 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname27, join as join56 } from "path";
+import { dirname as dirname27, join as join57 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var moduleDir = dirname27(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
-  return join56(moduleDir, "commands", "netcap", "netcap-extension");
+  return join57(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -22193,7 +22356,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join57(dir, "background.js");
+  const file = join58(dir, "background.js");
   const source = await readFile4(file, "utf8");
   await writeFile4(
     file,
@@ -22233,20 +22396,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute3, join as join59, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute3, join as join60, resolve as resolve17 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir20 } from "os";
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 function defaultCapturePath() {
-  return join58(homedir20(), ".assist", "netcap", "capture.jsonl");
+  return join59(homedir20(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute3(out) ? out : resolve17(process.cwd(), out);
-  return join59(dir, "capture.jsonl");
+  return join60(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -22292,8 +22455,8 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 }
 
 // src/commands/netcap/netcapExtract.ts
-import { writeFileSync as writeFileSync32 } from "fs";
-import { join as join60 } from "path";
+import { writeFileSync as writeFileSync33 } from "fs";
+import { join as join61 } from "path";
 import chalk170 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
@@ -22738,8 +22901,8 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join60(captureFile, "..", "posts.json");
-  writeFileSync32(outFile, `${JSON.stringify(posts, null, 2)}
+  const outFile = join61(captureFile, "..", "posts.json");
+  writeFileSync33(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
     chalk170.green(`extracted ${posts.length} posts`),
@@ -22913,13 +23076,13 @@ function postReviewComment(vars) {
 }
 
 // src/commands/prs/reviewProposedPrComment.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 async function reviewProposedPrComment(title, body, prNumber) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (process.env.ASSIST_SESSION !== "1" || !sessionId) return;
   await awaitPreviewApproval("PR comment preview", {
     sessionId,
-    requestId: randomUUID11(),
+    requestId: randomUUID12(),
     title,
     body,
     prNumber,
@@ -23045,7 +23208,7 @@ async function comment2(path80, line, body, startLine) {
 }
 
 // src/commands/prs/edit.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 
 // src/commands/prs/appendScreenshots.ts
 function appendScreenshots(body, screenshots) {
@@ -23058,13 +23221,13 @@ ${screenshots.join("\n\n")}`;
 }
 
 // src/commands/prs/applyEdit.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 function applyEdit(number, title, body) {
   const args = ["pr", "edit", String(number)];
   if (title) args.push("--title", title);
   args.push("--body", body);
   try {
-    execFileSync10("gh", args, { stdio: "inherit" });
+    execFileSync12("gh", args, { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
@@ -23242,7 +23405,7 @@ async function edit(options2) {
   if (process.env.ASSIST_SESSION === "1" && sessionId) {
     const decision = await awaitPreviewApproval("PR preview", {
       sessionId,
-      requestId: randomUUID12(),
+      requestId: randomUUID13(),
       title: options2.title ?? title,
       body: newBody,
       prNumber: number
@@ -23262,19 +23425,19 @@ import { execSync as execSync45 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
 import { execSync as execSync44 } from "child_process";
-import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
+import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync34 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync52, readFileSync as readFileSync40, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync40, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse2 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
 import { homedir as homedir21 } from "os";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 function commentsCachePath(org, repo, prNumber) {
-  return join61(
+  return join62(
     homedir21(),
     ".assist",
     "pr-comments",
@@ -23287,7 +23450,7 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync52(cachePath)) {
+  if (!existsSync53(cachePath)) {
     return null;
   }
   const content = readFileSync40(cachePath, "utf8");
@@ -23295,7 +23458,7 @@ function loadCommentsCache(org, repo, prNumber) {
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync52(cachePath)) {
+  if (existsSync53(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -23323,8 +23486,8 @@ function replyToComment(org, repo, prNumber, commentId, message3) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join62(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync33(queryFile, mutation);
+  const queryFile = join63(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync34(queryFile, mutation);
   try {
     execSync44(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
@@ -23406,13 +23569,13 @@ function fixed(commentId, sha) {
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync46 } from "child_process";
-import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync34 } from "fs";
+import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync35 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join63 } from "path";
+import { join as join64 } 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 = join63(tmpdir7(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync34(queryFile, THREAD_QUERY);
+  const queryFile = join64(tmpdir7(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync35(queryFile, THREAD_QUERY);
   try {
     const result = execSync46(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -23480,16 +23643,16 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/updateCommentsCache.ts
-import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync35 } from "fs";
+import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync36 } from "fs";
 import { dirname as dirname29 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
 import { readdirSync as readdirSync12, unlinkSync as unlinkSync16 } from "fs";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 var STALE_PATTERN = /^pr-\d+-comments\.yaml$/;
 function removeStaleCommentsCaches(cwd = process.cwd()) {
-  const dir = join64(cwd, ".assist");
+  const dir = join65(cwd, ".assist");
   let entries;
   try {
     entries = readdirSync12(dir);
@@ -23497,20 +23660,20 @@ function removeStaleCommentsCaches(cwd = process.cwd()) {
     return;
   }
   for (const entry of entries.filter((e) => STALE_PATTERN.test(e))) {
-    unlinkSync16(join64(dir, entry));
+    unlinkSync16(join65(dir, entry));
   }
 }
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 function writeCommentsCache(org, repo, prNumber, comments3) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  mkdirSync18(dirname29(cachePath), { recursive: true });
+  mkdirSync19(dirname29(cachePath), { recursive: true });
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  writeFileSync35(cachePath, stringify(cacheData));
+  writeFileSync36(cachePath, stringify(cacheData));
 }
 function updateCommentsCache(org, repo, prNumber, comments3) {
   removeStaleCommentsCaches();
@@ -23860,7 +24023,7 @@ function buildValidatedBody(options2, usage) {
 }
 
 // src/commands/prs/placePr.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 
 // src/commands/prs/buildCreateArgs.ts
 function buildEditArgs(number, title, body) {
@@ -23927,7 +24090,7 @@ async function recordPrActivity() {
 // src/commands/prs/placePr.ts
 function hasUpstream2() {
   try {
-    execFileSync11(
+    execFileSync13(
       "git",
       ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
       { stdio: "pipe" }
@@ -23939,13 +24102,13 @@ function hasUpstream2() {
 }
 function ensureBranchPushed() {
   const args = hasUpstream2() ? ["push"] : ["push", "--set-upstream", "origin", "HEAD"];
-  execFileSync11("git", args, { stdio: "inherit" });
+  execFileSync13("git", args, { stdio: "inherit" });
 }
 async function placePr(prNumber, title, body, options2) {
   const args = prNumber !== null ? buildEditArgs(prNumber, title, body) : buildCreateArgs(title, body, options2);
   try {
     if (prNumber === null && !options2.head) ensureBranchPushed();
-    execFileSync11("gh", args, { stdio: "inherit" });
+    execFileSync13("gh", args, { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
@@ -23953,7 +24116,7 @@ async function placePr(prNumber, title, body, options2) {
 }
 
 // src/commands/prs/previewAndPlace.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 
 // src/commands/sessions/shared/requestSession.ts
 function parseIncoming(line, type) {
@@ -24088,7 +24251,7 @@ function warn(reason4) {
 async function previewAndPlace(args) {
   const decision = await awaitPreviewApproval("PR preview", {
     sessionId: args.sessionId,
-    requestId: randomUUID13(),
+    requestId: randomUUID14(),
     title: args.title,
     body: args.body,
     prNumber: args.prNumber,
@@ -24108,9 +24271,9 @@ function resolveDraftState(options2, command) {
 }
 
 // src/commands/prs/raise.ts
-var USAGE3 = "Usage: assist prs raise --title <title> --what <what> --why <why> [--how <how>] [--resolves <key>] [--force]";
+var USAGE4 = "Usage: assist prs raise --title <title> --what <what> --why <why> [--how <how>] [--resolves <key>] [--force]";
 async function raise(options2, command) {
-  const { title, body } = buildValidatedBody(options2, USAGE3);
+  const { title, body } = buildValidatedBody(options2, USAGE4);
   const resolved = { ...options2, draft: resolveDraftState(options2, command) };
   const existing = findCurrentPrNumber();
   const sessionId = process.env.ASSIST_SESSION_ID;
@@ -26560,10 +26723,10 @@ function registerRefactor(program2) {
 }
 
 // src/commands/review/checkoutOnlySession.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 async function checkoutOnlySession(number) {
   await checkoutPr(number);
-  const claudeSessionId = randomUUID14();
+  const claudeSessionId = randomUUID15();
   emitActivity({ kind: "command", name: "review", claudeSessionId });
   const { done: done2 } = spawnClaude("", {
     permissionMode: "acceptEdits",
@@ -26686,9 +26849,9 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir22 } from "os";
-import { basename as basename18, join as join65 } from "path";
+import { basename as basename18, join as join66 } from "path";
 function buildReviewPaths(repoRoot2, key) {
-  const reviewDir = join65(
+  const reviewDir = join66(
     homedir22(),
     ".assist",
     "reviews",
@@ -26697,10 +26860,10 @@ function buildReviewPaths(repoRoot2, key) {
   );
   return {
     reviewDir,
-    requestPath: join65(reviewDir, "request.md"),
-    claudePath: join65(reviewDir, "claude.md"),
-    codexPath: join65(reviewDir, "codex.md"),
-    synthesisPath: join65(reviewDir, "synthesis.md")
+    requestPath: join66(reviewDir, "request.md"),
+    claudePath: join66(reviewDir, "claude.md"),
+    codexPath: join66(reviewDir, "codex.md"),
+    synthesisPath: join66(reviewDir, "synthesis.md")
   };
 }
 
@@ -27426,16 +27589,16 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync53, mkdirSync as mkdirSync19, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync20, unlinkSync as unlinkSync17, writeFileSync as writeFileSync37 } from "fs";
 function clearReviewFiles(paths) {
   for (const path80 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync53(path80)) unlinkSync17(path80);
+    if (existsSync54(path80)) unlinkSync17(path80);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync19(paths.reviewDir, { recursive: true });
+  mkdirSync20(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync36(paths.requestPath, requestBody);
+  writeFileSync37(paths.requestPath, requestBody);
 }
 
 // src/commands/review/cachedReviewerResult.ts
@@ -27656,7 +27819,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync55, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync56, unlinkSync as unlinkSync19 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -27731,7 +27894,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync37 } from "fs";
+import { writeFileSync as writeFileSync38 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -28067,7 +28230,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync37(spec.outputPath, finalText);
+    writeFileSync38(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -28085,7 +28248,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync54, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync55, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -28137,7 +28300,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync54(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync55(spec.outputPath)) {
     unlinkSync18(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -28292,7 +28455,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync55(paths.synthesisPath)) {
+  if (anyFresh && existsSync56(paths.synthesisPath)) {
     unlinkSync19(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -29591,27 +29754,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync60, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
-import { join as join76 } from "path";
+import { existsSync as existsSync61, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
+import { join as join77 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync60(vttDir)) return;
+  if (!existsSync61(vttDir)) return;
   for (const entry of readdirSync19(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync10(join76(vttDir, entry)).isDirectory()) continue;
+    if (statSync10(join77(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync61,
-  mkdirSync as mkdirSync25,
+  existsSync as existsSync62,
+  mkdirSync as mkdirSync26,
   readFileSync as readFileSync47,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync41
+  writeFileSync as writeFileSync42
 } from "fs";
-import { basename as basename21, join as join77 } from "path";
+import { basename as basename21, join as join78 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text18) {
@@ -29824,9 +29987,9 @@ function convertVttToMarkdown(inputPath) {
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join77(vttDir, "processed");
-  mkdirSync25(processedDir, { recursive: true });
-  renameSync2(sourcePath, join77(processedDir, filename));
+  const processedDir = join78(vttDir, "processed");
+  mkdirSync26(processedDir, { recursive: true });
+  renameSync2(sourcePath, join78(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -29836,19 +29999,19 @@ function move(file, options2) {
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename21(file);
-  const sourcePath = join77(vttDir, filename);
-  if (!existsSync61(sourcePath)) {
+  const sourcePath = join78(vttDir, filename);
+  if (!existsSync62(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
   const base = basename21(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join77(transcriptsDir, client);
-  mkdirSync25(formattedDir, { recursive: true });
-  const formattedPath = join77(formattedDir, outputName);
-  writeFileSync41(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
+  const formattedDir = join78(transcriptsDir, client);
+  mkdirSync26(formattedDir, { recursive: true });
+  const formattedPath = join78(formattedDir, outputName);
+  writeFileSync42(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join77(summaryDir, client, outputName);
+  const summaryPath = join78(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -29930,45 +30093,45 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir24 } from "os";
-import { dirname as dirname34, join as join78 } from "path";
+import { dirname as dirname34, join as join79 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 var __dirname6 = dirname34(fileURLToPath8(import.meta.url));
-var VOICE_DIR = join78(homedir24(), ".assist", "voice");
+var VOICE_DIR = join79(homedir24(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join78(VOICE_DIR, "voice.pid"),
-  log: join78(VOICE_DIR, "voice.log"),
-  venv: join78(VOICE_DIR, ".venv"),
-  lock: join78(VOICE_DIR, "voice.lock")
+  pid: join79(VOICE_DIR, "voice.pid"),
+  log: join79(VOICE_DIR, "voice.log"),
+  venv: join79(VOICE_DIR, ".venv"),
+  lock: join79(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join78(__dirname6, "commands", "voice", "python");
+  return join79(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join78(voicePaths.venv, "Scripts", "python.exe") : join78(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join79(voicePaths.venv, "Scripts", "python.exe") : join79(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join78(getLockDir(), "voice.lock");
+  return join79(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join79(getPythonDir(), "list_devices.py");
+  const script = join80(getPythonDir(), "list_devices.py");
   spawnSync7(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync62, readFileSync as readFileSync48 } from "fs";
+import { existsSync as existsSync63, readFileSync as readFileSync48 } from "fs";
 function logs(options2) {
-  if (!existsSync62(voicePaths.log)) {
+  if (!existsSync63(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -29995,13 +30158,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync8 } from "child_process";
-import { mkdirSync as mkdirSync27 } from "fs";
-import { join as join81 } from "path";
+import { mkdirSync as mkdirSync28 } from "fs";
+import { join as join82 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync63, mkdirSync as mkdirSync26, readFileSync as readFileSync49, writeFileSync as writeFileSync42 } from "fs";
-import { join as join80 } from "path";
+import { existsSync as existsSync64, mkdirSync as mkdirSync27, readFileSync as readFileSync49, writeFileSync as writeFileSync43 } from "fs";
+import { join as join81 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -30012,7 +30175,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync63(lockFile)) return;
+  if (!existsSync64(lockFile)) return;
   try {
     const lock2 = JSON.parse(readFileSync49(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
@@ -30025,7 +30188,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync63(getVenvPython())) return;
+  if (existsSync64(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync58(
@@ -30038,8 +30201,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync26(join80(lockFile, ".."), { recursive: true });
-  writeFileSync42(
+  mkdirSync27(join81(lockFile, ".."), { recursive: true });
+  writeFileSync43(
     lockFile,
     JSON.stringify({
       pid,
@@ -30051,10 +30214,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync27(voicePaths.dir, { recursive: true });
+  mkdirSync28(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join81(getPythonDir(), "setup_models.py");
+  const script = join82(getPythonDir(), "setup_models.py");
   const result = spawnSync8(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -30067,8 +30230,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync43 } from "fs";
-import { join as join82 } from "path";
+import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync44 } from "fs";
+import { join as join83 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -30096,17 +30259,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync43(voicePaths.pid, String(pid));
+  writeFileSync44(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync28(voicePaths.dir, { recursive: true });
+  mkdirSync29(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join82(getPythonDir(), "voice_daemon.py");
+  const script = join83(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -30116,7 +30279,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync64, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync65, readFileSync as readFileSync50 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -30126,12 +30289,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync64(voicePaths.log)) return [];
+  if (!existsSync65(voicePaths.log)) return [];
   const lines2 = readFileSync50(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync64(voicePaths.pid)) {
+  if (!existsSync65(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -30154,9 +30317,9 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync65, readFileSync as readFileSync51, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync51, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync65(voicePaths.pid)) {
+  if (!existsSync66(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -30173,7 +30336,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync65(lockFile)) unlinkSync20(lockFile);
+    if (existsSync66(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -30192,12 +30355,12 @@ function registerVoice(program2) {
 }
 
 // src/commands/watch/readBuiltVersion.ts
-import { join as join83 } from "path";
+import { join as join84 } from "path";
 
 // src/commands/watch/resolveUpstream.ts
-import { execFileSync as execFileSync12 } from "child_process";
-function runGit2(args, cwd) {
-  return execFileSync12("git", args, {
+import { execFileSync as execFileSync14 } from "child_process";
+function runGit3(args, cwd) {
+  return execFileSync14("git", args, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"],
     cwd
@@ -30205,7 +30368,7 @@ function runGit2(args, cwd) {
 }
 function resolveUpstream(cwd) {
   try {
-    runGit2(["rev-parse", "--is-inside-work-tree"], cwd);
+    runGit3(["rev-parse", "--is-inside-work-tree"], cwd);
   } catch {
     throw new Error(
       "not a git repository \u2014 run assist watch wait from inside a repo"
@@ -30213,7 +30376,7 @@ function resolveUpstream(cwd) {
   }
   let branch2;
   try {
-    branch2 = runGit2(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
+    branch2 = runGit3(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
   } catch {
     throw new Error(
       "HEAD is detached \u2014 check out a branch before waiting on its upstream"
@@ -30222,7 +30385,7 @@ function resolveUpstream(cwd) {
   try {
     return {
       branch: branch2,
-      upstream: runGit2(
+      upstream: runGit3(
         ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
         cwd
       )
@@ -30237,8 +30400,8 @@ function resolveUpstream(cwd) {
 // src/commands/watch/readBuiltVersion.ts
 function readBuiltVersion(cwd) {
   try {
-    const root = runGit2(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join83(root, "package.json")).version ?? "unknown";
+    const root = runGit3(["rev-parse", "--show-toplevel"], cwd);
+    return readPackageJson(join84(root, "package.json")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -30246,7 +30409,7 @@ function readBuiltVersion(cwd) {
 
 // src/commands/watch/readRecentCommits.ts
 function readRecentCommits(count8 = 10, cwd) {
-  const output = runGit2(
+  const output = runGit3(
     ["log", `-${count8}`, "--pretty=format:%H%x09%h%x09%ar%x09%s"],
     cwd
   );
@@ -30309,9 +30472,9 @@ function buildWatchReport(from, cwd) {
   return renderWatchReport({
     version: readBuiltVersion(cwd),
     commits: readRecentCommits(10, cwd),
-    newShas: range ? lines(runGit2(["rev-list", range], cwd)) : [],
+    newShas: range ? lines(runGit3(["rev-list", range], cwd)) : [],
     restarts: restartAdvice(
-      range ? lines(runGit2(["diff", "--name-only", range], cwd)) : []
+      range ? lines(runGit3(["diff", "--name-only", range], cwd)) : []
     )
   });
 }
@@ -30409,14 +30572,14 @@ function parseWatchDurations(interval, timeout) {
 var STASH_MESSAGE = "assist watch";
 function attemptGit(args, cwd) {
   try {
-    runGit2(args, cwd);
+    runGit3(args, cwd);
     return { ok: true };
   } catch (error) {
     return { ok: false, reason: gitFailureReason(error) };
   }
 }
 function fastForwarded(cwd) {
-  return { kind: "fast-forwarded", sha: runGit2(["rev-parse", "@"], cwd) };
+  return { kind: "fast-forwarded", sha: runGit3(["rev-parse", "@"], cwd) };
 }
 function operationInProgress(cwd) {
   return ["MERGE_HEAD", "REBASE_HEAD"].some(
@@ -30425,7 +30588,7 @@ function operationInProgress(cwd) {
 }
 function headMatchesUpstream(cwd) {
   try {
-    return runGit2(["rev-parse", "@"], cwd) === runGit2(["rev-parse", "@{u}"], cwd);
+    return runGit3(["rev-parse", "@"], cwd) === runGit3(["rev-parse", "@{u}"], cwd);
   } catch {
     return false;
   }
@@ -30436,7 +30599,7 @@ function behindUpstream(cwd) {
 function stashDirtyTree(cwd) {
   let dirty;
   try {
-    dirty = runGit2(["status", "--porcelain"], cwd) !== "";
+    dirty = runGit3(["status", "--porcelain"], cwd) !== "";
   } catch (error) {
     return { ok: false, reason: gitFailureReason(error) };
   }
@@ -30536,7 +30699,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync66 } from "fs";
+import { existsSync as existsSync67 } from "fs";
 import { resolve as resolve18 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -30549,25 +30712,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve18(baseDir, config.cwd);
-  if (!existsSync66(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync67(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 
 // src/commands/run/resolveCommand.ts
-import { execFileSync as execFileSync13 } from "child_process";
-import { existsSync as existsSync67 } from "fs";
-import { dirname as dirname35, join as join84, resolve as resolve19 } from "path";
+import { execFileSync as execFileSync15 } from "child_process";
+import { existsSync as existsSync68 } from "fs";
+import { dirname as dirname35, join as join85, resolve as resolve19 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync13("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitPath = execFileSync15("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve19(dirname35(gitPath), "..");
-    const gitBash = join84(gitRoot, "bin", "bash.exe");
-    if (existsSync67(gitBash)) return gitBash;
+    const gitBash = join85(gitRoot, "bin", "bash.exe");
+    if (existsSync68(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -30577,7 +30740,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync68(cwd)) {
+    if (cwd && !existsSync69(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -30661,11 +30824,11 @@ async function reportBuildOrExit(entry) {
 }
 
 // src/commands/watch/fetchQuietly.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 var MIN_FETCH_TIMEOUT_MS = 6e4;
 function fetchQuietly(cwd, intervalMs) {
   try {
-    execFileSync14("git", ["fetch", "--quiet"], {
+    execFileSync16("git", ["fetch", "--quiet"], {
       stdio: ["pipe", "pipe", "pipe"],
       cwd,
       timeout: Math.max(intervalMs, MIN_FETCH_TIMEOUT_MS)
@@ -30684,9 +30847,9 @@ function detectMovement(from, to, count8) {
 // src/commands/watch/readMovement.ts
 function readMovement(cwd) {
   try {
-    const from = runGit2(["rev-parse", "@"], cwd);
-    const to = runGit2(["rev-parse", "@{u}"], cwd);
-    const count8 = Number(runGit2(["rev-list", "--count", "@..@{u}"], cwd));
+    const from = runGit3(["rev-parse", "@"], cwd);
+    const to = runGit3(["rev-parse", "@{u}"], cwd);
+    const count8 = Number(runGit3(["rev-list", "--count", "@..@{u}"], cwd));
     return detectMovement(from, to, count8);
   } catch {
     return void 0;
@@ -30965,9 +31128,9 @@ async function auth() {
 }
 
 // src/commands/roam/postRoamActivity.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync17 } from "child_process";
 import { readdirSync as readdirSync20, readFileSync as readFileSync52, statSync as statSync11 } from "fs";
-import { join as join85 } from "path";
+import { join as join86 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -30976,7 +31139,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path80 = join85(roamDir, name);
+    const path80 = join86(roamDir, name);
     try {
       return { path: path80, mtimeMs: statSync11(path80).mtimeMs };
     } catch {
@@ -30988,7 +31151,7 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join85(appData, "Roam"));
+  const portFile = findPortFile(join86(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -30998,7 +31161,7 @@ function postRoamActivity(app, event) {
   }
   const url = `http://127.0.0.1:${port}/api/v1/activity/${app}/${event}?pid=${app === "codex" ? 99998 : 99999}`;
   try {
-    execFileSync15("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
+    execFileSync17("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
       stdio: "ignore"
     });
   } catch {
@@ -31120,8 +31283,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync44 } from "fs";
-import { join as join86 } from "path";
+import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync45 } from "fs";
+import { join as join87 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -31182,16 +31345,16 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join86(".claude", "commands");
-  mkdirSync29(dir, { recursive: true });
+  const dir = join87(".claude", "commands");
+  mkdirSync30(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join86(dir, `${name}.md`);
-  writeFileSync44(filePath, content);
+  const filePath = join87(dir, `${name}.md`);
+  writeFileSync45(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -31246,8 +31409,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync69, unlinkSync as unlinkSync21 } from "fs";
-import { join as join87 } from "path";
+import { existsSync as existsSync70, unlinkSync as unlinkSync21 } from "fs";
+import { join as join88 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -31262,8 +31425,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join87(".claude", "commands", `${name}.md`);
-  if (existsSync69(filePath)) {
+  const filePath = join88(".claude", "commands", `${name}.md`);
+  if (existsSync70(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -31308,9 +31471,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync70, mkdirSync as mkdirSync30, unlinkSync as unlinkSync22, writeFileSync as writeFileSync45 } from "fs";
+import { existsSync as existsSync71, mkdirSync as mkdirSync31, unlinkSync as unlinkSync22, writeFileSync as writeFileSync46 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join88, resolve as resolve20 } from "path";
+import { join as join89, resolve as resolve20 } from "path";
 import chalk216 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -31440,15 +31603,15 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync70(outputDir)) {
-    mkdirSync30(outputDir, { recursive: true });
+  if (!existsSync71(outputDir)) {
+    mkdirSync31(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve20(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join88(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync45(scriptPath, captureWindowPs1, "utf8");
+  const scriptPath = join89(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync46(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync60(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -31474,11 +31637,11 @@ function screenshot(processName) {
 }
 
 // src/commands/sessions/daemon/listDaemonPids.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 function listDaemonPids() {
   if (process.platform === "win32") return [];
   try {
-    const out = execFileSync16("ps", ["-eo", "pid=,args="], {
+    const out = execFileSync18("ps", ["-eo", "pid=,args="], {
       encoding: "utf8"
     });
     return out.split("\n").filter((line) => line.includes("assist") && / daemon run\b/.test(line)).map((line) => Number.parseInt(line.trim(), 10)).filter((pid) => Number.isInteger(pid));
@@ -31681,7 +31844,7 @@ function requestDrain(socket, lines2) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync34 } from "fs";
+import { mkdirSync as mkdirSync35 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -31785,12 +31948,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync72 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync71(session.cwd))
+  if (!existsSync72(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -31935,7 +32098,7 @@ var ClientHub = class extends Set {
 };
 
 // src/commands/sessions/daemon/createSession.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // src/commands/sessions/daemon/sessionBase.ts
 function sessionBase(id, status3) {
@@ -31954,11 +32117,11 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync73 } from "fs";
+import { existsSync as existsSync74 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync72, statSync as statSync12 } from "fs";
+import { chmodSync, existsSync as existsSync73, statSync as statSync12 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path75 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -31973,7 +32136,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync72(helper)) return;
+  if (!existsSync73(helper)) return;
   const mode = statSync12(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -32009,7 +32172,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync73(cwd)) return;
+  if (!cwd || existsSync74(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -32131,7 +32294,7 @@ function spawnRun(opts) {
 function createSession(id, { prompt, cwd, design, auto, harness, holdPty } = {}) {
   if (harness && harness !== "claude")
     return createHarnessSession(id, harness, prompt, cwd, holdPty);
-  const claudeSessionId = randomUUID15();
+  const claudeSessionId = randomUUID16();
   return {
     ...sessionBase(id, prompt ? "running" : "waiting"),
     name: `Session ${id}`,
@@ -32191,17 +32354,17 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync75 } from "fs";
+import { existsSync as existsSync76 } from "fs";
 import { basename as basename22 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync74 } from "fs";
-import { join as join91 } from "path";
+import { existsSync as existsSync75 } from "fs";
+import { join as join92 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync13 } from "fs";
 import { rm as rm2 } from "fs/promises";
-import { join as join90 } from "path";
+import { join as join91 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -32229,7 +32392,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync13(join90(worktreePath, ".git"), {
+  return statSync13(join91(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -32265,7 +32428,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync74(join91(worktreePath, ".git")))
+  if (!existsSync75(join92(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -32317,7 +32480,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync75(worktreePath)) {
+  if (!existsSync76(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -32342,7 +32505,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync75(recorded)) return recorded;
+  if (recorded && existsSync76(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -32473,12 +32636,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync76, watch } from "fs";
+import { existsSync as existsSync77, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync76(common)) return void 0;
+  if (!common || !existsSync77(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -32728,7 +32891,8 @@ var PREVIEW_KINDS = [
   "backlog-comment",
   "pr-comment",
   "github-issue",
-  "github-issue-comment"
+  "github-issue-comment",
+  "github-issue-edit"
 ];
 function isPreviewKind(value) {
   return PREVIEW_KINDS.includes(value);
@@ -32739,6 +32903,7 @@ function previewTargetLabel(kind, itemType, prNumber, draft) {
   if (kind === "backlog-comment") return "backlog comment";
   if (kind === "pr-comment") return "pr comment";
   if (kind === "github-issue-comment") return "github issue comment";
+  if (kind === "github-issue-edit") return "github issue edit";
   if (kind === "github-issue") return "github issue";
   if (kind === "backlog-item") return `backlog ${itemType}`;
   if (prNumber !== null) return `edit #${prNumber}`;
@@ -32950,10 +33115,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync77 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 import { resolve as resolve21 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync77(session.cwd))
+  if (session.cwd && !existsSync78(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -32967,7 +33132,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve21(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync77(configured)) return void 0;
+  if (existsSync78(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -33008,7 +33173,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync78, mkdirSync as mkdirSync31, watch as watch2 } from "fs";
+import { existsSync as existsSync79, mkdirSync as mkdirSync32, watch as watch2 } from "fs";
 import { dirname as dirname37 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -33073,7 +33238,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   const path80 = activityPath(session.id);
   const dir = dirname37(path80);
   try {
-    mkdirSync31(dir, { recursive: true });
+    mkdirSync32(dir, { recursive: true });
   } catch {
     return;
   }
@@ -33094,7 +33259,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read2, DEBOUNCE_MS2);
   });
-  if (existsSync78(path80)) read2();
+  if (existsSync79(path80)) read2();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -33276,10 +33441,10 @@ function headContainsSessionId(filePath, claudeSessionId) {
 }
 
 // src/commands/sessions/daemon/ensureProjectDirExists.ts
-import { mkdirSync as mkdirSync32 } from "fs";
+import { mkdirSync as mkdirSync33 } from "fs";
 function ensureProjectDirExists(dir, sessionId) {
   try {
-    mkdirSync32(dir, { recursive: true });
+    mkdirSync33(dir, { recursive: true });
     return true;
   } catch (error) {
     daemonLog(
@@ -34199,7 +34364,7 @@ function codexRespawnPlan(session) {
 }
 
 // src/commands/sessions/daemon/interactiveRespawnPlan.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 function interactiveRespawnPlan(session, resumes) {
   const { claudeSessionId, cwd, initialPrompt, design, auto } = session;
   if (!resumes) return null;
@@ -34219,7 +34384,7 @@ function interactiveRespawnPlan(session, resumes) {
   return null;
 }
 function freshClaudePlan(session, prompt, cwd) {
-  const claudeSessionId = randomUUID16();
+  const claudeSessionId = randomUUID17();
   return {
     spawn: () => {
       session.claudeSessionId = claudeSessionId;
@@ -34716,7 +34881,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync81 } from "fs";
+import { existsSync as existsSync82 } from "fs";
 import { basename as basename24 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -34771,9 +34936,9 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync80 } from "fs";
+import { existsSync as existsSync81 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync80(clone)) {
+  if (!existsSync81(clone)) {
     for (const { path: path80 } of paths) forgetWorktree(path80);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -34939,7 +35104,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
       );
       continue;
     }
-    if (!existsSync81(path80)) {
+    if (!existsSync82(path80)) {
       logVanishedTree(sessions, path80);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
@@ -35104,10 +35269,10 @@ function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatus
 }
 
 // src/commands/sessions/daemon/createWatcherSession.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var WATCH_PROMPT = "/watch";
 function createWatcherSession(id, cwd) {
-  const claudeSessionId = randomUUID17();
+  const claudeSessionId = randomUUID18();
   return {
     ...sessionBase(id, "running"),
     name: `Session ${id}`,
@@ -35556,13 +35721,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync82, readFileSync as readFileSync55 } from "fs";
+import { existsSync as existsSync83, readFileSync as readFileSync55 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync82(sessionsFile)) return false;
+    if (!existsSync83(sessionsFile)) return false;
     const data = JSON.parse(readFileSync55(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -36297,7 +36462,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync86 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -36328,11 +36493,11 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync84 } from "fs";
+import { existsSync as existsSync85 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync83, mkdirSync as mkdirSync33 } from "fs";
-import { join as join93 } from "path";
+import { copyFileSync as copyFileSync7, existsSync as existsSync84, mkdirSync as mkdirSync34 } from "fs";
+import { join as join94 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
   if (dir === projectDirForCwd(fromCwd)) {
@@ -36341,8 +36506,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     );
     return;
   }
-  const dest = join93(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync83(dest)) {
+  const dest = join94(dir, `${claudeSessionId}.jsonl`);
+  if (existsSync84(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -36354,7 +36519,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   try {
-    mkdirSync33(dir, { recursive: true });
+    mkdirSync34(dir, { recursive: true });
     copyFileSync7(source, dest);
     daemonLog(
       `transcript ${source} copied to ${dest} so ${toCwd} can resume it`
@@ -36393,7 +36558,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync84(clone))
+  if (!clone || !existsSync85(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -36402,7 +36567,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync85(cwd))
+  if (!existsSync86(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -36771,12 +36936,6 @@ function safeParse2(line) {
   }
 }
 
-// src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync86 } from "fs";
-function repoDirExists(cwd) {
-  return existsSync86(toGitCwd(cwd));
-}
-
 // src/commands/sessions/daemon/withRepoGroups.ts
 function withRepoGroups(sessions) {
   const existence = /* @__PURE__ */ new Map();
@@ -36984,7 +37143,7 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync46 } from "fs";
+import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync47 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
 import { readFileSync as readFileSync56 } from "fs";
@@ -37006,7 +37165,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync46(daemonPaths.pid, String(process.pid));
+  writeFileSync47(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {
@@ -37047,7 +37206,7 @@ function cleanupOwnedFiles() {
 import * as net3 from "net";
 
 // src/commands/sessions/daemon/findPortHolderPid.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 var PROBE_TIMEOUT_MS = 3e3;
 function findPortHolderPid(port) {
   try {
@@ -37057,7 +37216,7 @@ function findPortHolderPid(port) {
   }
 }
 function probe(command, args) {
-  return execFileSync17(command, args, {
+  return execFileSync19(command, args, {
     encoding: "utf8",
     timeout: PROBE_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "ignore"]
@@ -37193,7 +37352,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync34(daemonPaths.dir, { recursive: true });
+  mkdirSync35(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -37264,7 +37423,7 @@ function summaryPathFor(jsonlPath2) {
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 function summariseSession(jsonlPath2) {
   const firstMessage = extractFirstUserMessage(jsonlPath2);
   const backlogIds = scanSessionBacklogRefs(jsonlPath2);
@@ -37273,7 +37432,7 @@ function summariseSession(jsonlPath2) {
   }
   const prompt = buildPrompt6(firstMessage, backlogIds);
   try {
-    const output = execFileSync18("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync20("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -37454,9 +37613,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync58, statSync as statSync15 } from "fs";
-import { isAbsolute as isAbsolute4, join as join94, resolve as resolve22 } from "path";
+import { isAbsolute as isAbsolute4, join as join95, resolve as resolve22 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join94(cwd, ".git");
+  const dotGit = join95(cwd, ".git");
   let stat4;
   try {
     stat4 = statSync15(dotGit);
@@ -37486,7 +37645,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync58(join94(gitDir, "HEAD"), "utf8");
+    head = readFileSync58(join95(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }