@staff0rd/assist 0.94.0 → 0.95.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.94.0",
+  version: "0.95.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -129,6 +129,7 @@ var assistConfigSchema = z.strictObject({
   }).optional(),
   run: z.array(runConfigSchema).optional(),
   transcript: transcriptConfigSchema.optional(),
+  cliReadVerbs: z.record(z.string(), z.array(z.string())).optional(),
   voice: z.strictObject({
     wakeWords: z.array(z.string()).default(DEFAULT_WAKE_WORDS),
     mic: z.string().optional(),
@@ -1098,8 +1099,8 @@ function createSettingsJson() {
       "source.organizeImports.biome": "explicit"
     }
   };
-  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
-  fs3.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  const settingsPath2 = path9.join(process.cwd(), ".vscode", "settings.json");
+  fs3.writeFileSync(settingsPath2, `${JSON.stringify(settings, null, "	")}
 `);
   console.log(chalk16.green("Created .vscode/settings.json"));
 }
@@ -2509,16 +2510,422 @@ function registerBacklog(program2) {
   backlogCommand.command("web").description("Start a web view of the backlog").option("-p, --port <number>", "Port to listen on", "3000").action(web);
 }
 
+// src/commands/cliDiscover/index.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join12 } from "path";
+
+// src/commands/cliDiscover/assertCliExists.ts
+import { execSync as execSync13 } from "child_process";
+function assertCliExists(cli) {
+  const binary = cli.split(/\s+/)[0];
+  const opts = {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  };
+  try {
+    execSync13(`command -v ${binary}`, opts);
+  } catch {
+    try {
+      execSync13(`where ${binary}`, opts);
+    } catch {
+      console.error(`CLI "${cli}" not found in PATH`);
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/cliDiscover/colorize.ts
+import chalk30 from "chalk";
+function colorize(plainOutput) {
+  return plainOutput.split("\n").map((line) => {
+    if (line.startsWith(" R  ")) return chalk30.green(line);
+    if (line.startsWith(" W  ")) return chalk30.red(line);
+    return line;
+  }).join("\n");
+}
+
+// src/lib/isClaudeCode.ts
+function isClaudeCode() {
+  return process.env.CLAUDECODE !== void 0;
+}
+
+// src/commands/cliDiscover/mapAsync.ts
+async function mapAsync(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let next2 = 0;
+  async function worker() {
+    while (next2 < items.length) {
+      const idx = next2++;
+      results[idx] = await fn(items[idx]);
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+
+// src/commands/cliDiscover/parseCommands.ts
+var COMMAND_SECTION_RE = /^((?:core |general |available |additional |other |management |targeted |alias |github actions )?(?:commands|subgroups)):?$/i;
+function isSkippable(name) {
+  return name.startsWith("-") || name.startsWith("<") || name.startsWith("[");
+}
+function parseCommandLine(trimmed) {
+  const azMatch = trimmed.match(/^(\S+)\s+(?:\[.*?]\s+)?:\s*(.+)/);
+  if (azMatch && !isSkippable(azMatch[1])) {
+    return { name: azMatch[1], description: azMatch[2].trim() };
+  }
+  const colonMatch = trimmed.match(/^(\S+?):\s{2,}(.+)/);
+  if (colonMatch && !isSkippable(colonMatch[1])) {
+    return { name: colonMatch[1], description: colonMatch[2].trim() };
+  }
+  const spaceMatch = trimmed.match(/^(\S+)(?:,\s*\S+)?\s{2,}(.+)/);
+  if (spaceMatch && !isSkippable(spaceMatch[1])) {
+    return { name: spaceMatch[1], description: spaceMatch[2].trim() };
+  }
+  if (/^\S+$/.test(trimmed) && !isSkippable(trimmed)) {
+    return { name: trimmed, description: "" };
+  }
+  return void 0;
+}
+function parseCommands(helpText) {
+  const commands = [];
+  let inCommandSection = false;
+  for (const line of helpText.split("\n")) {
+    const trimmed = line.trim();
+    if (COMMAND_SECTION_RE.test(trimmed)) {
+      inCommandSection = true;
+      continue;
+    }
+    if (inCommandSection && trimmed && !line.startsWith(" ") && !line.startsWith("	")) {
+      inCommandSection = false;
+      continue;
+    }
+    if (!inCommandSection || !trimmed) continue;
+    if (trimmed.startsWith("-") || trimmed.startsWith("=")) continue;
+    const parsed = parseCommandLine(trimmed);
+    if (parsed) commands.push(parsed);
+  }
+  return commands;
+}
+var COMMAND_SECTION_MULTILINE_RE = new RegExp(
+  COMMAND_SECTION_RE.source,
+  "im"
+);
+function hasSubcommands(helpText) {
+  return COMMAND_SECTION_MULTILINE_RE.test(helpText);
+}
+
+// src/commands/cliDiscover/runHelp.ts
+import { exec as exec2 } from "child_process";
+function runHelp(args) {
+  return new Promise((resolve3) => {
+    exec2(
+      `${args.join(" ")} --help`,
+      { encoding: "utf-8", timeout: 3e4 },
+      (_err, stdout, stderr) => {
+        resolve3(stdout || stderr || "");
+      }
+    );
+  });
+}
+
+// src/commands/cliDiscover/discoverAll.ts
+var SAFETY_DEPTH = 10;
+var CONCURRENCY = 8;
+var interactive = !isClaudeCode();
+function showProgress(p, label2) {
+  if (!interactive) return;
+  const pct = Math.round(p.done / p.total * 100);
+  process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
+}
+async function resolveCommand(cli, path31, description, depth, p) {
+  showProgress(p, path31.join(" "));
+  const subHelp = await runHelp([cli, ...path31]);
+  if (!subHelp || !hasSubcommands(subHelp)) {
+    return [{ path: path31, description }];
+  }
+  const children = await discoverAt(cli, path31, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path31, description }];
+}
+async function discoverAt(cli, parentPath, depth, p) {
+  if (depth > SAFETY_DEPTH) return [];
+  const helpText = await runHelp([cli, ...parentPath]);
+  if (!helpText) return [];
+  const cmds = parseCommands(helpText);
+  const results = await mapAsync(
+    cmds,
+    CONCURRENCY,
+    (cmd) => resolveCommand(cli, [...parentPath, cmd.name], cmd.description, depth, p)
+  );
+  return results.flat();
+}
+async function discoverAll(cli) {
+  const topLevel = parseCommands(await runHelp([cli]));
+  const p = { done: 0, total: topLevel.length };
+  const results = await mapAsync(topLevel, CONCURRENCY, async (cmd) => {
+    showProgress(p, cmd.name);
+    const resolved = await resolveCommand(
+      cli,
+      [cmd.name],
+      cmd.description,
+      1,
+      p
+    );
+    p.done++;
+    showProgress(p, cmd.name);
+    return resolved;
+  });
+  if (interactive) process.stderr.write("\r\x1B[K");
+  return results.flat();
+}
+
+// src/commands/cliDiscover/classifyVerb.ts
+var READ_VERBS = /* @__PURE__ */ new Set([
+  "list",
+  "show",
+  "view",
+  "export",
+  "get",
+  "diff",
+  "status",
+  "search",
+  "checks",
+  "describe",
+  "inspect",
+  "logs",
+  "cat",
+  "top",
+  "explain",
+  "exists",
+  "browse",
+  "watch"
+]);
+var WRITE_VERBS = /* @__PURE__ */ new Set([
+  "create",
+  "delete",
+  "import",
+  "set",
+  "update",
+  "merge",
+  "close",
+  "reopen",
+  "edit",
+  "apply",
+  "patch",
+  "drain",
+  "cordon",
+  "taint",
+  "push",
+  "deploy",
+  "add",
+  "remove",
+  "assign",
+  "unassign",
+  "lock",
+  "unlock",
+  "start",
+  "stop",
+  "restart",
+  "enable",
+  "disable",
+  "revoke",
+  "rotate"
+]);
+function classifyVerb(verb) {
+  if (READ_VERBS.has(verb)) return "r";
+  if (WRITE_VERBS.has(verb)) return "w";
+  return "?";
+}
+
+// src/commands/cliDiscover/formatHuman.ts
+function prefix(kind) {
+  if (kind === "r") return " R  ";
+  if (kind === "w") return " W  ";
+  return " ?  ";
+}
+function formatHuman(cli, commands) {
+  const sorted = [...commands].sort(
+    (a, b) => a.path.join(" ").localeCompare(b.path.join(" "))
+  );
+  const lines = [`Discovered ${commands.length} commands for "${cli}":
+`];
+  for (const cmd of sorted) {
+    const verb = cmd.path[cmd.path.length - 1];
+    const full = `${cli} ${cmd.path.join(" ")}`;
+    const text = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
+    lines.push(`${prefix(classifyVerb(verb))}${text}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/cliDiscover/parseCached.ts
+function parseCached(cli, cached) {
+  const prefix2 = `${cli} `;
+  const commands = [];
+  for (const line of cached.split("\n")) {
+    const trimmed = line.replace(/^ [RW?] {2}/, "").trim();
+    if (!trimmed.startsWith(prefix2)) continue;
+    const rest = trimmed.slice(prefix2.length);
+    const dashIdx = rest.indexOf(" \u2014 ");
+    const pathStr = dashIdx >= 0 ? rest.slice(0, dashIdx) : rest;
+    const description = dashIdx >= 0 ? rest.slice(dashIdx + 3) : "";
+    commands.push({ path: pathStr.split(" "), description });
+  }
+  return commands;
+}
+
+// src/commands/cliDiscover/updateSettings.ts
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join11 } from "path";
+function settingsPath() {
+  return join11(process.cwd(), "claude", "settings.json");
+}
+function updateSettings(cli, commands) {
+  const path31 = settingsPath();
+  if (!existsSync15(path31)) return;
+  const settings = JSON.parse(readFileSync12(path31, "utf-8"));
+  const allow = settings.permissions?.allow ?? [];
+  const readCommands = commands.filter(
+    (cmd) => classifyVerb(cmd.path[cmd.path.length - 1]) === "r"
+  );
+  const newEntries = readCommands.map(
+    (cmd) => `Bash(${cli} ${cmd.path.join(" ")}:*)`
+  );
+  const existing = new Set(allow);
+  const added = newEntries.filter((e) => !existing.has(e));
+  if (added.length === 0) return;
+  settings.permissions = settings.permissions ?? {};
+  settings.permissions.allow = [...allow, ...added];
+  writeFileSync12(path31, `${JSON.stringify(settings, null, "	")}
+`);
+}
+
+// src/commands/cliDiscover/index.ts
+function logPath(cli) {
+  const safeName = cli.replace(/\s+/g, "-");
+  return join12(homedir3(), ".assist", `cli-discover-${safeName}.log`);
+}
+function readCache(cli) {
+  const path31 = logPath(cli);
+  if (!existsSync16(path31)) return void 0;
+  return readFileSync13(path31, "utf-8");
+}
+function writeCache(cli, output) {
+  const dir = join12(homedir3(), ".assist");
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync13(logPath(cli), output);
+}
+async function cliDiscover(cli, options2 = { noCache: false }) {
+  if (!cli) {
+    console.error("Usage: assist cli-discover <cli>");
+    process.exit(1);
+  }
+  if (!options2.noCache) {
+    const cached = readCache(cli);
+    if (cached) {
+      console.log(colorize(cached));
+      updateSettings(cli, parseCached(cli, cached));
+      return;
+    }
+  }
+  assertCliExists(cli);
+  const commands = await discoverAll(cli);
+  const output = formatHuman(cli, commands);
+  console.log(colorize(output));
+  writeCache(cli, output);
+  updateSettings(cli, commands);
+}
+
+// src/commands/registerCliDiscover.ts
+function registerCliDiscover(program2) {
+  program2.command("cli-discover").description("Discover a CLI's command tree via recursive --help parsing").argument(
+    "<cli...>",
+    "CLI binary and optional subcommand (e.g. gh, az, acli jira)"
+  ).option("--no-cache", "Force fresh discovery, ignoring cached results").action((cli, options2) => {
+    cliDiscover(cli.join(" "), { noCache: !options2.cache });
+  });
+}
+
+// src/commands/cliHook/extractVerb.ts
+var SHELL_OPERATORS = /* @__PURE__ */ new Set(["|", ">", ">>", ";", "&&", "||"]);
+function isShellBreak(token) {
+  return token.startsWith("-") || SHELL_OPERATORS.has(token);
+}
+function looksLikeArgument(token) {
+  return /[/=.]/.test(token) || /^\d+$/.test(token);
+}
+function extractVerb(command, readVerbs) {
+  const tokens = command.split(/\s+/);
+  for (let i = 1; i < tokens.length; i++) {
+    if (isShellBreak(tokens[i])) break;
+    if (readVerbs.includes(tokens[i])) return tokens[i];
+  }
+  for (let i = tokens.length - 1; i >= 1; i--) {
+    const token = tokens[i];
+    if (isShellBreak(token) || looksLikeArgument(token)) continue;
+    return token;
+  }
+  return void 0;
+}
+
+// src/commands/cliHook/index.ts
+async function cliHook() {
+  const inputData = await readStdin();
+  let data;
+  try {
+    data = JSON.parse(inputData);
+  } catch {
+    return;
+  }
+  if (data.tool_name !== "Bash" || !data.tool_input?.command) {
+    return;
+  }
+  const command = data.tool_input.command.trim();
+  const config = loadConfig();
+  const cliReadVerbs = config.cliReadVerbs;
+  if (!cliReadVerbs) return;
+  const cliKeys = Object.keys(cliReadVerbs).sort((a, b) => b.length - a.length);
+  const cli = cliKeys.find(
+    (key) => command === key || command.startsWith(`${key} `)
+  );
+  if (!cli) return;
+  const readVerbs = cliReadVerbs[cli];
+  if (!readVerbs || readVerbs.length === 0) return;
+  const verb = extractVerb(command, readVerbs);
+  if (verb && readVerbs.includes(verb)) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: `Read-only ${cli} command: ${verb}`
+        }
+      })
+    );
+  }
+}
+
+// src/commands/registerCliHook.ts
+function registerCliHook(program2) {
+  program2.command("cli-hook").description("PreToolUse hook for auto-approving read-only CLI commands").action(() => {
+    cliHook();
+  });
+}
+
 // src/commands/complexity/analyze.ts
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 
 // src/commands/complexity/cyclomatic.ts
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs11 from "fs";
 import path16 from "path";
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
@@ -2595,8 +3002,8 @@ function getNodeName(node) {
     return getIdentifierText(node.name);
   if (ts.isArrowFunction(node)) return getArrowFunctionName(node);
   if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
-    const prefix = ts.isGetAccessor(node) ? "get " : "set ";
-    return `${prefix}${getIdentifierText(node.name)}`;
+    const prefix2 = ts.isGetAccessor(node) ? "get " : "set ";
+    return `${prefix2}${getIdentifierText(node.name)}`;
   }
   if (ts.isConstructorDeclaration(node)) return "constructor";
   return "<unknown>";
@@ -2764,7 +3171,7 @@ function createSourceFromFile(filePath) {
 function withSourceFiles(pattern2, callback) {
   const files = findSourceFiles2(pattern2);
   if (files.length === 0) {
-    console.log(chalk30.yellow("No files found matching pattern"));
+    console.log(chalk31.yellow("No files found matching pattern"));
     return void 0;
   }
   return callback(files);
@@ -2797,11 +3204,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 ? chalk31.red : chalk31.white;
-      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk31.cyan(complexity)}`);
+      const color = exceedsThreshold ? chalk32.red : chalk32.white;
+      console.log(`${color(`${file}:${name}`)} \u2192 ${chalk32.cyan(complexity)}`);
     }
     console.log(
-      chalk31.dim(
+      chalk32.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -2813,7 +3220,7 @@ Analyzed ${results.length} functions across ${files.length} files`
 }
 
 // src/commands/complexity/halstead.ts
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 async function halstead(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -2828,13 +3235,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 ? chalk32.red : chalk32.white;
+      const color = exceedsThreshold ? chalk33.red : chalk33.white;
       console.log(
-        `${color(`${file}:${name}`)} \u2192 volume: ${chalk32.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk32.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk32.magenta(metrics.effort.toFixed(1))}`
+        `${color(`${file}:${name}`)} \u2192 volume: ${chalk33.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk33.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk33.magenta(metrics.effort.toFixed(1))}`
       );
     }
     console.log(
-      chalk32.dim(
+      chalk33.dim(
         `
 Analyzed ${results.length} functions across ${files.length} files`
       )
@@ -2849,28 +3256,28 @@ Analyzed ${results.length} functions across ${files.length} files`
 import fs12 from "fs";
 
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 function displayMaintainabilityResults(results, threshold) {
   const filtered = threshold !== void 0 ? results.filter((r) => r.minMaintainability < threshold) : results;
   if (threshold !== void 0 && filtered.length === 0) {
-    console.log(chalk33.green("All files pass maintainability threshold"));
+    console.log(chalk34.green("All files pass maintainability threshold"));
   } else {
     for (const { file, avgMaintainability, minMaintainability } of filtered) {
-      const color = threshold !== void 0 ? chalk33.red : chalk33.white;
+      const color = threshold !== void 0 ? chalk34.red : chalk34.white;
       console.log(
-        `${color(file)} \u2192 avg: ${chalk33.cyan(avgMaintainability.toFixed(1))}, min: ${chalk33.yellow(minMaintainability.toFixed(1))}`
+        `${color(file)} \u2192 avg: ${chalk34.cyan(avgMaintainability.toFixed(1))}, min: ${chalk34.yellow(minMaintainability.toFixed(1))}`
       );
     }
   }
-  console.log(chalk33.dim(`
+  console.log(chalk34.dim(`
 Analyzed ${results.length} files`));
   if (filtered.length > 0 && threshold !== void 0) {
     console.error(
-      chalk33.red(
+      chalk34.red(
         `
 Fail: ${filtered.length} file(s) below threshold ${threshold}. Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.
 
-\u26A0\uFE0F  ${chalk33.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel. Run 'assist complexity <file>' to see all metrics. For larger files, start by extracting responsibilities into smaller files.`
+\u26A0\uFE0F  ${chalk34.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel. Run 'assist complexity <file>' to see all metrics. For larger files, start by extracting responsibilities into smaller files.`
       )
     );
     process.exit(1);
@@ -2927,7 +3334,7 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 
 // src/commands/complexity/sloc.ts
 import fs13 from "fs";
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
@@ -2943,12 +3350,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 ? chalk34.red : chalk34.white;
-      console.log(`${color(file)} \u2192 ${chalk34.cyan(lines)} lines`);
+      const color = exceedsThreshold ? chalk35.red : chalk35.white;
+      console.log(`${color(file)} \u2192 ${chalk35.cyan(lines)} lines`);
     }
     const total = results.reduce((sum, r) => sum + r.lines, 0);
     console.log(
-      chalk34.dim(`
+      chalk35.dim(`
 Total: ${total} lines across ${files.length} files`)
     );
     if (hasViolation) {
@@ -2962,21 +3369,21 @@ async function analyze(pattern2) {
   const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
   const files = findSourceFiles2(searchPattern);
   if (files.length === 0) {
-    console.log(chalk35.yellow("No files found matching pattern"));
+    console.log(chalk36.yellow("No files found matching pattern"));
     return;
   }
   if (files.length === 1) {
     const file = files[0];
-    console.log(chalk35.bold.underline("SLOC"));
+    console.log(chalk36.bold.underline("SLOC"));
     await sloc(file);
     console.log();
-    console.log(chalk35.bold.underline("Cyclomatic Complexity"));
+    console.log(chalk36.bold.underline("Cyclomatic Complexity"));
     await cyclomatic(file);
     console.log();
-    console.log(chalk35.bold.underline("Halstead Metrics"));
+    console.log(chalk36.bold.underline("Halstead Metrics"));
     await halstead(file);
     console.log();
-    console.log(chalk35.bold.underline("Maintainability Index"));
+    console.log(chalk36.bold.underline("Maintainability Index"));
     await maintainability(file);
     return;
   }
@@ -3003,8 +3410,8 @@ function registerComplexity(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
-import chalk36 from "chalk";
+import { existsSync as existsSync17, readFileSync as readFileSync14, writeFileSync as writeFileSync14 } from "fs";
+import chalk37 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
         window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -3012,23 +3419,23 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync15(indexPath)) {
-    console.log(chalk36.yellow("No index.html found"));
+  if (!existsSync17(indexPath)) {
+    console.log(chalk37.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync12(indexPath, "utf-8");
+  const content = readFileSync14(indexPath, "utf-8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
-    console.log(chalk36.dim("Trailing slash script already present"));
+    console.log(chalk37.dim("Trailing slash script already present"));
     return;
   }
   const headCloseIndex = content.indexOf("</head>");
   if (headCloseIndex === -1) {
-    console.log(chalk36.red("Could not find </head> tag in index.html"));
+    console.log(chalk37.red("Could not find </head> tag in index.html"));
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
-  writeFileSync12(indexPath, newContent);
-  console.log(chalk36.green("Added trailing slash redirect to index.html"));
+  writeFileSync14(indexPath, newContent);
+  console.log(chalk37.green("Added trailing slash redirect to index.html"));
 }
 
 // src/commands/registerDeploy.ts
@@ -3039,24 +3446,24 @@ function registerDeploy(program2) {
 }
 
 // src/commands/devlog/list/index.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 import { basename as basename3 } from "path";
 
 // src/commands/devlog/shared.ts
-import { execSync as execSync13 } from "child_process";
-import chalk37 from "chalk";
+import { execSync as execSync14 } from "child_process";
+import chalk38 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync, readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join11 } from "path";
-var DEVLOG_DIR = join11(homedir3(), "git/blog/src/content/devlog");
+import { readdirSync, readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join13 } from "path";
+var DEVLOG_DIR = join13(homedir4(), "git/blog/src/content/devlog");
 function loadDevlogEntries(repoName) {
   const entries = /* @__PURE__ */ new Map();
   try {
     const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync13(join11(DEVLOG_DIR, file), "utf-8");
+      const content = readFileSync15(join13(DEVLOG_DIR, file), "utf-8");
       const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (frontmatterMatch) {
         const frontmatter = frontmatterMatch[1];
@@ -3087,7 +3494,7 @@ function loadDevlogEntries(repoName) {
 // src/commands/devlog/shared.ts
 function getCommitFiles(hash) {
   try {
-    const output = execSync13(`git show --name-only --format="" ${hash}`, {
+    const output = execSync14(`git show --name-only --format="" ${hash}`, {
       encoding: "utf-8"
     });
     return output.trim().split("\n").filter(Boolean);
@@ -3105,13 +3512,13 @@ function shouldIgnoreCommit(files, ignorePaths) {
 }
 function printCommitsWithFiles(commits, ignore2, verbose) {
   for (const commit2 of commits) {
-    console.log(`  ${chalk37.yellow(commit2.hash)} ${commit2.message}`);
+    console.log(`  ${chalk38.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(`    ${chalk37.dim(file)}`);
+        console.log(`    ${chalk38.dim(file)}`);
       }
     }
   }
@@ -3136,15 +3543,15 @@ function parseGitLogCommits(output, ignore2, afterDate) {
 }
 
 // src/commands/devlog/list/printDateHeader.ts
-import chalk38 from "chalk";
+import chalk39 from "chalk";
 function printDateHeader(date, isSkipped, entries) {
   if (isSkipped) {
-    console.log(`${chalk38.bold.blue(date)} ${chalk38.dim("skipped")}`);
+    console.log(`${chalk39.bold.blue(date)} ${chalk39.dim("skipped")}`);
   } else if (entries && entries.length > 0) {
-    const entryInfo = entries.map((e) => `${chalk38.green(e.version)} ${e.title}`).join(" | ");
-    console.log(`${chalk38.bold.blue(date)} ${entryInfo}`);
+    const entryInfo = entries.map((e) => `${chalk39.green(e.version)} ${e.title}`).join(" | ");
+    console.log(`${chalk39.bold.blue(date)} ${entryInfo}`);
   } else {
-    console.log(`${chalk38.bold.blue(date)} ${chalk38.red("\u26A0 devlog missing")}`);
+    console.log(`${chalk39.bold.blue(date)} ${chalk39.red("\u26A0 devlog missing")}`);
   }
 }
 
@@ -3158,7 +3565,7 @@ function list3(options2) {
   const devlogEntries = loadDevlogEntries(repoName);
   const reverseFlag = options2.reverse ? "--reverse " : "";
   const limitFlag = options2.reverse ? "" : "-n 500 ";
-  const output = execSync14(
+  const output = execSync15(
     `git log ${reverseFlag}${limitFlag}--pretty=format:'%ad|%h|%s' --date=short`,
     { encoding: "utf-8" }
   );
@@ -3184,11 +3591,11 @@ function list3(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execSync as execSync15 } from "child_process";
+import { execSync as execSync16 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
-    const content = execSync15(`git show ${hash}:package.json`, {
+    const content = execSync16(`git show ${hash}:package.json`, {
       encoding: "utf-8"
     });
     const pkg = JSON.parse(content);
@@ -3203,7 +3610,7 @@ function stripToMinor(version2) {
 }
 function getLastVersionInfoFromGit() {
   try {
-    const output = execSync15(
+    const output = execSync16(
       "git log -1 --pretty=format:'%ad|%h' --date=short",
       {
         encoding: "utf-8"
@@ -3246,25 +3653,25 @@ function bumpVersion(version2, type) {
 }
 
 // src/commands/devlog/next/displayNextEntry/index.ts
-import { execSync as execSync16 } from "child_process";
-import chalk40 from "chalk";
+import { execSync as execSync17 } from "child_process";
+import chalk41 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
-import chalk39 from "chalk";
+import chalk40 from "chalk";
 function displayVersion(conventional, firstHash, patchVersion, minorVersion) {
   if (conventional && firstHash) {
     const version2 = getVersionAtCommit(firstHash);
     if (version2) {
-      console.log(`${chalk39.bold("version:")} ${stripToMinor(version2)}`);
+      console.log(`${chalk40.bold("version:")} ${stripToMinor(version2)}`);
     } else {
-      console.log(`${chalk39.bold("version:")} ${chalk39.red("unknown")}`);
+      console.log(`${chalk40.bold("version:")} ${chalk40.red("unknown")}`);
     }
   } else if (patchVersion && minorVersion) {
     console.log(
-      `${chalk39.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+      `${chalk40.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
     );
   } else {
-    console.log(`${chalk39.bold("version:")} v0.1 (initial)`);
+    console.log(`${chalk40.bold("version:")} v0.1 (initial)`);
   }
 }
 
@@ -3280,7 +3687,7 @@ function findTargetDate(commitsByDate, skipDays) {
   return Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort()[0];
 }
 function fetchCommitsByDate(ignore2, lastDate) {
-  const output = execSync16(
+  const output = execSync17(
     "git log --pretty=format:'%ad|%h|%s' --date=short -n 500",
     { encoding: "utf-8" }
   );
@@ -3311,16 +3718,16 @@ function noCommitsMessage(hasLastInfo) {
   return hasLastInfo ? "No commits after last versioned entry" : "No commits found";
 }
 function logName(repoName) {
-  console.log(`${chalk40.bold("name:")} ${repoName}`);
+  console.log(`${chalk41.bold("name:")} ${repoName}`);
 }
 function displayNextEntry(ctx, targetDate, commits) {
   logName(ctx.repoName);
   printVersionInfo(ctx.config, ctx.lastInfo, commits[0]?.hash);
-  console.log(chalk40.bold.blue(targetDate));
+  console.log(chalk41.bold.blue(targetDate));
   printCommitsWithFiles(commits, ctx.ignore, ctx.verbose);
 }
 function logNoCommits(lastInfo) {
-  console.log(chalk40.dim(noCommitsMessage(!!lastInfo)));
+  console.log(chalk41.dim(noCommitsMessage(!!lastInfo)));
 }
 
 // src/commands/devlog/next/index.ts
@@ -3355,10 +3762,10 @@ function next(options2) {
 }
 
 // src/commands/devlog/skip.ts
-import chalk41 from "chalk";
+import chalk42 from "chalk";
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    console.log(chalk41.red("Invalid date format. Use YYYY-MM-DD"));
+    console.log(chalk42.red("Invalid date format. Use YYYY-MM-DD"));
     process.exit(1);
   }
   const config = loadProjectConfig();
@@ -3366,7 +3773,7 @@ function skip(date) {
   const skip2 = devlog.skip ?? {};
   const skipDays = skip2.days ?? [];
   if (skipDays.includes(date)) {
-    console.log(chalk41.yellow(`${date} is already in skip list`));
+    console.log(chalk42.yellow(`${date} is already in skip list`));
     return;
   }
   skipDays.push(date);
@@ -3375,20 +3782,20 @@ function skip(date) {
   devlog.skip = skip2;
   config.devlog = devlog;
   saveConfig(config);
-  console.log(chalk41.green(`Added ${date} to skip list`));
+  console.log(chalk42.green(`Added ${date} to skip list`));
 }
 
 // src/commands/devlog/version.ts
-import chalk42 from "chalk";
+import chalk43 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(`${chalk42.bold("name:")} ${name}`);
-  console.log(`${chalk42.bold("last:")} ${lastVersion ?? chalk42.dim("none")}`);
-  console.log(`${chalk42.bold("next:")} ${nextVersion ?? chalk42.dim("none")}`);
+  console.log(`${chalk43.bold("name:")} ${name}`);
+  console.log(`${chalk43.bold("last:")} ${lastVersion ?? chalk43.dim("none")}`);
+  console.log(`${chalk43.bold("next:")} ${nextVersion ?? chalk43.dim("none")}`);
 }
 
 // src/commands/registerDevlog.ts
@@ -3406,12 +3813,12 @@ function registerDevlog(program2) {
 
 // src/commands/prs/comment.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync13 } from "fs";
+import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 
 // src/commands/prs/shared.ts
-import { execSync as execSync17 } from "child_process";
+import { execSync as execSync18 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -3427,14 +3834,14 @@ function isNotFound(error) {
 }
 function getRepoInfo() {
   const repoInfo = JSON.parse(
-    execSync17("gh repo view --json owner,name", { encoding: "utf-8" })
+    execSync18("gh repo view --json owner,name", { encoding: "utf-8" })
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
 function getCurrentPrNumber() {
   try {
     const prInfo = JSON.parse(
-      execSync17("gh pr view --json number", { encoding: "utf-8" })
+      execSync18("gh pr view --json number", { encoding: "utf-8" })
     );
     return prInfo.number;
   } catch (error) {
@@ -3448,7 +3855,7 @@ function getCurrentPrNumber() {
 function getCurrentPrNodeId() {
   try {
     const prInfo = JSON.parse(
-      execSync17("gh pr view --json id", { encoding: "utf-8" })
+      execSync18("gh pr view --json id", { encoding: "utf-8" })
     );
     return prInfo.id;
   } catch (error) {
@@ -3480,8 +3887,8 @@ function comment(path31, line, body) {
   validateLine(line);
   try {
     const prId = getCurrentPrNodeId();
-    const queryFile = join12(tmpdir2(), `gh-query-${Date.now()}.graphql`);
-    writeFileSync13(queryFile, MUTATION);
+    const queryFile = join14(tmpdir2(), `gh-query-${Date.now()}.graphql`);
+    writeFileSync15(queryFile, MUTATION);
     try {
       const result = spawnSync2(
         "gh",
@@ -3519,32 +3926,32 @@ function comment(path31, line, body) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync19 } from "child_process";
+import { execSync as execSync20 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync18 } from "child_process";
-import { unlinkSync as unlinkSync5, writeFileSync as writeFileSync14 } from "fs";
+import { execSync as execSync19 } from "child_process";
+import { unlinkSync as unlinkSync5, writeFileSync as writeFileSync16 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14, unlinkSync as unlinkSync4 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, unlinkSync as unlinkSync4 } from "fs";
+import { join as join15 } from "path";
 import { parse } from "yaml";
 function getCachePath(prNumber) {
-  return join13(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join15(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync16(cachePath)) {
+  if (!existsSync18(cachePath)) {
     return null;
   }
-  const content = readFileSync14(cachePath, "utf-8");
+  const content = readFileSync16(cachePath, "utf-8");
   return parse(content);
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync16(cachePath)) {
+  if (existsSync18(cachePath)) {
     unlinkSync4(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -3552,17 +3959,17 @@ function deleteCommentsCache(prNumber) {
 
 // src/commands/prs/resolveCommentWithReply.ts
 function replyToComment(org, repo, prNumber, commentId, message) {
-  execSync18(
+  execSync19(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, '\\"')}" -F in_reply_to=${commentId}`,
     { stdio: "inherit" }
   );
 }
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join14(tmpdir3(), `gh-mutation-${Date.now()}.graphql`);
-  writeFileSync14(queryFile, mutation);
+  const queryFile = join16(tmpdir3(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync16(queryFile, mutation);
   try {
-    execSync18(
+    execSync19(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: "inherit" }
     );
@@ -3614,7 +4021,7 @@ function resolveCommentWithReply(commentId, message) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync19(`git rev-parse --verify ${sha}`, {
+    return execSync20(`git rev-parse --verify ${sha}`, {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -3640,26 +4047,21 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync4, writeFileSync as writeFileSync16 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync5, writeFileSync as writeFileSync18 } from "fs";
+import { join as join18 } from "path";
 import { stringify } from "yaml";
 
-// src/lib/isClaudeCode.ts
-function isClaudeCode() {
-  return process.env.CLAUDECODE !== void 0;
-}
-
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync20 } from "child_process";
-import { unlinkSync as unlinkSync6, writeFileSync as writeFileSync15 } from "fs";
+import { execSync as execSync21 } from "child_process";
+import { unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join15 } from "path";
+import { join as join17 } 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 = join15(tmpdir4(), `gh-query-${Date.now()}.graphql`);
-  writeFileSync15(queryFile, THREAD_QUERY);
+  const queryFile = join17(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync17(queryFile, THREAD_QUERY);
   try {
-    const result = execSync20(
+    const result = execSync21(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf-8" }
     );
@@ -3681,9 +4083,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync21 } from "child_process";
+import { execSync as execSync22 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync21(`gh api --paginate ${endpoint}`, {
+  const result = execSync22(`gh api --paginate ${endpoint}`, {
     encoding: "utf-8"
   });
   if (!result.trim()) return [];
@@ -3725,20 +4127,20 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 }
 
 // src/commands/prs/listComments/formatForHuman.ts
-import chalk43 from "chalk";
+import chalk44 from "chalk";
 function formatForHuman(comment2) {
   if (comment2.type === "review") {
-    const stateColor = comment2.state === "APPROVED" ? chalk43.green : comment2.state === "CHANGES_REQUESTED" ? chalk43.red : chalk43.yellow;
+    const stateColor = comment2.state === "APPROVED" ? chalk44.green : comment2.state === "CHANGES_REQUESTED" ? chalk44.red : chalk44.yellow;
     return [
-      `${chalk43.cyan("Review")} by ${chalk43.bold(comment2.user)} ${stateColor(`[${comment2.state}]`)}`,
+      `${chalk44.cyan("Review")} by ${chalk44.bold(comment2.user)} ${stateColor(`[${comment2.state}]`)}`,
       comment2.body,
       ""
     ].join("\n");
   }
   const location = comment2.line ? `:${comment2.line}` : "";
   return [
-    `${chalk43.cyan("Line comment")} by ${chalk43.bold(comment2.user)} on ${chalk43.dim(`${comment2.path}${location}`)}`,
-    chalk43.dim(comment2.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${chalk44.cyan("Line comment")} by ${chalk44.bold(comment2.user)} on ${chalk44.dim(`${comment2.path}${location}`)}`,
+    chalk44.dim(comment2.diff_hunk.split("\n").slice(-3).join("\n")),
     comment2.body,
     ""
   ].join("\n");
@@ -3761,17 +4163,17 @@ function printComments(comments) {
   }
 }
 function writeCommentsCache(prNumber, comments) {
-  const assistDir = join16(process.cwd(), ".assist");
-  if (!existsSync17(assistDir)) {
-    mkdirSync4(assistDir, { recursive: true });
+  const assistDir = join18(process.cwd(), ".assist");
+  if (!existsSync19(assistDir)) {
+    mkdirSync5(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments
   };
-  const cachePath = join16(assistDir, `pr-${prNumber}-comments.yaml`);
-  writeFileSync16(cachePath, stringify(cacheData));
+  const cachePath = join18(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync18(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -3811,19 +4213,19 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync22 } from "child_process";
+import { execSync as execSync23 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer5 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk44 from "chalk";
+import chalk45 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk44.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk44.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk45.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk45.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk44.green("opened"), date: pr.createdAt };
+  return { label: chalk45.green("opened"), date: pr.createdAt };
 }
 function getStatus(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -3832,11 +4234,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status2) {
-  return `${chalk44.cyan(`#${pr.number}`)} ${pr.title} ${chalk44.dim(`(${pr.author.login},`)} ${status2.label} ${chalk44.dim(`${formatDate(status2.date)})`)}`;
+  return `${chalk45.cyan(`#${pr.number}`)} ${pr.title} ${chalk45.dim(`(${pr.author.login},`)} ${status2.label} ${chalk45.dim(`${formatDate(status2.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk44.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk45.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -3917,7 +4319,7 @@ async function displayPaginated(pullRequests) {
 async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
-    const result = execSync22(
+    const result = execSync23(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
       { encoding: "utf-8" }
     );
@@ -3940,7 +4342,7 @@ async function prs(options2) {
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync23 } from "child_process";
+import { execSync as execSync24 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -3957,7 +4359,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync23(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync24(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -4006,7 +4408,7 @@ import { spawn as spawn3 } from "child_process";
 import * as path17 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk45 from "chalk";
+import chalk46 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -4015,43 +4417,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk45.red(`
+  console.error(chalk46.red(`
 Refactor check failed:
 `));
-  console.error(chalk45.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk46.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk45.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk46.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk45.yellow(
+    chalk46.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk45.gray(`    assist refactor ignore <file>
+  console.error(chalk46.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk45.cyan(`
+    console.error(chalk46.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk45.cyan(
+      chalk46.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk45.cyan(
+      chalk46.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(
-      chalk45.cyan(
+      chalk46.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -4061,7 +4463,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync24 } from "child_process";
+import { execSync as execSync25 } from "child_process";
 import fs15 from "fs";
 import { minimatch as minimatch4 } from "minimatch";
 
@@ -4111,7 +4513,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync24("git diff --cached --name-only", {
+    const staged = execSync25("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -4119,7 +4521,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync24("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync25("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -4207,11 +4609,11 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/ignore.ts
 import fs16 from "fs";
-import chalk46 from "chalk";
+import chalk47 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs16.existsSync(file)) {
-    console.error(chalk46.red(`Error: File does not exist: ${file}`));
+    console.error(chalk47.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs16.readFileSync(file, "utf-8");
@@ -4227,7 +4629,7 @@ function ignore(file) {
     fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk46.green(
+    chalk47.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -4235,7 +4637,7 @@ function ignore(file) {
 
 // src/commands/refactor/restructure/index.ts
 import path26 from "path";
-import chalk49 from "chalk";
+import chalk50 from "chalk";
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
 import path18 from "path";
@@ -4478,50 +4880,50 @@ function computeRewrites(moves, edges, allProjectFiles) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path22 from "path";
-import chalk47 from "chalk";
+import chalk48 from "chalk";
 function relPath(filePath) {
   return path22.relative(process.cwd(), filePath);
 }
 function displayMoves(plan) {
   if (plan.moves.length === 0) return;
-  console.log(chalk47.bold("\nFile moves:"));
+  console.log(chalk48.bold("\nFile moves:"));
   for (const move of plan.moves) {
     console.log(
-      `  ${chalk47.red(relPath(move.from))} \u2192 ${chalk47.green(relPath(move.to))}`
+      `  ${chalk48.red(relPath(move.from))} \u2192 ${chalk48.green(relPath(move.to))}`
     );
-    console.log(chalk47.dim(`    ${move.reason}`));
+    console.log(chalk48.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk47.bold(`
+  console.log(chalk48.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk47.cyan(relPath(file))}:`);
+    console.log(`  ${chalk48.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk47.red(`"${oldSpecifier}"`)} \u2192 ${chalk47.green(`"${newSpecifier}"`)}`
+        `    ${chalk48.red(`"${oldSpecifier}"`)} \u2192 ${chalk48.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan(plan) {
   if (plan.warnings.length > 0) {
-    console.log(chalk47.yellow("\nWarnings:"));
-    for (const w of plan.warnings) console.log(chalk47.yellow(`  ${w}`));
+    console.log(chalk48.yellow("\nWarnings:"));
+    for (const w of plan.warnings) console.log(chalk48.yellow(`  ${w}`));
   }
   if (plan.newDirectories.length > 0) {
-    console.log(chalk47.bold("\nNew directories:"));
+    console.log(chalk48.bold("\nNew directories:"));
     for (const dir of plan.newDirectories)
-      console.log(chalk47.green(`  ${dir}/`));
+      console.log(chalk48.green(`  ${dir}/`));
   }
   displayMoves(plan);
   displayRewrites(plan.rewrites);
   console.log(
-    chalk47.dim(
+    chalk48.dim(
       `
 Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rewritten`
     )
@@ -4531,18 +4933,18 @@ Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rew
 // src/commands/refactor/restructure/executePlan.ts
 import fs18 from "fs";
 import path23 from "path";
-import chalk48 from "chalk";
+import chalk49 from "chalk";
 function executePlan(plan) {
   const updatedContents = applyRewrites(plan.rewrites);
   for (const [file, content] of updatedContents) {
     fs18.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk48.cyan(`  Rewrote imports in ${path23.relative(process.cwd(), file)}`)
+      chalk49.cyan(`  Rewrote imports in ${path23.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan.newDirectories) {
     fs18.mkdirSync(dir, { recursive: true });
-    console.log(chalk48.green(`  Created ${path23.relative(process.cwd(), dir)}/`));
+    console.log(chalk49.green(`  Created ${path23.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan.moves) {
     const targetDir = path23.dirname(move.to);
@@ -4551,7 +4953,7 @@ function executePlan(plan) {
     }
     fs18.renameSync(move.from, move.to);
     console.log(
-      chalk48.white(
+      chalk49.white(
         `  Moved ${path23.relative(process.cwd(), move.from)} \u2192 ${path23.relative(process.cwd(), move.to)}`
       )
     );
@@ -4566,7 +4968,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs18.rmdirSync(dir);
       console.log(
-        chalk48.dim(
+        chalk49.dim(
           `  Removed empty directory ${path23.relative(process.cwd(), dir)}`
         )
       );
@@ -4697,22 +5099,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk49.yellow("No files found matching pattern"));
+    console.log(chalk50.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = path26.resolve("tsconfig.json");
   const plan = buildPlan(files, tsConfigPath);
   if (plan.moves.length === 0) {
-    console.log(chalk49.green("No restructuring needed"));
+    console.log(chalk50.green("No restructuring needed"));
     return;
   }
   displayPlan(plan);
   if (options2.apply) {
-    console.log(chalk49.bold("\nApplying changes..."));
+    console.log(chalk50.bold("\nApplying changes..."));
     executePlan(plan);
-    console.log(chalk49.green("\nRestructuring complete"));
+    console.log(chalk50.green("\nRestructuring complete"));
   } else {
-    console.log(chalk49.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk50.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -4735,8 +5137,8 @@ function registerRefactor(program2) {
 }
 
 // src/commands/transcript/shared.ts
-import { existsSync as existsSync18, readdirSync as readdirSync2, statSync } from "fs";
-import { basename as basename4, join as join17, relative } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync2, statSync } from "fs";
+import { basename as basename4, join as join19, relative } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -4751,10 +5153,10 @@ function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
 function collectFiles(dir, extension) {
-  if (!existsSync18(dir)) return [];
+  if (!existsSync20(dir)) return [];
   const results = [];
   for (const entry of readdirSync2(dir)) {
-    const fullPath = join17(dir, entry);
+    const fullPath = join19(dir, entry);
     if (statSync(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -4848,14 +5250,14 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname13, join as join19 } from "path";
+import { dirname as dirname13, join as join21 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync } from "fs";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -4868,9 +5270,9 @@ async function resolveDate(rl, choice) {
   console.log("Cancelled.");
   return null;
 }
-function renameWithPrefix(vttDir, vttFile, prefix) {
-  const newFilename = `${prefix}.${vttFile}`;
-  renameSync(join18(vttDir, vttFile), join18(vttDir, newFilename));
+function renameWithPrefix(vttDir, vttFile, prefix2) {
+  const newFilename = `${prefix2}.${vttFile}`;
+  renameSync(join20(vttDir, vttFile), join20(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -4887,9 +5289,9 @@ Error: File "${vttFile}" does not start with YYYY-MM-DD format.`
   console.log("  4. Cancel");
   try {
     const choice = await askQuestion(rl, "\nSelect an option (1/2/3/4): ");
-    const prefix = await resolveDate(rl, choice);
+    const prefix2 = await resolveDate(rl, choice);
     rl.close();
-    return prefix ? renameWithPrefix(vttDir, vttFile, prefix) : null;
+    return prefix2 ? renameWithPrefix(vttDir, vttFile, prefix2) : null;
   } catch (error) {
     rl.close();
     throw error;
@@ -4904,12 +5306,12 @@ async function fixInvalidDatePrefixes(vttFiles) {
       const vttFileDir = dirname13(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join19(
+        const newRelativePath = join21(
           dirname13(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join19(vttFileDir, newFilename),
+          absolutePath: join21(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -4922,8 +5324,8 @@ async function fixInvalidDatePrefixes(vttFiles) {
 }
 
 // src/commands/transcript/format/processVttFile/index.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync5, readFileSync as readFileSync15, writeFileSync as writeFileSync17 } from "fs";
-import { basename as basename5, dirname as dirname14, join as join20 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync19 } from "fs";
+import { basename as basename5, dirname as dirname14, join as join22 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text) {
@@ -4993,8 +5395,8 @@ function removeSubstringDuplicates(cues) {
 function findWordOverlap(currentWords, nextWords) {
   for (let j = Math.min(5, currentWords.length); j >= 1; j--) {
     const suffix = currentWords.slice(-j).join(" ");
-    const prefix = nextWords.slice(0, j).join(" ");
-    if (suffix === prefix) return j;
+    const prefix2 = nextWords.slice(0, j).join(" ");
+    if (suffix === prefix2) return j;
   }
   return 0;
 }
@@ -5133,22 +5535,22 @@ function toMdFilename(vttFilename) {
   return `${basename5(vttFilename, ".vtt").replace(/\s*Transcription\s*/g, " ").trim()}.md`;
 }
 function resolveOutputDir(relativeDir, transcriptsDir) {
-  return relativeDir === "." ? transcriptsDir : join20(transcriptsDir, relativeDir);
+  return relativeDir === "." ? transcriptsDir : join22(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
   const relativeDir = dirname14(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join20(outputDir, mdFile);
+  const outputPath = join22(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join20(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join22(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
-  if (!existsSync19(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync21(dir)) {
+    mkdirSync6(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -5170,10 +5572,10 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync15(inputPath, "utf-8"));
+  return processCues(readFileSync17(inputPath, "utf-8"));
 }
 function writeFormatted(outputPath, content) {
-  writeFileSync17(outputPath, content, "utf-8");
+  writeFileSync19(outputPath, content, "utf-8");
   console.log(`Written: ${outputPath}`);
 }
 function convertVttToMarkdown(inputPath, outputPath) {
@@ -5183,7 +5585,7 @@ function convertVttToMarkdown(inputPath, outputPath) {
   logReduction(cues.length, chatMessages.length);
 }
 function tryProcessVtt(vttFile, paths) {
-  if (existsSync19(paths.outputPath))
+  if (existsSync21(paths.outputPath))
     return logSkipped(paths.relativeDir, paths.mdFile);
   convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
   return "processed";
@@ -5209,7 +5611,7 @@ function processAllFiles(vttFiles, transcriptsDir) {
   logSummary(counts);
 }
 function requireVttDir(vttDir) {
-  if (!existsSync20(vttDir)) {
+  if (!existsSync22(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
@@ -5241,28 +5643,28 @@ async function format() {
 }
 
 // src/commands/transcript/summarise/index.ts
-import { existsSync as existsSync22 } from "fs";
-import { basename as basename6, dirname as dirname16, join as join22, relative as relative2 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { basename as basename6, dirname as dirname16, join as join24, relative as relative2 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync16,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync18,
   renameSync as renameSync2,
   rmSync
 } from "fs";
-import { dirname as dirname15, join as join21 } from "path";
+import { dirname as dirname15, join as join23 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk50 from "chalk";
+import chalk51 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(
-      chalk50.red(
+      chalk51.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -5271,7 +5673,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk50.red(
+      chalk51.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -5281,9 +5683,9 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join21(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join23(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync21(STAGING_DIR)) {
+  if (!existsSync23(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -5292,7 +5694,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync16(stagedFile.absolutePath, "utf-8");
+  const content = readFileSync18(stagedFile.absolutePath, "utf-8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -5305,10 +5707,10 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join21(summaryDir, matchingTranscript.relativePath);
+  const destPath = join23(summaryDir, matchingTranscript.relativePath);
   const destDir = dirname15(destPath);
-  if (!existsSync21(destDir)) {
-    mkdirSync6(destDir, { recursive: true });
+  if (!existsSync23(destDir)) {
+    mkdirSync7(destDir, { recursive: true });
   }
   renameSync2(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
@@ -5321,7 +5723,7 @@ function processStagedFile() {
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
   const relDir = dirname16(relativePath);
-  return relDir === "." ? baseName : join22(relDir, baseName);
+  return relDir === "." ? baseName : join24(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -5334,7 +5736,7 @@ function buildSummaryIndex(summaryDir) {
 function summarise() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync22(transcriptsDir)) {
+  if (!existsSync24(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -5355,8 +5757,8 @@ function summarise() {
   }
   const next2 = missing[0];
   const outputFilename = `${getTranscriptBaseName(next2.filename)}.md`;
-  const outputPath = join22(STAGING_DIR, outputFilename);
-  const summaryFileDir = join22(summaryDir, dirname16(next2.relativePath));
+  const outputPath = join24(STAGING_DIR, outputFilename);
+  const summaryFileDir = join24(summaryDir, dirname16(next2.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative2(summaryFileDir, next2.absolutePath).replace(/\\/g, "/")
   );
@@ -5402,50 +5804,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir4 } from "os";
-import { dirname as dirname17, join as join23 } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname17, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname5 = dirname17(fileURLToPath4(import.meta.url));
-var VOICE_DIR = join23(homedir4(), ".assist", "voice");
+var VOICE_DIR = join25(homedir5(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join23(VOICE_DIR, "voice.pid"),
-  log: join23(VOICE_DIR, "voice.log"),
-  venv: join23(VOICE_DIR, ".venv"),
-  lock: join23(VOICE_DIR, "voice.lock")
+  pid: join25(VOICE_DIR, "voice.pid"),
+  log: join25(VOICE_DIR, "voice.log"),
+  venv: join25(VOICE_DIR, ".venv"),
+  lock: join25(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join23(__dirname5, "commands", "voice", "python");
+  return join25(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join23(voicePaths.venv, "Scripts", "python.exe") : join23(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join25(voicePaths.venv, "Scripts", "python.exe") : join25(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join23(getLockDir(), "voice.lock");
+  return join25(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join24(getPythonDir(), "list_devices.py");
+  const script = join26(getPythonDir(), "list_devices.py");
   spawnSync3(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
 function logs(options2) {
-  if (!existsSync23(voicePaths.log)) {
+  if (!existsSync25(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync17(voicePaths.log, "utf-8").trim();
+  const content = readFileSync19(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -5467,13 +5869,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join26 } from "path";
+import { mkdirSync as mkdirSync9 } from "fs";
+import { join as join28 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync25 } from "child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync18 } from "fs";
-import { join as join25 } from "path";
+import { execSync as execSync26 } from "child_process";
+import { existsSync as existsSync26, mkdirSync as mkdirSync8, readFileSync as readFileSync20, writeFileSync as writeFileSync20 } from "fs";
+import { join as join27 } from "path";
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -5484,9 +5886,9 @@ function isProcessAlive(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync24(lockFile)) return;
+  if (!existsSync26(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync18(lockFile, "utf-8"));
+    const lock = JSON.parse(readFileSync20(lockFile, "utf-8"));
     if (lock.pid && isProcessAlive(lock.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock.pid}, env: ${lock.env}). Stop it first with: assist voice stop`
@@ -5497,10 +5899,10 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync24(getVenvPython())) return;
+  if (existsSync26(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync25(
+  execSync26(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -5510,8 +5912,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync7(join25(lockFile, ".."), { recursive: true });
-  writeFileSync18(
+  mkdirSync8(join27(lockFile, ".."), { recursive: true });
+  writeFileSync20(
     lockFile,
     JSON.stringify({
       pid,
@@ -5523,10 +5925,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync8(voicePaths.dir, { recursive: true });
+  mkdirSync9(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join26(getPythonDir(), "setup_models.py");
+  const script = join28(getPythonDir(), "setup_models.py");
   const result = spawnSync4(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -5539,8 +5941,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync19 } from "fs";
-import { join as join27 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync21 } from "fs";
+import { join as join29 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -5568,17 +5970,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync19(voicePaths.pid, String(pid));
+  writeFileSync21(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync9(voicePaths.dir, { recursive: true });
+  mkdirSync10(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join27(getPythonDir(), "voice_daemon.py");
+  const script = join29(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -5588,7 +5990,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync21 } from "fs";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -5598,16 +6000,16 @@ function isProcessAlive2(pid) {
   }
 }
 function readRecentLogs(count) {
-  if (!existsSync25(voicePaths.log)) return [];
-  const lines = readFileSync19(voicePaths.log, "utf-8").trim().split("\n");
+  if (!existsSync27(voicePaths.log)) return [];
+  const lines = readFileSync21(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count);
 }
 function status() {
-  if (!existsSync25(voicePaths.pid)) {
+  if (!existsSync27(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync19(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync21(voicePaths.pid, "utf-8").trim(), 10);
   const alive = isProcessAlive2(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -5626,13 +6028,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync26, readFileSync as readFileSync20, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync22, unlinkSync as unlinkSync7 } from "fs";
 function stop() {
-  if (!existsSync26(voicePaths.pid)) {
+  if (!existsSync28(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync20(voicePaths.pid, "utf-8").trim(), 10);
+  const pid = Number.parseInt(readFileSync22(voicePaths.pid, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -5645,7 +6047,7 @@ function stop() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync26(lockFile)) unlinkSync7(lockFile);
+    if (existsSync28(lockFile)) unlinkSync7(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -5664,14 +6066,14 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk51 from "chalk";
+import chalk52 from "chalk";
 
 // src/lib/openBrowser.ts
-import { execSync as execSync26 } from "child_process";
+import { execSync as execSync27 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync26(cmd);
+      execSync27(cmd);
       return true;
     } catch {
     }
@@ -5839,13 +6241,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk51.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk52.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk51.white("http://localhost:14523/callback\n"));
-  console.log(chalk51.blue("Opening browser for authorization..."));
-  console.log(chalk51.dim("Waiting for authorization callback..."));
+  console.log(chalk52.white("http://localhost:14523/callback\n"));
+  console.log(chalk52.blue("Opening browser for authorization..."));
+  console.log(chalk52.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk51.dim("Exchanging code for tokens..."));
+  console.log(chalk52.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -5861,7 +6263,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk51.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk52.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -5875,8 +6277,8 @@ function registerRoam(program2) {
 import { spawn as spawn5 } from "child_process";
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync20 } from "fs";
-import { join as join28 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync22 } from "fs";
+import { join as join30 } from "path";
 function findAddIndex() {
   const addIndex = process.argv.indexOf("add");
   if (addIndex === -1 || addIndex + 2 >= process.argv.length) return -1;
@@ -5930,16 +6332,16 @@ function saveNewRunConfig(name, command, args) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join28(".claude", "commands");
-  mkdirSync10(dir, { recursive: true });
+  const dir = join30(".claude", "commands");
+  mkdirSync11(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join28(dir, `${name}.md`);
-  writeFileSync20(filePath, content);
+  const filePath = join30(dir, `${name}.md`);
+  writeFileSync22(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add2() {
@@ -6009,14 +6411,14 @@ function run2(name, args) {
 }
 
 // src/commands/statusLine.ts
-import chalk52 from "chalk";
+import chalk53 from "chalk";
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${pct}%`;
-  if (pct > 80) return chalk52.red(label2);
-  if (pct > 40) return chalk52.yellow(label2);
+  if (pct > 80) return chalk53.red(label2);
+  if (pct > 40) return chalk53.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -6042,7 +6444,7 @@ import { fileURLToPath as fileURLToPath5 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs21 from "fs";
 import * as path27 from "path";
-import chalk53 from "chalk";
+import chalk54 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
   const source = path27.join(claudeDir, "CLAUDE.md");
   const target = path27.join(targetBase, "CLAUDE.md");
@@ -6051,12 +6453,12 @@ async function syncClaudeMd(claudeDir, targetBase) {
     const targetContent = fs21.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk53.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk54.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk53.red("Overwrite existing CLAUDE.md?"),
+        chalk54.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -6072,7 +6474,7 @@ async function syncClaudeMd(claudeDir, targetBase) {
 // src/commands/sync/syncSettings.ts
 import * as fs22 from "fs";
 import * as path28 from "path";
-import chalk54 from "chalk";
+import chalk55 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path28.join(claudeDir, "settings.json");
   const target = path28.join(targetBase, "settings.json");
@@ -6084,14 +6486,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (normalizedSource !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk54.yellow(
+          chalk55.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, sourceContent);
         const confirm = await promptConfirm(
-          chalk54.red("Overwrite existing settings.json?"),
+          chalk55.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -6128,7 +6530,7 @@ function syncCommands(claudeDir, targetBase) {
 }
 
 // src/commands/update.ts
-import { execSync as execSync27 } from "child_process";
+import { execSync as execSync28 } from "child_process";
 import * as path30 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __filename3 = fileURLToPath6(import.meta.url);
@@ -6138,7 +6540,7 @@ function getInstallDir() {
 }
 function isGitRepo(dir) {
   try {
-    const result = execSync27("git rev-parse --show-toplevel", {
+    const result = execSync28("git rev-parse --show-toplevel", {
       cwd: dir,
       stdio: "pipe"
     }).toString().trim();
@@ -6149,7 +6551,7 @@ function isGitRepo(dir) {
 }
 function isGlobalNpmInstall(dir) {
   try {
-    const globalPrefix = execSync27("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync28("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return path30.resolve(dir).toLowerCase().startsWith(path30.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -6160,16 +6562,16 @@ async function update() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync27("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync28("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync27("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync28("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync27("assist sync", { stdio: "inherit" });
+    execSync28("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync27("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync28("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync27("assist sync", { stdio: "inherit" });
+    execSync28("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."
@@ -6203,6 +6605,8 @@ program.command("notify").description(
   "Show notification from Claude Code hook (reads JSON from stdin)"
 ).action(notify);
 program.command("update").description("Update assist to the latest version and sync commands").action(update);
+registerCliDiscover(program);
+registerCliHook(program);
 registerPrs(program);
 registerRoam(program);
 registerBacklog(program);