@staff0rd/assist 0.324.1 → 0.325.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.324.1",
+  version: "0.325.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -9295,16 +9295,180 @@ function registerCliHook(program2) {
   registerDeny(cmd);
 }
 
+// src/commands/codeComment/codeCommentConfirm.ts
+import { existsSync as existsSync27, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync22 } from "fs";
+import chalk92 from "chalk";
+
+// src/commands/codeComment/getRestrictedDir.ts
+import { homedir as homedir11 } from "os";
+import { join as join25 } from "path";
+function getRestrictedDir() {
+  return join25(homedir11(), ".assist", "restricted");
+}
+function getPinStatePath(pin) {
+  return join25(getRestrictedDir(), `code-comment-${pin}.json`);
+}
+
+// src/commands/codeComment/sweepRestrictedDir.ts
+import { readdirSync, statSync as statSync2, unlinkSync as unlinkSync7 } from "fs";
+import { join as join26 } from "path";
+var STALE_AFTER_MS = 30 * 60 * 1e3;
+function sweepRestrictedDir(dir = getRestrictedDir()) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - STALE_AFTER_MS;
+  for (const entry of entries) {
+    const path57 = join26(dir, entry);
+    try {
+      if (statSync2(path57).mtimeMs < cutoff) unlinkSync7(path57);
+    } catch {
+      continue;
+    }
+  }
+}
+
+// src/commands/codeComment/codeCommentConfirm.ts
+function readPinState(pin) {
+  const path57 = getPinStatePath(pin);
+  if (!existsSync27(path57)) return void 0;
+  try {
+    const state = JSON.parse(readFileSync22(path57, "utf8"));
+    if (state.pin !== pin) return void 0;
+    return state;
+  } catch {
+    return void 0;
+  }
+}
+function codeCommentConfirm(pin) {
+  sweepRestrictedDir();
+  const state = readPinState(pin);
+  if (!state) {
+    console.error(chalk92.red(`No pending comment for pin: ${pin}`));
+    process.exitCode = 1;
+    return;
+  }
+  if (!existsSync27(state.file)) {
+    console.error(chalk92.red(`Target file no longer exists: ${state.file}`));
+    process.exitCode = 1;
+    return;
+  }
+  const original = readFileSync22(state.file, "utf8");
+  const lines = original.split("\n");
+  const index3 = state.line - 1;
+  if (index3 > lines.length) {
+    console.error(
+      chalk92.red(
+        `Line ${state.line} is beyond the end of ${state.file} (${lines.length} lines).`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const indentSource = lines[index3] ?? "";
+  const indent2 = indentSource.match(/^\s*/)?.[0] ?? "";
+  lines.splice(index3, 0, `${indent2}// ${state.text}`);
+  writeFileSync22(state.file, lines.join("\n"));
+  unlinkSync8(getPinStatePath(pin));
+  console.log(
+    chalk92.green(`Inserted "// ${state.text}" at ${state.file}:${state.line}`)
+  );
+}
+
+// src/commands/codeComment/codeCommentSet.ts
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync23 } from "fs";
+import { randomBytes } from "crypto";
+import chalk93 from "chalk";
+
+// src/commands/codeComment/validateCommentText.ts
+var MAX_COMMENT_LENGTH = 50;
+function validateCommentText(raw) {
+  const text6 = raw.replace(/^\/\/\s?/, "");
+  if (/[\r\n]/.test(text6)) {
+    return {
+      ok: false,
+      reason: "Comment must be a single line \u2014 multi-line comments are not allowed."
+    };
+  }
+  if (text6.includes("/*") || text6.includes("*/")) {
+    return {
+      ok: false,
+      reason: "Block comments (/* */) are not allowed \u2014 only single-line // comments."
+    };
+  }
+  if (text6.length > MAX_COMMENT_LENGTH) {
+    return {
+      ok: false,
+      reason: `Comment text is ${text6.length} chars; the cap is ${MAX_COMMENT_LENGTH}. Make it shorter or, better, make the code self-documenting.`
+    };
+  }
+  return { ok: true, text: text6 };
+}
+
+// src/commands/codeComment/codeCommentSet.ts
+function generatePin() {
+  return randomBytes(4).toString("hex");
+}
+function codeCommentSet(file, line, text6) {
+  const lineNumber = Number.parseInt(line, 10);
+  if (!Number.isInteger(lineNumber) || lineNumber < 1) {
+    console.error(chalk93.red(`Invalid line number: ${line}`));
+    process.exitCode = 1;
+    return;
+  }
+  const validation = validateCommentText(text6);
+  if (!validation.ok) {
+    console.error(chalk93.red(`Refused: ${validation.reason}`));
+    console.error(chalk93.red("No pin issued."));
+    process.exitCode = 1;
+    return;
+  }
+  console.error(
+    chalk93.yellow.bold(
+      "Think hard. Comments are a last resort, not a habit.\nAlmost every comment you reach for is a sign the code should be clearer instead.\nBefore you confirm this pin, ask whether a better name, a smaller function, or a\ntest would make the comment redundant. If you are still sure this one line earns\nits keep, run the confirm step below."
+    )
+  );
+  const pin = generatePin();
+  mkdirSync11(getRestrictedDir(), { recursive: true });
+  sweepRestrictedDir();
+  writeFileSync23(
+    getPinStatePath(pin),
+    JSON.stringify({ pin, file, line: lineNumber, text: validation.text })
+  );
+  console.log(
+    `${chalk93.green(`Pin issued: ${pin}`)}
+To insert "// ${validation.text}" at ${file}:${lineNumber}, run:
+${chalk93.cyan(`  assist code-comment confirm ${pin}`)}`
+  );
+}
+
+// src/commands/registerCodeComment.ts
+function registerCodeComment(parent) {
+  const codeComment = parent.command("code-comment").description(
+    "Escape hatch for the rare code comment that genuinely belongs"
+  );
+  codeComment.command("set").description(
+    "Validate a single-line comment and issue a pin to confirm its insertion"
+  ).argument("<file>", "File the comment belongs in").argument("<line>", "1-based line number to insert the comment at").argument(
+    "<text>",
+    "Single-line comment text (max 50 chars, no block comments)"
+  ).action(codeCommentSet);
+  codeComment.command("confirm").description("Confirm a pin to insert its comment and clear the pin state").argument("<pin>", "Pin issued by 'code-comment set'").action(codeCommentConfirm);
+}
+
 // src/commands/complexity/analyze.ts
-import chalk100 from "chalk";
+import chalk102 from "chalk";
 
 // src/commands/complexity/cyclomatic.ts
-import chalk93 from "chalk";
+import chalk95 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs16 from "fs";
 import path21 from "path";
-import chalk92 from "chalk";
+import chalk94 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
@@ -9555,7 +9719,7 @@ function createSourceFromFile(filePath) {
 function withSourceFiles(pattern2, callback, extraIgnore = []) {
   const files = findSourceFiles2(pattern2, ".", extraIgnore);
   if (files.length === 0) {
-    console.log(chalk92.yellow("No files found matching pattern"));
+    console.log(chalk94.yellow("No files found matching pattern"));
     return void 0;
   }
   return callback(files);
@@ -9588,11 +9752,11 @@ async function cyclomatic(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.complexity - a.complexity);
     for (const { file, name, complexity } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && complexity > options2.threshold;
-      const color = exceedsThreshold ? chalk93.red : chalk93.white;
-      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk93.cyan(complexity)}`);
+      const color = exceedsThreshold ? chalk95.red : chalk95.white;
+      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk95.cyan(complexity)}`);
     }
     console.log(
-      chalk93.dim(
+      chalk95.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -9604,7 +9768,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/halstead.ts
-import chalk94 from "chalk";
+import chalk96 from "chalk";
 async function halstead(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -9619,13 +9783,13 @@ async function halstead(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.metrics.effort - a.metrics.effort);
     for (const { file, name, metrics } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && metrics.volume > options2.threshold;
-      const color = exceedsThreshold ? chalk94.red : chalk94.white;
+      const color = exceedsThreshold ? chalk96.red : chalk96.white;
       console.log(
-        `${color(`${file}:${name}`)} \u2192 volume: ${chalk94.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk94.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk94.magenta(metrics.effort.toFixed(1))}`
+        `${color(`${file}:${name}`)} \u2192 volume: ${chalk96.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk96.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk96.magenta(metrics.effort.toFixed(1))}`
       );
     }
     console.log(
-      chalk94.dim(
+      chalk96.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -9637,27 +9801,27 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-import chalk97 from "chalk";
+import chalk99 from "chalk";
 
 // src/commands/complexity/maintainability/formatResultLine.ts
-import chalk95 from "chalk";
+import chalk97 from "chalk";
 function formatResultLine(entry, failing) {
   const { file, avgMaintainability, minMaintainability, override } = entry;
-  const name = failing ? chalk95.red(file) : chalk95.white(file);
-  const suffix = override !== void 0 ? chalk95.magenta(` (override: ${override})`) : "";
-  return `${name} \u2192 avg: ${chalk95.cyan(avgMaintainability.toFixed(1))}, min: ${chalk95.yellow(minMaintainability.toFixed(1))}${suffix}`;
+  const name = failing ? chalk97.red(file) : chalk97.white(file);
+  const suffix = override !== void 0 ? chalk97.magenta(` (override: ${override})`) : "";
+  return `${name} \u2192 avg: ${chalk97.cyan(avgMaintainability.toFixed(1))}, min: ${chalk97.yellow(minMaintainability.toFixed(1))}${suffix}`;
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
-import chalk96 from "chalk";
+import chalk98 from "chalk";
 function printMaintainabilityFailure(failingCount, threshold) {
   const thresholdLabel = threshold !== void 0 ? ` ${threshold}` : "";
   console.error(
-    chalk96.red(
+    chalk98.red(
       `
 Fail: ${failingCount} file(s) below threshold${thresholdLabel} (files marked "(override: N)" were judged against their own marker). Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.
 
-\u26A0\uFE0F  ${chalk96.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel.
+\u26A0\uFE0F  ${chalk98.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel.
 
 The score is a property of the whole file, not your diff: any existing logic counts, so the fix is to shrink the file \u2014 not to revert or micro-optimize the lines you just changed. Identify the largest cohesive responsibility (often the biggest function, or a related group of functions) and move it to a new file with 'assist refactor extract'. Run 'assist complexity <file>' for per-function metrics only to locate that responsibility, not to tweak individual lines.`
     )
@@ -9669,7 +9833,7 @@ function displayMaintainabilityResults(results, threshold) {
   const gating = threshold !== void 0 || results.some((r) => r.override !== void 0);
   if (!gating) {
     for (const entry of results) console.log(formatResultLine(entry, false));
-    console.log(chalk97.dim(`
+    console.log(chalk99.dim(`
 Analyzed ${results.length} files`));
     return;
   }
@@ -9678,7 +9842,7 @@ Analyzed ${results.length} files`));
     return limit !== void 0 && r.minMaintainability < limit;
   });
   if (failing.length === 0) {
-    console.log(chalk97.green("All files pass maintainability threshold"));
+    console.log(chalk99.green("All files pass maintainability threshold"));
   } else {
     for (const entry of failing) console.log(formatResultLine(entry, true));
   }
@@ -9687,7 +9851,7 @@ Analyzed ${results.length} files`));
   );
   for (const entry of passingOverrides)
     console.log(formatResultLine(entry, false));
-  console.log(chalk97.dim(`
+  console.log(chalk99.dim(`
 Analyzed ${results.length} files`));
   if (failing.length > 0) {
     printMaintainabilityFailure(failing.length, threshold);
@@ -9696,10 +9860,10 @@ Analyzed ${results.length} files`));
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFormula.ts
-import chalk98 from "chalk";
+import chalk100 from "chalk";
 var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
 function printMaintainabilityFormula() {
-  console.log(chalk98.dim(MI_FORMULA));
+  console.log(chalk100.dim(MI_FORMULA));
 }
 
 // src/commands/complexity/maintainability/collectFileMetrics.ts
@@ -9775,7 +9939,7 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 
 // src/commands/complexity/sloc.ts
 import fs18 from "fs";
-import chalk99 from "chalk";
+import chalk101 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -9791,12 +9955,12 @@ async function sloc(pattern2 = "**/*.ts", options2 = {}) {
     results.sort((a, b) => b.lines - a.lines);
     for (const { file, lines } of results) {
       const exceedsThreshold = options2.threshold !== void 0 && lines > options2.threshold;
-      const color = exceedsThreshold ? chalk99.red : chalk99.white;
-      console.log(`${color(file)} \u2192 ${chalk99.cyan(lines)} lines`);
+      const color = exceedsThreshold ? chalk101.red : chalk101.white;
+      console.log(`${color(file)} \u2192 ${chalk101.cyan(lines)} lines`);
     }
     const total = results.reduce((sum, r) => sum + r.lines, 0);
     console.log(
-      chalk99.dim(`
+      chalk101.dim(`
 Total: ${total} lines across ${files.length} files`)
     );
     if (hasViolation) {
@@ -9810,25 +9974,25 @@ async function analyze(pattern2) {
   const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
   const files = findSourceFiles2(searchPattern);
   if (files.length === 0) {
-    console.log(chalk100.yellow("No files found matching pattern"));
+    console.log(chalk102.yellow("No files found matching pattern"));
     return;
   }
   if (files.length === 1) {
     const file = files[0];
-    console.log(chalk100.bold.underline("SLOC"));
+    console.log(chalk102.bold.underline("SLOC"));
     await sloc(file);
     console.log();
-    console.log(chalk100.bold.underline("Cyclomatic Complexity"));
+    console.log(chalk102.bold.underline("Cyclomatic Complexity"));
     await cyclomatic(file);
     console.log();
-    console.log(chalk100.bold.underline("Halstead Metrics"));
+    console.log(chalk102.bold.underline("Halstead Metrics"));
     await halstead(file);
     console.log();
-    console.log(chalk100.bold.underline("Maintainability Index"));
+    console.log(chalk102.bold.underline("Maintainability Index"));
     await maintainability(file);
     console.log();
     console.log(
-      chalk100.dim(
+      chalk102.dim(
         "To improve the maintainability index, extract functions and logic out of this file into separate, smaller modules. Collapsing whitespace or removing comments is not the goal."
       )
     );
@@ -9862,7 +10026,7 @@ function registerComplexity(program2) {
 }
 
 // src/commands/config/index.ts
-import chalk101 from "chalk";
+import chalk103 from "chalk";
 import { stringify as stringifyYaml2 } from "yaml";
 
 // src/commands/config/setNestedValue.ts
@@ -9925,7 +10089,7 @@ function formatIssuePath(issue, key) {
 function printValidationErrors(issues, key) {
   for (const issue of issues) {
     console.error(
-      chalk101.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
+      chalk103.red(`${formatIssuePath(issue, key)}: ${issue.message}`)
     );
   }
 }
@@ -9942,7 +10106,7 @@ var GLOBAL_ONLY_KEYS = ["sync.autoConfirm"];
 function assertNotGlobalOnly(key, global) {
   if (!global && GLOBAL_ONLY_KEYS.some((k) => key.startsWith(k))) {
     console.error(
-      chalk101.red(
+      chalk103.red(
         `"${key}" is a global-only key. Use --global to set it in ~/.assist.yml`
       )
     );
@@ -9965,7 +10129,7 @@ function configSet(key, value, options2 = {}) {
   applyConfigSet(key, coerced, options2.global ?? false);
   const target = options2.global ? "global" : "project";
   console.log(
-    chalk101.green(`Set ${key} = ${JSON.stringify(coerced)} (${target})`)
+    chalk103.green(`Set ${key} = ${JSON.stringify(coerced)} (${target})`)
   );
 }
 function configList() {
@@ -9974,7 +10138,7 @@ function configList() {
 }
 
 // src/commands/config/configGet.ts
-import chalk102 from "chalk";
+import chalk104 from "chalk";
 
 // src/commands/config/getNestedValue.ts
 function isTraversable(value) {
@@ -10006,7 +10170,7 @@ function requireNestedValue(config, key) {
   return value;
 }
 function exitKeyNotSet(key) {
-  console.error(chalk102.red(`Key "${key}" is not set`));
+  console.error(chalk104.red(`Key "${key}" is not set`));
   process.exit(1);
 }
 
@@ -10019,8 +10183,8 @@ function registerConfig(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync27, readFileSync as readFileSync22, writeFileSync as writeFileSync22 } from "fs";
-import chalk103 from "chalk";
+import { existsSync as existsSync28, readFileSync as readFileSync23, writeFileSync as writeFileSync24 } from "fs";
+import chalk105 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -10028,24 +10192,24 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync27(indexPath)) {
-    console.log(chalk103.yellow("No index.html found"));
+  if (!existsSync28(indexPath)) {
+    console.log(chalk105.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync22(indexPath, "utf8");
+  const content = readFileSync23(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk103.dim("Trailing slash script already present"));
+    console.log(chalk105.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk103.red("Could not find </head> tag in index.html"));
+    console.log(chalk105.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = `${content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT}
   ${content.slice(headCloseIndex)}`;
-  writeFileSync22(indexPath, newContent);
-  console.log(chalk103.green("Added trailing slash redirect to index.html"));
+  writeFileSync24(indexPath, newContent);
+  console.log(chalk105.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/registerDeploy.ts
@@ -10060,11 +10224,11 @@ import { execFileSync as execFileSync2 } from "child_process";
 import { basename as basename4 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
-import { homedir as homedir11 } from "os";
-import { join as join25 } from "path";
-var BLOG_REPO_ROOT = join25(homedir11(), "git/blog");
+import { homedir as homedir12 } from "os";
+import { join as join27 } from "path";
+var BLOG_REPO_ROOT = join27(homedir12(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join25(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join27(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -10072,20 +10236,20 @@ function loadBlogSkipDays(repoName) {
 
 // src/commands/devlog/shared.ts
 import { execSync as execSync23 } from "child_process";
-import chalk104 from "chalk";
+import chalk106 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
-import { basename as basename3, join as join26 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { basename as basename3, join as join28 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join26(process.cwd(), "package.json");
-  if (existsSync28(packageJsonPath)) {
+  const packageJsonPath = join28(process.cwd(), "package.json");
+  if (existsSync29(packageJsonPath)) {
     try {
-      const content = readFileSync23(packageJsonPath, "utf8");
+      const content = readFileSync24(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -10097,9 +10261,9 @@ function getRepoName() {
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync, readFileSync as readFileSync24 } from "fs";
-import { join as join27 } from "path";
-var DEVLOG_DIR = join27(BLOG_REPO_ROOT, "src/content/devlog");
+import { readdirSync as readdirSync2, readFileSync as readFileSync25 } from "fs";
+import { join as join29 } from "path";
+var DEVLOG_DIR = join29(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -10125,9 +10289,9 @@ function parseFrontmatter(content, filename) {
 }
 function readDevlogFiles(callback) {
   try {
-    const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
+    const files = readdirSync2(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync24(join27(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync25(join29(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -10181,13 +10345,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits2, ignore2, verbose) {
   for (const commit2 of commits2) {
-    console.log(`  ${chalk104.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk106.yellow(commit2.hash)} ${commit2.message}`);
     if (verbose) {
       const visibleFiles = commit2.files.filter(
         (file) => !ignore2.some((p) => file.startsWith(p))
       );
       for (const file of visibleFiles) {
-        console.log(`    ${chalk104.dim(file)}`);
+        console.log(`    ${chalk106.dim(file)}`);
       }
     }
   }
@@ -10212,15 +10376,15 @@ function parseGitLogCommits(output, ignore2, afterDate) {
 }
 
 // src/commands/devlog/list/printDateHeader.ts
-import chalk105 from "chalk";
+import chalk107 from "chalk";
 function printDateHeader(date, isSkipped, entries) {
   if (isSkipped) {
-    console.log(`${chalk105.bold.blue(date)} ${chalk105.dim("skipped")}`);
+    console.log(`${chalk107.bold.blue(date)} ${chalk107.dim("skipped")}`);
   } else if (entries && entries.length > 0) {
-    const entryInfo = entries.map((e) => `${chalk105.green(e.version)} ${e.title}`).join(" | ");
-    console.log(`${chalk105.bold.blue(date)} ${entryInfo}`);
+    const entryInfo = entries.map((e) => `${chalk107.green(e.version)} ${e.title}`).join(" | ");
+    console.log(`${chalk107.bold.blue(date)} ${entryInfo}`);
   } else {
-    console.log(`${chalk105.bold.blue(date)} ${chalk105.red("\u26A0 devlog missing")}`);
+    console.log(`${chalk107.bold.blue(date)} ${chalk107.red("\u26A0 devlog missing")}`);
   }
 }
 
@@ -10324,24 +10488,24 @@ function bumpVersion(version2, type) {
 
 // src/commands/devlog/next/displayNextEntry/index.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import chalk107 from "chalk";
+import chalk109 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
-import chalk106 from "chalk";
+import chalk108 from "chalk";
 function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
   if (conventional && firstHash) {
     const version2 = getVersionAtCommit(firstHash);
     if (version2) {
-      console.log(`${chalk106.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk108.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk106.bold("version:")} ${chalk106.red("unknown")}`);
+      console.log(`${chalk108.bold("version:")} ${chalk108.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk106.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk108.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk106.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk108.bold("version:")} v0.1 (initial)`);
   }
 }
 
@@ -10389,16 +10553,16 @@ function noCommitsMessage(hasLastInfo) {
   return hasLastInfo ? "No commits after last versioned entry" : "No commits found";
 }
 function logName(repoName) {
-  console.log(`${chalk107.bold("name:")} ${repoName}`);
+  console.log(`${chalk109.bold("name:")} ${repoName}`);
 }
 function displayNextEntry(ctx, targetDate, commits2) {
   logName(ctx.repoName);
   printVersionInfo(ctx.config, ctx.lastInfo, commits2[0]?.hash);
-  console.log(chalk107.bold.blue(targetDate));
+  console.log(chalk109.bold.blue(targetDate));
   printCommitsWithFiles(commits2, ctx.ignore, ctx.verbose);
 }
 function logNoCommits(lastInfo) {
-  console.log(chalk107.dim(noCommitsMessage(!!lastInfo)));
+  console.log(chalk109.dim(noCommitsMessage(!!lastInfo)));
 }
 
 // src/commands/devlog/next/index.ts
@@ -10439,11 +10603,11 @@ function next2(options2) {
 import { execSync as execSync25 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
-import chalk108 from "chalk";
+import chalk110 from "chalk";
 function colorStatus(status2) {
-  if (status2 === "missing") return chalk108.red(status2);
-  if (status2 === "outdated") return chalk108.yellow(status2);
-  return chalk108.green(status2);
+  if (status2 === "missing") return chalk110.red(status2);
+  if (status2 === "outdated") return chalk110.yellow(status2);
+  return chalk110.green(status2);
 }
 function formatRow(row, nameWidth) {
   const devlog = (row.lastDevlog ?? "-").padEnd(11);
@@ -10457,8 +10621,8 @@ function printReposTable(rows) {
     "Last Devlog".padEnd(11),
     "Status"
   ].join("  ");
-  console.log(chalk108.dim(header));
-  console.log(chalk108.dim("-".repeat(header.length)));
+  console.log(chalk110.dim(header));
+  console.log(chalk110.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(formatRow(row, nameWidth));
   }
@@ -10514,16 +10678,16 @@ function repos(options2) {
 }
 
 // src/commands/devlog/skip.ts
-import { writeFileSync as writeFileSync23 } from "fs";
-import { join as join28 } from "path";
-import chalk109 from "chalk";
+import { writeFileSync as writeFileSync25 } from "fs";
+import { join as join30 } from "path";
+import chalk111 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join28(BLOG_REPO_ROOT, "assist.yml");
+  return join30(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk109.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk111.red("Invalid date format. Use YYYY-MM-DD"));
     process.exit(1);
   }
   const repoName = getRepoName();
@@ -10534,7 +10698,7 @@ function skip(date) {
   const skipDays = skip2[repoName] ?? [];
   if (skipDays.includes(date)) {
     console.log(
-      chalk109.yellow(`${date} is already in skip list for ${repoName}`)
+      chalk111.yellow(`${date} is already in skip list for ${repoName}`)
     );
     return;
   }
@@ -10543,21 +10707,21 @@ function skip(date) {
   skip2[repoName] = skipDays;
   devlog.skip = skip2;
   config.devlog = devlog;
-  writeFileSync23(configPath, stringifyYaml3(config, { lineWidth: 0 }));
-  console.log(chalk109.green(`Added ${date} to skip list for ${repoName}`));
+  writeFileSync25(configPath, stringifyYaml3(config, { lineWidth: 0 }));
+  console.log(chalk111.green(`Added ${date} to skip list for ${repoName}`));
 }
 
 // src/commands/devlog/version.ts
-import chalk110 from "chalk";
+import chalk112 from "chalk";
 function version() {
   const config = loadConfig();
   const name = getRepoName();
   const lastInfo = getLastVersionInfo(name, config);
   const lastVersion = lastInfo?.version ?? null;
   const nextVersion = lastVersion ? bumpVersion(lastVersion, "patch") : null;
-  console.log(`${chalk110.bold("name:")} ${name}`);
-  console.log(`${chalk110.bold("last:")} ${lastVersion ?? chalk110.dim("none")}`);
-  console.log(`${chalk110.bold("next:")} ${nextVersion ?? chalk110.dim("none")}`);
+  console.log(`${chalk112.bold("name:")} ${name}`);
+  console.log(`${chalk112.bold("last:")} ${lastVersion ?? chalk112.dim("none")}`);
+  console.log(`${chalk112.bold("next:")} ${nextVersion ?? chalk112.dim("none")}`);
 }
 
 // src/commands/registerDevlog.ts
@@ -10579,17 +10743,17 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join29 } from "path";
-import chalk111 from "chalk";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync3 } from "fs";
+import { join as join31 } from "path";
+import chalk113 from "chalk";
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import path22 from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path22.dirname(current)) {
-    if (existsSync29(path22.join(current, ".git"))) {
+    if (existsSync30(path22.join(current, ".git"))) {
       return current;
     }
     current = path22.dirname(current);
@@ -10602,13 +10766,13 @@ var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
 function isLockedDll(debugDir) {
   let files;
   try {
-    files = readdirSync2(debugDir, { recursive: true });
+    files = readdirSync3(debugDir, { recursive: true });
   } catch {
     return null;
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join29(debugDir, file);
+    const dllPath = join31(debugDir, file);
     try {
       const fd = openSync2(dllPath, "r+");
       closeSync2(fd);
@@ -10621,18 +10785,18 @@ function isLockedDll(debugDir) {
 function findFirstLockedDll(dir) {
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync3(dir);
   } catch {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join29(dir, "bin", "Debug"));
+    const locked = isLockedDll(join31(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(join29(dir, entry));
+    const found = findFirstLockedDll(join31(dir, entry));
     if (found) return found;
   }
   return null;
@@ -10644,22 +10808,22 @@ function checkBuildLocks(startDir) {
   const locked = findFirstLockedDll(startDir ?? getSearchRoot());
   if (locked) {
     console.error(
-      chalk111.red("Build output locked (is VS debugging?): ") + locked
+      chalk113.red("Build output locked (is VS debugging?): ") + locked
     );
     process.exit(1);
   }
 }
 async function checkBuildLocksCommand() {
   checkBuildLocks();
-  console.log(chalk111.green("No build locks detected"));
+  console.log(chalk113.green("No build locks detected"));
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import path23 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync25(csprojPath, "utf8");
+  const content = readFileSync26(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -10676,7 +10840,7 @@ function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
   for (const ref of getProjectRefs(abs)) {
     const childAbs = path23.resolve(dir, ref);
     try {
-      readFileSync25(childAbs);
+      readFileSync26(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
     } catch {
       node.children.push({
@@ -10701,14 +10865,14 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync26, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync27, statSync as statSync3 } from "fs";
 import path24 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return results;
   }
@@ -10717,7 +10881,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path24.join(dir, entry);
     try {
-      const stat2 = statSync2(full);
+      const stat2 = statSync3(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat2.isDirectory()) {
@@ -10736,7 +10900,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync26(sln, "utf8");
+      const content = readFileSync27(sln, "utf8");
       if (pattern2.test(content)) {
         matches.push(path24.relative(repoRoot, sln));
       }
@@ -10750,30 +10914,30 @@ function escapeRegex(s) {
 }
 
 // src/commands/dotnet/printTree.ts
-import chalk112 from "chalk";
+import chalk114 from "chalk";
 function printNodes(nodes, prefix2) {
   for (let i = 0; i < nodes.length; i++) {
     const isLast = i === nodes.length - 1;
     const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
     const childPrefix = isLast ? "    " : "\u2502   ";
     const isMissing = nodes[i].relativePath.startsWith("[MISSING]");
-    const label2 = isMissing ? chalk112.red(nodes[i].relativePath) : nodes[i].relativePath;
+    const label2 = isMissing ? chalk114.red(nodes[i].relativePath) : nodes[i].relativePath;
     console.log(`${prefix2}${connector}${label2}`);
     printNodes(nodes[i].children, prefix2 + childPrefix);
   }
 }
 function printTree(tree, totalCount, solutions) {
-  console.log(chalk112.bold("\nProject Dependency Tree"));
-  console.log(chalk112.cyan(tree.relativePath));
+  console.log(chalk114.bold("\nProject Dependency Tree"));
+  console.log(chalk114.cyan(tree.relativePath));
   printNodes(tree.children, "");
-  console.log(chalk112.dim(`
+  console.log(chalk114.dim(`
 ${totalCount} projects total (including root)`));
-  console.log(chalk112.bold("\nSolution Membership"));
+  console.log(chalk114.bold("\nSolution Membership"));
   if (solutions.length === 0) {
-    console.log(chalk112.yellow("  Not found in any .sln"));
+    console.log(chalk114.yellow("  Not found in any .sln"));
   } else {
     for (const sln of solutions) {
-      console.log(`  ${chalk112.green(sln)}`);
+      console.log(`  ${chalk114.green(sln)}`);
     }
   }
   console.log();
@@ -10800,18 +10964,18 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import path25 from "path";
-import chalk113 from "chalk";
+import chalk115 from "chalk";
 function resolveCsproj(csprojPath) {
   const resolved = path25.resolve(csprojPath);
-  if (!existsSync30(resolved)) {
-    console.error(chalk113.red(`File not found: ${resolved}`));
+  if (!existsSync31(resolved)) {
+    console.error(chalk115.red(`File not found: ${resolved}`));
     process.exit(1);
   }
   const repoRoot = findRepoRoot(path25.dirname(resolved));
   if (!repoRoot) {
-    console.error(chalk113.red("Could not find git repository root"));
+    console.error(chalk115.red("Could not find git repository root"));
     process.exit(1);
   }
   return { resolved, repoRoot };
@@ -10861,12 +11025,12 @@ function getChangedCsFiles(scope) {
 }
 
 // src/commands/dotnet/inSln.ts
-import chalk114 from "chalk";
+import chalk116 from "chalk";
 async function inSln(csprojPath) {
   const { resolved, repoRoot } = resolveCsproj(csprojPath);
   const solutions = findContainingSolutions(resolved, repoRoot);
   if (solutions.length === 0) {
-    console.log(chalk114.yellow("Not found in any .sln file"));
+    console.log(chalk116.yellow("Not found in any .sln file"));
     process.exit(1);
   }
   for (const sln of solutions) {
@@ -10875,7 +11039,7 @@ async function inSln(csprojPath) {
 }
 
 // src/commands/dotnet/inspect.ts
-import chalk120 from "chalk";
+import chalk122 from "chalk";
 
 // src/shared/formatElapsed.ts
 function formatElapsed(ms) {
@@ -10887,12 +11051,12 @@ function formatElapsed(ms) {
 }
 
 // src/commands/dotnet/displayIssues.ts
-import chalk115 from "chalk";
+import chalk117 from "chalk";
 var SEVERITY_COLOR = {
-  ERROR: chalk115.red,
-  WARNING: chalk115.yellow,
-  SUGGESTION: chalk115.cyan,
-  HINT: chalk115.dim
+  ERROR: chalk117.red,
+  WARNING: chalk117.yellow,
+  SUGGESTION: chalk117.cyan,
+  HINT: chalk117.dim
 };
 function groupByFile(issues) {
   const byFile = /* @__PURE__ */ new Map();
@@ -10908,15 +11072,15 @@ function groupByFile(issues) {
 }
 function displayIssues(issues) {
   for (const [file, fileIssues] of groupByFile(issues)) {
-    console.log(chalk115.bold(file));
+    console.log(chalk117.bold(file));
     for (const issue of fileIssues.sort((a, b) => a.line - b.line)) {
-      const color = SEVERITY_COLOR[issue.severity] ?? chalk115.white;
+      const color = SEVERITY_COLOR[issue.severity] ?? chalk117.white;
       console.log(
-        `  ${chalk115.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
+        `  ${chalk117.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
       );
     }
   }
-  console.log(chalk115.dim(`
+  console.log(chalk117.dim(`
 ${issues.length} issue(s) found`));
 }
 
@@ -10973,17 +11137,17 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import path26 from "path";
-import chalk117 from "chalk";
+import chalk119 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
-import { readdirSync as readdirSync4 } from "fs";
-import { dirname as dirname18, join as join30 } from "path";
-import chalk116 from "chalk";
+import { readdirSync as readdirSync5 } from "fs";
+import { dirname as dirname18, join as join32 } from "path";
+import chalk118 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync4(dir).filter((f) => f.endsWith(".sln")).map((f) => join30(dir, f));
+    return readdirSync5(dir).filter((f) => f.endsWith(".sln")).map((f) => join32(dir, f));
   } catch {
     return [];
   }
@@ -10996,17 +11160,17 @@ function findSolution() {
     const slnFiles = findSlnInDir(current);
     if (slnFiles.length === 1) return slnFiles[0];
     if (slnFiles.length > 1) {
-      console.error(chalk116.red(`Multiple .sln files found in ${current}:`));
+      console.error(chalk118.red(`Multiple .sln files found in ${current}:`));
       for (const f of slnFiles) console.error(`  ${f}`);
       console.error(
-        chalk116.yellow("Specify which one: assist dotnet inspect <sln>")
+        chalk118.yellow("Specify which one: assist dotnet inspect <sln>")
       );
       process.exit(1);
     }
     if (current === ceiling) break;
     current = dirname18(current);
   }
-  console.error(chalk116.red("No .sln file found between cwd and repo root"));
+  console.error(chalk118.red("No .sln file found between cwd and repo root"));
   process.exit(1);
 }
 
@@ -11014,8 +11178,8 @@ function findSolution() {
 function resolveSolution(sln) {
   if (sln) {
     const resolved = path26.resolve(sln);
-    if (!existsSync31(resolved)) {
-      console.error(chalk117.red(`Solution file not found: ${resolved}`));
+    if (!existsSync32(resolved)) {
+      console.error(chalk119.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
     return resolved;
@@ -11054,17 +11218,17 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync27 } from "child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync27, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync28, unlinkSync as unlinkSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path27 from "path";
-import chalk118 from "chalk";
+import chalk120 from "chalk";
 function assertJbInstalled() {
   try {
     execSync27("jb inspectcode --version", { stdio: "pipe" });
   } catch {
-    console.error(chalk118.red("jb is not installed. Install with:"));
+    console.error(chalk120.red("jb is not installed. Install with:"));
     console.error(
-      chalk118.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
+      chalk120.yellow("  dotnet tool install -g JetBrains.ReSharper.GlobalTools")
     );
     process.exit(1);
   }
@@ -11082,21 +11246,21 @@ function runInspectCode(slnPath, include, swea) {
     if (error && typeof error === "object" && "stderr" in error) {
       process.stderr.write(error.stderr);
     }
-    console.error(chalk118.red("jb inspectcode failed"));
+    console.error(chalk120.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync32(reportPath)) {
-    console.error(chalk118.red("Report file not generated"));
+  if (!existsSync33(reportPath)) {
+    console.error(chalk120.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync27(reportPath, "utf8");
-  unlinkSync7(reportPath);
+  const xml = readFileSync28(reportPath, "utf8");
+  unlinkSync9(reportPath);
   return xml;
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
 import { execSync as execSync28 } from "child_process";
-import chalk119 from "chalk";
+import chalk121 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
   const configs = resolveRunConfigs(run4, getConfigDir());
@@ -11108,9 +11272,9 @@ function assertMsbuildInstalled() {
   try {
     execSync28(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
-    console.error(chalk119.red(`msbuild not found at: ${msbuild}`));
+    console.error(chalk121.red(`msbuild not found at: ${msbuild}`));
     console.error(
-      chalk119.yellow(
+      chalk121.yellow(
         "Configure it via a 'build' run entry in .claude/assist.yml or add msbuild to PATH."
       )
     );
@@ -11157,17 +11321,17 @@ function runEngine(resolved, changedFiles, options2) {
 // src/commands/dotnet/inspect.ts
 function logScope(changedFiles) {
   if (changedFiles === null) {
-    console.log(chalk120.dim("Inspecting full solution..."));
+    console.log(chalk122.dim("Inspecting full solution..."));
   } else {
     console.log(
-      chalk120.dim(`Inspecting ${changedFiles.length} changed file(s)...`)
+      chalk122.dim(`Inspecting ${changedFiles.length} changed file(s)...`)
     );
   }
 }
 function reportResults(issues, elapsed) {
   if (issues.length > 0) displayIssues(issues);
-  else console.log(chalk120.green("No issues found"));
-  console.log(chalk120.dim(`Completed in ${formatElapsed(elapsed)}`));
+  else console.log(chalk122.green("No issues found"));
+  console.log(chalk122.dim(`Completed in ${formatElapsed(elapsed)}`));
   if (issues.length > 0) process.exit(1);
 }
 async function inspect(sln, options2) {
@@ -11178,7 +11342,7 @@ async function inspect(sln, options2) {
   const scope = parseScope(options2.scope);
   const changedFiles = getChangedCsFiles(scope);
   if (changedFiles !== null && changedFiles.length === 0) {
-    console.log(chalk120.green("No changed .cs files found"));
+    console.log(chalk122.green("No changed .cs files found"));
     return;
   }
   logScope(changedFiles);
@@ -11206,8 +11370,94 @@ function registerDotnet(program2) {
 // src/commands/editHook/index.ts
 import fs19 from "fs";
 
+// src/commands/editHook/extractComments.ts
+var SOURCE_EXTENSIONS2 = [
+  ".ts",
+  ".tsx",
+  ".cts",
+  ".mts",
+  ".js",
+  ".jsx",
+  ".cjs",
+  ".mjs"
+];
+function isSourceFile(filePath) {
+  if (!filePath) return false;
+  return SOURCE_EXTENSIONS2.some((ext) => filePath.endsWith(ext));
+}
+function blankNonNewline(text6) {
+  return text6.replace(/[^\n]/g, " ");
+}
+function extractComments(text6) {
+  const comments3 = [];
+  let work = text6.replace(
+    /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g,
+    blankNonNewline
+  );
+  work = work.replace(/\/\*[\s\S]*?\*\//g, (match) => {
+    comments3.push(match);
+    return blankNonNewline(match);
+  });
+  for (const match of work.matchAll(/\/\/.*/g)) {
+    comments3.push(match[0]);
+  }
+  return comments3.map((comment3) => comment3.replace(/\s+/g, " ").trim()).filter((comment3) => comment3.length > 0).filter((comment3) => !isCommentExempt(comment3));
+}
+
+// src/commands/editHook/decideCommentGuard.ts
+var DENY_REASON = 'This edit introduces a code comment, which is blocked by the comment gate. Comments are a last resort \u2014 prefer a clearer name, a smaller function, or a test that makes the comment unnecessary. The comment must not appear in your edit itself. If this one line genuinely earns its keep, use the escape hatch: run `assist code-comment set <file> <line> "<text>"` (single line, max 50 chars, no block comments) to get a pin, then `assist code-comment confirm <pin>` to insert it.';
+function defined(values) {
+  return values.filter((value) => value != null);
+}
+function partitionStrings(input, existingContent) {
+  const { tool_name, tool_input } = input;
+  switch (tool_name) {
+    case "Edit":
+      return {
+        added: defined([tool_input.new_string]),
+        removed: defined([tool_input.old_string])
+      };
+    case "MultiEdit": {
+      const edits = tool_input.edits ?? [];
+      return {
+        added: defined(edits.map((e) => e.new_string)),
+        removed: defined(edits.map((e) => e.old_string))
+      };
+    }
+    case "Write":
+      return {
+        added: defined([tool_input.content]),
+        removed: defined([existingContent])
+      };
+    default:
+      return { added: [], removed: [] };
+  }
+}
+function introducedComments(added, removed) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const comment3 of removed) {
+    counts.set(comment3, (counts.get(comment3) ?? 0) + 1);
+  }
+  const introduced = [];
+  for (const comment3 of added) {
+    const remaining = counts.get(comment3) ?? 0;
+    if (remaining > 0) counts.set(comment3, remaining - 1);
+    else introduced.push(comment3);
+  }
+  return introduced;
+}
+function decideCommentGuard(input, existingContent) {
+  if (!isSourceFile(input.tool_input.file_path)) return void 0;
+  const { added, removed } = partitionStrings(input, existingContent);
+  const introduced = introducedComments(
+    added.flatMap(extractComments),
+    removed.flatMap(extractComments)
+  );
+  return introduced.length > 0 ? DENY_REASON : void 0;
+}
+
 // src/commands/editHook/decideOverrideGuard.ts
-var DENY_REASON = `Edits touching the '${MAINTAINABILITY_OVERRIDE_MARKER}' marker are blocked. This marker is a human-managed maintainability gate exception \u2014 an agent may not add, change, or remove it. If a file genuinely needs a different threshold, raise it with a human.`;
+var DENY_REASON2 = `Edits touching the '${MAINTAINABILITY_OVERRIDE_MARKER}' marker are blocked. This marker is a human-managed maintainability gate exception \u2014 an agent may not add, change, or remove it. If a file genuinely needs a different threshold, raise it with a human.`;
 function candidateStrings(input, existingContent) {
   const { tool_name, tool_input } = input;
   switch (tool_name) {
@@ -11233,7 +11483,7 @@ function decideOverrideGuard(input, existingContent) {
   const touchesMarker = candidateStrings(input, existingContent).some(
     (s) => s.includes(MAINTAINABILITY_OVERRIDE_MARKER)
   );
-  return touchesMarker ? DENY_REASON : void 0;
+  return touchesMarker ? DENY_REASON2 : void 0;
 }
 
 // src/commands/editHook/index.ts
@@ -11259,7 +11509,7 @@ async function editHook() {
   const input = tryParseInput2(await readStdin());
   if (!input) return;
   const existing = input.tool_name === "Write" ? readExisting(input.tool_input.file_path) : void 0;
-  const reason = decideOverrideGuard(input, existing);
+  const reason = decideOverrideGuard(input, existing) ?? decideCommentGuard(input, existing);
   if (!reason) return;
   console.log(
     JSON.stringify({
@@ -11275,7 +11525,7 @@ async function editHook() {
 // src/commands/registerEditHook.ts
 function registerEditHook(program2) {
   program2.command("edit-hook").description(
-    "PreToolUse hook that blocks edits to the maintainability override marker"
+    "PreToolUse hook that blocks edits to the maintainability override marker and edits that introduce code comments"
   ).action(() => {
     editHook();
   });
@@ -11294,9 +11544,9 @@ function aggregateCommitters(authorLists) {
 
 // src/shared/runGhGraphql.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync26 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join31 } from "path";
+import { join as join33 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -11321,8 +11571,8 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join31(tmpdir4(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync24(queryFile, mutation);
+  const queryFile = join33(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync26(queryFile, mutation);
   try {
     const result = spawnSync3("gh", buildArgs2(queryFile, vars), {
       encoding: "utf8"
@@ -11331,7 +11581,7 @@ function runGhGraphql(mutation, vars) {
     throwOnGraphqlErrors(result.stdout);
     return result.stdout;
   } finally {
-    unlinkSync8(queryFile);
+    unlinkSync10(queryFile);
   }
 }
 
@@ -11385,25 +11635,25 @@ function fetchRepoCommitAuthors(org, repo, since) {
 }
 
 // src/commands/github/printCountTable.ts
-import chalk121 from "chalk";
+import chalk123 from "chalk";
 function printCountTable(labelHeader, rows) {
   const labelWidth = Math.max(
     labelHeader.length,
     ...rows.map((row) => row.label.length)
   );
   const header = `${labelHeader.padEnd(labelWidth)}  Commits`;
-  console.log(chalk121.dim(header));
-  console.log(chalk121.dim("-".repeat(header.length)));
+  console.log(chalk123.dim(header));
+  console.log(chalk123.dim("-".repeat(header.length)));
   for (const row of rows) {
     console.log(`${row.label.padEnd(labelWidth)}  ${row.count}`);
   }
 }
 
 // src/commands/github/printRepoAuthorBreakdown.ts
-import chalk122 from "chalk";
+import chalk124 from "chalk";
 function printRepoAuthorBreakdown(repos2) {
   for (const repo of repos2) {
-    console.log(chalk122.bold(repo.name));
+    console.log(chalk124.bold(repo.name));
     const authorWidth = Math.max(
       0,
       ...repo.authors.map((a) => a.author.length)
@@ -11508,24 +11758,24 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync33,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync28,
+  existsSync as existsSync34,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync29,
   rmSync as rmSync2,
-  statSync as statSync3
+  statSync as statSync4
 } from "fs";
-import { basename as basename5, join as join34 } from "path";
+import { basename as basename5, join as join36 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join32 } from "path";
+import { join as join34 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join32(cwd, ".assist", "HANDOVER.md");
+  return join34(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join33(cwd, ".assist", "handovers");
+  return join35(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -11563,17 +11813,17 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync33(dir)) return [];
+  if (!existsSync34(dir)) return [];
   const out = [];
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const full = join34(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const full = join36(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 = readFileSync28(file, "utf8");
+  const content = readFileSync29(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -11585,13 +11835,13 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename5(file)) ?? statSync3(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename5(file)) ?? statSync4(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync33(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync3(handoverPath).mtime);
+  if (existsSync34(handoverPath)) {
+    await migrateFile(orm, origin, handoverPath, statSync4(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -11721,7 +11971,7 @@ function registerHandover(program2) {
 }
 
 // src/commands/jira/acceptanceCriteria.ts
-import chalk124 from "chalk";
+import chalk126 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
@@ -11782,7 +12032,7 @@ function adfToText(doc) {
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync29 } from "child_process";
-import chalk123 from "chalk";
+import chalk125 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
@@ -11795,15 +12045,15 @@ function fetchIssue(issueKey, fields) {
       const stderr = error.stderr;
       if (stderr.includes("unauthorized")) {
         console.error(
-          chalk123.red("Jira authentication expired."),
+          chalk125.red("Jira authentication expired."),
           "Run",
-          chalk123.cyan("assist jira auth"),
+          chalk125.cyan("assist jira auth"),
           "to re-authenticate."
         );
         process.exit(1);
       }
     }
-    console.error(chalk123.red(`Failed to fetch ${issueKey}.`));
+    console.error(chalk125.red(`Failed to fetch ${issueKey}.`));
     process.exit(1);
   }
   return JSON.parse(result);
@@ -11817,7 +12067,7 @@ function acceptanceCriteria(issueKey) {
   const parsed = fetchIssue(issueKey, field);
   const acValue = parsed?.fields?.[field];
   if (!acValue) {
-    console.log(chalk124.yellow(`No acceptance criteria found on ${issueKey}.`));
+    console.log(chalk126.yellow(`No acceptance criteria found on ${issueKey}.`));
     return;
   }
   if (typeof acValue === "string") {
@@ -11835,20 +12085,20 @@ function acceptanceCriteria(issueKey) {
 import { execSync as execSync30 } from "child_process";
 
 // src/shared/loadJson.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync11, readFileSync as readFileSync29, writeFileSync as writeFileSync25 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join35 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync12, readFileSync as readFileSync30, writeFileSync as writeFileSync27 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join37 } from "path";
 function getStoreDir() {
-  return join35(homedir12(), ".assist");
+  return join37(homedir13(), ".assist");
 }
 function getStorePath(filename) {
-  return join35(getStoreDir(), filename);
+  return join37(getStoreDir(), filename);
 }
 function loadJson(filename) {
   const path57 = getStorePath(filename);
-  if (existsSync34(path57)) {
+  if (existsSync35(path57)) {
     try {
-      return JSON.parse(readFileSync29(path57, "utf8"));
+      return JSON.parse(readFileSync30(path57, "utf8"));
     } catch {
       return {};
     }
@@ -11857,10 +12107,10 @@ function loadJson(filename) {
 }
 function saveJson(filename, data) {
   const dir = getStoreDir();
-  if (!existsSync34(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  if (!existsSync35(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
-  writeFileSync25(getStorePath(filename), JSON.stringify(data, null, 2));
+  writeFileSync27(getStorePath(filename), JSON.stringify(data, null, 2));
 }
 
 // src/shared/promptInput.ts
@@ -11912,14 +12162,14 @@ async function jiraAuth() {
 }
 
 // src/commands/jira/viewIssue.ts
-import chalk125 from "chalk";
+import chalk127 from "chalk";
 function viewIssue(issueKey) {
   const parsed = fetchIssue(issueKey, "summary,description");
   const fields = parsed?.fields;
   const summary = fields?.summary;
   const description = fields?.description;
   if (summary) {
-    console.log(chalk125.bold(summary));
+    console.log(chalk127.bold(summary));
   }
   if (description) {
     if (summary) console.log();
@@ -11933,7 +12183,7 @@ function viewIssue(issueKey) {
   }
   if (!summary && !description) {
     console.log(
-      chalk125.yellow(`No summary or description found on ${issueKey}.`)
+      chalk127.yellow(`No summary or description found on ${issueKey}.`)
     );
   }
 }
@@ -11949,13 +12199,13 @@ function registerJira(program2) {
 // src/commands/reviewComments.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
-import chalk126 from "chalk";
+import chalk128 from "chalk";
 async function reviewComments(number) {
   if (number) {
     try {
       execFileSync5("gh", ["pr", "checkout", number], { stdio: "inherit" });
     } catch {
-      console.error(chalk126.red(`gh pr checkout ${number} failed; aborting.`));
+      console.error(chalk128.red(`gh pr checkout ${number} failed; aborting.`));
       process.exit(1);
     }
   }
@@ -11999,17 +12249,17 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync12, readdirSync as readdirSync6 } from "fs";
+import { mkdirSync as mkdirSync13, readdirSync as readdirSync7 } from "fs";
 import { resolve as resolve11 } from "path";
-import chalk129 from "chalk";
+import chalk131 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync26 } from "fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
 import { basename as basename6, extname, resolve as resolve10 } from "path";
-import chalk128 from "chalk";
+import chalk130 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
-import chalk127 from "chalk";
+import chalk129 from "chalk";
 async function renderBlock(krokiUrl, source) {
   const response = await fetch(`${krokiUrl}/mermaid/svg`, {
     method: "POST",
@@ -12018,7 +12268,7 @@ async function renderBlock(krokiUrl, source) {
   });
   if (!response.ok) {
     console.error(
-      chalk127.red(
+      chalk129.red(
         `Kroki request failed: ${response.status} ${response.statusText}`
       )
     );
@@ -12030,33 +12280,33 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync30(file, "utf8");
+  const content = readFileSync31(file, "utf8");
   const blocks = extractMermaidBlocks(content);
   const stem = basename6(file, extname(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
-        chalk128.red(
+        chalk130.red(
           `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk128.gray(
+      chalk130.gray(
         `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
       )
     );
   } else {
-    console.log(chalk128.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
+    console.log(chalk130.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
   }
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
     const outPath = resolve10(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
-    writeFileSync26(outPath, svg, "utf8");
-    console.log(chalk128.green(`  \u2192 ${outPath}`));
+    writeFileSync28(outPath, svg, "utf8");
+    console.log(chalk130.green(`  \u2192 ${outPath}`));
   }
 }
 function extractMermaidBlocks(markdown) {
@@ -12068,22 +12318,22 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve11(process.cwd(), options2.out ?? ".");
-  mkdirSync12(outDir, { recursive: true });
+  mkdirSync13(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
-        chalk129.red(`--index must be a positive integer (got ${options2.index})`)
+        chalk131.red(`--index must be a positive integer (got ${options2.index})`)
       );
       process.exit(1);
     }
     if (!file) {
-      console.error(chalk129.red("--index requires a file argument"));
+      console.error(chalk131.red("--index requires a file argument"));
       process.exit(1);
     }
   }
-  const files = file ? [file] : readdirSync6(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
+  const files = file ? [file] : readdirSync7(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
-    console.log(chalk129.gray("No markdown files found in current directory."));
+    console.log(chalk131.gray("No markdown files found in current directory."));
     return;
   }
   for (const f of files) {
@@ -12109,7 +12359,7 @@ function registerMermaid(program2) {
 import { mkdir as mkdir3 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import { dirname as dirname20 } from "path";
-import chalk131 from "chalk";
+import chalk133 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -12187,15 +12437,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join37 } from "path";
-import chalk130 from "chalk";
+import { join as join39 } from "path";
+import chalk132 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname19, join as join36 } from "path";
+import { dirname as dirname19, join as join38 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var moduleDir = dirname19(fileURLToPath5(import.meta.url));
 function netcapExtensionDir() {
-  return join36(moduleDir, "commands", "netcap", "netcap-extension");
+  return join38(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -12210,7 +12460,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join37(dir, "background.js");
+  const file = join39(dir, "background.js");
   const source = await readFile2(file, "utf8");
   await writeFile2(
     file,
@@ -12232,7 +12482,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk130.yellow("could not determine the WSL IP for the extension")
+      chalk132.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -12243,27 +12493,27 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
-      chalk130.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+      chalk132.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
     );
     return source;
   }
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute, join as join39, resolve as resolve12 } from "path";
+import { isAbsolute, join as join41, resolve as resolve12 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
-import { homedir as homedir13 } from "os";
-import { join as join38 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join40 } from "path";
 function defaultCapturePath() {
-  return join38(homedir13(), ".assist", "netcap", "capture.jsonl");
+  return join40(homedir14(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute(out) ? out : resolve12(process.cwd(), out);
-  return join39(dir, "capture.jsonl");
+  return join41(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -12276,30 +12526,30 @@ async function netcap(options2) {
   let count6 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk131.dim("ping from extension")),
+    onPing: () => console.log(chalk133.dim("ping from extension")),
     onCapture: (entry) => {
       count6 += 1;
       console.log(
-        chalk131.green(`captured #${count6}`),
-        chalk131.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk133.green(`captured #${count6}`),
+        chalk133.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk131.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk133.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk131.dim(`appending captures to ${outPath}`));
+    console.log(chalk133.dim(`appending captures to ${outPath}`));
     if (filter)
-      console.log(chalk131.dim(`forwarding only URLs matching "${filter}"`));
-    console.log(chalk131.dim(`load the unpacked extension from ${extensionPath}`));
-    console.log(chalk131.dim("press Ctrl-C to stop"));
+      console.log(chalk133.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk133.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk133.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk131.bold(
+      chalk133.bold(
         `
 netcap stopped \u2014 captured ${count6} ${count6 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -12309,12 +12559,12 @@ netcap stopped \u2014 captured ${count6} ${count6 === 1 ? "entry" : "entries"} t
 }
 
 // src/commands/netcap/netcapExtract.ts
-import { writeFileSync as writeFileSync27 } from "fs";
-import { join as join40 } from "path";
-import chalk132 from "chalk";
+import { writeFileSync as writeFileSync29 } from "fs";
+import { join as join42 } from "path";
+import chalk134 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -12710,7 +12960,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines = readFileSync31(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync32(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines) {
     let entry;
@@ -12755,12 +13005,12 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join40(captureFile, "..", "posts.json");
-  writeFileSync27(outFile, `${JSON.stringify(posts, null, 2)}
+  const outFile = join42(captureFile, "..", "posts.json");
+  writeFileSync29(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk132.green(`extracted ${posts.length} posts`),
-    chalk132.dim(`-> ${outFile}`)
+    chalk134.green(`extracted ${posts.length} posts`),
+    chalk134.dim(`-> ${outFile}`)
   );
 }
 
@@ -12781,7 +13031,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk133 from "chalk";
+import chalk135 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -12803,10 +13053,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk133.yellow("Feed already exists"));
+    console.log(chalk135.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk133.green(`Added feed: ${url}`));
+  console.log(chalk135.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -12816,7 +13066,7 @@ function registerNews(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk134 from "chalk";
+import chalk136 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -12834,14 +13084,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk134.dim(header));
-  console.log(chalk134.dim("-".repeat(header.length)));
+  console.log(chalk136.dim(header));
+  console.log(chalk136.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count6 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk134.yellow(count6)}  ${tool}  ${command}  ${chalk134.dim(row.repos)}`
+      `${chalk136.yellow(count6)}  ${tool}  ${command}  ${chalk136.dim(row.repos)}`
     );
   }
 }
@@ -13189,29 +13439,29 @@ import { execSync as execSync35 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
 import { execSync as execSync34 } from "child_process";
-import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync28 } from "fs";
+import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join42 } from "path";
+import { join as join44 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync35, readFileSync as readFileSync32, unlinkSync as unlinkSync9 } from "fs";
-import { join as join41 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync33, unlinkSync as unlinkSync11 } from "fs";
+import { join as join43 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join41(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join43(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync35(cachePath)) {
+  if (!existsSync36(cachePath)) {
     return null;
   }
-  const content = readFileSync32(cachePath, "utf8");
+  const content = readFileSync33(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync35(cachePath)) {
-    unlinkSync9(cachePath);
+  if (existsSync36(cachePath)) {
+    unlinkSync11(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
 }
@@ -13228,15 +13478,15 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join42(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync28(queryFile, mutation);
+  const queryFile = join44(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync30(queryFile, mutation);
   try {
     execSync34(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
   } finally {
-    unlinkSync10(queryFile);
+    unlinkSync12(queryFile);
   }
 }
 function requireCache(prNumber) {
@@ -13310,19 +13560,19 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync13, writeFileSync as writeFileSync30 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync14, writeFileSync as writeFileSync32 } from "fs";
+import { join as join46 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync36 } from "child_process";
-import { unlinkSync as unlinkSync11, writeFileSync as writeFileSync29 } from "fs";
+import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join43 } from "path";
+import { join as join45 } 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 = join43(tmpdir6(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync29(queryFile, THREAD_QUERY);
+  const queryFile = join45(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync31(queryFile, THREAD_QUERY);
   try {
     const result = execSync36(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
@@ -13341,7 +13591,7 @@ function fetchThreadIds(org, repo, prNumber) {
     }
     return { threadMap, resolvedThreadIds };
   } finally {
-    unlinkSync11(queryFile);
+    unlinkSync13(queryFile);
   }
 }
 
@@ -13390,20 +13640,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/printComments.ts
-import chalk135 from "chalk";
+import chalk137 from "chalk";
 function formatForHuman(comment3) {
   if (comment3.type === "review") {
-    const stateColor = comment3.state === "APPROVED" ? chalk135.green : comment3.state === "CHANGES_REQUESTED" ? chalk135.red : chalk135.yellow;
+    const stateColor = comment3.state === "APPROVED" ? chalk137.green : comment3.state === "CHANGES_REQUESTED" ? chalk137.red : chalk137.yellow;
     return [
-      `${chalk135.cyan("Review")} by ${chalk135.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
+      `${chalk137.cyan("Review")} by ${chalk137.bold(comment3.user)} ${stateColor(`[${comment3.state}]`)}`,
       comment3.body,
       ""
     ].join("\n");
   }
   const location = comment3.line ? `:${comment3.line}` : "";
   return [
-    `${chalk135.cyan("Line comment")} by ${chalk135.bold(comment3.user)} on ${chalk135.dim(`${comment3.path}${location}`)}`,
-    chalk135.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk137.cyan("Line comment")} by ${chalk137.bold(comment3.user)} on ${chalk137.dim(`${comment3.path}${location}`)}`,
+    chalk137.dim(comment3.diff_hunk.split("\n").slice(-3).join("\n")),
     comment3.body,
     ""
   ].join("\n");
@@ -13435,17 +13685,17 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join44(process.cwd(), ".assist");
-  if (!existsSync36(assistDir)) {
-    mkdirSync13(assistDir, { recursive: true });
+  const assistDir = join46(process.cwd(), ".assist");
+  if (!existsSync37(assistDir)) {
+    mkdirSync14(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join44(assistDir, `pr-${prNumber}-comments.yaml`);
-  writeFileSync30(cachePath, stringify(cacheData));
+  const cachePath = join46(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync32(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -13477,7 +13727,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join44(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join46(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -13493,13 +13743,13 @@ import { execSync as execSync38 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk136 from "chalk";
+import chalk138 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk136.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk136.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk138.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk138.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk136.green("opened"), date: pr.createdAt };
+  return { label: chalk138.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -13508,11 +13758,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status2) {
-  return `${chalk136.cyan(`#${pr.number}`)} ${pr.title} ${chalk136.dim(`(${pr.author.login},`)} ${status2.label} ${chalk136.dim(`${formatDate(status2.date)})`)}`;
+  return `${chalk138.cyan(`#${pr.number}`)} ${pr.title} ${chalk138.dim(`(${pr.author.login},`)} ${status2.label} ${chalk138.dim(`${formatDate(status2.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk136.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk138.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -13819,10 +14069,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk142 from "chalk";
+import chalk144 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk137 from "chalk";
+import chalk139 from "chalk";
 function listConnections(connections, format2) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -13835,7 +14085,7 @@ function listConnections(connections, format2) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk137.red(`Connection "${name}" not found.`));
+    console.error(chalk139.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -13881,15 +14131,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk140 from "chalk";
+import chalk142 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk139 from "chalk";
+import chalk141 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync41 } from "child_process";
-import chalk138 from "chalk";
+import chalk140 from "chalk";
 function opExec(args) {
   return execSync41(`op ${args}`, {
     encoding: "utf8",
@@ -13902,7 +14152,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk138.red(
+      chalk140.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -13916,7 +14166,7 @@ function getItemFields(itemId) {
     const item = JSON.parse(opExec(`item get "${itemId}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk138.red("Failed to get item details from 1Password."));
+    console.error(chalk140.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -13935,7 +14185,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk139.red(`No items found matching "${search2}".`));
+    console.error(chalk141.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId = await selectOne(
@@ -13944,7 +14194,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId);
   if (fields.length === 0) {
-    console.error(chalk139.red("No fields with references found on this item."));
+    console.error(chalk141.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -13958,7 +14208,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk140.red(`Connection "${name}" already exists.`));
+    console.error(chalk142.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -13967,22 +14217,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk140.red("All fields are required."));
+    console.error(chalk142.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk140.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk142.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk141 from "chalk";
+import chalk143 from "chalk";
 function ravendbSetConnection(name) {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb ?? {};
   const connections = ravendb.connections ?? [];
   if (!connections.some((c) => c.name === name)) {
-    console.error(chalk141.red(`Connection "${name}" not found.`));
+    console.error(chalk143.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -13998,16 +14248,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk142.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk144.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk146 from "chalk";
+import chalk148 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk144 from "chalk";
+import chalk146 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -14044,10 +14294,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync42 } from "child_process";
-import chalk143 from "chalk";
+import chalk145 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk143.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk145.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -14057,7 +14307,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk143.red(
+      chalk145.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -14084,7 +14334,7 @@ async function ravenFetch(connection, path57) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk144.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk146.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -14093,7 +14343,7 @@ async function ravenFetch(connection, path57) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk145 from "chalk";
+import chalk147 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -14107,7 +14357,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk145.red(
+      chalk147.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -14115,7 +14365,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk145.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk147.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -14146,15 +14396,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk146.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk148.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk148 from "chalk";
+import chalk150 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk147 from "chalk";
+import chalk149 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -14192,7 +14442,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk147.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk149.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -14207,7 +14457,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk148.red("Provide a collection name or --query filter."));
+    console.error(chalk150.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -14245,7 +14495,7 @@ import { spawn as spawn5 } from "child_process";
 import * as path28 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk149 from "chalk";
+import chalk151 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -14254,43 +14504,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk149.red(`
+  console.error(chalk151.red(`
 Refactor check failed:
 `));
-  console.error(chalk149.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk151.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk149.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk151.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk149.yellow(
+    chalk151.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk149.gray(`    assist refactor ignore <file>
+  console.error(chalk151.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk149.cyan(`
+    console.error(chalk151.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk149.cyan(
+      chalk151.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk149.cyan(
+      chalk151.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk149.cyan(
+      chalk151.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -14446,7 +14696,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path35 from "path";
-import chalk152 from "chalk";
+import chalk154 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -15021,23 +15271,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path32 from "path";
-import chalk150 from "chalk";
+import chalk152 from "chalk";
 function section(title) {
   return `
-  ${chalk150.cyan(title)}`;
+  ${chalk152.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path32.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk150.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk152.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk150.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk152.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk150.cyan("Functions to move:")}`);
+  console.log(`  ${chalk152.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -15071,7 +15321,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path34 from "path";
-import chalk151 from "chalk";
+import chalk153 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -15131,7 +15381,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk151.red(`File not found in project: ${file}`));
+    console.log(chalk153.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -15154,19 +15404,19 @@ async function extract(file, functionName, destination, options2 = {}) {
   displayPlan(functionName, relDest, plan2, cwd);
   if (options2.apply) {
     await applyExtraction(functionName, sourceFile, destPath, plan2, project);
-    console.log(chalk152.green("\nExtraction complete"));
+    console.log(chalk154.green("\nExtraction complete"));
   } else {
-    console.log(chalk152.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk154.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs23 from "fs";
-import chalk153 from "chalk";
+import chalk155 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs23.existsSync(file)) {
-    console.error(chalk153.red(`Error: File does not exist: ${file}`));
+    console.error(chalk155.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs23.readFileSync(file, "utf8");
@@ -15182,7 +15432,7 @@ function ignore(file) {
     fs23.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk153.green(
+    chalk155.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -15191,12 +15441,12 @@ function ignore(file) {
 // src/commands/refactor/rename/index.ts
 import fs26 from "fs";
 import path40 from "path";
-import chalk156 from "chalk";
+import chalk158 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs25 from "fs";
 import path37 from "path";
-import chalk154 from "chalk";
+import chalk156 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path36 from "path";
@@ -15301,13 +15551,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs25.writeFileSync(file, content, "utf8");
-    console.log(chalk154.cyan(`  Updated imports in ${path37.relative(cwd, file)}`));
+    console.log(chalk156.cyan(`  Updated imports in ${path37.relative(cwd, file)}`));
   }
   const destDir = path37.dirname(destPath);
   if (!fs25.existsSync(destDir)) fs25.mkdirSync(destDir, { recursive: true });
   fs25.renameSync(sourcePath, destPath);
   console.log(
-    chalk154.white(
+    chalk156.white(
       `  Moved ${path37.relative(cwd, sourcePath)} \u2192 ${path37.relative(cwd, destPath)}`
     )
   );
@@ -15394,16 +15644,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path39 from "path";
-import chalk155 from "chalk";
+import chalk157 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk155.dim(
+      chalk157.dim(
         `  ${path39.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk155.dim("Dry run. Use --apply to execute."));
+  console.log(chalk157.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -15414,20 +15664,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path40.relative(cwd, sourcePath);
   const relDest = path40.relative(cwd, destPath);
   if (!fs26.existsSync(sourcePath)) {
-    console.log(chalk156.red(`File not found: ${source}`));
+    console.log(chalk158.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs26.existsSync(destPath)) {
-    console.log(chalk156.red(`Destination already exists: ${destination}`));
+    console.log(chalk158.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk156.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk156.dim("Loading project..."));
-  console.log(chalk156.dim("Scanning imports across the project..."));
+  console.log(chalk158.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk158.dim("Loading project..."));
+  console.log(chalk158.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk156.dim(
+    chalk158.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -15436,11 +15686,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk156.green("Done"));
+  console.log(chalk158.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk157 from "chalk";
+import chalk159 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind14 } from "ts-morph";
@@ -15486,33 +15736,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk157.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk159.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk157.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk159.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk157.dim(refFile)}: lines ${chalk157.cyan(lines.join(", "))}`
+      `  ${chalk159.dim(refFile)}: lines ${chalk159.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk157.green(`
+    console.log(chalk159.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk157.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk159.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path48 from "path";
-import chalk160 from "chalk";
+import chalk162 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path42 from "path";
@@ -15591,50 +15841,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path44 from "path";
-import chalk158 from "chalk";
+import chalk160 from "chalk";
 function relPath(filePath) {
   return path44.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk158.bold("\nFile moves:"));
+  console.log(chalk160.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk158.red(relPath(move.from))} \u2192 ${chalk158.green(relPath(move.to))}`
+      `  ${chalk160.red(relPath(move.from))} \u2192 ${chalk160.green(relPath(move.to))}`
     );
-    console.log(chalk158.dim(`    ${move.reason}`));
+    console.log(chalk160.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk158.bold(`
+  console.log(chalk160.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk158.cyan(relPath(file))}:`);
+    console.log(`  ${chalk160.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk158.red(`"${oldSpecifier}"`)} \u2192 ${chalk158.green(`"${newSpecifier}"`)}`
+        `    ${chalk160.red(`"${oldSpecifier}"`)} \u2192 ${chalk160.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk158.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk158.yellow(`  ${w}`));
+    console.log(chalk160.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk160.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk158.bold("\nNew directories:"));
+    console.log(chalk160.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk158.green(`  ${dir}/`));
+      console.log(chalk160.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk158.dim(
+    chalk160.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -15644,18 +15894,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs27 from "fs";
 import path45 from "path";
-import chalk159 from "chalk";
+import chalk161 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs27.writeFileSync(file, content, "utf8");
     console.log(
-      chalk159.cyan(`  Rewrote imports in ${path45.relative(process.cwd(), file)}`)
+      chalk161.cyan(`  Rewrote imports in ${path45.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs27.mkdirSync(dir, { recursive: true });
-    console.log(chalk159.green(`  Created ${path45.relative(process.cwd(), dir)}/`));
+    console.log(chalk161.green(`  Created ${path45.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
     const targetDir = path45.dirname(move.to);
@@ -15664,7 +15914,7 @@ function executePlan(plan2) {
     }
     fs27.renameSync(move.from, move.to);
     console.log(
-      chalk159.white(
+      chalk161.white(
         `  Moved ${path45.relative(process.cwd(), move.from)} \u2192 ${path45.relative(process.cwd(), move.to)}`
       )
     );
@@ -15679,7 +15929,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs27.rmdirSync(dir);
       console.log(
-        chalk159.dim(
+        chalk161.dim(
           `  Removed empty directory ${path45.relative(process.cwd(), dir)}`
         )
       );
@@ -15812,22 +16062,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk160.yellow("No files found matching pattern"));
+    console.log(chalk162.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = path48.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk160.green("No restructuring needed"));
+    console.log(chalk162.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk160.bold("\nApplying changes..."));
+    console.log(chalk162.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk160.green("\nRestructuring complete"));
+    console.log(chalk162.green("\nRestructuring complete"));
   } else {
-    console.log(chalk160.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk162.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -15982,11 +16232,11 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir14 } from "os";
-import { basename as basename7, join as join45 } from "path";
+import { homedir as homedir15 } from "os";
+import { basename as basename7, join as join47 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join45(
-    homedir14(),
+  const reviewDir = join47(
+    homedir15(),
     ".assist",
     "reviews",
     basename7(repoRoot),
@@ -15994,10 +16244,10 @@ function buildReviewPaths(repoRoot, key) {
   );
   return {
     reviewDir,
-    requestPath: join45(reviewDir, "request.md"),
-    claudePath: join45(reviewDir, "claude.md"),
-    codexPath: join45(reviewDir, "codex.md"),
-    synthesisPath: join45(reviewDir, "synthesis.md")
+    requestPath: join47(reviewDir, "request.md"),
+    claudePath: join47(reviewDir, "claude.md"),
+    codexPath: join47(reviewDir, "codex.md"),
+    synthesisPath: join47(reviewDir, "synthesis.md")
   };
 }
 
@@ -16140,7 +16390,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync33 } from "fs";
+import { readFileSync as readFileSync34 } from "fs";
 
 // src/commands/review/parseFindings.ts
 var SEVERITIES = ["blocker", "major", "minor", "nit"];
@@ -16396,18 +16646,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk161 from "chalk";
+import chalk163 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk161.yellow(
+    chalk163.yellow(
       `Skipped ${outOfDiff.length} finding(s) whose lines fall outside the PR diff (GitHub would silently drop these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk161.yellow("\xB7")} ${finding.title} ${chalk161.dim(
+      `  ${chalk163.yellow("\xB7")} ${finding.title} ${chalk163.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -16426,18 +16676,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk162 from "chalk";
+import chalk164 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk162.yellow(
+    chalk164.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk162.dim("missing");
+    const where = finding.location || chalk164.dim("missing");
     console.warn(
-      `  ${chalk162.yellow("\xB7")} ${finding.title} ${chalk162.dim(`(${where})`)}`
+      `  ${chalk164.yellow("\xB7")} ${finding.title} ${chalk164.dim(`(${where})`)}`
     );
   }
 }
@@ -16450,7 +16700,7 @@ async function confirmPost(prNumber, count6, options2) {
 async function postReviewToPr(synthesisPath, options2) {
   const prInfo = fetchPrDiffInfo();
   const prNumber = prInfo.prNumber;
-  const markdown = readFileSync33(synthesisPath, "utf8");
+  const markdown = readFileSync34(synthesisPath, "utf8");
   const findings = parseFindings(markdown);
   if (findings.length === 0) {
     console.log("Synthesis contains no findings; nothing to post.");
@@ -16532,16 +16782,16 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync31 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync15, unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 function clearReviewFiles(paths) {
   for (const path57 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync37(path57)) unlinkSync12(path57);
+    if (existsSync38(path57)) unlinkSync14(path57);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync14(paths.reviewDir, { recursive: true });
+  mkdirSync15(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
-  writeFileSync31(paths.requestPath, requestBody);
+  writeFileSync33(paths.requestPath, requestBody);
 }
 
 // src/commands/review/runApplySession.ts
@@ -16603,11 +16853,11 @@ async function runBacklogSession(synthesisPath) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync5 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync4(outputPath).size;
+    size = statSync5(outputPath).size;
   } catch {
     return null;
   }
@@ -16820,7 +17070,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync39, unlinkSync as unlinkSync14 } from "fs";
+import { existsSync as existsSync40, unlinkSync as unlinkSync16 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -16886,7 +17136,7 @@ The review request is at: ${requestPath}
 }
 
 // src/commands/review/runClaudeReviewer.ts
-import { writeFileSync as writeFileSync32 } from "fs";
+import { writeFileSync as writeFileSync34 } from "fs";
 
 // src/commands/review/finaliseReviewerSpinner.ts
 var SUMMARY_MAX_LEN = 80;
@@ -17222,7 +17472,7 @@ async function runClaudeReviewer(spec) {
     }
   });
   if (result.exitCode === 0 && finalText)
-    writeFileSync32(spec.outputPath, finalText);
+    writeFileSync34(spec.outputPath, finalText);
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
 
@@ -17240,7 +17490,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync38, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync39, unlinkSync as unlinkSync15 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -17292,8 +17542,8 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync38(spec.outputPath)) {
-    unlinkSync13(spec.outputPath);
+  if (result.exitCode !== 0 && existsSync39(spec.outputPath)) {
+    unlinkSync15(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
 }
@@ -17334,7 +17584,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } 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.
@@ -17390,7 +17640,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync34(synthesisPath, "utf8");
+  const markdown = readFileSync35(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -17438,8 +17688,8 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync39(paths.synthesisPath)) {
-    unlinkSync14(paths.synthesisPath);
+  if (anyFresh && existsSync40(paths.synthesisPath)) {
+    unlinkSync16(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
   if (synthesisResult.exitCode !== 0) failures.push(synthesisResult);
@@ -17608,7 +17858,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk164 from "chalk";
+import chalk166 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -17637,10 +17887,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk163 from "chalk";
+import chalk165 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk163.red(`Connection "${name}" already exists.`));
+    console.error(chalk165.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -17658,16 +17908,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk164.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk166.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk168 from "chalk";
+import chalk170 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk165 from "chalk";
+import chalk167 from "chalk";
 async function fetchSeq(conn, path57, params) {
   const url = `${conn.url}${path57}?${params}`;
   const response = await fetch(url, {
@@ -17678,7 +17928,7 @@ async function fetchSeq(conn, path57, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk165.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk167.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -17737,23 +17987,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk166 from "chalk";
+import chalk168 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk166.bgRed.white;
+      return chalk168.bgRed.white;
     case "Error":
-      return chalk166.red;
+      return chalk168.red;
     case "Warning":
-      return chalk166.yellow;
+      return chalk168.yellow;
     case "Information":
-      return chalk166.cyan;
+      return chalk168.cyan;
     case "Debug":
-      return chalk166.gray;
+      return chalk168.gray;
     case "Verbose":
-      return chalk166.dim;
+      return chalk168.dim;
     default:
-      return chalk166.white;
+      return chalk168.white;
   }
 }
 function levelAbbrev(level) {
@@ -17794,12 +18044,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk166.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk168.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk166.red(`  ${line}`));
+      lines.push(chalk168.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -17832,11 +18082,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk167 from "chalk";
+import chalk169 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk167.red(
+      chalk169.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -17845,7 +18095,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk167.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk169.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -17874,7 +18124,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk168.yellow("No events found."));
+    console.log(chalk170.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -17885,11 +18135,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk168.dim(`
+  console.log(chalk170.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk168.yellow(
+      chalk170.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -17897,10 +18147,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk169 from "chalk";
+import chalk171 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk169.red(`Connection "${name}" not found.`));
+    console.error(chalk171.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -17948,7 +18198,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk171 from "chalk";
+import chalk173 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -17977,7 +18227,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk170 from "chalk";
+import chalk172 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -17985,7 +18235,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk170.red(`Invalid port "${portStr}".`));
+    console.error(chalk172.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -17998,13 +18248,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk171.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk173.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk172 from "chalk";
+import chalk174 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -18013,7 +18263,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk172.yellow("(no rows)"));
+    console.log(chalk174.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -18021,13 +18271,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk172.dim(header));
-  console.log(chalk172.dim("-".repeat(header.length)));
+  console.log(chalk174.dim(header));
+  console.log(chalk174.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk172.dim(`
+  console.log(chalk174.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -18087,7 +18337,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk173 from "chalk";
+import chalk175 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -18121,7 +18371,7 @@ function isMutation(sql6) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk173.red(
+      chalk175.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -18131,18 +18381,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk173.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk175.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk174 from "chalk";
+import chalk176 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk174.red(
+      chalk176.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -18157,7 +18407,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk174.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk176.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -18217,8 +18467,8 @@ function registerSql(program2) {
 }
 
 // src/commands/transcript/shared.ts
-import { existsSync as existsSync40, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { basename as basename8, join as join46, relative as relative2 } from "path";
+import { existsSync as existsSync41, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
+import { basename as basename8, join as join48, relative as relative2 } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -18233,11 +18483,11 @@ function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
 function collectFiles(dir, extension) {
-  if (!existsSync40(dir)) return [];
+  if (!existsSync41(dir)) return [];
   const results = [];
-  for (const entry of readdirSync7(dir)) {
-    const fullPath = join46(dir, entry);
-    if (statSync5(fullPath).isDirectory()) {
+  for (const entry of readdirSync8(dir)) {
+    const fullPath = join48(dir, entry);
+    if (statSync6(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
       results.push(fullPath);
@@ -18330,14 +18580,14 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname22, join as join48 } from "path";
+import { dirname as dirname22, join as join50 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync as renameSync2 } from "fs";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -18352,7 +18602,7 @@ async function resolveDate(rl, choice) {
 }
 function renameWithPrefix(vttDir, vttFile, prefix2) {
   const newFilename = `${prefix2}.${vttFile}`;
-  renameSync2(join47(vttDir, vttFile), join47(vttDir, newFilename));
+  renameSync2(join49(vttDir, vttFile), join49(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -18386,12 +18636,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname22(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join48(
+        const newRelativePath = join50(
           dirname22(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join48(vttFileDir, newFilename),
+          absolutePath: join50(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -18404,8 +18654,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync15, readFileSync as readFileSync35, writeFileSync as writeFileSync33 } from "fs";
-import { basename as basename9, dirname as dirname23, join as join49 } from "path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync16, readFileSync as readFileSync36, writeFileSync as writeFileSync35 } from "fs";
+import { basename as basename9, dirname as dirname23, join as join51 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text6) {
@@ -18615,22 +18865,22 @@ function toMdFilename(vttFilename) {
   return `${basename9(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join49(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join51(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname23(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join49(outputDir, mdFile);
+  const outputPath = join51(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join49(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join51(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
-  if (!existsSync41(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  if (!existsSync42(dir)) {
+    mkdirSync16(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -18652,10 +18902,10 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync35(inputPath, "utf8"));
+  return processCues(readFileSync36(inputPath, "utf8"));
 }
 function writeFormatted(outputPath, content) {
-  writeFileSync33(outputPath, content, "utf8");
+  writeFileSync35(outputPath, content, "utf8");
   console.log(`Written: ${outputPath}`);
 }
 function convertVttToMarkdown(inputPath, outputPath) {
@@ -18665,7 +18915,7 @@ function convertVttToMarkdown(inputPath, outputPath) {
   logReduction(cues.length, chatMessages.length);
 }
 function tryProcessVtt(vttFile, paths) {
-  if (existsSync41(paths.outputPath))
+  if (existsSync42(paths.outputPath))
     return logSkipped(paths.relativeDir, paths.mdFile);
   convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
   return "processed";
@@ -18691,7 +18941,7 @@ function processAllFiles(vttFiles, transcriptsDir) {
   logSummary(counts);
 }
 function requireVttDir(vttDir) {
-  if (!existsSync42(vttDir)) {
+  if (!existsSync43(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
@@ -18723,28 +18973,28 @@ async function format() {
 }
 
 // src/commands/transcript/summarise/index.ts
-import { existsSync as existsSync44 } from "fs";
-import { basename as basename10, dirname as dirname25, join as join51, relative as relative3 } from "path";
+import { existsSync as existsSync45 } from "fs";
+import { basename as basename10, dirname as dirname25, join as join53, relative as relative3 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync43,
-  mkdirSync as mkdirSync16,
-  readFileSync as readFileSync36,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync17,
+  readFileSync as readFileSync37,
   renameSync as renameSync3,
   rmSync as rmSync3
 } from "fs";
-import { dirname as dirname24, join as join50 } from "path";
+import { dirname as dirname24, join as join52 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk175 from "chalk";
+import chalk177 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk175.red(
+      chalk177.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -18753,7 +19003,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk175.red(
+      chalk177.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -18763,9 +19013,9 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join50(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join52(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync43(STAGING_DIR)) {
+  if (!existsSync44(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -18774,7 +19024,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync36(stagedFile.absolutePath, "utf8");
+  const content = readFileSync37(stagedFile.absolutePath, "utf8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -18787,10 +19037,10 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join50(summaryDir, matchingTranscript.relativePath);
+  const destPath = join52(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname24(destPath);
-  if (!existsSync43(destDir)) {
-    mkdirSync16(destDir, { recursive: true });
+  if (!existsSync44(destDir)) {
+    mkdirSync17(destDir, { recursive: true });
   }
   renameSync3(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
@@ -18803,7 +19053,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname25(relativePath);
-  return relDir === "." ? baseName : join51(relDir, baseName);
+  return relDir === "." ? baseName : join53(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -18816,7 +19066,7 @@ function buildSummaryIndex(summaryDir) {
 function summarise2() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync44(transcriptsDir)) {
+  if (!existsSync45(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -18837,8 +19087,8 @@ function summarise2() {
   }
   const next3 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next3.filename)}.md`;
-  const outputPath = join51(STAGING_DIR, outputFilename);
-  const summaryFileDir = join51(summaryDir, dirname25(next3.relativePath));
+  const outputPath = join53(STAGING_DIR, outputFilename);
+  const summaryFileDir = join53(summaryDir, dirname25(next3.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative3(summaryFileDir, next3.absolutePath).replace(/\\/g, "/")
   );
@@ -18895,50 +19145,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join53 } from "path";
+import { join as join55 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir15 } from "os";
-import { dirname as dirname26, join as join52 } from "path";
+import { homedir as homedir16 } from "os";
+import { dirname as dirname26, join as join54 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname5 = dirname26(fileURLToPath6(import.meta.url));
-var VOICE_DIR = join52(homedir15(), ".assist", "voice");
+var VOICE_DIR = join54(homedir16(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join52(VOICE_DIR, "voice.pid"),
-  log: join52(VOICE_DIR, "voice.log"),
-  venv: join52(VOICE_DIR, ".venv"),
-  lock: join52(VOICE_DIR, "voice.lock")
+  pid: join54(VOICE_DIR, "voice.pid"),
+  log: join54(VOICE_DIR, "voice.log"),
+  venv: join54(VOICE_DIR, ".venv"),
+  lock: join54(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join52(__dirname5, "commands", "voice", "python");
+  return join54(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join52(voicePaths.venv, "Scripts", "python.exe") : join52(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join54(voicePaths.venv, "Scripts", "python.exe") : join54(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join52(getLockDir(), "voice.lock");
+  return join54(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join53(getPythonDir(), "list_devices.py");
+  const script = join55(getPythonDir(), "list_devices.py");
   spawnSync5(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync45, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync38 } from "fs";
 function logs(options2) {
-  if (!existsSync45(voicePaths.log)) {
+  if (!existsSync46(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count6 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync37(voicePaths.log, "utf8").trim();
+  const content = readFileSync38(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -18960,13 +19210,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { mkdirSync as mkdirSync18 } from "fs";
-import { join as join55 } from "path";
+import { mkdirSync as mkdirSync19 } from "fs";
+import { join as join57 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync48 } from "child_process";
-import { existsSync as existsSync46, mkdirSync as mkdirSync17, readFileSync as readFileSync38, writeFileSync as writeFileSync34 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync18, readFileSync as readFileSync39, writeFileSync as writeFileSync36 } from "fs";
+import { join as join56 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -18977,9 +19227,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync46(lockFile)) return;
+  if (!existsSync47(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync38(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync39(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -18990,7 +19240,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync46(getVenvPython())) return;
+  if (existsSync47(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync48(
@@ -19003,8 +19253,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync17(join54(lockFile, ".."), { recursive: true });
-  writeFileSync34(
+  mkdirSync18(join56(lockFile, ".."), { recursive: true });
+  writeFileSync36(
     lockFile,
     JSON.stringify({
       pid,
@@ -19016,10 +19266,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync18(voicePaths.dir, { recursive: true });
+  mkdirSync19(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join55(getPythonDir(), "setup_models.py");
+  const script = join57(getPythonDir(), "setup_models.py");
   const result = spawnSync6(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -19032,8 +19282,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync35 } from "fs";
-import { join as join56 } from "path";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync37 } from "fs";
+import { join as join58 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -19061,17 +19311,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync35(voicePaths.pid, String(pid));
+  writeFileSync37(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync19(voicePaths.dir, { recursive: true });
+  mkdirSync20(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join56(getPythonDir(), "voice_daemon.py");
+  const script = join58(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -19081,7 +19331,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync47, readFileSync as readFileSync39 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync40 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -19091,16 +19341,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count6) {
-  if (!existsSync47(voicePaths.log)) return [];
-  const lines = readFileSync39(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync48(voicePaths.log)) return [];
+  const lines = readFileSync40(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count6);
 }
 function status() {
-  if (!existsSync47(voicePaths.pid)) {
+  if (!existsSync48(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync39(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync40(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -19119,13 +19369,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync48, readFileSync as readFileSync40, unlinkSync as unlinkSync15 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync41, unlinkSync as unlinkSync17 } from "fs";
 function stop2() {
-  if (!existsSync48(voicePaths.pid)) {
+  if (!existsSync49(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync40(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync41(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -19133,12 +19383,12 @@ function stop2() {
     console.log(`Voice daemon (PID ${pid}) is not running`);
   }
   try {
-    unlinkSync15(voicePaths.pid);
+    unlinkSync17(voicePaths.pid);
   } catch {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync48(lockFile)) unlinkSync15(lockFile);
+    if (existsSync49(lockFile)) unlinkSync17(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -19156,8 +19406,8 @@ function registerVoice(program2) {
 }
 
 // src/commands/roam/auth.ts
-import { randomBytes } from "crypto";
-import chalk176 from "chalk";
+import { randomBytes as randomBytes2 } from "crypto";
+import chalk178 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -19286,15 +19536,15 @@ async function auth() {
   const existingRoam = config.roam ?? {};
   config.roam = { ...existingRoam, clientId, clientSecret };
   saveGlobalConfig(config);
-  const state = randomBytes(16).toString("hex");
+  const state = randomBytes2(16).toString("hex");
   console.log(
-    chalk176.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk178.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk176.white("http://localhost:14523/callback\n"));
-  console.log(chalk176.blue("Opening browser for authorization..."));
-  console.log(chalk176.dim("Waiting for authorization callback..."));
+  console.log(chalk178.white("http://localhost:14523/callback\n"));
+  console.log(chalk178.blue("Opening browser for authorization..."));
+  console.log(chalk178.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk176.dim("Exchanging code for tokens..."));
+  console.log(chalk178.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -19310,25 +19560,25 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk176.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk178.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { readdirSync as readdirSync8, readFileSync as readFileSync41, statSync as statSync6 } from "fs";
-import { join as join57 } from "path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync42, statSync as statSync7 } from "fs";
+import { join as join59 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
-    entries = readdirSync8(roamDir);
+    entries = readdirSync9(roamDir);
   } catch {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path57 = join57(roamDir, name);
+    const path57 = join59(roamDir, name);
     try {
-      return { path: path57, mtimeMs: statSync6(path57).mtimeMs };
+      return { path: path57, mtimeMs: statSync7(path57).mtimeMs };
     } catch {
       return void 0;
     }
@@ -19338,11 +19588,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join57(appData, "Roam"));
+  const portFile = findPortFile(join59(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync41(portFile, "utf8").trim();
+    port = readFileSync42(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -19484,15 +19734,15 @@ function runPreCommands(pre, cwd) {
 
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
-import { existsSync as existsSync49 } from "fs";
-import { dirname as dirname27, join as join58, resolve as resolve13 } from "path";
+import { existsSync as existsSync50 } from "fs";
+import { dirname as dirname27, join as join60, resolve as resolve13 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync8("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve13(dirname27(gitPath), "..");
-    const gitBash = join58(gitRoot, "bin", "bash.exe");
-    if (existsSync49(gitBash)) return gitBash;
+    const gitBash = join60(gitRoot, "bin", "bash.exe");
+    if (existsSync50(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -19577,8 +19827,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync36 } from "fs";
-import { join as join59 } from "path";
+import { mkdirSync as mkdirSync21, writeFileSync as writeFileSync38 } from "fs";
+import { join as join61 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -19639,16 +19889,16 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join59(".claude", "commands");
-  mkdirSync20(dir, { recursive: true });
+  const dir = join61(".claude", "commands");
+  mkdirSync21(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join59(dir, `${name}.md`);
-  writeFileSync36(filePath, content);
+  const filePath = join61(dir, `${name}.md`);
+  writeFileSync38(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -19703,8 +19953,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync50, unlinkSync as unlinkSync16 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync51, unlinkSync as unlinkSync18 } from "fs";
+import { join as join62 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -19719,9 +19969,9 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join60(".claude", "commands", `${name}.md`);
-  if (existsSync50(filePath)) {
-    unlinkSync16(filePath);
+  const filePath = join62(".claude", "commands", `${name}.md`);
+  if (existsSync51(filePath)) {
+    unlinkSync18(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
 }
@@ -19759,10 +20009,10 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync50 } from "child_process";
-import { existsSync as existsSync51, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync37 } from "fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync22, unlinkSync as unlinkSync19, writeFileSync as writeFileSync39 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join61, resolve as resolve15 } from "path";
-import chalk177 from "chalk";
+import { join as join63, resolve as resolve15 } from "path";
+import chalk179 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -19891,35 +20141,35 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync51(outputDir)) {
-    mkdirSync21(outputDir, { recursive: true });
+  if (!existsSync52(outputDir)) {
+    mkdirSync22(outputDir, { recursive: true });
   }
   const timestamp4 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve15(outputDir, `${processName}-${timestamp4}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join61(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync37(scriptPath, captureWindowPs1, "utf8");
+  const scriptPath = join63(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync39(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync50(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
   } finally {
-    unlinkSync17(scriptPath);
+    unlinkSync19(scriptPath);
   }
 }
 function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve15(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk177.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk179.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk177.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk179.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk177.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk179.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -19975,7 +20225,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -19987,7 +20237,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync42(daemonPaths.pid, "utf8").trim(),
+      readFileSync43(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -20152,7 +20402,7 @@ function requestDrain(socket) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync23 } from "fs";
+import { mkdirSync as mkdirSync24 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -20329,7 +20579,7 @@ var ClientHub = class extends Set {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync52, statSync as statSync7 } from "fs";
+import { chmodSync, existsSync as existsSync53, statSync as statSync8 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path49 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -20344,8 +20594,8 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync52(helper)) return;
-  const mode = statSync7(helper).mode;
+  if (!existsSync53(helper)) return;
+  const mode = statSync8(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -20763,7 +21013,7 @@ function resumeSession(id2, sessionId, cwd, name) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync53, mkdirSync as mkdirSync22, watch } from "fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync23, watch } from "fs";
 import { dirname as dirname28 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -20784,7 +21034,7 @@ function watchActivity(session, notify2) {
   const path57 = activityPath(session.id);
   const dir = dirname28(path57);
   try {
-    mkdirSync22(dir, { recursive: true });
+    mkdirSync23(dir, { recursive: true });
   } catch {
     return;
   }
@@ -20805,7 +21055,7 @@ function watchActivity(session, notify2) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync53(path57)) read();
+  if (existsSync54(path57)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -21614,7 +21864,7 @@ var SessionManager = class {
 };
 
 // src/commands/sessions/daemon/startDaemonServer.ts
-import { unlinkSync as unlinkSync19 } from "fs";
+import { unlinkSync as unlinkSync21 } from "fs";
 import * as net3 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
@@ -22021,10 +22271,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync38 } from "fs";
+import { unlinkSync as unlinkSync20, writeFileSync as writeFileSync40 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -22035,7 +22285,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync43(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync44(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -22043,7 +22293,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync38(daemonPaths.pid, String(process.pid));
+  writeFileSync40(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     manager.shutdown();
@@ -22062,12 +22312,12 @@ function onListening(manager, checkAutoExit) {
 function cleanupOwnedFiles() {
   if (!ownsPidFile()) return;
   try {
-    unlinkSync18(daemonPaths.pid);
+    unlinkSync20(daemonPaths.pid);
   } catch {
   }
   if (process.platform !== "win32") {
     try {
-      unlinkSync18(daemonPaths.socket);
+      unlinkSync20(daemonPaths.socket);
     } catch {
     }
   }
@@ -22110,7 +22360,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
   daemonLog("removing stale socket left by a crashed daemon");
   if (process.platform !== "win32") {
     try {
-      unlinkSync19(daemonPaths.socket);
+      unlinkSync21(daemonPaths.socket);
     } catch {
     }
   }
@@ -22119,7 +22369,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync23(daemonPaths.dir, { recursive: true });
+  mkdirSync24(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -22159,7 +22409,7 @@ function registerDaemon(program2) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs35 from "fs";
-import chalk178 from "chalk";
+import chalk180 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs33 from "fs";
@@ -22313,22 +22563,22 @@ ${firstMessage}`);
 async function summarise3(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk178.yellow("No sessions found."));
+    console.log(chalk180.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk178.green("All sessions already summarised."));
+    console.log(chalk180.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk178.cyan(
+    chalk180.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk178.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk178.yellow(`, ${failed2} skipped`) : "")
+    chalk180.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk180.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -22348,16 +22598,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk178.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk180.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk178.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk180.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk178.yellow("skip")}
+      process.stdout.write(` ${chalk180.yellow("skip")}
 `);
     }
   }
@@ -22375,10 +22625,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk180 from "chalk";
+import chalk182 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk179 from "chalk";
+import chalk181 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -22409,9 +22659,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk179.green,
-  warn: chalk179.yellow,
-  over: chalk179.red
+  ok: chalk181.green,
+  warn: chalk181.yellow,
+  over: chalk181.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -22451,14 +22701,14 @@ async function relayRateLimits(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk180.level = 3;
+chalk182.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk180.red(label2);
-  if (pct > 40) return chalk180.yellow(label2);
+  if (pct > 80) return chalk182.red(label2);
+  if (pct > 40) return chalk182.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -22482,7 +22732,7 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs36 from "fs";
 import * as path53 from "path";
-import chalk181 from "chalk";
+import chalk183 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path53.join(claudeDir, "CLAUDE.md");
   const target = path53.join(targetBase, "CLAUDE.md");
@@ -22491,12 +22741,12 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs36.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk181.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk183.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk181.red("Overwrite existing CLAUDE.md?"),
+        chalk183.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -22512,7 +22762,7 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs37 from "fs";
 import * as path54 from "path";
-import chalk182 from "chalk";
+import chalk184 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path54.join(claudeDir, "settings.json");
   const target = path54.join(targetBase, "settings.json");
@@ -22528,14 +22778,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk182.yellow(
+          chalk184.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk182.red("Overwrite existing settings.json?"),
+          chalk184.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -22653,6 +22903,7 @@ program.command("screenshot").description("Capture a screenshot of a running app
 registerActivity(program);
 registerBackup(program);
 registerCliHook(program);
+registerCodeComment(program);
 registerEditHook(program);
 registerGithub(program);
 registerHandover(program);