@staff0rd/assist 0.485.1 → 0.485.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.485.1",
+  version: "0.485.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -142,9 +142,9 @@ import chalk from "chalk";
 import { stringify as stringifyYaml } from "yaml";
 
 // src/shared/loadConfigFrom.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
@@ -201,13 +201,68 @@ function getCurrentOrigin(cwd) {
   return `local:${root ?? cwd}`;
 }
 
+// src/shared/linkedWorktree.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+function linkedWorktree(dir) {
+  const root = findGitLink(dir);
+  if (!root) return null;
+  const gitDir = readGitDirPointer(root);
+  if (!gitDir) return null;
+  const commonDir = resolveCommonDir(gitDir);
+  if (!commonDir || basename(commonDir) !== ".git") return null;
+  const clone = dirname(commonDir);
+  return existsSync(clone) ? { root, clone } : null;
+}
+function findGitLink(dir) {
+  let current = resolve(dir);
+  while (current !== dirname(current)) {
+    const entry = join(current, ".git");
+    if (existsSync(entry)) return isFile(entry) ? current : null;
+    current = dirname(current);
+  }
+  return null;
+}
+function isFile(path71) {
+  try {
+    return statSync(path71).isFile();
+  } catch {
+    return false;
+  }
+}
+function readGitDirPointer(root) {
+  const target = readTrimmed(join(root, ".git"));
+  if (!target?.startsWith("gitdir:")) return null;
+  return absolute(target.slice("gitdir:".length).trim(), root);
+}
+function resolveCommonDir(gitDir) {
+  const recorded = readTrimmed(join(gitDir, "commondir"));
+  if (recorded) return absolute(recorded, gitDir);
+  return linkedGitDirParent(gitDir);
+}
+function linkedGitDirParent(gitDir) {
+  const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
+  return match ? match[1] : null;
+}
+function readTrimmed(path71) {
+  try {
+    const content = readFileSync(path71, "utf8").trim();
+    return content === "" ? null : content;
+  } catch {
+    return null;
+  }
+}
+function absolute(target, from) {
+  return isAbsolute(target) ? target : resolve(from, target);
+}
+
 // src/shared/loadRawYaml.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { parse as parseYaml } from "yaml";
 function loadRawYaml(path71) {
-  if (!existsSync(path71)) return {};
+  if (!existsSync2(path71)) return {};
   try {
-    const content = readFileSync(path71, "utf8");
+    const content = readFileSync2(path71, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -580,30 +635,35 @@ var assistConfigSchema = z2.strictObject({
 // src/shared/loadConfigFrom.ts
 function findConfigUp(startDir) {
   let current = startDir;
-  while (current !== dirname(current)) {
-    const claudePath = join(current, ".claude", "assist.yml");
-    if (existsSync2(claudePath))
+  while (current !== dirname2(current)) {
+    const claudePath = join2(current, ".claude", "assist.yml");
+    if (existsSync3(claudePath))
       return { configPath: claudePath, rootDir: current };
-    const rootPath = join(current, "assist.yml");
-    if (existsSync2(rootPath)) return { configPath: rootPath, rootDir: current };
-    current = dirname(current);
+    const rootPath = join2(current, "assist.yml");
+    if (existsSync3(rootPath)) return { configPath: rootPath, rootDir: current };
+    current = dirname2(current);
   }
   return null;
 }
 function getConfigPathFrom(cwd) {
   const found = findConfigUp(cwd);
   if (found) return found.configPath;
-  return join(cwd, "assist.yml");
+  return join2(cwd, "assist.yml");
 }
 function getGlobalConfigPath() {
-  return join(homedir(), ".assist.yml");
+  return join2(homedir(), ".assist.yml");
 }
 function getConfigDirFrom(cwd) {
-  return dirname(getConfigPathFrom(cwd));
+  return dirname2(getConfigPathFrom(cwd));
+}
+function projectConfigPathFrom(cwd) {
+  if (findConfigUp(cwd)) return getConfigPathFrom(cwd);
+  const clone = linkedWorktree(cwd)?.clone;
+  return getConfigPathFrom(clone ?? cwd);
 }
 function loadConfigFrom(cwd) {
   const globalRaw = loadRawYaml(getGlobalConfigPath());
-  const projectRaw = loadRawYaml(getConfigPathFrom(cwd));
+  const projectRaw = loadRawYaml(projectConfigPathFrom(cwd));
   const repoOverride = globalRaw.repos ? resolveRepoOverride(globalRaw, getCurrentOrigin(cwd)) : {};
   const globalWithRepo = mergeRawConfigs(globalRaw, repoOverride);
   const merged = mergeRawConfigs(globalWithRepo, projectRaw);
@@ -624,7 +684,7 @@ function loadConfig() {
   return loadConfigFrom(process.cwd());
 }
 function loadProjectConfig(cwd = process.cwd()) {
-  return loadRawYaml(getConfigPathFrom(cwd));
+  return loadRawYaml(projectConfigPathFrom(cwd));
 }
 function loadGlobalConfigRaw() {
   return loadRawYaml(getGlobalConfigPath());
@@ -633,7 +693,7 @@ function saveGlobalConfig(config) {
   writeFileSync(getGlobalConfigPath(), stringifyYaml(config, { lineWidth: 0 }));
 }
 function saveConfig(config, cwd = process.cwd()) {
-  const configPath = getConfigPathFrom(cwd);
+  const configPath = projectConfigPathFrom(cwd);
   writeFileSync(configPath, stringifyYaml(config, { lineWidth: 0 }));
 }
 function getTranscriptConfig() {
@@ -1781,7 +1841,7 @@ function gitRefUrl(kind, ref, cwd) {
 }
 
 // src/commands/commit/collectCommitRefs.ts
-function collectCommitRefs(message2) {
+function collectCommitRefs(message3) {
   const refs = [];
   const branch2 = git("rev-parse --abbrev-ref HEAD");
   if (branch2 && branch2 !== "HEAD") {
@@ -1798,7 +1858,7 @@ function collectCommitRefs(message2) {
       ref: sha,
       url: gitRefUrl("commit", sha)
     };
-    const subject = message2.split("\n", 1)[0];
+    const subject = message3.split("\n", 1)[0];
     if (subject) ref.title = subject;
     refs.push(ref);
     const parent = git("rev-parse HEAD^");
@@ -1866,16 +1926,16 @@ function shouldPull(config) {
 
 // src/commands/commit/stageAndCommit.ts
 import { execSync as execSync7 } from "child_process";
-function commitStaged(message2) {
-  execSync7(`git commit -m ${shellQuote(message2)}`, { stdio: "inherit" });
+function commitStaged(message3) {
+  execSync7(`git commit -m ${shellQuote(message3)}`, { stdio: "inherit" });
   return execSync7("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
 }
-function stageAndCommit(files, message2) {
+function stageAndCommit(files, message3) {
   const escaped = files.map(shellQuote).join(" ");
   execSync7(`git add ${escaped}`, { stdio: "inherit" });
-  return commitStaged(message2);
+  return commitStaged(message3);
 }
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
@@ -1970,34 +2030,34 @@ function backlogRefError(subject, context, ids) {
 // src/commands/commit/validateMessage.ts
 var MAX_MESSAGE_LENGTH = 50;
 var CONVENTIONAL_COMMIT_REGEX = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!)?(\(.+\))?!?: .+$/;
-function validateMessage(message2, config) {
-  if (message2.toLowerCase().includes("claude")) {
+function validateMessage(message3, config) {
+  if (message3.toLowerCase().includes("claude")) {
     console.error("Error: Commit message must not reference Claude");
     process.exit(1);
   }
-  const backlogIds = findBacklogRefs(message2);
+  const backlogIds = findBacklogRefs(message3);
   if (backlogIds.length > 0) {
     console.error(
       backlogRefError("Commit message", "commit messages", backlogIds)
     );
     process.exit(1);
   }
-  if (config.commit?.conventional && !CONVENTIONAL_COMMIT_REGEX.test(message2)) {
+  if (config.commit?.conventional && !CONVENTIONAL_COMMIT_REGEX.test(message3)) {
     console.error(
       "Error: Commit message must follow conventional commit format (e.g., 'feat: add feature', 'fix(scope): fix bug')"
     );
     process.exit(1);
   }
-  if (message2.length > MAX_MESSAGE_LENGTH) {
+  if (message3.length > MAX_MESSAGE_LENGTH) {
     console.error(
-      `Error: Commit message must be ${MAX_MESSAGE_LENGTH} characters or less (current: ${message2.length})`
+      `Error: Commit message must be ${MAX_MESSAGE_LENGTH} characters or less (current: ${message3.length})`
     );
     process.exit(1);
   }
 }
 
 // src/commands/commit.ts
-async function execCommit(files, message2, config) {
+async function execCommit(files, message3, config) {
   try {
     warnIfUnexpectedBranch(config);
     const pulled = shouldPull(config);
@@ -2005,21 +2065,21 @@ async function execCommit(files, message2, config) {
       execSync8("git pull --autostash", { stdio: "inherit" });
     }
     abortOnConflicts(files, pulled);
-    const sha = files.length > 0 ? stageAndCommit(files, message2) : commitStaged(message2);
+    const sha = files.length > 0 ? stageAndCommit(files, message3) : commitStaged(message3);
     console.log(`Committed: ${sha}`);
     if (config.commit?.push) {
       pushCommit(config.worktree?.trunk === true);
       console.log("Pushed to remote");
     }
-    await recordCommitActivity(message2);
+    await recordCommitActivity(message3);
     process.exit(0);
   } catch {
     process.exit(1);
   }
 }
-async function recordCommitActivity(message2) {
+async function recordCommitActivity(message3) {
   if (resolveSessionItemId() === null) return;
-  await recordSessionRefs(collectCommitRefs(message2));
+  await recordSessionRefs(collectCommitRefs(message3));
 }
 async function commit(args) {
   if (args[0] === "status") {
@@ -2032,11 +2092,11 @@ async function commit(args) {
     console.error("Usage: assist commit <message> [files...]");
     process.exit(1);
   }
-  const message2 = args[0];
+  const message3 = args[0];
   const files = args.slice(1);
   const config = loadConfig();
-  validateMessage(message2, config);
-  await execCommit(files, message2, config);
+  validateMessage(message3, config);
+  await execCommit(files, message3, config);
 }
 
 // src/commands/coverage.ts
@@ -2074,12 +2134,12 @@ async function exitOnCancel(promise) {
 }
 
 // src/shared/promptMultiselect.ts
-async function promptMultiselect(message2, options2) {
+async function promptMultiselect(message3, options2) {
   const { selected } = await exitOnCancel(
     enquirer.prompt({
       type: "multiselect",
       name: "selected",
-      message: message2,
+      message: message3,
       choices: options2.map((opt) => ({
         name: opt.value,
         message: `${opt.name} - ${chalk4.dim(opt.description)}`
@@ -2259,17 +2319,17 @@ import * as path3 from "path";
 import chalk10 from "chalk";
 
 // src/commands/verify/addToKnipIgnoreBinaries.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
 import chalk9 from "chalk";
 function loadKnipConfig(knipJsonPath) {
-  if (existsSync4(knipJsonPath)) {
-    return JSON.parse(readFileSync3(knipJsonPath, "utf8"));
+  if (existsSync5(knipJsonPath)) {
+    return JSON.parse(readFileSync4(knipJsonPath, "utf8"));
   }
   return { $schema: "https://unpkg.com/knip@5/schema.json" };
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = join3(cwd, "knip.json");
+  const knipJsonPath = join4(cwd, "knip.json");
   try {
     const knipConfig = loadKnipConfig(knipJsonPath);
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
@@ -2316,17 +2376,17 @@ import * as path5 from "path";
 import chalk15 from "chalk";
 
 // src/commands/format/init.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import chalk13 from "chalk";
 
 // src/shared/promptConfirm.ts
 import enquirer2 from "enquirer";
-async function promptConfirm(message2, initial = true) {
+async function promptConfirm(message3, initial = true) {
   const { confirmed } = await exitOnCancel(
     enquirer2.prompt({
       type: "confirm",
       name: "confirmed",
-      message: message2,
+      message: message3,
       initial,
       // @ts-expect-error - enquirer types don't include symbols but it's supported
       symbols: {
@@ -2378,7 +2438,7 @@ async function init() {
   const newContent = `${JSON.stringify(oxfmtrc_template_default, null, "	")}
 `;
   const configPath = ".oxfmtrc.json";
-  const oldContent = existsSync5(configPath) ? readFileSync4(configPath, "utf8") : "";
+  const oldContent = existsSync6(configPath) ? readFileSync5(configPath, "utf8") : "";
   if (oldContent === newContent) {
     console.log(".oxfmtrc.json already has the baseline formatter config");
     return;
@@ -2401,15 +2461,15 @@ async function init() {
 }
 
 // src/commands/lint/init.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import chalk14 from "chalk";
 
 // src/shared/removeEslint/index.ts
 import { execSync as execSync11 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 
 // src/shared/removeEslint/removeEslintConfigFiles.ts
-import { existsSync as existsSync6, unlinkSync } from "fs";
+import { existsSync as existsSync7, unlinkSync } from "fs";
 var ESLINT_CONFIG_FILES = [
   "eslint.config.js",
   "eslint.config.mjs",
@@ -2425,7 +2485,7 @@ var ESLINT_CONFIG_FILES = [
 function removeEslintConfigFiles() {
   let removed = false;
   for (const configFile of ESLINT_CONFIG_FILES) {
-    if (existsSync6(configFile)) {
+    if (existsSync7(configFile)) {
       unlinkSync(configFile);
       console.log(`Removed ${configFile}`);
       removed = true;
@@ -2447,10 +2507,10 @@ function removeEslint(options2 = {}) {
 }
 function removeEslintFromPackageJson(options2) {
   const packageJsonPath = "package.json";
-  if (!existsSync7(packageJsonPath)) {
+  if (!existsSync8(packageJsonPath)) {
     return false;
   }
-  const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
   let modified = false;
   modified = removeEslintDeps(packageJson.dependencies) || modified;
   modified = removeEslintDeps(packageJson.devDependencies) || modified;
@@ -2514,7 +2574,7 @@ async function writeOxlintConfig() {
   const newContent = `${JSON.stringify(oxlintrc_template_default, null, "	")}
 `;
   const configPath = ".oxlintrc.json";
-  const oldContent = existsSync8(configPath) ? readFileSync6(configPath, "utf8") : "";
+  const oldContent = existsSync9(configPath) ? readFileSync7(configPath, "utf8") : "";
   if (oldContent === newContent) {
     console.log(".oxlintrc.json already has the baseline linter config");
     return;
@@ -3289,7 +3349,7 @@ function lint(options2 = {}) {
 
 // src/commands/new/registerNew/newCli/index.ts
 import { execSync as execSync20 } from "child_process";
-import { basename as basename2, resolve as resolve5 } from "path";
+import { basename as basename3, resolve as resolve6 } from "path";
 
 // src/commands/verify/blockCodeComments/findComments.ts
 import { execSync as execSync12 } from "child_process";
@@ -3872,7 +3932,7 @@ function configKeys() {
 }
 
 // src/commands/verify/forbiddenStrings/index.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
@@ -3913,13 +3973,13 @@ function forbiddenStrings() {
   const cache4 = /* @__PURE__ */ new Map();
   const readJson = (file) => {
     if (cache4.has(file)) return cache4.get(file);
-    if (!existsSync12(file)) {
+    if (!existsSync13(file)) {
       console.log(`Forbidden-strings file not found: ${file}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync9(file, "utf8"));
+      parsed = JSON.parse(readFileSync10(file, "utf8"));
     } catch (error) {
       console.log(`Could not parse ${file}: ${error.message}`);
       process.exit(1);
@@ -3992,7 +4052,7 @@ Total: ${lines.length} hardcoded color(s)`);
 import * as path19 from "path";
 
 // src/shared/resolveRunConfigs.ts
-import { dirname as dirname9, relative, resolve as resolve3 } from "path";
+import { dirname as dirname10, relative, resolve as resolve4 } from "path";
 
 // src/shared/assertNoDuplicateRunNames.ts
 function findDuplicateNames(configs) {
@@ -4014,14 +4074,14 @@ function assertNoDuplicateRunNames(configs) {
 }
 
 // src/shared/findLinkedConfigPath.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join8, resolve } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join9, resolve as resolve2 } from "path";
 function findLinkedConfigPath(linkPath, fromDir) {
-  const resolved = resolve(fromDir, linkPath);
-  const claudePath = join8(resolved, ".claude", "assist.yml");
-  if (existsSync13(claudePath)) return claudePath;
-  const rootPath = join8(resolved, "assist.yml");
-  if (existsSync13(rootPath)) return rootPath;
+  const resolved = resolve2(fromDir, linkPath);
+  const claudePath = join9(resolved, ".claude", "assist.yml");
+  if (existsSync14(claudePath)) return claudePath;
+  const rootPath = join9(resolved, "assist.yml");
+  if (existsSync14(rootPath)) return rootPath;
   throw new Error(`No assist.yml found in linked project: ${resolved}`);
 }
 
@@ -4031,9 +4091,9 @@ function isRunLink(entry) {
 }
 
 // src/shared/loadLinkedEntries.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 function loadLinkedEntries(configPath, visited) {
-  const canonical = resolve2(configPath);
+  const canonical = resolve3(configPath);
   if (visited.has(canonical)) {
     throw new Error(
       `Circular link detected: ${canonical} has already been visited`
@@ -4055,15 +4115,15 @@ function applyPrefix(configs, prefix2) {
 function setDefaultCwd(configs, defaultCwd) {
   return configs.map((c) => c.cwd ? c : { ...c, cwd: defaultCwd });
 }
-function relativeToRoot(ctx, absolute) {
-  return relative(ctx.rootConfigDir, absolute);
+function relativeToRoot(ctx, absolute2) {
+  return relative(ctx.rootConfigDir, absolute2);
 }
 function loadAndResolveLink(linkPath, configDir, ctx) {
   const configPath = findLinkedConfigPath(linkPath, configDir);
   const entries = loadLinkedEntries(configPath, ctx.visited);
-  const defaultCwd = relativeToRoot(ctx, resolve3(configDir, linkPath));
+  const defaultCwd = relativeToRoot(ctx, resolve4(configDir, linkPath));
   return setDefaultCwd(
-    resolveRecursive(entries, dirname9(configPath), ctx),
+    resolveRecursive(entries, dirname10(configPath), ctx),
     defaultCwd
   );
 }
@@ -4085,7 +4145,7 @@ function resolveLocalCwd(config, configDir, ctx) {
   if (!config.cwd || configDir === ctx.rootConfigDir) return config;
   return {
     ...config,
-    cwd: relativeToRoot(ctx, resolve3(configDir, config.cwd))
+    cwd: relativeToRoot(ctx, resolve4(configDir, config.cwd))
   };
 }
 
@@ -4132,7 +4192,7 @@ function list() {
 }
 
 // src/commands/verify/migrations/index.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import path20 from "path";
 import { fileURLToPath } from "url";
 
@@ -4213,7 +4273,7 @@ function listMigrationFiles(dir) {
 
 // src/commands/verify/migrations/readBaselineMigrations.ts
 import { execSync as execSync14 } from "child_process";
-import { basename } from "path";
+import { basename as basename2 } from "path";
 var MIGRATION_FILE3 = /^migration\d+[A-Za-z0-9]*\.ts$/;
 function readBaselineMigrations(repoRelativeDir, ref) {
   const baseline = /* @__PURE__ */ new Map();
@@ -4226,7 +4286,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path71) => MIGRATION_FILE3.test(basename(path71)));
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path71) => MIGRATION_FILE3.test(basename2(path71)));
   for (const path71 of paths) {
     try {
       const content = execSync14(`git show "${ref}:${path71}"`, {
@@ -4234,7 +4294,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path71), content);
+      baseline.set(basename2(path71), content);
     } catch {
     }
   }
@@ -4294,7 +4354,7 @@ function migrations2() {
   if (ref) {
     const baseline = readBaselineMigrations(REPO_RELATIVE_DIR, ref);
     const current = new Map(
-      files.map((file) => [file, readFileSync10(path20.join(dir, file), "utf8")])
+      files.map((file) => [file, readFileSync11(path20.join(dir, file), "utf8")])
     );
     for (const finding of checkAppendOnly(baseline, current)) {
       problems.push(
@@ -4462,7 +4522,7 @@ ${failed2.length} script(s) failed:`);
   }
 }
 function runEntry(entry) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const startTime = Date.now();
     const child = spawnCommand(
       entry.fullCommand,
@@ -4474,7 +4534,7 @@ function runEntry(entry) {
     child.on("close", (code) => {
       const exitCode = code ?? 1;
       flushIfFailed(exitCode, chunks);
-      resolve20({
+      resolve21({
         script: entry.name,
         code: exitCode,
         durationMs: Date.now() - startTime
@@ -4605,7 +4665,7 @@ program.parse();
 
 // src/commands/new/registerNew/newCli/index.ts
 async function newCli() {
-  const name = basename2(resolve5("."));
+  const name = basename3(resolve6("."));
   initGit();
   initPackageJson(name);
   console.log("Installing dependencies...");
@@ -4620,7 +4680,7 @@ async function newCli() {
 
 // src/commands/new/registerNew/newProject.ts
 import { execSync as execSync22 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
 
 // src/commands/deploy/init/index.ts
 import { execSync as execSync21 } from "child_process";
@@ -4628,33 +4688,33 @@ import chalk28 from "chalk";
 import enquirer3 from "enquirer";
 
 // src/commands/deploy/init/updateWorkflow.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname11, join as join9 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname12, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk27 from "chalk";
 var WORKFLOW_PATH = ".github/workflows/build.yml";
-var __dirname2 = dirname11(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname12(fileURLToPath2(import.meta.url));
 function getExistingSiteId() {
-  if (!existsSync14(WORKFLOW_PATH)) {
+  if (!existsSync15(WORKFLOW_PATH)) {
     return null;
   }
-  const content = readFileSync11(WORKFLOW_PATH, "utf8");
+  const content = readFileSync12(WORKFLOW_PATH, "utf8");
   const match = content.match(/-s\s+([a-f0-9-]{36})/);
   return match ? match[1] : null;
 }
 function getTemplateContent(siteId) {
-  const templatePath = join9(__dirname2, "commands/deploy/build.yml");
-  const template = readFileSync11(templatePath, "utf8");
+  const templatePath = join10(__dirname2, "commands/deploy/build.yml");
+  const template = readFileSync12(templatePath, "utf8");
   return template.replace("{{NETLIFY_SITE_ID}}", siteId);
 }
 async function updateWorkflow(siteId) {
   const newContent = getTemplateContent(siteId);
   const workflowDir = ".github/workflows";
-  if (!existsSync14(workflowDir)) {
+  if (!existsSync15(workflowDir)) {
     mkdirSync3(workflowDir, { recursive: true });
   }
-  if (existsSync14(WORKFLOW_PATH)) {
-    const oldContent = readFileSync11(WORKFLOW_PATH, "utf8");
+  if (existsSync15(WORKFLOW_PATH)) {
+    const oldContent = readFileSync12(WORKFLOW_PATH, "utf8");
     if (oldContent === newContent) {
       console.log(chalk27.green("build.yml is already up to date"));
       return;
@@ -4748,11 +4808,11 @@ async function newProject() {
 }
 function addViteBaseConfig() {
   const viteConfigPath = "vite.config.ts";
-  if (!existsSync15(viteConfigPath)) {
+  if (!existsSync16(viteConfigPath)) {
     console.log("No vite.config.ts found, skipping base config");
     return;
   }
-  const content = readFileSync12(viteConfigPath, "utf8");
+  const content = readFileSync13(viteConfigPath, "utf8");
   if (content.includes("base:")) {
     console.log("vite.config.ts already has base config");
     return;
@@ -4819,13 +4879,13 @@ function getSnoreToastPath() {
   return path21.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options2) {
-  const { title, message: message2, sound } = options2;
+  const { title, message: message3, sound } = options2;
   const snoreToastPath = getSnoreToastPath();
   try {
     fs16.chmodSync(snoreToastPath, 493);
   } catch {
   }
-  const args = ["-t", title, "-m", message2];
+  const args = ["-t", title, "-m", message3];
   if (sound) {
     args.push("-s", "ms-winsoundevent:Notification.Default");
   }
@@ -4839,14 +4899,14 @@ function showWindowsNotificationFromWsl(options2) {
 
 // src/commands/notify/showNotification/index.ts
 function showNotification(options2) {
-  const { title, message: message2, sound } = options2;
+  const { title, message: message3, sound } = options2;
   const platform = detectPlatform();
   if (platform === "wsl") {
-    return showWindowsNotificationFromWsl({ title, message: message2, sound });
+    return showWindowsNotificationFromWsl({ title, message: message3, sound });
   }
   const notificationOptions = {
     title,
-    message: message2,
+    message: message3,
     wait: false
   };
   if (platform === "windows") {
@@ -4868,7 +4928,7 @@ async function notify() {
   }
   const inputData = await readStdin();
   const data = JSON.parse(inputData);
-  const { notification_type, cwd, message: message2 } = data;
+  const { notification_type, cwd, message: message3 } = data;
   const projectName = cwd?.split(/[/\\]/).pop() ?? "Unknown Project";
   let title;
   let body;
@@ -4876,7 +4936,7 @@ async function notify() {
   switch (notification_type) {
     case "permission_prompt":
       title = "Claude needs permission";
-      body = `${projectName} - ${message2 || "Permission required"}`;
+      body = `${projectName} - ${message3 || "Permission required"}`;
       sound = "Alarm";
       break;
     case "idle_prompt":
@@ -4886,7 +4946,7 @@ async function notify() {
       break;
     default:
       title = "Claude Code";
-      body = message2 ? `${projectName} - ${message2}` : projectName;
+      body = message3 ? `${projectName} - ${message3}` : projectName;
       sound = "Default";
   }
   showNotification({ title, message: body, sound });
@@ -4994,7 +5054,7 @@ function registerActivity(program2) {
 
 // src/commands/registerBackup.ts
 import { mkdir as mkdir2, stat } from "fs/promises";
-import { join as join11, resolve as resolve6 } from "path";
+import { join as join12, resolve as resolve7 } from "path";
 import chalk31 from "chalk";
 
 // src/shared/db/recordBackup.ts
@@ -5014,7 +5074,7 @@ function expandTilde2(value) {
 
 // src/commands/backup/scheduleBackup.ts
 import { mkdir } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import chalk29 from "chalk";
 
 // src/commands/backup/readCrontab.ts
@@ -5140,8 +5200,8 @@ function readScheduleBlock(crontab) {
 }
 
 // src/commands/backup/scheduleBackup.ts
-function fail(message2) {
-  console.error(chalk29.red(message2));
+function fail(message3) {
+  console.error(chalk29.red(message3));
   process.exit(1);
 }
 async function scheduleBackup({
@@ -5156,7 +5216,7 @@ async function scheduleBackup({
     const cronExpr = durationToCron(every);
     const dir = expandTilde2(loadConfig().backup.dir);
     await mkdir(dir, { recursive: true });
-    const logPath2 = join10(dir, "cron.log");
+    const logPath2 = join11(dir, "cron.log");
     const cronLine = `${cronExpr} ${resolveAssistCommand()} backup >> ${logPath2} 2>&1`;
     writeCrontab(upsertScheduleBlock(readCrontab(), every, cronLine));
     console.error(
@@ -5335,7 +5395,7 @@ async function backup({ out }) {
   await mkdir2(dir, { recursive: true });
   const start3 = Date.now();
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const filePath = resolve6(join11(dir, `backup-${timestamp6}.dump`));
+  const filePath = resolve7(join12(dir, `backup-${timestamp6}.dump`));
   await exportBacklog(filePath);
   const { size } = await stat(filePath);
   const durationMs = Date.now() - start3;
@@ -5442,19 +5502,19 @@ function parseItemId(input) {
 
 // src/commands/backlog/acquireLock.ts
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync14
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function getLocksDir() {
-  return join12(homedir4(), ".assist", "locks");
+  return join13(homedir4(), ".assist", "locks");
 }
 function getLockPath(itemId2) {
-  return join12(getLocksDir(), `lock-${itemId2}.json`);
+  return join13(getLocksDir(), `lock-${itemId2}.json`);
 }
 function isProcessAlive(pid) {
   try {
@@ -5466,9 +5526,9 @@ function isProcessAlive(pid) {
 }
 function foreignLockHolder(itemId2) {
   const lockPath = getLockPath(itemId2);
-  if (!existsSync16(lockPath)) return null;
+  if (!existsSync17(lockPath)) return null;
   try {
-    const lock2 = JSON.parse(readFileSync13(lockPath, "utf8"));
+    const lock2 = JSON.parse(readFileSync14(lockPath, "utf8"));
     if (typeof lock2.pid !== "number" || lock2.pid === process.pid) return null;
     if (!isProcessAlive(lock2.pid)) return null;
     return { pid: lock2.pid, timestamp: lock2.timestamp };
@@ -5579,19 +5639,19 @@ import chalk45 from "chalk";
 
 // src/commands/sessions/daemon/ensureHooksSettings.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 
 // src/commands/sessions/daemon/daemonPaths.ts
 import { homedir as homedir5 } from "os";
-import { join as join13 } from "path";
-var DAEMON_DIR = join13(homedir5(), ".assist", "daemon");
+import { join as join14 } from "path";
+var DAEMON_DIR = join14(homedir5(), ".assist", "daemon");
 var daemonPaths = {
   dir: DAEMON_DIR,
-  socket: process.platform === "win32" ? String.raw`\\.\pipe\assist-sessions-daemon` : join13(DAEMON_DIR, "daemon.sock"),
-  log: join13(DAEMON_DIR, "daemon.log"),
-  pid: join13(DAEMON_DIR, "daemon.pid"),
-  spawnLock: join13(DAEMON_DIR, "spawn.lock"),
-  hooksSettings: join13(DAEMON_DIR, "hooks-settings.json")
+  socket: process.platform === "win32" ? String.raw`\\.\pipe\assist-sessions-daemon` : join14(DAEMON_DIR, "daemon.sock"),
+  log: join14(DAEMON_DIR, "daemon.log"),
+  pid: join14(DAEMON_DIR, "daemon.pid"),
+  spawnLock: join14(DAEMON_DIR, "spawn.lock"),
+  hooksSettings: join14(DAEMON_DIR, "hooks-settings.json")
 };
 
 // src/commands/sessions/daemon/ensureHooksSettings.ts
@@ -5626,7 +5686,7 @@ var hooksSettings = {
 };
 function ensureHooksSettings() {
   const path71 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path71), { recursive: true });
+  mkdirSync5(dirname13(path71), { recursive: true });
   writeFileSync15(path71, JSON.stringify(hooksSettings, null, 2));
   return path71;
 }
@@ -5644,8 +5704,8 @@ function spawnInherit(command, args, options2 = {}) {
     env,
     cwd: options2.cwd
   });
-  const done2 = new Promise((resolve20, reject) => {
-    child.on("close", (code) => resolve20(code ?? 0));
+  const done2 = new Promise((resolve21, reject) => {
+    child.on("close", (code) => resolve21(code ?? 0));
     child.on("error", reject);
   });
   return { child, done: done2 };
@@ -5679,6 +5739,10 @@ function buildArgs(prompt, options2) {
   return [prompt];
 }
 
+// src/commands/backlog/ensureStoryBranch.ts
+import { execSync as execSync28 } from "child_process";
+import { basename as basename4 } from "path";
+
 // src/commands/branch/createBranch.ts
 import { execSync as execSync27 } from "child_process";
 
@@ -5829,8 +5893,8 @@ function buildPrompt(description) {
 
 // src/commands/sessions/daemon/appendDaemonLog.ts
 import { appendFileSync } from "fs";
-function appendDaemonLog(message2) {
-  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`;
+function appendDaemonLog(message3) {
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message3}`;
   try {
     appendFileSync(daemonPaths.log, `${line}
 `);
@@ -5841,36 +5905,89 @@ function appendDaemonLog(message2) {
 // src/commands/backlog/ensureStoryBranch.ts
 async function ensureStoryBranch(item) {
   const config = loadConfig();
-  if (!config.prs?.required) return;
-  if (hasBranchRef(item)) return;
+  if (!config.prs?.required) {
+    log(item, "prs.required not set; left the session on its current branch");
+    return;
+  }
+  const recorded = recordedBranch(item);
+  if (recorded) {
+    adoptRecordedBranch(item, recorded);
+    return;
+  }
   process.env.ASSIST_BACKLOG_ITEM_ID = String(item.id);
   const slug = await generateBranchSlug(item.name);
   const { branchName } = await createBranch({ slug, jira: item.jiraKey });
-  appendDaemonLog(
-    `backlog run ${item.id}: prs.required set and no branch recorded; created ${branchName}`
-  );
+  log(item, `prs.required set and no branch recorded; created ${branchName}`);
 }
-function hasBranchRef(item) {
-  return (item.gitRefs ?? []).some((ref) => ref.kind === "branch");
+function recordedBranch(item) {
+  return (item.gitRefs ?? []).find((ref) => ref.kind === "branch")?.ref;
+}
+function adoptRecordedBranch(item, branch2) {
+  const parked = worktreeBranchInPlay();
+  if (!parked) {
+    log(
+      item,
+      `branch ${branch2} already recorded; left the session on its current branch`
+    );
+    return;
+  }
+  try {
+    execSync28("git fetch", { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    execSync28(`git switch ${shellQuote(branch2)}`, { stdio: "inherit" });
+    log(
+      item,
+      `branch ${branch2} already recorded; switched off ${parked} onto it`
+    );
+  } catch (error) {
+    log(
+      item,
+      `branch ${branch2} already recorded but the worktree stayed on ${parked}: ${message(error)}`
+    );
+  }
+}
+function worktreeBranchInPlay() {
+  const tree = linkedWorktree(process.cwd());
+  if (!tree) return null;
+  const head = currentBranch2();
+  return head === basename4(tree.root) ? head : null;
+}
+function currentBranch2() {
+  try {
+    return execSync28("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function log(item, outcome) {
+  appendDaemonLog(`backlog run ${item.id}: ${outcome}`);
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 
 // src/commands/backlog/shared.ts
 import chalk37 from "chalk";
 
 // src/commands/backlog/migrateLocalBacklog.ts
-import { existsSync as existsSync18 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join16 } from "path";
 import chalk36 from "chalk";
 
 // src/commands/backlog/backupLocalBacklogFiles.ts
-import { existsSync as existsSync17, renameSync } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync18, renameSync } from "fs";
+import { join as join15 } from "path";
 var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path71 = join14(dir, ".assist", name);
-    if (existsSync17(path71)) {
+    const path71 = join15(dir, ".assist", name);
+    if (existsSync18(path71)) {
       renameSync(path71, `${path71}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
@@ -5879,11 +5996,11 @@ function backupLocalBacklogFiles(dir) {
 }
 
 // src/commands/backlog/gitPullBacklog.ts
-import { execSync as execSync28 } from "child_process";
+import { execSync as execSync29 } from "child_process";
 import chalk35 from "chalk";
 function gitPullBacklog(dir) {
   try {
-    execSync28("git pull --ff-only", {
+    execSync29("git pull --ff-only", {
       cwd: dir,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -6258,7 +6375,7 @@ async function loadAllItems(orm, origin) {
 }
 
 // src/commands/backlog/parseBacklogJsonl.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 
 // src/commands/backlog/types.ts
 import { z as z3 } from "zod";
@@ -6350,14 +6467,14 @@ var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
 function parseBacklogJsonl(path71) {
-  const content = readFileSync14(path71, "utf8").trim();
+  const content = readFileSync15(path71, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
 
 // src/commands/backlog/migrateLocalBacklog.ts
 function jsonlPath(dir) {
-  return join15(dir, ".assist", "backlog.jsonl");
+  return join16(dir, ".assist", "backlog.jsonl");
 }
 async function verifyImport(orm, origin, items2, imported) {
   const reloaded = await loadAllItems(orm, origin);
@@ -6373,7 +6490,7 @@ async function verifyImport(orm, origin, items2, imported) {
   }
 }
 async function migrateLocalBacklog(orm, dir, origin) {
-  if (!existsSync18(jsonlPath(dir))) return;
+  if (!existsSync19(jsonlPath(dir))) return;
   const existing = (await loadAllItems(orm, origin)).length;
   if (existing > 0) {
     const moved2 = backupLocalBacklogFiles(dir);
@@ -6412,20 +6529,20 @@ async function deleteItem(orm, id) {
 }
 
 // src/commands/backlog/findBacklogUp.ts
-import { existsSync as existsSync19 } from "fs";
-import { dirname as dirname13, join as join16 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { dirname as dirname14, join as join17 } from "path";
 var BACKLOG_MARKERS = [
-  join16(".assist", "backlog.db"),
-  join16(".assist", "backlog.jsonl"),
+  join17(".assist", "backlog.db"),
+  join17(".assist", "backlog.jsonl"),
   "assist.backlog.yml"
 ];
 function findBacklogUp(startDir) {
   let current = startDir;
-  while (current !== dirname13(current)) {
-    if (BACKLOG_MARKERS.some((marker) => existsSync19(join16(current, marker)))) {
+  while (current !== dirname14(current)) {
+    if (BACKLOG_MARKERS.some((marker) => existsSync20(join17(current, marker)))) {
       return current;
     }
-    current = dirname13(current);
+    current = dirname14(current);
   }
   return null;
 }
@@ -6610,10 +6727,10 @@ async function reconcileResumePhase(orm, item, startPhase, resumeSessionId) {
   if (resumedPhaseIdx === void 0 || resumedPhaseIdx === startPhase) {
     return startPhase;
   }
-  const message2 = `resume reconciliation: currentPhase implied phase ${startPhase + 1} but the resumed conversation ${resumeSessionId} ran phase ${resumedPhaseIdx + 1}; resuming phase ${resumedPhaseIdx + 1} to match the conversation`;
-  appendDaemonLog(`backlog run ${item.id}: ${message2}`);
+  const message3 = `resume reconciliation: currentPhase implied phase ${startPhase + 1} but the resumed conversation ${resumeSessionId} ran phase ${resumedPhaseIdx + 1}; resuming phase ${resumedPhaseIdx + 1} to match the conversation`;
+  appendDaemonLog(`backlog run ${item.id}: ${message3}`);
   try {
-    await appendComment(orm, item.id, `Resume reconciled \u2014 ${message2}`, {
+    await appendComment(orm, item.id, `Resume reconciled \u2014 ${message3}`, {
       phase: resumedPhaseIdx + 1
     });
   } catch {
@@ -6676,14 +6793,14 @@ function reportDuplicateRun(itemId2, holder) {
 }
 
 // src/commands/backlog/consumePause.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function getControlsDir() {
-  return join17(homedir6(), ".assist", "controls");
+  return join18(homedir6(), ".assist", "controls");
 }
 function getPausePath(itemId2) {
-  return join17(getControlsDir(), `pause-${itemId2}.json`);
+  return join18(getControlsDir(), `pause-${itemId2}.json`);
 }
 function requestPause(itemId2) {
   mkdirSync6(getControlsDir(), { recursive: true });
@@ -6693,7 +6810,7 @@ function requestPause(itemId2) {
   );
 }
 function isPausePending(itemId2) {
-  return existsSync20(getPausePath(itemId2));
+  return existsSync21(getPausePath(itemId2));
 }
 function clearPause(itemId2) {
   try {
@@ -6703,7 +6820,7 @@ function clearPause(itemId2) {
 }
 function consumePause(itemId2) {
   const pausePath = getPausePath(itemId2);
-  if (!existsSync20(pausePath)) return false;
+  if (!existsSync21(pausePath)) return false;
   try {
     unlinkSync3(pausePath);
   } catch {
@@ -6722,10 +6839,10 @@ async function awaitClaude(done2, context) {
   try {
     return await done2;
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
+    const message3 = error instanceof Error ? error.message : String(error);
     console.error(
       chalk40.red(`
-Failed to launch Claude for ${context}: ${message2}`)
+Failed to launch Claude for ${context}: ${message3}`)
     );
     return CLAUDE_SPAWN_FAILED;
   }
@@ -6734,9 +6851,9 @@ Failed to launch Claude for ${context}: ${message2}`)
 // src/commands/sessions/daemon/connectToDaemon.ts
 import * as net from "net";
 function connectToDaemon() {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const socket = net.connect(daemonPaths.socket);
-    socket.once("connect", () => resolve20(socket));
+    socket.once("connect", () => resolve21(socket));
     socket.once("error", reject);
   });
 }
@@ -6751,8 +6868,8 @@ async function isDaemonRunning() {
 
 // src/commands/sessions/daemon/sendToDaemon.ts
 var WRITE_TIMEOUT_MS = 500;
-function sendToDaemon(message2) {
-  return new Promise((resolve20, reject) => {
+function sendToDaemon(message3) {
+  return new Promise((resolve21, reject) => {
     connectToDaemon().then((socket) => {
       const timer = setTimeout(() => {
         socket.destroy();
@@ -6762,11 +6879,11 @@ function sendToDaemon(message2) {
         clearTimeout(timer);
         reject(error);
       });
-      socket.write(`${JSON.stringify(message2)}
+      socket.write(`${JSON.stringify(message3)}
 `, () => {
         clearTimeout(timer);
         socket.end();
-        resolve20();
+        resolve21();
       });
     }, reject);
   });
@@ -6788,8 +6905,8 @@ function readSocketLines(socket, onLine) {
 
 // src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
 var ACK_TIMEOUT_MS = 1e3;
-function sendToDaemonAwaitAck(message2) {
-  return new Promise((resolve20, reject) => {
+function sendToDaemonAwaitAck(message3) {
+  return new Promise((resolve21, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error) => {
@@ -6798,7 +6915,7 @@ function sendToDaemonAwaitAck(message2) {
         clearTimeout(timer);
         socket.destroy();
         if (error) reject(error);
-        else resolve20();
+        else resolve21();
       };
       const timer = setTimeout(
         () => finish(new Error("timed out awaiting daemon ack")),
@@ -6812,7 +6929,7 @@ function sendToDaemonAwaitAck(message2) {
         "close",
         () => finish(new Error("daemon closed before acknowledging"))
       );
-      socket.write(`${JSON.stringify(message2)}
+      socket.write(`${JSON.stringify(message3)}
 `);
     }, reject);
   });
@@ -6872,7 +6989,7 @@ async function deliverReliably(sessionId, status3, payload) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -7026,42 +7143,42 @@ function buildPhasePrompt(item, phaseNumber, phase) {
 }
 
 // src/commands/backlog/watchForMarker.ts
-import { existsSync as existsSync23, unwatchFile, watchFile } from "fs";
+import { existsSync as existsSync24, unwatchFile, watchFile } from "fs";
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
 
 // src/commands/backlog/writeSignal.ts
 import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname15, join as join19 } from "path";
+import { dirname as dirname16, join as join20 } from "path";
 import chalk41 from "chalk";
 
 // src/commands/backlog/recordSignalOwner.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   rmSync,
   writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname14, join as join18 } from "path";
+import { dirname as dirname15, join as join19 } from "path";
 function getOwnerPath(itemId2) {
-  return join18(homedir7(), ".assist", "signals", `owner-${itemId2}.json`);
+  return join19(homedir7(), ".assist", "signals", `owner-${itemId2}.json`);
 }
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
   const path71 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path71), { recursive: true });
+  mkdirSync7(dirname15(path71), { recursive: true });
   writeFileSync17(path71, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
   const path71 = getOwnerPath(itemId2);
-  if (!existsSync21(path71)) return void 0;
+  if (!existsSync22(path71)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path71, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path71, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
@@ -7078,7 +7195,7 @@ function clearSignalOwner(itemId2) {
 // src/commands/backlog/writeSignal.ts
 function getSignalPath(sessionId = process.env.ASSIST_SESSION_ID) {
   if (!sessionId) return void 0;
-  return join19(homedir8(), ".assist", "signals", `signal-${sessionId}.json`);
+  return join20(homedir8(), ".assist", "signals", `signal-${sessionId}.json`);
 }
 function resolveSignalTarget(event, data) {
   const caller = process.env.ASSIST_SESSION_ID;
@@ -7110,16 +7227,16 @@ function writeSignal(event, data) {
   const path71 = getSignalPath(target);
   if (!path71) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path71), { recursive: true });
+  mkdirSync8(dirname16(path71), { recursive: true });
   writeFileSync18(path71, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
   const path71 = getSignalPath();
-  if (!path71 || !existsSync22(path71)) return void 0;
+  if (!path71 || !existsSync23(path71)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path71, "utf8"));
+    return JSON.parse(readFileSync17(path71, "utf8"));
   } catch {
     return void 0;
   }
@@ -7131,7 +7248,7 @@ function watchForMarker(child, options2) {
   const statusPath = getSignalPath();
   if (!statusPath) return { killedOnMarker: () => killed };
   watchFile(statusPath, { interval: 1e3 }, () => {
-    if (!existsSync23(statusPath)) return;
+    if (!existsSync24(statusPath)) return;
     const signal = readSignal();
     if (!signal) return;
     if (signal.event === "done" && !options2?.actOnDone) return;
@@ -7230,9 +7347,9 @@ async function persistPhaseSessionId(itemId2, phaseIdx, claudeSessionId) {
 }
 
 // src/shared/emitActivity.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync19 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync2, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname16, join as join20 } from "path";
+import { dirname as dirname17, join as join21 } from "path";
 import { z as z4 } from "zod";
 var activitySchema = z4.object({
   kind: z4.enum(["command", "backlog"]),
@@ -7247,18 +7364,18 @@ var activitySchema = z4.object({
   startedAt: z4.number()
 });
 function activityPath(sessionId) {
-  return join20(homedir9(), ".assist", "activity", `activity-${sessionId}.json`);
+  return join21(homedir9(), ".assist", "activity", `activity-${sessionId}.json`);
 }
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
   const path71 = activityPath(sessionId);
-  mkdirSync9(dirname16(path71), { recursive: true });
+  mkdirSync9(dirname17(path71), { recursive: true });
   writeFileSync19(path71, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
 function readActivity(path71) {
   try {
-    return JSON.parse(readFileSync17(path71, "utf8"));
+    return JSON.parse(readFileSync18(path71, "utf8"));
   } catch {
     return void 0;
   }
@@ -7269,7 +7386,7 @@ function reconcileActivity(sessionId, activity2) {
     return;
   }
   const path71 = activityPath(sessionId);
-  mkdirSync9(dirname16(path71), { recursive: true });
+  mkdirSync9(dirname17(path71), { recursive: true });
   writeFileSync19(path71, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
@@ -7294,7 +7411,7 @@ function reportPhaseActivity(item, phaseNumber, totalPhases, phase, claudeSessio
 }
 
 // src/commands/backlog/resolvePhaseResult.ts
-import { existsSync as existsSync24, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync25, unlinkSync as unlinkSync4 } from "fs";
 import chalk42 from "chalk";
 
 // src/commands/backlog/handleIncompletePhase.ts
@@ -7316,7 +7433,7 @@ async function handleIncompletePhase() {
 // src/commands/backlog/resolvePhaseResult.ts
 function cleanupSignal() {
   const statusPath = getSignalPath();
-  if (statusPath && existsSync24(statusPath)) {
+  if (statusPath && existsSync25(statusPath)) {
     unlinkSync4(statusPath);
   }
 }
@@ -7327,7 +7444,7 @@ async function isTerminalStatus(itemId2) {
 }
 async function resolvePhaseResult(phaseIndex, itemId2) {
   const signalPath = getSignalPath();
-  if (!signalPath || !existsSync24(signalPath)) {
+  if (!signalPath || !existsSync25(signalPath)) {
     if (await isTerminalStatus(itemId2)) return { kind: "abort" };
     const action = await handleIncompletePhase();
     if (action === "abort") return { kind: "abort" };
@@ -7566,13 +7683,13 @@ async function findSessionJsonlPath(sessionId) {
 // src/commands/backlog/verifyResumeConversation.ts
 async function verifyResumeConversation(itemId2, resumeSessionId, phaseLabel2) {
   if (await findSessionJsonlPath(resumeSessionId)) return true;
-  const message2 = `${phaseLabel2}: resume found no conversation for session ${resumeSessionId}; phase not advanced`;
+  const message3 = `${phaseLabel2}: resume found no conversation for session ${resumeSessionId}; phase not advanced`;
   console.error(chalk43.red(`
-${message2}`));
-  appendDaemonLog(`backlog run ${itemId2}: ${message2}`);
+${message3}`));
+  appendDaemonLog(`backlog run ${itemId2}: ${message3}`);
   try {
     const { orm } = await getReady();
-    await appendComment(orm, itemId2, `Resume failed \u2014 ${message2}`);
+    await appendComment(orm, itemId2, `Resume failed \u2014 ${message3}`);
   } catch {
   }
   return false;
@@ -8183,21 +8300,21 @@ import chalk61 from "chalk";
 import { WebSocketServer } from "ws";
 
 // src/shared/getInstallDir.ts
-import { execSync as execSync29 } from "child_process";
-import { dirname as dirname18, resolve as resolve7 } from "path";
+import { execSync as execSync30 } from "child_process";
+import { dirname as dirname19, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname18(__filename2);
+var __dirname3 = dirname19(__filename2);
 function getInstallDir() {
-  return resolve7(__dirname3, "..");
+  return resolve8(__dirname3, "..");
 }
 function isGitRepo(dir) {
   try {
-    const result = execSync29("git rev-parse --show-toplevel", {
+    const result = execSync30("git rev-parse --show-toplevel", {
       cwd: dir,
       stdio: "pipe"
     }).toString().trim();
-    return resolve7(result) === resolve7(dir);
+    return resolve8(result) === resolve8(dir);
   } catch {
     return false;
   }
@@ -8210,11 +8327,11 @@ import {
 import chalk57 from "chalk";
 
 // src/lib/openBrowser.ts
-import { execSync as execSync30 } from "child_process";
+import { execSync as execSync31 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync30(cmd, { stdio: "ignore" });
+      execSync31(cmd, { stdio: "ignore" });
       return true;
     } catch {
     }
@@ -8332,7 +8449,7 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync10,
   openSync as openSync2,
-  statSync,
+  statSync as statSync2,
   unlinkSync as unlinkSync5,
   writeSync
 } from "fs";
@@ -8381,7 +8498,7 @@ function tryCreateLock() {
 }
 function isLockStale() {
   try {
-    return Date.now() - statSync(daemonPaths.spawnLock).mtimeMs > STALE_LOCK_MS;
+    return Date.now() - statSync2(daemonPaths.spawnLock).mtimeMs > STALE_LOCK_MS;
   } catch {
     return true;
   }
@@ -8393,16 +8510,16 @@ function releaseSpawnLock() {
   }
 }
 function spawnDaemon(reason4) {
-  const log = openSync2(daemonPaths.log, "a");
+  const log2 = openSync2(daemonPaths.log, "a");
   const child = spawn4(process.execPath, [process.argv[1], "daemon", "run"], {
     detached: true,
-    stdio: ["ignore", log, log],
+    stdio: ["ignore", log2, log2],
     env: { ...process.env, ASSIST_DAEMON_SPAWN_REASON: reason4 }
   });
   child.unref();
 }
 function delay(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 
 // src/commands/sessions/daemon/isWindowsCwd.ts
@@ -8439,10 +8556,10 @@ function gitInvocation(cwd, args) {
 }
 function git2(cwd, args) {
   const { file, argv, options: options2 } = gitInvocation(cwd, args);
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     execFile2(file, argv, options2, (error, stdout) => {
       if (error) reject(error);
-      else resolve20(stdout.toString());
+      else resolve21(stdout.toString());
     });
   });
 }
@@ -8514,20 +8631,20 @@ function gitCommonDir(cwd) {
 }
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function getStoreDir() {
-  return join22(homedir11(), ".assist");
+  return join23(homedir11(), ".assist");
 }
 function getStorePath(filename) {
-  return join22(getStoreDir(), filename);
+  return join23(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path71 = getStorePath(filename);
-  if (existsSync25(path71)) {
+  if (existsSync26(path71)) {
     try {
-      return JSON.parse(readFileSync18(path71, "utf8"));
+      return JSON.parse(readFileSync19(path71, "utf8"));
     } catch {
       return {};
     }
@@ -8536,7 +8653,7 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   writeFileSync20(getStorePath(filename), JSON.stringify(data, null, 2));
@@ -8591,16 +8708,16 @@ function hostedGroup(cwd, origin, clone) {
 
 // src/shared/createBundleHandler.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync19, statSync as statSync2 } from "fs";
-import { dirname as dirname19, join as join23 } from "path";
+import { readFileSync as readFileSync20, statSync as statSync3 } from "fs";
+import { dirname as dirname20, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
-  const file = join23(dirname19(fileURLToPath4(importMetaUrl)), bundlePath);
+  const file = join24(dirname20(fileURLToPath4(importMetaUrl)), bundlePath);
   let cache4;
   return (req, res) => {
-    const mtimeMs = statSync2(file).mtimeMs;
+    const mtimeMs = statSync3(file).mtimeMs;
     if (cache4?.mtimeMs !== mtimeMs) {
-      const body = readFileSync19(file, "utf8");
+      const body = readFileSync20(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache4 = { body, etag, mtimeMs };
     }
@@ -8729,15 +8846,15 @@ async function loadItemSummaries(orm, origin) {
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 
 // src/commands/backlog/cloneTargetDir.ts
-import { join as join24, resolve as resolve8 } from "path";
+import { join as join25, resolve as resolve9 } from "path";
 function cloneTargetDir(origin, baseDir) {
   if (origin.startsWith("local:")) return null;
   const repoName = origin.split("/").filter(Boolean).pop();
   if (!repoName) return null;
-  return resolve8(join24(baseDir, repoName));
+  return resolve9(join25(baseDir, repoName));
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
@@ -8745,7 +8862,7 @@ function resolveRepoLocation(origin, knownCwd, baseDir) {
   if (knownCwd) return { cwd: knownCwd };
   const target = cloneTargetDir(origin, baseDir);
   if (!target) return {};
-  if (existsSync26(target) && getCurrentOrigin(target) === origin)
+  if (existsSync27(target) && getCurrentOrigin(target) === origin)
     return { cwd: target };
   return { cloneTarget: target };
 }
@@ -8854,12 +8971,12 @@ async function loadVisibleItems(req) {
 
 // src/commands/backlog/web/parseStatusBody.ts
 function readBody(req) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
-    req.on("end", () => resolve20(body));
+    req.on("end", () => resolve21(body));
     req.on("error", reject);
   });
 }
@@ -9441,13 +9558,13 @@ async function diffScopes(req, res) {
 
 // src/commands/sessions/web/fileContent.ts
 import { readFile, stat as stat2 } from "fs/promises";
-import { isAbsolute, relative as relative2, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10 } from "path";
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 function resolveWithinCwd(cwd, path71) {
-  const root = resolve9(toGitCwd(cwd));
-  const target = resolve9(root, path71);
+  const root = resolve10(toGitCwd(cwd));
+  const target = resolve10(root, path71);
   const rel = relative2(root, target);
-  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
 }
 async function fileContent(req, res) {
@@ -9516,13 +9633,13 @@ function readRawConfigLayers(cwd) {
   const global = loadRawYaml(getGlobalConfigPath());
   if (!global.repos)
     return {
-      project: loadRawYaml(getConfigPathFrom(cwd)),
+      project: loadRawYaml(projectConfigPathFrom(cwd)),
       global,
       repoOverride: {}
     };
   const origin = getCurrentOrigin(cwd);
   return {
-    project: loadRawYaml(getConfigPathFrom(cwd)),
+    project: loadRawYaml(projectConfigPathFrom(cwd)),
     global,
     repoOverride: resolveRepoOverride(global, origin),
     repoKey: matchRepoConfigKey(global, origin)
@@ -9710,20 +9827,20 @@ function handleServerRuns(req, res) {
 
 // src/commands/sessions/web/getReviewSynthesis.ts
 import { execFile as execFile4 } from "child_process";
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir12 } from "os";
-import { basename as basename6, join as join26 } from "path";
+import { basename as basename8, join as join27 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync27, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { basename as basename5, dirname as dirname20, join as join25 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { basename as basename7, dirname as dirname21, join as join26 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
-  const branchKeyPath = join25(repoReviewsDir, `${branch2}-`);
-  const parent = dirname20(branchKeyPath);
-  const branchPrefix = basename5(branchKeyPath);
-  if (!existsSync27(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join25(parent, name, "synthesis.md")).filter((path71) => existsSync27(path71)).map((path71) => ({ path: path71, mtime: statSync3(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const branchKeyPath = join26(repoReviewsDir, `${branch2}-`);
+  const parent = dirname21(branchKeyPath);
+  const branchPrefix = basename7(branchKeyPath);
+  if (!existsSync28(parent)) return null;
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join26(parent, name, "synthesis.md")).filter((path71) => existsSync28(path71)).map((path71) => ({ path: path71, mtime: statSync4(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -9740,11 +9857,11 @@ async function resolveSynthesisPath(cwd) {
     runGit(cwd, ["rev-parse", "--show-toplevel"]),
     runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
-  const repoReviewsDir = join26(
+  const repoReviewsDir = join27(
     homedir12(),
     ".assist",
     "reviews",
-    basename6(repoRoot)
+    basename8(repoRoot)
   );
   return findSynthesisForBranch(repoReviewsDir, branch2);
 }
@@ -9757,7 +9874,7 @@ async function getReviewSynthesis(req, res) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync20(path71, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path71, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -9888,7 +10005,7 @@ import * as os3 from "os";
 import * as path25 from "path";
 
 // src/shared/checkCliAvailable.ts
-import { execSync as execSync31 } from "child_process";
+import { execSync as execSync32 } from "child_process";
 function checkCliAvailable(cli) {
   const binary = cli.split(/\s+/)[0];
   const opts = {
@@ -9896,11 +10013,11 @@ function checkCliAvailable(cli) {
     stdio: ["ignore", "pipe", "pipe"]
   };
   try {
-    execSync31(`command -v ${binary}`, opts);
+    execSync32(`command -v ${binary}`, opts);
     return true;
   } catch {
     try {
-      execSync31(`where ${binary}`, opts);
+      execSync32(`where ${binary}`, opts);
       return true;
     } catch {
       return false;
@@ -9991,8 +10108,8 @@ function subsequenceScore(text17, query) {
 function scoreFilePath(path71, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename19 = path71.slice(path71.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename19, needle);
+  const basename21 = path71.slice(path71.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename21, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
   return subsequenceScore(path71, needle);
 }
@@ -10389,17 +10506,17 @@ async function stopDaemon() {
   }
 }
 function closedBeforeTimeout(socket) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve20(false);
+      resolve21(false);
     }, STOP_TIMEOUT_MS);
     socket.resume();
     socket.on("error", () => {
     });
     socket.once("close", () => {
       clearTimeout(timer);
-      resolve20(true);
+      resolve21(true);
     });
   });
 }
@@ -10450,8 +10567,8 @@ async function restartWeb(req, res, deps2 = {}) {
     respondJson(res, 400, { error: "Invalid target" });
     return;
   }
-  await new Promise((resolve20) => {
-    res.once("finish", resolve20);
+  await new Promise((resolve21) => {
+    res.once("finish", resolve21);
     respondJson(res, 200, { ok: true });
   });
   if (target === "daemon" || target === "both") {
@@ -10966,7 +11083,7 @@ async function readRequestBuffer(req, limit) {
 // src/commands/sessions/web/writeTempImage.ts
 import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { extname, join as join28 } from "path";
+import { extname, join as join29 } from "path";
 var EXT_BY_MIME = {
   "image/png": "png",
   "image/jpeg": "jpg",
@@ -10986,8 +11103,8 @@ function safeBaseName(name) {
   return base.replace(/^-+|-+$/g, "").slice(0, 60) || "screenshot";
 }
 async function writeTempImage(name, contentType, body) {
-  const dir = await mkdtemp(join28(tmpdir(), "assist-pr-img-"));
-  const filePath = join28(
+  const dir = await mkdtemp(join29(tmpdir(), "assist-pr-img-"));
+  const filePath = join29(
     dir,
     `${safeBaseName(name)}.${pickExtension(name, contentType)}`
   );
@@ -11035,7 +11152,7 @@ async function uploadPrImage(req, res) {
 
 // src/commands/sessions/web/createCssHandler.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 function createCssHandler(packageEntry) {
@@ -11043,7 +11160,7 @@ function createCssHandler(packageEntry) {
   return (req, res) => {
     if (!cache4) {
       const resolved = require3.resolve(packageEntry);
-      const body = readFileSync21(resolved, "utf8");
+      const body = readFileSync22(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache4 = { body, etag };
     }
@@ -11193,8 +11310,8 @@ async function runRestartItem(item, { runRestartDaemon, reExec }) {
       reExec();
     }
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
-    console.error(chalk58.red(`Restart failed: ${message2}`));
+    const message3 = error instanceof Error ? error.message : String(error);
+    console.error(chalk58.red(`Restart failed: ${message3}`));
   }
 }
 
@@ -11294,10 +11411,10 @@ function renderRestartMenu(items2, selected) {
 }
 
 // src/commands/sessions/web/restartMenu/createMenuState.ts
-function createMenuState(items2, log) {
+function createMenuState(items2, log2) {
   let open = false;
   let selected = firstEnabledIndex(items2);
-  const render = () => log(renderRestartMenu(items2, selected));
+  const render = () => log2(renderRestartMenu(items2, selected));
   return {
     isOpen: () => open,
     open() {
@@ -11308,7 +11425,7 @@ function createMenuState(items2, log) {
     close() {
       if (!open) return;
       open = false;
-      log.clear();
+      log2.clear();
     },
     move(direction) {
       selected = nextIndex(items2, selected, direction);
@@ -11365,8 +11482,8 @@ function installRestartMenu(options2 = {}) {
   const { stdin, out, toggleKey, exit, restartDaemonFn, reExecFn, items: items2 } = resolveOptions(options2);
   if (!stdin.isTTY) return () => {
   };
-  const log = createLogUpdate(out);
-  const menu = createMenuState(items2, log);
+  const log2 = createLogUpdate(out);
+  const menu = createMenuState(items2, log2);
   const reExec = () => reExecFn({ beforeExec: () => cleanup(), exit });
   const { isBusy, activate } = createActivate(menu, {
     runRestartDaemon: restartDaemonFn,
@@ -11582,13 +11699,13 @@ async function beginAssociation(id, options2, clearPatch, label2) {
 }
 
 // src/commands/backlog/associate-github/fetchGithubIssueTitle.ts
-import { execSync as execSync32 } from "child_process";
+import { execSync as execSync33 } from "child_process";
 function fetchGithubIssueTitle(issue) {
   const match = /^([^/]+)\/([^#]+)#(\d+)$/.exec(issue);
   if (!match) return void 0;
   const [, owner, repo, number] = match;
   try {
-    const result = execSync32(
+    const result = execSync33(
       `gh issue view ${number} -R ${owner}/${repo} --json title`,
       { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
     );
@@ -11655,12 +11772,12 @@ import chalk66 from "chalk";
 import { eq as eq22 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
-import { execSync as execSync33 } from "child_process";
+import { execSync as execSync34 } from "child_process";
 import chalk65 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
-    result = execSync33(
+    result = execSync34(
       `acli jira workitem view ${issueKey} -f ${fields} --json`,
       { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -11731,7 +11848,7 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/cloneRepo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import chalk67 from "chalk";
 
@@ -11747,8 +11864,8 @@ function originToSshUrl(origin) {
 }
 
 // src/commands/backlog/cloneRepo.ts
-function fail2(message2) {
-  console.log(chalk67.red(message2));
+function fail2(message3) {
+  console.log(chalk67.red(message3));
   process.exitCode = 1;
 }
 async function cloneRepo(originRaw) {
@@ -11767,7 +11884,7 @@ async function cloneRepo(originRaw) {
   if (!target) {
     return fail2(`Could not derive a repository name from "${origin}".`);
   }
-  if (existsSync28(target)) {
+  if (existsSync29(target)) {
     return fail2(`Clone target already exists: ${target}`);
   }
   await mkdir3(baseDir, { recursive: true });
@@ -12190,9 +12307,9 @@ function ensureRemoteOrigin() {
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync22, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync23, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -12232,15 +12349,15 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join29(tmpdir2(), "assist-"));
-  const filePath = join29(dir, "description.md");
+  const dir = mkdtempSync(join30(tmpdir2(), "assist-"));
+  const filePath = join30(dir, "description.md");
   writeFileSync21(filePath, "");
   const result = spawnSync3(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
     unlinkSync6(filePath);
     return void 0;
   }
-  const content = readFileSync22(filePath, "utf8").trim();
+  const content = readFileSync23(filePath, "utf8").trim();
   unlinkSync6(filePath);
   return content || void 0;
 }
@@ -12356,7 +12473,7 @@ function parsePreviewDecision(line, requestId) {
 
 // src/commands/sessions/shared/requestPreviewDecision.ts
 function requestPreviewDecision(request) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error, decision) => {
@@ -12364,7 +12481,7 @@ function requestPreviewDecision(request) {
         settled = true;
         socket.destroy();
         if (error) reject(error);
-        else resolve20(decision);
+        else resolve21(decision);
       };
       readSocketLines(socket, (line) => {
         const incoming = parsePreviewDecision(line, request.requestId);
@@ -12507,10 +12624,10 @@ import { randomUUID as randomUUID3 } from "crypto";
 import chalk79 from "chalk";
 
 // src/commands/backlog/readJsonPayload.ts
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import chalk78 from "chalk";
-function fail3(message2) {
-  console.error(chalk78.red(message2));
+function fail3(message3) {
+  console.error(chalk78.red(message3));
   process.exit(1);
 }
 function describe(error) {
@@ -12519,7 +12636,7 @@ function describe(error) {
 async function readSource(source) {
   try {
     if (source === "-") return (await readStdinBuffer()).toString("utf8");
-    return readFileSync23(source, "utf8");
+    return readFileSync24(source, "utf8");
   } catch (error) {
     return fail3(
       `Cannot read the payload from ${source === "-" ? "stdin" : source}: ${describe(error)}`
@@ -12679,8 +12796,8 @@ function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
 }
 
 // src/commands/backlog/link.ts
-function fail4(message2) {
-  console.log(chalk81.red(message2));
+function fail4(message3) {
+  console.log(chalk81.red(message3));
   return void 0;
 }
 function parseLinkType(type) {
@@ -12802,8 +12919,8 @@ Pass the full origin.`
 }
 
 // src/commands/backlog/move-repo/index.ts
-function fail5(message2) {
-  console.log(chalk84.red(message2));
+function fail5(message3) {
+  console.log(chalk84.red(message3));
   process.exitCode = 1;
 }
 async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
@@ -12958,11 +13075,11 @@ async function handleLaunchSignal(slashCommand, once) {
       await next({ allowEdits: true, once });
     }
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
+    const message3 = error instanceof Error ? error.message : String(error);
     console.error(
       chalk86.yellow(
         `
-Could not complete post-run step (${message2}).
+Could not complete post-run step (${message3}).
 This is usually a transient database/network blip \u2014 the work is saved and the session is safe to resume.`
       )
     );
@@ -14334,7 +14451,7 @@ function registerBranch(program2) {
 }
 
 // src/commands/cliHook/index.ts
-import { basename as basename7 } from "path";
+import { basename as basename9 } from "path";
 
 // src/shared/splitCompound.ts
 import { parse } from "shell-quote";
@@ -14520,7 +14637,7 @@ function findBuiltinDenyRaw(rawCommand) {
 }
 
 // src/shared/isApprovedRead.ts
-import { resolve as resolve11, sep } from "path";
+import { resolve as resolve12, sep } from "path";
 
 // src/shared/tokenize.ts
 function tokenize(command) {
@@ -14601,29 +14718,29 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname21, resolve as resolve10 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname22, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
-var __dirname4 = dirname21(__filename3);
+var __dirname4 = dirname22(__filename3);
 function packageRoot() {
   return __dirname4;
 }
 function readLines(path71) {
-  if (!existsSync29(path71)) return [];
-  return readFileSync24(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
+  if (!existsSync30(path71)) return [];
+  return readFileSync25(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
 function getCliReadsLines() {
   if (!cachedReads) {
-    cachedReads = readLines(resolve10(packageRoot(), "allowed.cli-reads"));
+    cachedReads = readLines(resolve11(packageRoot(), "allowed.cli-reads"));
   }
   return cachedReads;
 }
 function getCliWritesLines() {
   if (!cachedWrites) {
-    cachedWrites = readLines(resolve10(packageRoot(), "allowed.cli-writes"));
+    cachedWrites = readLines(resolve11(packageRoot(), "allowed.cli-writes"));
   }
   return cachedWrites;
 }
@@ -14632,7 +14749,7 @@ function loadCliReads() {
 }
 function saveCliReads(commands) {
   writeFileSync22(
-    resolve10(packageRoot(), "allowed.cli-reads"),
+    resolve11(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
   );
@@ -14657,14 +14774,14 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join30(homedir14(), ".claude", "settings.json"),
-    join30(process.cwd(), ".claude", "settings.json"),
-    join30(process.cwd(), ".claude", "settings.local.json")
+    join31(homedir14(), ".claude", "settings.json"),
+    join31(process.cwd(), ".claude", "settings.json"),
+    join31(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -14673,9 +14790,9 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync30(filePath)) return [];
+  if (!existsSync31(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync25(filePath, "utf8"));
+    const data = JSON.parse(readFileSync26(filePath, "utf8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -14754,19 +14871,19 @@ function isCdToCwd(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length > 2) return false;
   if (parts.length === 1) return false;
-  const resolved = resolve11(normalizeMsysPath(parts[1]));
-  return resolved === resolve11(process.cwd());
+  const resolved = resolve12(normalizeMsysPath(parts[1]));
+  return resolved === resolve12(process.cwd());
 }
 function isCdToReadAllowedDir(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length !== 2) return void 0;
-  const target = resolve11(normalizeMsysPath(parts[1]));
+  const target = resolve12(normalizeMsysPath(parts[1]));
   for (const entry of readSettingsPerms("allow")) {
     const m = entry.match(READ_RE);
     if (!m) continue;
     const base = globBaseDir(m[1]);
     if (!base) continue;
-    const resolved = resolve11(normalizeMsysPath(base));
+    const resolved = resolve12(normalizeMsysPath(base));
     if (target === resolved || target.startsWith(resolved + sep)) {
       return `cd to Read-allowed directory: ${entry}`;
     }
@@ -14866,11 +14983,11 @@ function decideCommand(toolName, rawCommand) {
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync12 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join31(homedir15(), ".assist");
+  return join32(homedir15(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -14889,7 +15006,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync12(dbDir, { recursive: true });
-  const db = new Database(join31(dbDir, "assist.db"));
+  const db = new Database(join32(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -14939,7 +15056,7 @@ async function cliHook() {
       logDeniedToolCall({
         tool: input.toolName,
         command: input.command,
-        repo: basename7(process.cwd()),
+        repo: basename9(process.cwd()),
         sessionId: process.env.CLAUDE_SESSION_ID,
         denyReason: decision.permissionDecisionReason
       });
@@ -14985,9 +15102,9 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync13, readFileSync as readFileSync26, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/commands/permitCliReads/assertCliExists.ts
 function assertCliExists(cli) {
@@ -15078,12 +15195,12 @@ function hasSubcommands(helpText) {
 // src/commands/permitCliReads/runHelp.ts
 import { exec as exec2 } from "child_process";
 function runHelp(args) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     exec2(
       `${args.join(" ")} --help`,
       { encoding: "utf8", timeout: 3e4 },
       (_err, stdout, stderr) => {
-        resolve20(stdout || stderr || "");
+        resolve21(stdout || stderr || "");
       }
     );
   });
@@ -15250,15 +15367,15 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join32(homedir16(), ".assist", `cli-discover-${safeName}.log`);
+  return join33(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path71 = logPath(cli);
-  if (!existsSync31(path71)) return void 0;
-  return readFileSync26(path71, "utf8");
+  if (!existsSync32(path71)) return void 0;
+  return readFileSync27(path71, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join32(homedir16(), ".assist");
+  const dir = join33(homedir16(), ".assist");
   mkdirSync13(dir, { recursive: true });
   writeFileSync23(logPath(cli), output);
 }
@@ -15311,15 +15428,15 @@ function loadDenyConfig(global) {
 }
 
 // src/commands/deny/denyAdd.ts
-function denyAdd(pattern2, message2, options2) {
+function denyAdd(pattern2, message3, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   if (deny.some((r) => r.pattern === pattern2)) {
     console.log(chalk115.yellow(`Deny rule already exists for: ${pattern2}`));
     return;
   }
-  deny.push({ pattern: pattern2, message: message2 });
+  deny.push({ pattern: pattern2, message: message3 });
   saveDeny(deny);
-  console.log(chalk115.green(`Added deny rule: ${pattern2} \u2192 ${message2}`));
+  console.log(chalk115.green(`Added deny rule: ${pattern2} \u2192 ${message3}`));
 }
 
 // src/commands/deny/denyList.ts
@@ -15401,22 +15518,22 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync33, readFileSync as readFileSync28, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
 import chalk118 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
 import { homedir as homedir17 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function getRestrictedDir() {
-  return join33(homedir17(), ".assist", "restricted");
+  return join34(homedir17(), ".assist", "restricted");
 }
 function getPinStatePath(pin) {
-  return join33(getRestrictedDir(), `code-comment-${pin}.json`);
+  return join34(getRestrictedDir(), `code-comment-${pin}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync as readdirSync3, statSync as statSync4, unlinkSync as unlinkSync7 } from "fs";
-import { join as join34 } from "path";
+import { readdirSync as readdirSync3, statSync as statSync5, unlinkSync as unlinkSync7 } from "fs";
+import { join as join35 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
@@ -15427,9 +15544,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path71 = join34(dir, entry);
+    const path71 = join35(dir, entry);
     try {
-      if (statSync4(path71).mtimeMs < cutoff) unlinkSync7(path71);
+      if (statSync5(path71).mtimeMs < cutoff) unlinkSync7(path71);
     } catch {
       continue;
     }
@@ -15437,12 +15554,12 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync28 } from "fs";
 function readPinState(pin) {
   const path71 = getPinStatePath(pin);
-  if (!existsSync32(path71)) return void 0;
+  if (!existsSync33(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync27(path71, "utf8"));
+    const state = JSON.parse(readFileSync28(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -15459,12 +15576,12 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync33(state.file)) {
+  if (!existsSync34(state.file)) {
     console.error(chalk118.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
   }
-  const original = readFileSync28(state.file, "utf8");
+  const original = readFileSync29(state.file, "utf8");
   const lines = original.split("\n");
   const index3 = state.line - 1;
   if (index3 > lines.length) {
@@ -16061,10 +16178,10 @@ function formatResultLine(entry, failing) {
 }
 
 // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
-import { execSync as execSync34 } from "child_process";
+import { execSync as execSync35 } from "child_process";
 import path28 from "path";
 function git3(command) {
-  return execSync34(command, { encoding: "utf8" });
+  return execSync35(command, { encoding: "utf8" });
 }
 function toAbsolute(root, repoRelative) {
   return path28.resolve(root, repoRelative);
@@ -16481,21 +16598,21 @@ import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync26 } from "fs"
 import chalk134 from "chalk";
 
 // src/commands/dbMigration/getMigrationPinPath.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 function getMigrationPinPath(pin) {
-  return join35(getRestrictedDir(), `db-migration-pin-${pin}.json`);
+  return join36(getRestrictedDir(), `db-migration-pin-${pin}.json`);
 }
 function getMigrationApprovalPath(migrationId) {
-  return join35(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
+  return join36(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync34, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync30 } from "fs";
 function readMigrationPinState(pin) {
   const path71 = getMigrationPinPath(pin);
-  if (!existsSync34(path71)) return void 0;
+  if (!existsSync35(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync29(path71, "utf8"));
+    const state = JSON.parse(readFileSync30(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -16582,7 +16699,7 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
 import chalk136 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -16591,11 +16708,11 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync35(indexPath)) {
+  if (!existsSync36(indexPath)) {
     console.log(chalk136.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync30(indexPath, "utf8");
+  const content = readFileSync31(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk136.dim("Trailing slash script already present"));
     return;
@@ -16620,35 +16737,35 @@ function registerDeploy(program2) {
 
 // src/commands/devlog/list/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { basename as basename9 } from "path";
+import { basename as basename11 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir18 } from "os";
-import { join as join36 } from "path";
-var BLOG_REPO_ROOT = join36(homedir18(), "git/blog");
+import { join as join37 } from "path";
+var BLOG_REPO_ROOT = join37(homedir18(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join36(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join37(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
 }
 
 // src/commands/devlog/shared.ts
-import { execSync as execSync35 } from "child_process";
+import { execSync as execSync36 } from "child_process";
 import chalk137 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
-import { basename as basename8, join as join37 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync32 } from "fs";
+import { basename as basename10, join as join38 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join37(process.cwd(), "package.json");
-  if (existsSync36(packageJsonPath)) {
+  const packageJsonPath = join38(process.cwd(), "package.json");
+  if (existsSync37(packageJsonPath)) {
     try {
-      const content = readFileSync31(packageJsonPath, "utf8");
+      const content = readFileSync32(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -16656,13 +16773,13 @@ function getRepoName() {
     } catch {
     }
   }
-  return basename8(process.cwd());
+  return basename10(process.cwd());
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync32 } from "fs";
-import { join as join38 } from "path";
-var DEVLOG_DIR = join38(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync as readdirSync4, readFileSync as readFileSync33 } from "fs";
+import { join as join39 } from "path";
+var DEVLOG_DIR = join39(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -16690,7 +16807,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync4(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync32(join38(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync33(join39(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -16726,7 +16843,7 @@ function loadAllDevlogLatestDates() {
 // src/commands/devlog/shared.ts
 function getCommitFiles(hash) {
   try {
-    const output = execSync35(`git show --name-only --format="" ${hash}`, {
+    const output = execSync36(`git show --name-only --format="" ${hash}`, {
       encoding: "utf8"
     });
     return output.trim().split("\n").filter(Boolean);
@@ -16760,14 +16877,14 @@ function parseGitLogCommits(output, ignore3, afterDate) {
   const commitsByDate = /* @__PURE__ */ new Map();
   for (const line of lines) {
     const [date, hash, ...messageParts] = line.split("|");
-    const message2 = messageParts.join("|");
+    const message3 = messageParts.join("|");
     if (afterDate && date <= afterDate) {
       continue;
     }
     const files = getCommitFiles(hash);
     if (!shouldIgnoreCommit(files, ignore3)) {
       const existing = commitsByDate.get(date) || [];
-      existing.push({ date, hash, message: message2, files });
+      existing.push({ date, hash, message: message3, files });
       commitsByDate.set(date, existing);
     }
   }
@@ -16792,7 +16909,7 @@ function list3(options2) {
   const config = loadConfig();
   const days = options2.days ?? 30;
   const ignore3 = options2.ignore ?? config.devlog?.ignore ?? [];
-  const repoName = basename9(process.cwd());
+  const repoName = basename11(process.cwd());
   const skipDays = loadBlogSkipDays(repoName);
   const devlogEntries = loadDevlogEntries(repoName);
   const args = ["log"];
@@ -16822,11 +16939,11 @@ function list3(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execFileSync as execFileSync4, execSync as execSync36 } from "child_process";
+import { execFileSync as execFileSync4, execSync as execSync37 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
-    const content = execSync36(`git show ${hash}:package.json`, {
+    const content = execSync37(`git show ${hash}:package.json`, {
       encoding: "utf8"
     });
     const pkg = JSON.parse(content);
@@ -16999,7 +17116,7 @@ function next2(options2) {
 }
 
 // src/commands/devlog/repos/index.ts
-import { execSync as execSync37 } from "child_process";
+import { execSync as execSync38 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
 import chalk141 from "chalk";
@@ -17034,7 +17151,7 @@ function getStatus(lastPush, lastDevlog) {
   return lastDevlog < lastPush ? "outdated" : "ok";
 }
 function fetchRepos(days, all) {
-  const json = execSync37(
+  const json = execSync38(
     "gh repo list staff0rd --json name,pushedAt,isArchived --limit 200",
     { encoding: "utf8" }
   );
@@ -17078,11 +17195,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync29 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import chalk142 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join39(BLOG_REPO_ROOT, "assist.yml");
+  return join40(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -17163,16 +17280,16 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync5 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import chalk144 from "chalk";
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import path30 from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path30.dirname(current)) {
-    if (existsSync37(path30.join(current, ".git"))) {
+    if (existsSync38(path30.join(current, ".git"))) {
       return current;
     }
     current = path30.dirname(current);
@@ -17191,7 +17308,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join40(debugDir, file);
+    const dllPath = join41(debugDir, file);
     try {
       const fd = openSync3(dllPath, "r+");
       closeSync3(fd);
@@ -17209,13 +17326,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join40(dir, "bin", "Debug"));
+    const locked = isLockedDll(join41(dir, "bin", "Debug"));
     if (locked) return locked;
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry) || entry === "bin" || entry.startsWith("."))
       continue;
-    const found = findFirstLockedDll(join40(dir, entry));
+    const found = findFirstLockedDll(join41(dir, entry));
     if (found) return found;
   }
   return null;
@@ -17238,11 +17355,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync33 } from "fs";
+import { readFileSync as readFileSync34 } from "fs";
 import path31 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync33(csprojPath, "utf8");
+  const content = readFileSync34(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -17259,7 +17376,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path31.resolve(dir, ref);
     try {
-      readFileSync33(childAbs);
+      readFileSync34(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -17284,7 +17401,7 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync34, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync35, statSync as statSync6 } from "fs";
 import path32 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
@@ -17300,7 +17417,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path32.join(dir, entry);
     try {
-      const stat3 = statSync5(full);
+      const stat3 = statSync6(full);
       if (stat3.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat3.isDirectory()) {
@@ -17319,7 +17436,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync34(sln, "utf8");
+      const content = readFileSync35(sln, "utf8");
       if (pattern2.test(content)) {
         matches.push(path32.relative(repoRoot, sln));
       }
@@ -17383,12 +17500,12 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import path33 from "path";
 import chalk146 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path33.resolve(csprojPath);
-  if (!existsSync38(resolved)) {
+  if (!existsSync39(resolved)) {
     console.error(chalk146.red(`File not found: ${resolved}`));
     process.exit(1);
   }
@@ -17414,7 +17531,7 @@ async function deps(csprojPath, options2) {
 }
 
 // src/commands/dotnet/getChangedCsFiles.ts
-import { execSync as execSync38 } from "child_process";
+import { execSync as execSync39 } from "child_process";
 var SCOPE_ALL = "all";
 var SCOPE_BASE = "base:";
 var SCOPE_COMMIT = "commit:";
@@ -17438,7 +17555,7 @@ function getChangedCsFiles(scope) {
   } else {
     cmd = "git diff --name-only HEAD";
   }
-  const output = execSync38(cmd, { encoding: "utf8" }).trim();
+  const output = execSync39(cmd, { encoding: "utf8" }).trim();
   if (output === "") return [];
   return output.split("\n").filter((f) => f.toLowerCase().endsWith(".cs"));
 }
@@ -17556,17 +17673,17 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import path34 from "path";
 import chalk150 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync7 } from "fs";
-import { dirname as dirname22, join as join41 } from "path";
+import { dirname as dirname23, join as join42 } from "path";
 import chalk149 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join41(dir, f));
+    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join42(dir, f));
   } catch {
     return [];
   }
@@ -17587,7 +17704,7 @@ function findSolution() {
       process.exit(1);
     }
     if (current === ceiling) break;
-    current = dirname22(current);
+    current = dirname23(current);
   }
   console.error(chalk149.red("No .sln file found between cwd and repo root"));
   process.exit(1);
@@ -17597,7 +17714,7 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path34.resolve(sln);
-    if (!existsSync39(resolved)) {
+    if (!existsSync40(resolved)) {
       console.error(chalk150.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -17636,14 +17753,14 @@ function parseInspectReport(json) {
 }
 
 // src/commands/dotnet/runInspectCode.ts
-import { execSync as execSync39 } from "child_process";
-import { existsSync as existsSync40, readFileSync as readFileSync35, unlinkSync as unlinkSync10 } from "fs";
+import { execSync as execSync40 } from "child_process";
+import { existsSync as existsSync41, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import path35 from "path";
 import chalk151 from "chalk";
 function assertJbInstalled() {
   try {
-    execSync39("jb inspectcode --version", { stdio: "pipe" });
+    execSync40("jb inspectcode --version", { stdio: "pipe" });
   } catch {
     console.error(chalk151.red("jb is not installed. Install with:"));
     console.error(
@@ -17657,7 +17774,7 @@ function runInspectCode(slnPath, include, swea) {
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
-    execSync39(
+    execSync40(
       `jb inspectcode "${slnPath}" -o="${reportPath}"${includeFlag}${sweaFlag} --verbosity=OFF`,
       { stdio: "pipe" }
     );
@@ -17668,17 +17785,17 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk151.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync40(reportPath)) {
+  if (!existsSync41(reportPath)) {
     console.error(chalk151.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync35(reportPath, "utf8");
+  const xml = readFileSync36(reportPath, "utf8");
   unlinkSync10(reportPath);
   return xml;
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
-import { execSync as execSync40 } from "child_process";
+import { execSync as execSync41 } from "child_process";
 import chalk152 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
@@ -17689,7 +17806,7 @@ function resolveMsbuildPath() {
 function assertMsbuildInstalled() {
   const msbuild = resolveMsbuildPath();
   try {
-    execSync40(`"${msbuild}" -version`, { stdio: "pipe" });
+    execSync41(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
     console.error(chalk152.red(`msbuild not found at: ${msbuild}`));
     console.error(
@@ -17715,7 +17832,7 @@ function runRoslynInspect(slnPath) {
   const msbuild = resolveMsbuildPath();
   let output;
   try {
-    output = execSync40(
+    output = execSync41(
       `"${msbuild}" "${slnPath}" -t:Build -v:minimal -maxcpucount -p:EnforceCodeStyleInBuild=true -p:RunAnalyzersDuringBuild=true 2>&1`,
       { encoding: "utf8", stdio: "pipe", maxBuffer: 50 * 1024 * 1024 }
     );
@@ -17931,11 +18048,11 @@ function decideCommentGuard(input, existingContent) {
 }
 
 // src/commands/dbMigration/consumeMigrationApproval.ts
-import { existsSync as existsSync41, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync42, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
   const path71 = getMigrationApprovalPath(migrationId);
-  if (!existsSync41(path71)) return false;
+  if (!existsSync42(path71)) return false;
   try {
     unlinkSync11(path71);
     return true;
@@ -18055,7 +18172,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync4 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -18080,7 +18197,7 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join42(tmpdir5(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join43(tmpdir5(), `gh-query-${Date.now()}.graphql`);
   writeFileSync30(queryFile, mutation);
   try {
     const result = spawnSync4("gh", buildArgs2(queryFile, vars), {
@@ -18267,24 +18384,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   rmSync as rmSync3,
-  statSync as statSync6
+  statSync as statSync7
 } from "fs";
-import { basename as basename10, join as join45 } from "path";
+import { basename as basename12, join as join46 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join43(cwd, ".assist", "HANDOVER.md");
+  return join44(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join44(cwd, ".assist", "handovers");
+  return join45(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -18322,17 +18439,17 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync42(dir)) return [];
+  if (!existsSync43(dir)) return [];
   const out = [];
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-    const full = join45(dir, entry.name);
+    const full = join46(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
   return out;
 }
 async function migrateFile(orm, origin, file, createdAt) {
-  const content = readFileSync36(file, "utf8");
+  const content = readFileSync37(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -18344,13 +18461,13 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename10(file)) ?? statSync6(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename12(file)) ?? statSync7(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync42(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync6(handoverPath).mtime);
+  if (existsSync43(handoverPath)) {
+    await migrateFile(orm, origin, handoverPath, statSync7(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -18380,10 +18497,10 @@ function advisory(count8) {
   const noun = count8 === 1 ? "handover" : "handovers";
   return `${count8} unrecalled ${noun} for this repo. Run /recall to load.`;
 }
-function emit2(message2) {
+function emit2(message3) {
   const json = JSON.stringify({
     hookSpecificOutput: { hookEventName: "SessionStart" },
-    systemMessage: message2
+    systemMessage: message3
   });
   console.log(json);
   return json;
@@ -18562,16 +18679,16 @@ function acceptanceCriteria(issueKey) {
 }
 
 // src/commands/jira/jiraAuth.ts
-import { execSync as execSync41 } from "child_process";
+import { execSync as execSync42 } from "child_process";
 
 // src/shared/promptInput.ts
 import Enquirer from "enquirer";
 var prompts = Enquirer;
-async function promptInput(name, message2, initial) {
-  return exitOnCancel(new prompts.Input({ name, message: message2, initial }).run());
+async function promptInput(name, message3, initial) {
+  return exitOnCancel(new prompts.Input({ name, message: message3, initial }).run());
 }
-async function promptPassword(name, message2) {
-  return exitOnCancel(new prompts.Password({ name, message: message2 }).run());
+async function promptPassword(name, message3) {
+  return exitOnCancel(new prompts.Password({ name, message: message3 }).run());
 }
 
 // src/commands/jira/jiraAuth.ts
@@ -18597,7 +18714,7 @@ async function jiraAuth() {
       console.error("All fields are required.");
       process.exit(1);
     }
-    execSync41(`acli jira auth login --site ${site} --email "${email}" --token`, {
+    execSync42(`acli jira auth login --site ${site} --email "${email}" --token`, {
       encoding: "utf8",
       input: token,
       stdio: ["pipe", "inherit", "inherit"]
@@ -18698,8 +18815,8 @@ import chalk158 from "chalk";
 var RING_CAPACITY = 1e3;
 var ring = [];
 var sink;
-function daemonLog(message2) {
-  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`);
+function daemonLog(message3) {
+  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message3}`);
 }
 function relayDaemonLog(line) {
   emit3(`[windows] ${line}`);
@@ -18718,18 +18835,18 @@ function recentDaemonLogLines() {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync43 } from "fs";
-import { basename as basename12, dirname as dirname23 } from "path";
+import { existsSync as existsSync44 } from "fs";
+import { basename as basename14, dirname as dirname24 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename11, join as join46 } from "path";
+import { basename as basename13, join as join47 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
-  const name = basename11(clone);
+  const name = basename13(clone);
   for (let n = 2; n < 1e3; n++) {
-    const candidate = join46(base, `${name}-${n}`);
+    const candidate = join47(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
   }
   throw new Error(`no free worktree suffix for ${clone}`);
@@ -18762,13 +18879,13 @@ function cloneHead(clone) {
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
 function createWorktree(clone, strategy, boundTreeRoots2) {
-  const base = strategy.root ? expandTilde2(strategy.root) : dirname23(clone);
+  const base = strategy.root ? expandTilde2(strategy.root) : dirname24(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
   const path71 = nextWorktreePath(
     clone,
     base,
-    (candidate) => registered.has(candidate) || existsSync43(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename12(candidate))
+    (candidate) => registered.has(candidate) || existsSync44(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate))
   );
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
@@ -18776,19 +18893,19 @@ function createWorktree(clone, strategy, boundTreeRoots2) {
     "add",
     start3.track ? "--track" : "--no-track",
     "-b",
-    basename12(path71),
+    basename14(path71),
     path71,
     start3.ref
   ]);
   recordWorktree(path71, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path71} (branch ${basename12(path71)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path71} (branch ${basename12(path71)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path71} (branch ${basename14(path71)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path71} (branch ${basename14(path71)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
   return path71;
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
   if (state.localOnlyCommits)
@@ -18818,14 +18935,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync44(cwd)) return { durable: true };
+  if (!existsSync45(cwd)) return { durable: true };
   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 (!existsSync44(cwd)) return { durable: true };
+  if (!existsSync45(cwd)) return { durable: true };
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -18987,20 +19104,20 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { copyFileSync, existsSync as existsSync46, mkdirSync as mkdirSync16 } from "fs";
-import { dirname as dirname24, join as join48 } from "path";
+import { copyFileSync, existsSync as existsSync47, mkdirSync as mkdirSync16 } from "fs";
+import { dirname as dirname25, join as join49 } 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 existsSync45 } from "fs";
-import { join as join47 } from "path";
+import { existsSync as existsSync46 } from "fs";
+import { join as join48 } from "path";
 function detectInstallCommand(repoRoot) {
-  if (!existsSync45(join47(repoRoot, "package.json"))) return null;
-  if (existsSync45(join47(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync45(join47(repoRoot, "yarn.lock"))) return "yarn install";
-  if (existsSync45(join47(repoRoot, "bun.lockb"))) return "bun install";
+  if (!existsSync46(join48(repoRoot, "package.json"))) return null;
+  if (existsSync46(join48(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync46(join48(repoRoot, "yarn.lock"))) return "yarn install";
+  if (existsSync46(join48(repoRoot, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 function resolveInstallCommand(repoRoot, install) {
@@ -19102,21 +19219,21 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 }
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
-    const src = join48(clone, rel);
-    if (!existsSync46(src)) continue;
-    const dest = join48(worktreePath, rel);
+    const src = join49(clone, rel);
+    if (!existsSync47(src)) continue;
+    const dest = join49(worktreePath, rel);
     try {
-      mkdirSync16(dirname24(dest), { recursive: true });
+      mkdirSync16(dirname25(dest), { recursive: true });
       copyFileSync(src, dest);
       daemonLog(`worktree ${worktreePath} seeded ${rel}`);
     } catch (error) {
       daemonLog(
-        `worktree ${worktreePath} failed to seed ${rel}: ${message(error)}`
+        `worktree ${worktreePath} failed to seed ${rel}: ${message2(error)}`
       );
     }
   }
 }
-function message(error) {
+function message2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -19127,7 +19244,7 @@ function placedByDaemon() {
 function seed(worktreePath, clone) {
   console.log(`Preparing ${worktreePath}\u2026`);
   return new Promise(
-    (resolve20) => seedWorktree(worktreePath, clone, resolve20)
+    (resolve21) => seedWorktree(worktreePath, clone, resolve21)
   );
 }
 async function moveToPrCheckoutTree() {
@@ -19175,11 +19292,11 @@ function worktreeHoldingBranch(cwd, branch2) {
 }
 
 // src/commands/review/checkoutPr.ts
-function currentBranch2() {
+function currentBranch3() {
   return gitSyncOrNull(process.cwd(), ["rev-parse", "--abbrev-ref", "HEAD"]);
 }
 function moveToExistingCheckout(number, headRef) {
-  if (currentBranch2() === headRef) {
+  if (currentBranch3() === headRef) {
     console.log(`Already on ${headRef} for PR #${number}; reviewing here.`);
     return true;
   }
@@ -19273,12 +19390,12 @@ function registerList(program2) {
 
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync17, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 import chalk161 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync37, writeFileSync as writeFileSync31 } from "fs";
-import { basename as basename13, extname as extname2, resolve as resolve12 } from "path";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync31 } from "fs";
+import { basename as basename15, extname as extname2, resolve as resolve13 } from "path";
 import chalk160 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -19303,9 +19420,9 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync37(file, "utf8");
+  const content = readFileSync38(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename13(file, extname2(file));
+  const stem = basename15(file, extname2(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -19326,7 +19443,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
-    const outPath = resolve12(outDir, `${stem}-${idx}.svg`);
+    const outPath = resolve13(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync31(outPath, svg, "utf8");
     console.log(chalk160.green(`  \u2192 ${outPath}`));
@@ -19340,7 +19457,7 @@ function extractMermaidBlocks(markdown) {
 // src/commands/mermaid/index.ts
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
-  const outDir = resolve13(process.cwd(), options2.out ?? ".");
+  const outDir = resolve14(process.cwd(), options2.out ?? ".");
   mkdirSync17(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
@@ -19388,7 +19505,7 @@ function registerMermaid(program2) {
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname26 } from "path";
+import { dirname as dirname27 } from "path";
 import chalk163 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
@@ -19467,15 +19584,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 import chalk162 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname25, join as join49 } from "path";
+import { dirname as dirname26, join as join50 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var moduleDir = dirname25(fileURLToPath6(import.meta.url));
+var moduleDir = dirname26(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
-  return join49(moduleDir, "commands", "netcap", "netcap-extension");
+  return join50(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -19490,7 +19607,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join50(dir, "background.js");
+  const file = join51(dir, "background.js");
   const source = await readFile3(file, "utf8");
   await writeFile3(
     file,
@@ -19530,20 +19647,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute2, join as join52, resolve as resolve14 } from "path";
+import { isAbsolute as isAbsolute3, join as join53, resolve as resolve15 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir19 } from "os";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function defaultCapturePath() {
-  return join51(homedir19(), ".assist", "netcap", "capture.jsonl");
+  return join52(homedir19(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
-  const dir = isAbsolute2(out) ? out : resolve14(process.cwd(), out);
-  return join52(dir, "capture.jsonl");
+  const dir = isAbsolute3(out) ? out : resolve15(process.cwd(), out);
+  return join53(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -19551,7 +19668,7 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir4(dirname26(outPath), { recursive: true });
+  await mkdir4(dirname27(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count8 = 0;
   const handler = createNetcapHandler({
@@ -19590,11 +19707,11 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync32 } from "fs";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 import chalk164 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync38 } from "fs";
+import { readFileSync as readFileSync39 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -19633,25 +19750,25 @@ function isVisibleText(t) {
   return /[a-zA-Z]{3,}/.test(t);
 }
 var isHashtag = (t) => /^#[A-Za-z0-9_]+$/.test(t);
-function collectRscText(v, resolve20, sink2, seen) {
+function collectRscText(v, resolve21, sink2, seen) {
   if (v == null) return;
   if (typeof v === "string") {
     if (isRscRef(v)) {
       if (!seen.has(v)) {
         seen.add(v);
-        collectRscText(resolve20(v), resolve20, sink2, seen);
+        collectRscText(resolve21(v), resolve21, sink2, seen);
       }
     } else if (isHashtag(v)) sink2.hashtags.push(v);
     else if (isVisibleText(v)) sink2.text.push(v);
     return;
   }
   if (Array.isArray(v)) {
-    for (const x of v) collectRscText(x, resolve20, sink2, seen);
+    for (const x of v) collectRscText(x, resolve21, sink2, seen);
     return;
   }
   if (typeof v === "object") {
     for (const val of Object.values(v)) {
-      collectRscText(val, resolve20, sink2, seen);
+      collectRscText(val, resolve21, sink2, seen);
     }
   }
 }
@@ -19683,7 +19800,7 @@ function visitObjects(root, fn) {
     }
   }
 }
-function buildMentionMap(rows, resolve20) {
+function buildMentionMap(rows, resolve21) {
   const map = /* @__PURE__ */ new Map();
   visitObjects(rows, (o) => {
     const url = profileActionUrl(o);
@@ -19691,7 +19808,7 @@ function buildMentionMap(rows, resolve20) {
     const slug = slugFromProfileUrl(url);
     if (!slug || map.has(slug)) return;
     const sink2 = { text: [], hashtags: [] };
-    collectRscText(o.children, resolve20, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve21, sink2, /* @__PURE__ */ new Set());
     const name = sink2.text.join(" ").replace(/\s+/g, " ").trim();
     map.set(slug, name ? { slug, name, url } : { slug, url });
   });
@@ -19777,10 +19894,10 @@ function buildPost(raw, mentionMap, author) {
 
 // src/commands/netcap/walkPostRow.ts
 var isCommentary = (o) => asObject(o.viewTrackingSpecs)?.viewName === "feed-commentary";
-function walkPostRow(v, resolve20, raw) {
+function walkPostRow(v, resolve21, raw) {
   if (v == null || typeof v !== "object") return;
   if (Array.isArray(v)) {
-    for (const x of v) walkPostRow(x, resolve20, raw);
+    for (const x of v) walkPostRow(x, resolve21, raw);
     return;
   }
   const o = v;
@@ -19794,9 +19911,9 @@ function walkPostRow(v, resolve20, raw) {
   }
   if (isCommentary(o)) {
     const sink2 = { text: raw.text, hashtags: raw.hashtags };
-    collectRscText(o.children, resolve20, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve21, sink2, /* @__PURE__ */ new Set());
   }
-  for (const val of Object.values(o)) walkPostRow(val, resolve20, raw);
+  for (const val of Object.values(o)) walkPostRow(val, resolve21, raw);
 }
 
 // src/commands/netcap/extractLinkedInPosts.ts
@@ -19810,8 +19927,8 @@ function findCommentaryRows(rows) {
 }
 function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
   const rows = parseRscRows(flight);
-  const resolve20 = makeRscResolver(rows);
-  const mentionMap = buildMentionMap(rows, resolve20);
+  const resolve21 = makeRscResolver(rows);
+  const mentionMap = buildMentionMap(rows, resolve21);
   const posts = [];
   for (const id of findCommentaryRows(rows)) {
     const raw = {
@@ -19821,7 +19938,7 @@ function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
       links: [],
       related: []
     };
-    walkPostRow(rows[id], resolve20, raw);
+    walkPostRow(rows[id], resolve21, raw);
     const post = buildPost(raw, mentionMap, author);
     if (post) posts.push(post);
   }
@@ -19990,7 +20107,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines = readFileSync38(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync39(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines) {
     let entry;
@@ -20035,7 +20152,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join53(captureFile, "..", "posts.json");
+  const outFile = join54(captureFile, "..", "posts.json");
   writeFileSync32(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -20187,7 +20304,7 @@ function registerPrompts(program2) {
 }
 
 // src/commands/prs/shared.ts
-import { execSync as execSync42 } from "child_process";
+import { execSync as execSync43 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -20205,12 +20322,12 @@ function getRepoInfo() {
   const preferred = getPreferredRemoteRepo();
   if (preferred) return preferred;
   const repoInfo = JSON.parse(
-    execSync42("gh repo view --json owner,name", { encoding: "utf8" })
+    execSync43("gh repo view --json owner,name", { encoding: "utf8" })
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
 function getCurrentBranch2() {
-  return execSync42("git rev-parse --abbrev-ref HEAD", {
+  return execSync43("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -20218,7 +20335,7 @@ function viewCurrentPr(fields) {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch2();
   return JSON.parse(
-    execSync42(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
+    execSync43(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf8"
     })
   );
@@ -20520,23 +20637,23 @@ function edit(options2) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync45 } from "child_process";
+import { execSync as execSync46 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync44 } from "child_process";
+import { execSync as execSync45 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync47, readFileSync as readFileSync39, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync40, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse2 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
 import { homedir as homedir20 } from "os";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 function commentsCachePath(org, repo, prNumber) {
-  return join54(
+  return join55(
     homedir20(),
     ".assist",
     "pr-comments",
@@ -20549,25 +20666,25 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync47(cachePath)) {
+  if (!existsSync48(cachePath)) {
     return null;
   }
-  const content = readFileSync39(cachePath, "utf8");
+  const content = readFileSync40(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync47(cachePath)) {
+  if (existsSync48(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
 }
 
 // src/commands/prs/replyToComment.ts
-import { execSync as execSync43 } from "child_process";
-function replyToComment(org, repo, prNumber, commentId, message2) {
-  execSync43(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message2.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
+import { execSync as execSync44 } from "child_process";
+function replyToComment(org, repo, prNumber, commentId, message3) {
+  execSync44(
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message3.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
 }
@@ -20575,10 +20692,10 @@ function replyToComment(org, repo, prNumber, commentId, message2) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join55(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join56(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync33(queryFile, mutation);
   try {
-    execSync44(
+    execSync45(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
@@ -20615,12 +20732,12 @@ function cleanupCacheIfDone(cache4, org, repo, prNumber, commentId) {
   );
   if (!hasRemaining) deleteCommentsCache(org, repo, prNumber);
 }
-function resolveCommentWithReply(commentId, message2) {
+function resolveCommentWithReply(commentId, message3) {
   const prNumber = getCurrentPrNumber();
   const { org, repo } = getRepoInfo();
   const cache4 = requireCache(org, repo, prNumber);
   const comment3 = requireLineComment(cache4, commentId);
-  replyToComment(org, repo, prNumber, commentId, message2);
+  replyToComment(org, repo, prNumber, commentId, message3);
   console.log("Reply posted successfully.");
   resolveThread(comment3.threadId);
   console.log("Thread resolved successfully.");
@@ -20630,7 +20747,7 @@ function resolveCommentWithReply(commentId, message2) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync45(`git rev-parse --verify ${sha}`, {
+    return execSync46(`git rev-parse --verify ${sha}`, {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -20643,9 +20760,9 @@ function fixed(commentId, sha) {
     const fullSha = verifySha(sha);
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
-    const message2 = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
+    const message3 = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
     pushCommit(loadConfig().worktree?.trunk === true);
-    resolveCommentWithReply(commentId, message2);
+    resolveCommentWithReply(commentId, message3);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -20657,16 +20774,16 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync46 } from "child_process";
+import { execSync as execSync47 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync34 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join56 } from "path";
+import { join as join57 } 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 = join56(tmpdir7(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join57(tmpdir7(), `gh-query-${Date.now()}.graphql`);
   writeFileSync34(queryFile, THREAD_QUERY);
   try {
-    const result = execSync46(
+    const result = execSync47(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf8" }
     );
@@ -20688,9 +20805,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync47 } from "child_process";
+import { execSync as execSync48 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync47(`gh api --paginate ${endpoint}`, {
+  const result = execSync48(`gh api --paginate ${endpoint}`, {
     encoding: "utf8"
   });
   if (!result.trim()) return [];
@@ -20733,11 +20850,11 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 
 // src/commands/prs/listComments/updateCommentsCache.ts
 import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync35 } from "fs";
-import { dirname as dirname27 } from "path";
+import { dirname as dirname28 } from "path";
 import { stringify } from "yaml";
 function writeCommentsCache(org, repo, prNumber, comments3) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  mkdirSync18(dirname27(cachePath), { recursive: true });
+  mkdirSync18(dirname28(cachePath), { recursive: true });
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -20831,7 +20948,7 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync48 } from "child_process";
+import { execSync as execSync49 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer9 from "enquirer";
@@ -20938,7 +21055,7 @@ async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
     const { org, repo } = getRepoInfo();
-    const result = execSync48(
+    const result = execSync49(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100 -R ${org}/${repo}`,
       { encoding: "utf8" }
     );
@@ -21009,16 +21126,16 @@ function buildCreateArgs(title, body, options2) {
 }
 
 // src/commands/prs/readSessionPrRef.ts
-import { execSync as execSync49 } from "child_process";
+import { execSync as execSync50 } from "child_process";
 function readSessionPrRef() {
   try {
-    const branch2 = execSync49("git rev-parse --abbrev-ref HEAD", {
+    const branch2 = execSync50("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!branch2 || branch2 === "HEAD") return null;
     const pr = JSON.parse(
-      execSync49(`gh pr view ${branch2} --json number,title,url,state`, {
+      execSync50(`gh pr view ${branch2} --json number,title,url,state`, {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       })
@@ -21146,7 +21263,7 @@ function reply(commentId, body) {
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync50 } from "child_process";
+import { execSync as execSync51 } from "child_process";
 function validateReason(reason4) {
   const lowerReason = reason4.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -21163,7 +21280,7 @@ function validateShaReferences(reason4) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync50(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync51(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -21440,10 +21557,10 @@ import chalk171 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync51 } from "child_process";
+import { execSync as execSync52 } from "child_process";
 import chalk170 from "chalk";
 function opExec(args) {
-  return execSync51(`op ${args}`, {
+  return execSync52(`op ${args}`, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -21475,9 +21592,9 @@ function getItemFields(itemId2) {
 
 // src/commands/ravendb/selectOpSecret.ts
 var { Input, Select } = Enquirer2;
-async function selectOne(message2, choices) {
+async function selectOne(message3, choices) {
   if (choices.length === 1) return choices[0].value;
-  const selected = await new Select({ name: "choice", message: message2, choices }).run();
+  const selected = await new Select({ name: "choice", message: message3, choices }).run();
   return choices.find((c) => c.name === selected)?.value ?? selected;
 }
 async function selectOpSecret(searchTerm) {
@@ -21595,7 +21712,7 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync52 } from "child_process";
+import { execSync as execSync53 } from "child_process";
 import chalk175 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
@@ -21603,7 +21720,7 @@ function resolveOpSecret(reference) {
     process.exit(1);
   }
   try {
-    return execSync52(`op read "${reference}"`, {
+    return execSync53(`op read "${reference}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -21867,7 +21984,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync53 } from "child_process";
+import { execSync as execSync54 } from "child_process";
 import fs25 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
@@ -21917,7 +22034,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync53("git diff --cached --name-only", {
+    const staged = execSync54("git diff --cached --name-only", {
       encoding: "utf8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -21925,7 +22042,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync53("git diff --name-only", { encoding: "utf8" });
+    const unstaged = execSync54("git diff --name-only", { encoding: "utf8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -21955,7 +22072,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const child = spawn6("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
@@ -21969,7 +22086,7 @@ function runScript(script, cwd) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve20({ script, code: code ?? 1, output });
+      resolve21({ script, code: code ?? 1, output });
     });
   });
 }
@@ -22541,9 +22658,9 @@ function rewriteImportPaths(imports, sourcePath, destPath) {
   const destDir = path39.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute = path39.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path39.relative(destDir, absolute).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path39.basename(absolute)}`;
+    const absolute2 = path39.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path39.relative(destDir, absolute2).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path39.basename(absolute2)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -23192,8 +23309,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename19 = path52.basename(file, path52.extname(file));
-    if (basename19 === "index") continue;
+    const basename21 = path52.basename(file, path52.extname(file));
+    if (basename21 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -23613,28 +23730,28 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir21 } from "os";
-import { basename as basename14, join as join57 } from "path";
+import { basename as basename16, join as join58 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join57(
+  const reviewDir = join58(
     homedir21(),
     ".assist",
     "reviews",
-    basename14(repoRoot),
+    basename16(repoRoot),
     key
   );
   return {
     reviewDir,
-    requestPath: join57(reviewDir, "request.md"),
-    claudePath: join57(reviewDir, "claude.md"),
-    codexPath: join57(reviewDir, "codex.md"),
-    synthesisPath: join57(reviewDir, "synthesis.md")
+    requestPath: join58(reviewDir, "request.md"),
+    claudePath: join58(reviewDir, "claude.md"),
+    codexPath: join58(reviewDir, "codex.md"),
+    synthesisPath: join58(reviewDir, "synthesis.md")
   };
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync54 } from "child_process";
+import { execSync as execSync55 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync54(
+  const out = execSync55(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -23665,14 +23782,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync57 } from "child_process";
+import { execSync as execSync58 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync55 } from "child_process";
+import { execSync as execSync56 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync55(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync56(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -23687,19 +23804,19 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync55(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync56(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync55(`git diff ${baseSha}...${headSha}`, {
+  return execSync56(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
 // src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync56 } from "child_process";
+import { execSync as execSync57 } from "child_process";
 function getCurrentBranch3() {
-  return execSync56("git rev-parse --abbrev-ref HEAD", {
+  return execSync57("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -23707,7 +23824,7 @@ function fetchPrDiffInfo() {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch3();
   const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
-  const raw = execSync56(
+  const raw = execSync57(
     `gh pr list --state open --head ${branch2} --json ${fields} -R ${org}/${repo}`,
     {
       encoding: "utf8",
@@ -23732,7 +23849,7 @@ function fetchPrDiffInfo() {
 }
 function fetchPrChangedFiles(prNumber) {
   const { org, repo } = getRepoInfo();
-  const out = execSync56(
+  const out = execSync57(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
     {
       encoding: "utf8",
@@ -23744,11 +23861,11 @@ function fetchPrChangedFiles(prNumber) {
 
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch2 = execSync57("git rev-parse --abbrev-ref HEAD", {
+  const branch2 = execSync58("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
-  const sha = execSync57("git rev-parse HEAD", { encoding: "utf8" }).trim();
-  const shortSha = execSync57("git rev-parse --short=7 HEAD", {
+  const sha = execSync58("git rev-parse HEAD", { encoding: "utf8" }).trim();
+  const shortSha = execSync58("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -23769,7 +23886,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -23924,9 +24041,9 @@ function postFindings(findings) {
       posted++;
     } catch (error) {
       failed2++;
-      const message2 = error instanceof Error ? error.message : String(error);
+      const message3 = error instanceof Error ? error.message : String(error);
       console.error(
-        `Failed to post comment on ${finding.file}:${finding.line}: ${message2}`
+        `Failed to post comment on ${finding.file}:${finding.line}: ${message3}`
       );
     }
   }
@@ -23945,8 +24062,8 @@ function submitPendingReview(body) {
       console.error("Error: GitHub CLI (gh) is not installed.");
       return;
     }
-    const message2 = error instanceof Error ? error.message : String(error);
-    console.error(`Failed to submit review: ${message2}`);
+    const message3 = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to submit review: ${message3}`);
   }
 }
 
@@ -24084,7 +24201,7 @@ async function confirmPost(prNumber, count8, options2) {
 async function postReviewToPr(synthesisPath, options2) {
   const prInfo = fetchPrDiffInfo();
   const prNumber = prInfo.prNumber;
-  const markdown = readFileSync40(synthesisPath, "utf8");
+  const markdown = readFileSync41(synthesisPath, "utf8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -24166,10 +24283,10 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync48, mkdirSync as mkdirSync19, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync19, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
   for (const path71 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync48(path71)) unlinkSync16(path71);
+    if (existsSync49(path71)) unlinkSync16(path71);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -24237,11 +24354,11 @@ async function runBacklogSession(synthesisPath) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync7 } from "fs";
+import { statSync as statSync8 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync7(outputPath).size;
+    size = statSync8(outputPath).size;
   } catch {
     return null;
   }
@@ -24454,7 +24571,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync50, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync51, unlinkSync as unlinkSync18 } 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.
@@ -24737,10 +24854,10 @@ function messageFor(err, command) {
   return err.message || String(err);
 }
 function handleSpawnError(ctx, err) {
-  const message2 = messageFor(err, ctx.command);
+  const message3 = messageFor(err, ctx.command);
   const stderr = ctx.stderr ? `${ctx.stderr}
-${message2}` : message2;
-  if (!ctx.quiet) console.error(`[${ctx.name}] failed: ${message2}`);
+${message3}` : message3;
+  if (!ctx.quiet) console.error(`[${ctx.name}] failed: ${message3}`);
   return {
     exitCode: 127,
     stderr,
@@ -24778,12 +24895,12 @@ function onCloseResult(ctx, code) {
   return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
 }
 function waitForChildExit(ctx) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve20(result);
+      resolve21(result);
     };
     ctx.child.on("error", (err) => settle(onErrorResult(ctx, err)));
     ctx.child.on("close", (code) => settle(onCloseResult(ctx, code)));
@@ -24874,7 +24991,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync49, unlinkSync as unlinkSync17 } from "fs";
+import { existsSync as existsSync50, unlinkSync as unlinkSync17 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -24926,7 +25043,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync49(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync50(spec.outputPath)) {
     unlinkSync17(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -24968,7 +25085,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync41 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -25024,7 +25141,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync41(synthesisPath, "utf8");
+  const markdown = readFileSync42(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -25072,7 +25189,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync50(paths.synthesisPath)) {
+  if (anyFresh && existsSync51(paths.synthesisPath)) {
     unlinkSync18(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -25883,9 +26000,9 @@ function createReadlineInterface() {
   });
 }
 function askQuestion(rl, question) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     rl.question(question, (answer) => {
-      resolve20(answer.trim());
+      resolve21(answer.trim());
     });
   });
 }
@@ -25945,27 +26062,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync51, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync52, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
+import { join as join59 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync51(vttDir)) return;
+  if (!existsSync52(vttDir)) return;
   for (const entry of readdirSync10(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync8(join58(vttDir, entry)).isDirectory()) continue;
+    if (statSync9(join59(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync52,
+  existsSync as existsSync53,
   mkdirSync as mkdirSync20,
-  readFileSync as readFileSync42,
+  readFileSync as readFileSync43,
   renameSync as renameSync2,
   writeFileSync as writeFileSync38
 } from "fs";
-import { basename as basename15, join as join59 } from "path";
+import { basename as basename17, join as join60 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text17) {
@@ -26173,14 +26290,14 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync42(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync43(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join59(vttDir, "processed");
+  const processedDir = join60(vttDir, "processed");
   mkdirSync20(processedDir, { recursive: true });
-  renameSync2(sourcePath, join59(processedDir, filename));
+  renameSync2(sourcePath, join60(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -26189,20 +26306,20 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename15(file);
-  const sourcePath = join59(vttDir, filename);
-  if (!existsSync52(sourcePath)) {
+  const filename = basename17(file);
+  const sourcePath = join60(vttDir, filename);
+  if (!existsSync53(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename15(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename17(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join59(transcriptsDir, client);
+  const formattedDir = join60(transcriptsDir, client);
   mkdirSync20(formattedDir, { recursive: true });
-  const formattedPath = join59(formattedDir, outputName);
+  const formattedPath = join60(formattedDir, outputName);
   writeFileSync38(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join59(summaryDir, client, outputName);
+  const summaryPath = join60(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -26322,50 +26439,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir22 } from "os";
-import { dirname as dirname29, join as join60 } from "path";
+import { dirname as dirname30, join as join61 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
-var __dirname5 = dirname29(fileURLToPath7(import.meta.url));
-var VOICE_DIR = join60(homedir22(), ".assist", "voice");
+var __dirname5 = dirname30(fileURLToPath7(import.meta.url));
+var VOICE_DIR = join61(homedir22(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join60(VOICE_DIR, "voice.pid"),
-  log: join60(VOICE_DIR, "voice.log"),
-  venv: join60(VOICE_DIR, ".venv"),
-  lock: join60(VOICE_DIR, "voice.lock")
+  pid: join61(VOICE_DIR, "voice.pid"),
+  log: join61(VOICE_DIR, "voice.log"),
+  venv: join61(VOICE_DIR, ".venv"),
+  lock: join61(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join60(__dirname5, "commands", "voice", "python");
+  return join61(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join60(voicePaths.venv, "Scripts", "python.exe") : join60(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join61(voicePaths.venv, "Scripts", "python.exe") : join61(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join60(getLockDir(), "voice.lock");
+  return join61(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join61(getPythonDir(), "list_devices.py");
+  const script = join62(getPythonDir(), "list_devices.py");
   spawnSync6(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync53, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync54, readFileSync as readFileSync44 } from "fs";
 function logs(options2) {
-  if (!existsSync53(voicePaths.log)) {
+  if (!existsSync54(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync43(voicePaths.log, "utf8").trim();
+  const content = readFileSync44(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -26388,12 +26505,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync7 } from "child_process";
 import { mkdirSync as mkdirSync22 } from "fs";
-import { join as join63 } from "path";
+import { join as join64 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync54, mkdirSync as mkdirSync21, readFileSync as readFileSync44, writeFileSync as writeFileSync39 } from "fs";
-import { join as join62 } from "path";
+import { execSync as execSync59 } from "child_process";
+import { existsSync as existsSync55, mkdirSync as mkdirSync21, readFileSync as readFileSync45, writeFileSync as writeFileSync39 } from "fs";
+import { join as join63 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -26404,9 +26521,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync54(lockFile)) return;
+  if (!existsSync55(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync44(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync45(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -26417,10 +26534,10 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync54(getVenvPython())) return;
+  if (existsSync55(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync58(
+  execSync59(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -26430,7 +26547,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync21(join62(lockFile, ".."), { recursive: true });
+  mkdirSync21(join63(lockFile, ".."), { recursive: true });
   writeFileSync39(
     lockFile,
     JSON.stringify({
@@ -26446,7 +26563,7 @@ function setup() {
   mkdirSync22(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join63(getPythonDir(), "setup_models.py");
+  const script = join64(getPythonDir(), "setup_models.py");
   const result = spawnSync7(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -26460,7 +26577,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
 import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync40 } from "fs";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -26498,7 +26615,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join64(getPythonDir(), "voice_daemon.py");
+  const script = join65(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -26508,7 +26625,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync55, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync56, readFileSync as readFileSync46 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -26518,16 +26635,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync55(voicePaths.log)) return [];
-  const lines = readFileSync45(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync56(voicePaths.log)) return [];
+  const lines = readFileSync46(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count8);
 }
 function status2() {
-  if (!existsSync55(voicePaths.pid)) {
+  if (!existsSync56(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync45(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync46(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -26546,13 +26663,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync56, readFileSync as readFileSync46, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync47, unlinkSync as unlinkSync19 } from "fs";
 function stop2() {
-  if (!existsSync56(voicePaths.pid)) {
+  if (!existsSync57(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync46(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync47(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -26565,7 +26682,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync56(lockFile)) unlinkSync19(lockFile);
+    if (existsSync57(lockFile)) unlinkSync19(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -26686,8 +26803,8 @@ function gitFailureReason(error) {
     const text17 = stream == null ? "" : String(stream).trim();
     if (text17) return text17;
   }
-  const message2 = error instanceof Error ? error.message : String(error);
-  return message2.trim() || "git failed without reporting a reason";
+  const message3 = error instanceof Error ? error.message : String(error);
+  return message3.trim() || "git failed without reporting a reason";
 }
 
 // src/commands/watch/resolveUpstream.ts
@@ -26791,7 +26908,7 @@ function waitForUpstream(options2) {
     return Promise.resolve({ kind: "moved", upstream, ...moved });
   }
   const fetchTimeoutMs = Math.max(intervalMs, MIN_FETCH_TIMEOUT_MS);
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     let settled = false;
     const finish = (outcome) => {
       if (settled) return;
@@ -26799,7 +26916,7 @@ function waitForUpstream(options2) {
       clearInterval(ticker);
       clearTimeout(deadline);
       process.off("SIGINT", onInterrupt);
-      resolve20(outcome);
+      resolve21(outcome);
     };
     const onInterrupt = () => finish({ kind: "interrupted" });
     const ticker = setInterval(() => {
@@ -26824,9 +26941,9 @@ function parseOrExit(value) {
     return process.exit(1);
   }
 }
-function report({ exitCode, message: message2 }) {
-  if (exitCode === 0) console.log(message2);
-  else console.error(message2);
+function report({ exitCode, message: message3 }) {
+  if (exitCode === 0) console.log(message3);
+  else console.error(message3);
 }
 async function watchWait(options2) {
   const intervalMs = parseOrExit(options2.interval);
@@ -26887,7 +27004,7 @@ function extractCode(url, expectedState) {
   return code;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authorization timed out after 120 seconds"));
@@ -26904,7 +27021,7 @@ function waitForCallback(port, expectedState) {
         const code = extractCode(url, expectedState);
         respondHtml(res, 200, "Authorization successful!");
         server.close();
-        resolve20(code);
+        resolve21(code);
       } catch (error) {
         respondHtml(res, 400, error.message);
         server.close();
@@ -27025,8 +27142,8 @@ async function auth() {
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync12 } from "child_process";
-import { readdirSync as readdirSync11, readFileSync as readFileSync47, statSync as statSync9 } from "fs";
-import { join as join65 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync48, statSync as statSync10 } from "fs";
+import { join as join66 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -27035,9 +27152,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path71 = join65(roamDir, name);
+    const path71 = join66(roamDir, name);
     try {
-      return { path: path71, mtimeMs: statSync9(path71).mtimeMs };
+      return { path: path71, mtimeMs: statSync10(path71).mtimeMs };
     } catch {
       return void 0;
     }
@@ -27047,11 +27164,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join65(appData, "Roam"));
+  const portFile = findPortFile(join66(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync47(portFile, "utf8").trim();
+    port = readFileSync48(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -27181,7 +27298,7 @@ var rootConfigHelp = {
 };
 
 // src/commands/run/index.ts
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 
 // src/commands/run/findRunConfig.ts
 function exitNoRunConfigs() {
@@ -27265,11 +27382,11 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync59 } from "child_process";
+import { execSync as execSync60 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync59(cmd, { stdio: "inherit", cwd });
+      execSync60(cmd, { stdio: "inherit", cwd });
     } catch (error) {
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
@@ -27279,15 +27396,15 @@ function runPreCommands(pre, cwd) {
 
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync13, spawn as spawn9 } from "child_process";
-import { existsSync as existsSync57 } from "fs";
-import { dirname as dirname30, join as join66, resolve as resolve15 } from "path";
+import { existsSync as existsSync58 } from "fs";
+import { dirname as dirname31, join as join67, resolve as resolve16 } 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 gitRoot = resolve15(dirname30(gitPath), "..");
-    const gitBash = join66(gitRoot, "bin", "bash.exe");
-    if (existsSync57(gitBash)) return gitBash;
+    const gitRoot = resolve16(dirname31(gitPath), "..");
+    const gitBash = join67(gitRoot, "bin", "bash.exe");
+    if (existsSync58(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -27333,7 +27450,7 @@ function listRunConfigs(verbose) {
   }
 }
 function execRunConfig(config, args) {
-  const cwd = config.cwd ? resolve16(getConfigDir(), config.cwd) : void 0;
+  const cwd = config.cwd ? resolve17(getConfigDir(), config.cwd) : void 0;
   if (config.pre) runPreCommands(config.pre, cwd);
   const resolved = resolveParams(config.params, args);
   spawnRunCommand(
@@ -27375,7 +27492,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync41 } from "fs";
-import { join as join67 } from "path";
+import { join as join68 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -27436,7 +27553,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join67(".claude", "commands");
+  const dir = join68(".claude", "commands");
   mkdirSync24(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -27444,7 +27561,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join67(dir, `${name}.md`);
+  const filePath = join68(dir, `${name}.md`);
   writeFileSync41(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -27500,8 +27617,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync58, unlinkSync as unlinkSync20 } from "fs";
-import { join as join68 } from "path";
+import { existsSync as existsSync59, unlinkSync as unlinkSync20 } from "fs";
+import { join as join69 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -27516,8 +27633,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join68(".claude", "commands", `${name}.md`);
-  if (existsSync58(filePath)) {
+  const filePath = join69(".claude", "commands", `${name}.md`);
+  if (existsSync59(filePath)) {
     unlinkSync20(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -27570,10 +27687,10 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync59, mkdirSync as mkdirSync25, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
+import { execSync as execSync61 } from "child_process";
+import { existsSync as existsSync60, mkdirSync as mkdirSync25, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join69, resolve as resolve17 } from "path";
+import { join as join70, resolve as resolve18 } from "path";
 import chalk209 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -27703,17 +27820,17 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync59(outputDir)) {
+  if (!existsSync60(outputDir)) {
     mkdirSync25(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve17(outputDir, `${processName}-${timestamp6}.png`);
+  return resolve18(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join69(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join70(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync42(scriptPath, captureWindowPs1, "utf8");
   try {
-    execSync60(
+    execSync61(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
@@ -27723,7 +27840,7 @@ function runPowerShellScript(processName, outputPath) {
 }
 function screenshot(processName) {
   const config = loadConfig();
-  const outputDir = resolve17(config.screenshot.outputDir);
+  const outputDir = resolve18(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
   console.log(chalk209.gray(`Capturing window for process "${processName}" ...`));
   try {
@@ -27756,10 +27873,10 @@ var STATUS_TIMEOUT_MS = 5e3;
 function queryDaemon(socket) {
   socket.write(`${JSON.stringify({ type: "ping" })}
 `);
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const result = { sessions: [] };
     const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
-    const timer = setTimeout(() => resolve20(result), STATUS_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve21(result), STATUS_TIMEOUT_MS);
     const lines = createInterface5({ input: socket });
     lines.on("error", () => {
     });
@@ -27767,7 +27884,7 @@ function queryDaemon(socket) {
       applyLine(result, pending, line);
       if (pending.size === 0) {
         clearTimeout(timer);
-        resolve20(result);
+        resolve21(result);
       }
     });
   });
@@ -27787,7 +27904,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync48 } from "fs";
+import { readFileSync as readFileSync49 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -27799,7 +27916,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync48(daemonPaths.pid, "utf8").trim(),
+      readFileSync49(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -27853,11 +27970,11 @@ function clearPersistedSessionsOnDrain() {
 
 // src/commands/sessions/daemon/readDaemonMessage.ts
 function readDaemonMessage(lines, timeoutMs, fallback, match) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const finish = (value) => {
       clearTimeout(timer);
       lines.off("line", onLine);
-      resolve20(value);
+      resolve21(value);
     };
     const timer = setTimeout(() => finish(fallback), timeoutMs);
     const onLine = (line) => {
@@ -28195,7 +28312,7 @@ function readDesignSystemPrompt() {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync60, statSync as statSync10 } from "fs";
+import { chmodSync, existsSync as existsSync61, statSync as statSync11 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path59 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -28210,8 +28327,8 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync60(helper)) return;
-  const mode = statSync10(helper).mode;
+  if (!existsSync61(helper)) return;
+  const mode = statSync11(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -28370,17 +28487,17 @@ function otherTreeHolders(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync62 } from "fs";
-import { basename as basename16 } from "path";
+import { existsSync as existsSync63 } from "fs";
+import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync61 } from "fs";
-import { join as join72 } from "path";
+import { existsSync as existsSync62 } from "fs";
+import { join as join73 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
-import { statSync as statSync11 } from "fs";
+import { statSync as statSync12 } from "fs";
 import { rm as rm2 } from "fs/promises";
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     daemonLog(
@@ -28407,7 +28524,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return true;
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync11(join71(worktreePath, ".git"), {
+  return statSync12(join72(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -28443,7 +28560,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync61(join72(worktreePath, ".git")))
+  if (!existsSync62(join73(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";
@@ -28495,7 +28612,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync62(worktreePath)) {
+  if (!existsSync63(worktreePath)) {
     daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
     return false;
   }
@@ -28509,14 +28626,14 @@ async function reapWorktree(worktreePath, force = false) {
   stopInstall(worktreePath);
   const clone = owningClone(worktreePath);
   if (!await removeTree(clone, worktreePath, force)) return false;
-  await deleteWorktreeBranch(clone, basename16(worktreePath));
+  await deleteWorktreeBranch(clone, basename18(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return true;
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync62(recorded)) return recorded;
+  if (recorded && existsSync63(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -28603,12 +28720,12 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync63, watch } from "fs";
+import { existsSync as existsSync64, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync63(common)) return void 0;
+  if (!common || !existsSync64(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -29012,10 +29129,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 function exitReason(session, exitCode) {
   const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync64(session.cwd))
+  if (session.cwd && !existsSync65(session.cwd))
     return `${base}: working directory ${session.cwd} no longer exists`;
   return base;
 }
@@ -29033,8 +29150,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync65, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
-import { dirname as dirname32 } from "path";
+import { existsSync as existsSync66, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
+import { dirname as dirname33 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
 function applyReviewPause(session, activity2) {
@@ -29088,7 +29205,7 @@ var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path71 = activityPath(session.id);
-  const dir = dirname32(path71);
+  const dir = dirname33(path71);
   try {
     mkdirSync26(dir, { recursive: true });
   } catch {
@@ -29114,7 +29231,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync65(path71)) read();
+  if (existsSync66(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -29304,9 +29421,9 @@ function normalizeEntry(entry) {
   return null;
 }
 function normalizeAssistant(entry) {
-  const message2 = asRecord2(entry.message);
-  const stopReason = typeof message2?.stop_reason === "string" ? message2.stop_reason : null;
-  const content = message2?.content;
+  const message3 = asRecord2(entry.message);
+  const stopReason = typeof message3?.stop_reason === "string" ? message3.stop_reason : null;
+  const content = message3?.content;
   const toolUses = [];
   if (Array.isArray(content))
     for (const block of content) {
@@ -30203,8 +30320,8 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync68 } from "fs";
-import { basename as basename18 } from "path";
+import { existsSync as existsSync69 } from "fs";
+import { basename as basename20 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -30273,9 +30390,9 @@ async function changedFiles(path71) {
   };
 }
 async function unpushedCommits(path71, reason4) {
-  const log = await gitResult(path71, ["log", "--oneline", "@{upstream}..HEAD"]);
-  if (!log.ok) return { summary: reason4, items: [] };
-  const lines = nonEmptyLines(log.out);
+  const log2 = await gitResult(path71, ["log", "--oneline", "@{upstream}..HEAD"]);
+  if (!log2.ok) return { summary: reason4, items: [] };
+  const lines = nonEmptyLines(log2.out);
   return {
     summary: `${lines.length} unpushed ${lines.length === 1 ? "commit" : "commits"}`,
     items: capped(lines)
@@ -30293,9 +30410,9 @@ function capped(lines) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync67(clone)) {
+  if (!existsSync68(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -30331,7 +30448,7 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename17 } from "path";
+import { basename as basename19 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason4, held } = recovered;
   let id;
@@ -30354,7 +30471,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename17(orphan.path)}`,
+    name: `recovered ${basename19(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -30388,10 +30505,10 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
     if (accounted.has(path71)) continue;
-    if (!existsSync68(path71)) {
+    if (!existsSync69(path71)) {
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path71, branch: basename18(path71) }
+        { path: path71, branch: basename20(path71) }
       ]);
       continue;
     }
@@ -30658,7 +30775,7 @@ function windowsDaemonHost() {
 var CONNECT_TIMEOUT_MS = 2e3;
 var KEEPALIVE_PROBE_MS = 1e4;
 function connectToWindowsDaemon() {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
     socket.setTimeout(CONNECT_TIMEOUT_MS);
     socket.once("timeout", () => {
@@ -30668,7 +30785,7 @@ function connectToWindowsDaemon() {
     socket.once("connect", () => {
       socket.setTimeout(0);
       socket.setKeepAlive(true, KEEPALIVE_PROBE_MS);
-      resolve20(socket);
+      resolve21(socket);
     });
     socket.once("error", reject);
   });
@@ -30746,7 +30863,7 @@ async function waitForWindowsDaemon() {
   );
 }
 function delay2(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
 
 // src/commands/sessions/daemon/defaultConnect.ts
@@ -30756,19 +30873,19 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync69, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync70, readFileSync as readFileSync51 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync69(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync50(sessionsFile, "utf8"));
+    if (!existsSync70(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync51(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
+    const message3 = error instanceof Error ? error.message : String(error);
     daemonLog(
-      `windows proxy: could not read windows sessions.json: ${message2}`
+      `windows proxy: could not read windows sessions.json: ${message3}`
     );
     return false;
   }
@@ -30795,8 +30912,8 @@ async function discoverWindowsSessions(conn) {
   try {
     await conn.ensure();
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: discovery failed: ${message2}`);
+    const message3 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: discovery failed: ${message3}`);
   }
 }
 
@@ -30834,11 +30951,11 @@ async function forwardWindowsCreate(conn, state, client, data) {
     state.pendingCreators.push({ client, timer });
     conn.write(stripOutboundSessionId(data));
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: forwardCreate failed: ${message2}`);
+    const message3 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: forwardCreate failed: ${message3}`);
     sendTo(client, {
       type: "error",
-      message: `Windows session unavailable: ${message2}`
+      message: `Windows session unavailable: ${message3}`
     });
   }
 }
@@ -30876,10 +30993,10 @@ function takePendingCreator(state) {
   clearTimeout(pending.timer);
   return pending.client;
 }
-function failPendingCreators(state, message2) {
+function failPendingCreators(state, message3) {
   for (const { client, timer } of state.pendingCreators) {
     clearTimeout(timer);
-    sendTo(client, { type: "error", message: message2 });
+    sendTo(client, { type: "error", message: message3 });
   }
   state.pendingCreators = [];
 }
@@ -31019,9 +31136,9 @@ async function healWindowsDaemon() {
   try {
     await runOnWindowsHost("assist update", UPDATE_TIMEOUT_MS);
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
+    const message3 = error instanceof Error ? error.message : String(error);
     daemonLog(
-      `windows daemon: auto-heal: \`assist update\` failed: ${message2}`
+      `windows daemon: auto-heal: \`assist update\` failed: ${message3}`
     );
     throw error;
   }
@@ -31030,7 +31147,7 @@ async function healWindowsDaemon() {
   daemonLog("windows daemon: auto-heal: stale daemon stopped");
 }
 function runOnWindowsHost(command, timeoutMs) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     const child = spawn12("pwsh.exe", ["-Command", command], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -31050,7 +31167,7 @@ function runOnWindowsHost(command, timeoutMs) {
     });
     child.on("exit", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve20();
+      if (code === 0) resolve21();
       else
         reject(
           new Error(
@@ -31188,11 +31305,11 @@ async function autoHealWindowsDaemon(conn, state, heal, version2) {
     daemonLog("windows proxy: heal complete, reconnecting to windows daemon");
     await conn.ensure();
   } catch (error) {
-    const message2 = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: auto-heal failed: ${message2}`);
+    const message3 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: auto-heal failed: ${message3}`);
     state.broadcast({
       type: "error",
-      message: `Windows host auto-update failed: ${message2}`
+      message: `Windows host auto-update failed: ${message3}`
     });
   }
 }
@@ -31787,9 +31904,9 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 function repoDirExists(cwd) {
-  return existsSync70(toGitCwd(cwd));
+  return existsSync71(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/withRepoGroups.ts
@@ -31981,7 +32098,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync22, writeFileSync as writeFileSync43 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync51 } from "fs";
+import { readFileSync as readFileSync52 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -31992,7 +32109,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync51(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync52(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -32409,13 +32526,13 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync53, statSync as statSync13 } from "fs";
-import { isAbsolute as isAbsolute3, join as join74, resolve as resolve18 } from "path";
+import { readFileSync as readFileSync54, statSync as statSync14 } from "fs";
+import { isAbsolute as isAbsolute4, join as join75, resolve as resolve19 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join74(cwd, ".git");
+  const dotGit = join75(cwd, ".git");
   let stat3;
   try {
-    stat3 = statSync13(dotGit);
+    stat3 = statSync14(dotGit);
   } catch {
     return null;
   }
@@ -32424,7 +32541,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync53(dotGit, "utf8");
+    contents = readFileSync54(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -32433,7 +32550,7 @@ function resolveGitDir(cwd) {
     return null;
   }
   const gitDir = match[1].trim();
-  return isAbsolute3(gitDir) ? gitDir : resolve18(cwd, gitDir);
+  return isAbsolute4(gitDir) ? gitDir : resolve19(cwd, gitDir);
 }
 function readGitBranch(cwd) {
   const gitDir = resolveGitDir(cwd);
@@ -32442,7 +32559,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync53(join74(gitDir, "HEAD"), "utf8");
+    head = readFileSync54(join75(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -32798,7 +32915,7 @@ function syncCommands(claudeDir, targetBase) {
 }
 
 // src/commands/update.ts
-import { execSync as execSync61 } from "child_process";
+import { execSync as execSync62 } from "child_process";
 import * as path70 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
@@ -32822,7 +32939,7 @@ function isGlobalNpmInstall(dir) {
     if (resolved.split(path70.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync61("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync62("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return resolved.toLowerCase().startsWith(path70.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -32833,18 +32950,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync61("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync62("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync61("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync62("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync61("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync62("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync61("assist sync", { stdio: "inherit" });
+    execSync62("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync61("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync62("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync61("assist sync", { stdio: "inherit" });
+    execSync62("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."