@staff0rd/assist 0.94.1 → 0.96.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.94.1",
+  version: "0.96.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -15,7 +15,8 @@ var package_default = {
   },
   files: [
     "dist",
-    "claude"
+    "claude",
+    "assist.cli-reads"
   ],
   publishConfig: {
     access: "public"
@@ -23,7 +24,8 @@ var package_default = {
   scripts: {
     build: "tsup",
     start: "node dist/index.js",
-    "check:types": "tsc --noEmit"
+    "check:types": "tsc --noEmit",
+    test: "vitest run"
   },
   keywords: [],
   author: "",
@@ -65,7 +67,8 @@ var package_default = {
     react: "^19.2.4",
     "react-dom": "^19.2.4",
     "semantic-release": "^25.0.2",
-    tsup: "^8.5.1"
+    tsup: "^8.5.1",
+    vitest: "^4.0.18"
   }
 };
 
@@ -73,11 +76,24 @@ var package_default = {
 import { execSync } from "child_process";
 
 // src/shared/loadConfig.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir } from "os";
 import { basename, join } from "path";
 import chalk from "chalk";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/shared/loadRawYaml.ts
+import { existsSync, readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function loadRawYaml(path31) {
+  if (!existsSync(path31)) return {};
+  try {
+    const content = readFileSync(path31, "utf-8");
+    return parseYaml(content) || {};
+  } catch {
+    return {};
+  }
+}
 
 // src/shared/types.ts
 import { z } from "zod";
@@ -129,6 +145,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(),
@@ -150,7 +167,7 @@ var assistConfigSchema = z.strictObject({
 // src/shared/loadConfig.ts
 function getConfigPath() {
   const claudeConfigPath = join(process.cwd(), ".claude", "assist.yml");
-  if (existsSync(claudeConfigPath)) {
+  if (existsSync2(claudeConfigPath)) {
     return claudeConfigPath;
   }
   return join(process.cwd(), "assist.yml");
@@ -158,26 +175,17 @@ function getConfigPath() {
 function getGlobalConfigPath() {
   return join(homedir(), ".assist.yml");
 }
-function loadRawConfig(path31) {
-  if (!existsSync(path31)) return {};
-  try {
-    const content = readFileSync(path31, "utf-8");
-    return parseYaml(content) || {};
-  } catch {
-    return {};
-  }
-}
 function loadConfig() {
-  const globalRaw = loadRawConfig(getGlobalConfigPath());
-  const projectRaw = loadRawConfig(getConfigPath());
+  const globalRaw = loadRawYaml(getGlobalConfigPath());
+  const projectRaw = loadRawYaml(getConfigPath());
   const merged = { ...globalRaw, ...projectRaw };
   return assistConfigSchema.parse(merged);
 }
 function loadProjectConfig() {
-  return loadRawConfig(getConfigPath());
+  return loadRawYaml(getConfigPath());
 }
 function loadGlobalConfigRaw() {
-  return loadRawConfig(getGlobalConfigPath());
+  return loadRawYaml(getGlobalConfigPath());
 }
 function saveGlobalConfig(config) {
   writeFileSync(getGlobalConfigPath(), stringifyYaml(config, { lineWidth: 0 }));
@@ -192,9 +200,9 @@ function getRepoName() {
     return config.devlog.name;
   }
   const packageJsonPath = join(process.cwd(), "package.json");
-  if (existsSync(packageJsonPath)) {
+  if (existsSync2(packageJsonPath)) {
     try {
-      const content = readFileSync(packageJsonPath, "utf-8");
+      const content = readFileSync2(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -646,7 +654,7 @@ import chalk12 from "chalk";
 
 // src/commands/lint/init.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, join as join4 } from "path";
 import { fileURLToPath } from "url";
 import chalk11 from "chalk";
@@ -670,10 +678,10 @@ async function promptConfirm(message, initial = true) {
 
 // src/shared/removeEslint/index.ts
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 
 // src/shared/removeEslint/removeEslintConfigFiles.ts
-import { existsSync as existsSync4, unlinkSync } from "fs";
+import { existsSync as existsSync5, unlinkSync } from "fs";
 var ESLINT_CONFIG_FILES = [
   "eslint.config.js",
   "eslint.config.mjs",
@@ -689,7 +697,7 @@ var ESLINT_CONFIG_FILES = [
 function removeEslintConfigFiles() {
   let removed = false;
   for (const configFile of ESLINT_CONFIG_FILES) {
-    if (existsSync4(configFile)) {
+    if (existsSync5(configFile)) {
       unlinkSync(configFile);
       console.log(`Removed ${configFile}`);
       removed = true;
@@ -711,10 +719,10 @@ function removeEslint(options2 = {}) {
 }
 function removeEslintFromPackageJson(options2) {
   const packageJsonPath = "package.json";
-  if (!existsSync5(packageJsonPath)) {
+  if (!existsSync6(packageJsonPath)) {
     return false;
   }
-  const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
   let modified = false;
   modified = removeEslintDeps(packageJson.dependencies) || modified;
   modified = removeEslintDeps(packageJson.devDependencies) || modified;
@@ -784,17 +792,17 @@ var __dirname2 = dirname5(fileURLToPath(import.meta.url));
 async function init() {
   removeEslint();
   const biomeConfigPath = "biome.json";
-  if (!existsSync6(biomeConfigPath)) {
+  if (!existsSync7(biomeConfigPath)) {
     console.log("Initializing Biome...");
     execSync4("npx @biomejs/biome init", { stdio: "inherit" });
   }
-  if (!existsSync6(biomeConfigPath)) {
+  if (!existsSync7(biomeConfigPath)) {
     console.log("No biome.json found, skipping linter config");
     return;
   }
   const linterConfigPath = join4(__dirname2, "commands/lint/biome.linter.json");
-  const linterConfig = JSON.parse(readFileSync5(linterConfigPath, "utf-8"));
-  const biomeConfig = JSON.parse(readFileSync5(biomeConfigPath, "utf-8"));
+  const linterConfig = JSON.parse(readFileSync6(linterConfigPath, "utf-8"));
+  const biomeConfig = JSON.parse(readFileSync6(biomeConfigPath, "utf-8"));
   const oldContent = `${JSON.stringify(biomeConfig, null, 2)}
 `;
   biomeConfig.linter = linterConfig.linter;
@@ -1617,14 +1625,14 @@ function flushIfFailed(exitCode, chunks) {
 
 // src/commands/verify/run/runAllEntries.ts
 function runEntry(entry, onComplete) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     const child = spawnCommand(entry.fullCommand, entry.cwd, entry.env);
     const chunks = collectOutput(child);
     child.on("close", (code) => {
       const exitCode = code ?? 1;
       flushIfFailed(exitCode, chunks);
       onComplete?.(exitCode);
-      resolve3({ script: entry.name, code: exitCode });
+      resolve5({ script: entry.name, code: exitCode });
     });
   });
 }
@@ -1769,7 +1777,7 @@ async function newCli() {
 
 // src/commands/new/registerNew/newProject.ts
 import { execSync as execSync12 } from "child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
 
 // src/commands/deploy/init/index.ts
 import { execSync as execSync11 } from "child_process";
@@ -1777,33 +1785,33 @@ import chalk21 from "chalk";
 import enquirer3 from "enquirer";
 
 // src/commands/deploy/init/updateWorkflow.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname10, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk20 from "chalk";
 var WORKFLOW_PATH = ".github/workflows/build.yml";
 var __dirname3 = dirname10(fileURLToPath2(import.meta.url));
 function getExistingSiteId() {
-  if (!existsSync9(WORKFLOW_PATH)) {
+  if (!existsSync10(WORKFLOW_PATH)) {
     return null;
   }
-  const content = readFileSync7(WORKFLOW_PATH, "utf-8");
+  const content = readFileSync8(WORKFLOW_PATH, "utf-8");
   const match = content.match(/-s\s+([a-f0-9-]{36})/);
   return match ? match[1] : null;
 }
 function getTemplateContent(siteId) {
   const templatePath = join7(__dirname3, "commands/deploy/build.yml");
-  const template = readFileSync7(templatePath, "utf-8");
+  const template = readFileSync8(templatePath, "utf-8");
   return template.replace("{{NETLIFY_SITE_ID}}", siteId);
 }
 async function updateWorkflow(siteId) {
   const newContent = getTemplateContent(siteId);
   const workflowDir = ".github/workflows";
-  if (!existsSync9(workflowDir)) {
+  if (!existsSync10(workflowDir)) {
     mkdirSync3(workflowDir, { recursive: true });
   }
-  if (existsSync9(WORKFLOW_PATH)) {
-    const oldContent = readFileSync7(WORKFLOW_PATH, "utf-8");
+  if (existsSync10(WORKFLOW_PATH)) {
+    const oldContent = readFileSync8(WORKFLOW_PATH, "utf-8");
     if (oldContent === newContent) {
       console.log(chalk20.green("build.yml is already up to date"));
       return;
@@ -1897,11 +1905,11 @@ async function newProject() {
 }
 function addViteBaseConfig() {
   const viteConfigPath = "vite.config.ts";
-  if (!existsSync10(viteConfigPath)) {
+  if (!existsSync11(viteConfigPath)) {
     console.log("No vite.config.ts found, skipping base config");
     return;
   }
-  const content = readFileSync8(viteConfigPath, "utf-8");
+  const content = readFileSync9(viteConfigPath, "utf-8");
   if (content.includes("base:")) {
     console.log("vite.config.ts already has base config");
     return;
@@ -2044,11 +2052,11 @@ async function notify() {
 }
 
 // src/commands/backlog/add/index.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import chalk23 from "chalk";
 
 // src/commands/backlog/shared.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "fs";
 import { join as join8 } from "path";
 import chalk22 from "chalk";
 import { parse as parseYaml2, stringify as stringifyYaml3 } from "yaml";
@@ -2073,11 +2081,11 @@ function getBacklogPath() {
 }
 function loadBacklog() {
   const backlogPath = getBacklogPath();
-  if (!existsSync11(backlogPath)) {
+  if (!existsSync12(backlogPath)) {
     return [];
   }
   try {
-    const content = readFileSync9(backlogPath, "utf-8");
+    const content = readFileSync10(backlogPath, "utf-8");
     const raw = parseYaml2(content) || [];
     return backlogFileSchema.parse(raw);
   } catch {
@@ -2092,7 +2100,7 @@ function findItem(items, id) {
   return items.find((item) => item.id === id);
 }
 function loadAndFindItem(id) {
-  if (!existsSync11(getBacklogPath())) {
+  if (!existsSync12(getBacklogPath())) {
     console.log(
       chalk22.yellow(
         "No backlog found. Run 'assist backlog init' to create one."
@@ -2128,7 +2136,7 @@ function getNextId(items) {
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir } from "os";
 import { join as join9 } from "path";
 import enquirer4 from "enquirer";
@@ -2178,7 +2186,7 @@ function openEditor() {
     unlinkSync2(filePath);
     return void 0;
   }
-  const content = readFileSync10(filePath, "utf-8").trim();
+  const content = readFileSync11(filePath, "utf-8").trim();
   unlinkSync2(filePath);
   return content || void 0;
 }
@@ -2199,7 +2207,7 @@ async function promptAcceptanceCriteria() {
 // src/commands/backlog/add/index.ts
 async function add() {
   const backlogPath = getBacklogPath();
-  if (!existsSync12(backlogPath)) {
+  if (!existsSync13(backlogPath)) {
     console.log(
       chalk23.yellow(
         "No backlog found. Run 'assist backlog init' to create one."
@@ -2244,11 +2252,11 @@ async function done(id) {
 }
 
 // src/commands/backlog/init/index.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import chalk26 from "chalk";
 async function init6() {
   const backlogPath = getBacklogPath();
-  if (existsSync13(backlogPath)) {
+  if (existsSync14(backlogPath)) {
     console.log(chalk26.yellow("assist.backlog.yml already exists."));
     return;
   }
@@ -2257,7 +2265,7 @@ async function init6() {
 }
 
 // src/commands/backlog/list/index.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import chalk27 from "chalk";
 function statusIcon(status2) {
   switch (status2) {
@@ -2296,7 +2304,7 @@ function filterItems(items, options2) {
 }
 async function list2(options2) {
   const backlogPath = getBacklogPath();
-  if (!existsSync14(backlogPath)) {
+  if (!existsSync15(backlogPath)) {
     console.log(
       chalk27.yellow(
         "No backlog found. Run 'assist backlog init' to create one."
@@ -2334,7 +2342,7 @@ import { createServer } from "http";
 import chalk29 from "chalk";
 
 // src/commands/backlog/web/handleRequest.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname11, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -2367,12 +2375,12 @@ function respondJson(res, status2, data) {
   res.end(JSON.stringify(data));
 }
 function readBody(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
-    req.on("end", () => resolve3(body));
+    req.on("end", () => resolve5(body));
     req.on("error", reject);
   });
 }
@@ -2437,7 +2445,7 @@ var __dirname4 = dirname11(fileURLToPath3(import.meta.url));
 var bundleCache;
 function serveBundle(_req, res) {
   if (!bundleCache) {
-    bundleCache = readFileSync11(
+    bundleCache = readFileSync12(
       join10(__dirname4, "commands/backlog/web/bundle.js"),
       "utf-8"
     );
@@ -2509,6 +2517,167 @@ 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/shared/tokenize.ts
+function tokenize(command) {
+  const tokens = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+    } else if (ch === "\\" && inDouble && i + 1 < command.length) {
+      current += ch + command[++i];
+    } else if (/\s/.test(ch) && !inSingle && !inDouble) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+// src/shared/isGhApiRead.ts
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var BODY_FLAGS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var FIELD_FLAGS = /* @__PURE__ */ new Set(["-f", "--field", "-F"]);
+function isGhApiRead(command) {
+  const tokens = tokenize(command);
+  if (tokens.length < 2 || tokens[0] !== "gh" || tokens[1] !== "api") {
+    return false;
+  }
+  const args = tokens.slice(2);
+  if (args.includes("graphql")) {
+    return isGraphqlRead(args);
+  }
+  const method = extractMethod(args);
+  if (method) return READ_METHODS.has(method.toUpperCase());
+  if (args.some((t) => BODY_FLAGS.has(t))) return false;
+  return true;
+}
+function extractMethod(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--method=")) return arg.slice("--method=".length);
+    if (arg.startsWith("-X=")) return arg.slice("-X=".length);
+    if ((arg === "--method" || arg === "-X") && i + 1 < args.length) {
+      return args[i + 1];
+    }
+  }
+  return void 0;
+}
+function isGraphqlRead(args) {
+  const method = extractMethod(args);
+  if (method) return READ_METHODS.has(method.toUpperCase());
+  const queryBody = extractGraphqlQuery(args);
+  if (!queryBody) return false;
+  const trimmed = queryBody.replace(/^['"]|['"]$/g, "").trimStart();
+  if (trimmed.startsWith("mutation")) return false;
+  if (trimmed.startsWith("query") || trimmed.startsWith("{")) return true;
+  return false;
+}
+function extractGraphqlQuery(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (FIELD_FLAGS.has(args[i]) && i + 1 < args.length) {
+      const match = args[i + 1].match(/^query=(.*)/s);
+      if (match) return match[1];
+    }
+  }
+  return void 0;
+}
+
+// src/shared/loadCliReads.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname12, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname5 = dirname12(__filename2);
+function getCliReadsPath() {
+  return resolve2(__dirname5, "..", "assist.cli-reads");
+}
+function loadCliReads() {
+  const path31 = getCliReadsPath();
+  if (!existsSync16(path31)) return [];
+  return readFileSync13(path31, "utf-8").split("\n").filter((line) => line.trim() !== "");
+}
+function saveCliReads(commands) {
+  writeFileSync12(getCliReadsPath(), `${commands.join("\n")}
+`);
+}
+function findCliRead(command) {
+  const filePath = getCliReadsPath();
+  if (!existsSync16(filePath)) return void 0;
+  const words = command.split(/\s+/);
+  if (words.length < 2) return void 0;
+  const prefix2 = `${words[0]} ${words[1]}`;
+  let candidates;
+  try {
+    const output = execFileSync("grep", ["-E", `^${prefix2}( |$)`, filePath], {
+      encoding: "utf-8"
+    });
+    candidates = output.split("\n").filter((l) => l !== "");
+  } catch {
+    return void 0;
+  }
+  return candidates.sort((a, b) => b.length - a.length).find((rc) => command === rc || command.startsWith(`${rc} `));
+}
+
+// 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 matched = findCliRead(command);
+  if (matched) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: `Read-only CLI command: ${matched}`
+        }
+      })
+    );
+    return;
+  }
+  if (isGhApiRead(command)) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: "Read-only gh api command"
+        }
+      })
+    );
+  }
+}
+
+// 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";
 
@@ -2595,8 +2764,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>";
@@ -3003,7 +3172,7 @@ function registerComplexity(program2) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "fs";
 import chalk36 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -3012,11 +3181,11 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync15(indexPath)) {
+  if (!existsSync17(indexPath)) {
     console.log(chalk36.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"));
     return;
@@ -3027,7 +3196,7 @@ function redirect() {
     return;
   }
   const newContent = content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT + "\n  " + content.slice(headCloseIndex);
-  writeFileSync12(indexPath, newContent);
+  writeFileSync13(indexPath, newContent);
   console.log(chalk36.green("Added trailing slash redirect to index.html"));
 }
 
@@ -3047,7 +3216,7 @@ import { execSync as execSync13 } from "child_process";
 import chalk37 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync, readFileSync as readFileSync13 } from "fs";
+import { readdirSync, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join11 } from "path";
 var DEVLOG_DIR = join11(homedir3(), "git/blog/src/content/devlog");
@@ -3056,7 +3225,7 @@ function loadDevlogEntries(repoName) {
   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(join11(DEVLOG_DIR, file), "utf-8");
       const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (frontmatterMatch) {
         const frontmatter = frontmatterMatch[1];
@@ -3404,14 +3573,366 @@ function registerDevlog(program2) {
   devlogCommand.command("skip <date>").description("Add a date (YYYY-MM-DD) to the skip list").action(skip);
 }
 
+// src/commands/permitCliReads/index.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync4, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join12 } from "path";
+
+// src/shared/getInstallDir.ts
+import { execSync as execSync17 } from "child_process";
+import { dirname as dirname13, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __filename3 = fileURLToPath5(import.meta.url);
+var __dirname6 = dirname13(__filename3);
+function getInstallDir() {
+  return resolve3(__dirname6, "..");
+}
+function isGitRepo(dir) {
+  try {
+    const result = execSync17("git rev-parse --show-toplevel", {
+      cwd: dir,
+      stdio: "pipe"
+    }).toString().trim();
+    return resolve3(result) === resolve3(dir);
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/permitCliReads/assertCliExists.ts
+import { execSync as execSync18 } from "child_process";
+function assertCliExists(cli) {
+  const binary = cli.split(/\s+/)[0];
+  const opts = {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  };
+  try {
+    execSync18(`command -v ${binary}`, opts);
+  } catch {
+    try {
+      execSync18(`where ${binary}`, opts);
+    } catch {
+      console.error(`CLI "${cli}" not found in PATH`);
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/permitCliReads/colorize.ts
+import chalk43 from "chalk";
+function colorize(plainOutput) {
+  return plainOutput.split("\n").map((line) => {
+    if (line.startsWith(" R  ")) return chalk43.green(line);
+    if (line.startsWith(" W  ")) return chalk43.red(line);
+    return line;
+  }).join("\n");
+}
+
+// src/lib/isClaudeCode.ts
+function isClaudeCode() {
+  return process.env.CLAUDECODE !== void 0;
+}
+
+// src/commands/permitCliReads/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/permitCliReads/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/permitCliReads/runHelp.ts
+import { exec as exec2 } from "child_process";
+function runHelp(args) {
+  return new Promise((resolve5) => {
+    exec2(
+      `${args.join(" ")} --help`,
+      { encoding: "utf-8", timeout: 3e4 },
+      (_err, stdout, stderr) => {
+        resolve5(stdout || stderr || "");
+      }
+    );
+  });
+}
+
+// src/commands/permitCliReads/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/permitCliReads/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/permitCliReads/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/permitCliReads/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/permitCliReads/updateSettings.ts
+function updateSettings(cli, commands) {
+  const existing = loadCliReads();
+  const readEntries = commands.filter((cmd) => classifyVerb(cmd.path[cmd.path.length - 1]) === "r").map((cmd) => `${cli} ${cmd.path.join(" ")}`);
+  const merged = [.../* @__PURE__ */ new Set([...existing, ...readEntries])].sort();
+  if (merged.length === existing.length && merged.every((e, i) => e === existing[i]))
+    return;
+  saveCliReads(merged);
+}
+
+// src/commands/permitCliReads/index.ts
+function logPath(cli) {
+  const safeName = cli.replace(/\s+/g, "-");
+  return join12(homedir4(), ".assist", `cli-discover-${safeName}.log`);
+}
+function readCache(cli) {
+  const path31 = logPath(cli);
+  if (!existsSync18(path31)) return void 0;
+  return readFileSync16(path31, "utf-8");
+}
+function writeCache(cli, output) {
+  const dir = join12(homedir4(), ".assist");
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync14(logPath(cli), output);
+}
+async function permitCliReads(cli, options2 = { noCache: false }) {
+  if (!cli) {
+    console.error("Usage: assist permit-cli-reads <cli>");
+    process.exit(1);
+  }
+  const installDir = getInstallDir();
+  if (!isGitRepo(installDir)) {
+    console.error(
+      "permit-cli-reads must be run from the assist git repo, not a global install."
+    );
+    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/registerPermitCliReads.ts
+function registerPermitCliReads(program2) {
+  program2.command("permit-cli-reads").description("Discover a CLI's commands and auto-permit read-only ones").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) => {
+    permitCliReads(cli.join(" "), { noCache: !options2.cache });
+  });
+}
+
 // 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 join13 } from "path";
 
 // src/commands/prs/shared.ts
-import { execSync as execSync17 } from "child_process";
+import { execSync as execSync19 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -3427,14 +3948,14 @@ function isNotFound(error) {
 }
 function getRepoInfo() {
   const repoInfo = JSON.parse(
-    execSync17("gh repo view --json owner,name", { encoding: "utf-8" })
+    execSync19("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" })
+      execSync19("gh pr view --json number", { encoding: "utf-8" })
     );
     return prInfo.number;
   } catch (error) {
@@ -3448,7 +3969,7 @@ function getCurrentPrNumber() {
 function getCurrentPrNodeId() {
   try {
     const prInfo = JSON.parse(
-      execSync17("gh pr view --json id", { encoding: "utf-8" })
+      execSync19("gh pr view --json id", { encoding: "utf-8" })
     );
     return prInfo.id;
   } catch (error) {
@@ -3480,8 +4001,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 = join13(tmpdir2(), `gh-query-${Date.now()}.graphql`);
+    writeFileSync15(queryFile, MUTATION);
     try {
       const result = spawnSync2(
         "gh",
@@ -3519,32 +4040,32 @@ function comment(path31, line, body) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync19 } from "child_process";
+import { execSync as execSync21 } 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 execSync20 } 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 join15 } 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 existsSync19, readFileSync as readFileSync17, unlinkSync as unlinkSync4 } from "fs";
+import { join as join14 } from "path";
 import { parse } from "yaml";
 function getCachePath(prNumber) {
-  return join13(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join14(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync16(cachePath)) {
+  if (!existsSync19(cachePath)) {
     return null;
   }
-  const content = readFileSync14(cachePath, "utf-8");
+  const content = readFileSync17(cachePath, "utf-8");
   return parse(content);
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync16(cachePath)) {
+  if (existsSync19(cachePath)) {
     unlinkSync4(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -3552,17 +4073,17 @@ function deleteCommentsCache(prNumber) {
 
 // src/commands/prs/resolveCommentWithReply.ts
 function replyToComment(org, repo, prNumber, commentId, message) {
-  execSync18(
+  execSync20(
     `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 = join15(tmpdir3(), `gh-mutation-${Date.now()}.graphql`);
+  writeFileSync16(queryFile, mutation);
   try {
-    execSync18(
+    execSync20(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: "inherit" }
     );
@@ -3614,7 +4135,7 @@ function resolveCommentWithReply(commentId, message) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync19(`git rev-parse --verify ${sha}`, {
+    return execSync21(`git rev-parse --verify ${sha}`, {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -3640,26 +4161,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 existsSync20, mkdirSync as mkdirSync5, writeFileSync as writeFileSync18 } from "fs";
+import { join as join17 } 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 execSync22 } 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 join16 } 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 = join16(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  writeFileSync17(queryFile, THREAD_QUERY);
   try {
-    const result = execSync20(
+    const result = execSync22(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf-8" }
     );
@@ -3681,9 +4197,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync21 } from "child_process";
+import { execSync as execSync23 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync21(`gh api --paginate ${endpoint}`, {
+  const result = execSync23(`gh api --paginate ${endpoint}`, {
     encoding: "utf-8"
   });
   if (!result.trim()) return [];
@@ -3725,20 +4241,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 +4277,17 @@ function printComments(comments) {
   }
 }
 function writeCommentsCache(prNumber, comments) {
-  const assistDir = join16(process.cwd(), ".assist");
-  if (!existsSync17(assistDir)) {
-    mkdirSync4(assistDir, { recursive: true });
+  const assistDir = join17(process.cwd(), ".assist");
+  if (!existsSync20(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 = join17(assistDir, `pr-${prNumber}-comments.yaml`);
+  writeFileSync18(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
   if (isGhNotInstalled(error)) {
@@ -3811,19 +4327,19 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync22 } from "child_process";
+import { execSync as execSync24 } 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 +4348,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 +4433,7 @@ async function displayPaginated(pullRequests) {
 async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
-    const result = execSync22(
+    const result = execSync24(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
       { encoding: "utf-8" }
     );
@@ -3940,7 +4456,7 @@ async function prs(options2) {
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync23 } from "child_process";
+import { execSync as execSync25 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -3957,7 +4473,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync23(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync25(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -4006,7 +4522,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 +4531,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 +4577,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync24 } from "child_process";
+import { execSync as execSync26 } from "child_process";
 import fs15 from "fs";
 import { minimatch as minimatch4 } from "minimatch";
 
@@ -4111,7 +4627,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync24("git diff --cached --name-only", {
+    const staged = execSync26("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -4119,7 +4635,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync24("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync26("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -4149,7 +4665,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     const child = spawn3("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
@@ -4163,7 +4679,7 @@ function runScript(script, cwd) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve3({ script, code: code ?? 1, output });
+      resolve5({ script, code: code ?? 1, output });
     });
   });
 }
@@ -4207,11 +4723,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 +4743,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 +4751,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 +4994,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 +5047,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 +5067,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 +5082,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 +5213,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 +5251,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 existsSync21, readdirSync as readdirSync2, statSync } from "fs";
+import { basename as basename4, join as join18, relative } from "path";
 import * as readline2 from "readline";
 var DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
 function getDatePrefix(daysOffset = 0) {
@@ -4751,10 +5267,10 @@ function isValidDatePrefix(filename) {
   return DATE_PREFIX_REGEX.test(filename);
 }
 function collectFiles(dir, extension) {
-  if (!existsSync18(dir)) return [];
+  if (!existsSync21(dir)) return [];
   const results = [];
   for (const entry of readdirSync2(dir)) {
-    const fullPath = join17(dir, entry);
+    const fullPath = join18(dir, entry);
     if (statSync(fullPath).isDirectory()) {
       results.push(...collectFiles(fullPath, extension));
     } else if (entry.endsWith(extension)) {
@@ -4786,9 +5302,9 @@ function createReadlineInterface() {
   });
 }
 function askQuestion(rl, question) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     rl.question(question, (answer) => {
-      resolve3(answer.trim());
+      resolve5(answer.trim());
     });
   });
 }
@@ -4848,14 +5364,14 @@ async function configure() {
 }
 
 // src/commands/transcript/format/index.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/index.ts
-import { dirname as dirname13, join as join19 } from "path";
+import { dirname as dirname15, join as join20 } from "path";
 
 // src/commands/transcript/format/fixInvalidDatePrefixes/promptForDateFix.ts
 import { renameSync } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function resolveDate(rl, choice) {
   if (choice === "1") return getDatePrefix(0);
   if (choice === "2") return getDatePrefix(-1);
@@ -4868,9 +5384,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(join19(vttDir, vttFile), join19(vttDir, newFilename));
   console.log(`Renamed to: ${newFilename}`);
   return newFilename;
 }
@@ -4887,9 +5403,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;
@@ -4901,15 +5417,15 @@ async function fixInvalidDatePrefixes(vttFiles) {
   for (let i = 0; i < vttFiles.length; i++) {
     const vttFile = vttFiles[i];
     if (!isValidDatePrefix(vttFile.filename)) {
-      const vttFileDir = dirname13(vttFile.absolutePath);
+      const vttFileDir = dirname15(vttFile.absolutePath);
       const newFilename = await promptForDateFix(vttFile.filename, vttFileDir);
       if (newFilename) {
-        const newRelativePath = join19(
-          dirname13(vttFile.relativePath),
+        const newRelativePath = join20(
+          dirname15(vttFile.relativePath),
           newFilename
         );
         vttFiles[i] = {
-          absolutePath: join19(vttFileDir, newFilename),
+          absolutePath: join20(vttFileDir, newFilename),
           relativePath: newRelativePath,
           filename: newFilename
         };
@@ -4922,8 +5438,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 existsSync22, mkdirSync as mkdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync19 } from "fs";
+import { basename as basename5, dirname as dirname16, join as join21 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text) {
@@ -4993,8 +5509,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 +5649,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 : join21(transcriptsDir, relativeDir);
 }
 function buildOutputPaths(vttFile, transcriptsDir) {
   const mdFile = toMdFilename(vttFile.filename);
-  const relativeDir = dirname14(vttFile.relativePath);
+  const relativeDir = dirname16(vttFile.relativePath);
   const outputDir = resolveOutputDir(relativeDir, transcriptsDir);
-  const outputPath = join20(outputDir, mdFile);
+  const outputPath = join21(outputDir, mdFile);
   return { outputDir, outputPath, mdFile, relativeDir };
 }
 function logSkipped(relativeDir, mdFile) {
-  console.log(`Skipping (already exists): ${join20(relativeDir, mdFile)}`);
+  console.log(`Skipping (already exists): ${join21(relativeDir, mdFile)}`);
   return "skipped";
 }
 function ensureDirectory(dir, label2) {
-  if (!existsSync19(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync22(dir)) {
+    mkdirSync6(dir, { recursive: true });
     console.log(`Created ${label2}: ${dir}`);
   }
 }
@@ -5170,10 +5686,10 @@ function logReduction(cueCount, messageCount) {
 }
 function readAndParseCues(inputPath) {
   console.log(`Reading: ${inputPath}`);
-  return processCues(readFileSync15(inputPath, "utf-8"));
+  return processCues(readFileSync18(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 +5699,7 @@ function convertVttToMarkdown(inputPath, outputPath) {
   logReduction(cues.length, chatMessages.length);
 }
 function tryProcessVtt(vttFile, paths) {
-  if (existsSync19(paths.outputPath))
+  if (existsSync22(paths.outputPath))
     return logSkipped(paths.relativeDir, paths.mdFile);
   convertVttToMarkdown(vttFile.absolutePath, paths.outputPath);
   return "processed";
@@ -5209,7 +5725,7 @@ function processAllFiles(vttFiles, transcriptsDir) {
   logSummary(counts);
 }
 function requireVttDir(vttDir) {
-  if (!existsSync20(vttDir)) {
+  if (!existsSync23(vttDir)) {
     console.error(`VTT directory not found: ${vttDir}`);
     process.exit(1);
   }
@@ -5241,28 +5757,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 existsSync25 } from "fs";
+import { basename as basename6, dirname as dirname18, join as join23, relative as relative2 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
 import {
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync16,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync19,
   renameSync as renameSync2,
   rmSync
 } from "fs";
-import { dirname as dirname15, join as join21 } from "path";
+import { dirname as dirname17, join as join22 } 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 +5787,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 +5797,9 @@ function validateStagedContent(filename, content) {
 }
 
 // src/commands/transcript/summarise/processStagedFile/index.ts
-var STAGING_DIR = join21(process.cwd(), ".assist", "transcript");
+var STAGING_DIR = join22(process.cwd(), ".assist", "transcript");
 function processStagedFile() {
-  if (!existsSync21(STAGING_DIR)) {
+  if (!existsSync24(STAGING_DIR)) {
     return false;
   }
   const stagedFiles = findMdFilesRecursive(STAGING_DIR);
@@ -5292,7 +5808,7 @@ function processStagedFile() {
   }
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
   const stagedFile = stagedFiles[0];
-  const content = readFileSync16(stagedFile.absolutePath, "utf-8");
+  const content = readFileSync19(stagedFile.absolutePath, "utf-8");
   validateStagedContent(stagedFile.filename, content);
   const stagedBaseName = getTranscriptBaseName(stagedFile.filename);
   const transcriptFiles = findMdFilesRecursive(transcriptsDir);
@@ -5305,10 +5821,10 @@ function processStagedFile() {
     );
     process.exit(1);
   }
-  const destPath = join21(summaryDir, matchingTranscript.relativePath);
-  const destDir = dirname15(destPath);
-  if (!existsSync21(destDir)) {
-    mkdirSync6(destDir, { recursive: true });
+  const destPath = join22(summaryDir, matchingTranscript.relativePath);
+  const destDir = dirname17(destPath);
+  if (!existsSync24(destDir)) {
+    mkdirSync7(destDir, { recursive: true });
   }
   renameSync2(stagedFile.absolutePath, destPath);
   const remaining = findMdFilesRecursive(STAGING_DIR);
@@ -5320,8 +5836,8 @@ function processStagedFile() {
 
 // src/commands/transcript/summarise/index.ts
 function buildRelativeKey(relativePath, baseName) {
-  const relDir = dirname16(relativePath);
-  return relDir === "." ? baseName : join22(relDir, baseName);
+  const relDir = dirname18(relativePath);
+  return relDir === "." ? baseName : join23(relDir, baseName);
 }
 function buildSummaryIndex(summaryDir) {
   const summaryFiles = findMdFilesRecursive(summaryDir);
@@ -5334,7 +5850,7 @@ function buildSummaryIndex(summaryDir) {
 function summarise() {
   processStagedFile();
   const { transcriptsDir, summaryDir } = getTranscriptConfig();
-  if (!existsSync22(transcriptsDir)) {
+  if (!existsSync25(transcriptsDir)) {
     console.log("No transcripts directory found.");
     return;
   }
@@ -5355,8 +5871,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 = join23(STAGING_DIR, outputFilename);
+  const summaryFileDir = join23(summaryDir, dirname18(next2.relativePath));
   const relativeTranscriptPath = encodeURI(
     relative2(summaryFileDir, next2.absolutePath).replace(/\\/g, "/")
   );
@@ -5402,50 +5918,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 join25 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir4 } from "os";
-import { dirname as dirname17, join as join23 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-var __dirname5 = dirname17(fileURLToPath4(import.meta.url));
-var VOICE_DIR = join23(homedir4(), ".assist", "voice");
+import { homedir as homedir5 } from "os";
+import { dirname as dirname19, join as join24 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+var __dirname7 = dirname19(fileURLToPath6(import.meta.url));
+var VOICE_DIR = join24(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: join24(VOICE_DIR, "voice.pid"),
+  log: join24(VOICE_DIR, "voice.log"),
+  venv: join24(VOICE_DIR, ".venv"),
+  lock: join24(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join23(__dirname5, "commands", "voice", "python");
+  return join24(__dirname7, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join23(voicePaths.venv, "Scripts", "python.exe") : join23(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join24(voicePaths.venv, "Scripts", "python.exe") : join24(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join23(getLockDir(), "voice.lock");
+  return join24(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join24(getPythonDir(), "list_devices.py");
+  const script = join25(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 existsSync26, readFileSync as readFileSync20 } from "fs";
 function logs(options2) {
-  if (!existsSync23(voicePaths.log)) {
+  if (!existsSync26(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 = readFileSync20(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -5467,13 +5983,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 join27 } 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 execSync27 } from "child_process";
+import { existsSync as existsSync27, mkdirSync as mkdirSync8, readFileSync as readFileSync21, writeFileSync as writeFileSync20 } from "fs";
+import { join as join26 } from "path";
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -5484,9 +6000,9 @@ function isProcessAlive(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync24(lockFile)) return;
+  if (!existsSync27(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync18(lockFile, "utf-8"));
+    const lock = JSON.parse(readFileSync21(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 +6013,10 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync24(getVenvPython())) return;
+  if (existsSync27(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync25(
+  execSync27(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -5510,8 +6026,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync7(join25(lockFile, ".."), { recursive: true });
-  writeFileSync18(
+  mkdirSync8(join26(lockFile, ".."), { recursive: true });
+  writeFileSync20(
     lockFile,
     JSON.stringify({
       pid,
@@ -5523,10 +6039,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 = join27(getPythonDir(), "setup_models.py");
   const result = spawnSync4(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -5539,8 +6055,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 join28 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -5568,17 +6084,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 = join28(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -5588,7 +6104,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -5598,16 +6114,16 @@ function isProcessAlive2(pid) {
   }
 }
 function readRecentLogs(count) {
-  if (!existsSync25(voicePaths.log)) return [];
-  const lines = readFileSync19(voicePaths.log, "utf-8").trim().split("\n");
+  if (!existsSync28(voicePaths.log)) return [];
+  const lines = readFileSync22(voicePaths.log, "utf-8").trim().split("\n");
   return lines.slice(-count);
 }
 function status() {
-  if (!existsSync25(voicePaths.pid)) {
+  if (!existsSync28(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(readFileSync22(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 +6142,13 @@ function status() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync26, readFileSync as readFileSync20, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync23, unlinkSync as unlinkSync7 } from "fs";
 function stop() {
-  if (!existsSync26(voicePaths.pid)) {
+  if (!existsSync29(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(readFileSync23(voicePaths.pid, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -5645,7 +6161,7 @@ function stop() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync26(lockFile)) unlinkSync7(lockFile);
+    if (existsSync29(lockFile)) unlinkSync7(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -5664,14 +6180,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 execSync28 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync26(cmd);
+      execSync28(cmd);
       return true;
     } catch {
     }
@@ -5729,7 +6245,7 @@ function extractCode(url, expectedState) {
   return code;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authorization timed out after 120 seconds"));
@@ -5746,7 +6262,7 @@ function waitForCallback(port, expectedState) {
         const code = extractCode(url, expectedState);
         respondHtml(res, 200, "Authorization successful!");
         server.close();
-        resolve3(code);
+        resolve5(code);
       } catch (err) {
         respondHtml(res, 400, err.message);
         server.close();
@@ -5839,13 +6355,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 +6377,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 +6391,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 join29 } from "path";
 function findAddIndex() {
   const addIndex = process.argv.indexOf("add");
   if (addIndex === -1 || addIndex + 2 >= process.argv.length) return -1;
@@ -5930,16 +6446,16 @@ function saveNewRunConfig(name, command, args) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join28(".claude", "commands");
-  mkdirSync10(dir, { recursive: true });
+  const dir = join29(".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 = join29(dir, `${name}.md`);
+  writeFileSync22(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add2() {
@@ -6009,14 +6525,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() {
@@ -6037,12 +6553,12 @@ async function statusLine() {
 import * as fs23 from "fs";
 import * as os from "os";
 import * as path29 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { fileURLToPath as fileURLToPath7 } 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 +6567,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,26 +6588,30 @@ 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");
   const sourceContent = fs22.readFileSync(source, "utf-8");
-  const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
+  const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
   if (fs22.existsSync(target)) {
     const targetContent = fs22.readFileSync(target, "utf-8");
-    const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
-    if (normalizedSource !== normalizedTarget) {
+    const normalizedTarget = JSON.stringify(
+      JSON.parse(targetContent),
+      null,
+      "	"
+    );
+    if (mergedContent !== 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);
+        printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk54.red("Overwrite existing settings.json?"),
+          chalk55.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -6101,15 +6621,15 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs22.copyFileSync(source, target);
+  fs22.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
-var __filename2 = fileURLToPath5(import.meta.url);
-var __dirname6 = path29.dirname(__filename2);
+var __filename4 = fileURLToPath7(import.meta.url);
+var __dirname8 = path29.dirname(__filename4);
 async function sync(options2) {
-  const claudeDir = path29.join(__dirname6, "..", "claude");
+  const claudeDir = path29.join(__dirname8, "..", "claude");
   const targetBase = path29.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes: options2?.yes });
@@ -6128,28 +6648,11 @@ function syncCommands(claudeDir, targetBase) {
 }
 
 // src/commands/update.ts
-import { execSync as execSync27 } from "child_process";
+import { execSync as execSync29 } from "child_process";
 import * as path30 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-var __filename3 = fileURLToPath6(import.meta.url);
-var __dirname7 = path30.dirname(__filename3);
-function getInstallDir() {
-  return path30.resolve(__dirname7, "..");
-}
-function isGitRepo(dir) {
-  try {
-    const result = execSync27("git rev-parse --show-toplevel", {
-      cwd: dir,
-      stdio: "pipe"
-    }).toString().trim();
-    return path30.resolve(result) === path30.resolve(dir);
-  } catch {
-    return false;
-  }
-}
 function isGlobalNpmInstall(dir) {
   try {
-    const globalPrefix = execSync27("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync29("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return path30.resolve(dir).toLowerCase().startsWith(path30.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -6160,16 +6663,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" });
+    execSync29("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync27("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync29("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync27("assist sync", { stdio: "inherit" });
+    execSync29("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync27("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync29("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync27("assist sync", { stdio: "inherit" });
+    execSync29("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."
@@ -6203,6 +6706,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);
+registerPermitCliReads(program);
+registerCliHook(program);
 registerPrs(program);
 registerRoam(program);
 registerBacklog(program);