@staff0rd/assist 0.407.0 → 0.408.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.407.0",
+  version: "0.408.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -142,10 +142,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path67) {
-  if (!existsSync(path67)) return {};
+function loadRawYaml(path69) {
+  if (!existsSync(path69)) return {};
   try {
-    const content = readFileSync(path67, "utf8");
+    const content = readFileSync(path69, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -1436,8 +1436,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path67 = line.split("	")[1];
-    if (path67) found.add(path67.trim());
+    const path69 = line.split("	")[1];
+    if (path69) found.add(path69.trim());
   }
   return [...found];
 }
@@ -1536,8 +1536,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path67 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path67}/${ref}`;
+  const path69 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path69}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3404,9 +3404,9 @@ import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path67) {
+function resolveStringsAtPath(data, path69) {
   let current = data;
-  for (const segment of path67.split(".")) {
+  for (const segment of path69.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3419,10 +3419,10 @@ function resolveStringsAtPath(data, path67) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path67 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path67)) {
+  for (const path69 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path69)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path67, value });
+        violations.push({ file: rule.file, path: path69, value });
     }
   }
   return violations;
@@ -3461,8 +3461,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path67, value } of violations) {
-    console.log(`  ${file} ${path67}: ${value}`);
+  for (const { file, path: path69, value } of violations) {
+    console.log(`  ${file} ${path69}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -3754,15 +3754,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path67) => MIGRATION_FILE3.test(basename(path67)));
-  for (const path67 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path69) => MIGRATION_FILE3.test(basename(path69)));
+  for (const path69 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path67}"`, {
+      const content = execSync12(`git show "${ref}:${path69}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path67), content);
+      baseline.set(basename(path69), content);
     } catch {
     }
   }
@@ -5127,10 +5127,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path67 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path67), { recursive: true });
-  writeFileSync15(path67, JSON.stringify(hooksSettings, null, 2));
-  return path67;
+  const path69 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path69), { recursive: true });
+  writeFileSync15(path69, JSON.stringify(hooksSettings, null, 2));
+  return path69;
 }
 
 // src/shared/spawnInherit.ts
@@ -5395,9 +5395,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path67 = join15(dir, ".assist", name);
-    if (existsSync18(path67)) {
-      renameSync(path67, `${path67}.bak`);
+    const path69 = join15(dir, ".assist", name);
+    if (existsSync18(path69)) {
+      renameSync(path69, `${path69}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -5869,8 +5869,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path67) {
-  const content = readFileSync14(path67, "utf8").trim();
+function parseBacklogJsonl(path69) {
+  const content = readFileSync14(path69, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -5952,8 +5952,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path67) {
-  return path67.replace(/^\/+/, "");
+function stripLeadingSlashes(path69) {
+  return path69.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -6493,24 +6493,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path67 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path67), { recursive: true });
-  writeFileSync17(path67, JSON.stringify({ sessionId }));
+  const path69 = getOwnerPath(itemId2);
+  mkdirSync7(dirname14(path69), { recursive: true });
+  writeFileSync17(path69, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path67 = getOwnerPath(itemId2);
-  if (!existsSync21(path67)) return void 0;
+  const path69 = getOwnerPath(itemId2);
+  if (!existsSync21(path69)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path67, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path69, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path67 = getOwnerPath(itemId2);
+  const path69 = getOwnerPath(itemId2);
   try {
-    rmSync(path67);
+    rmSync(path69);
   } catch {
   }
 }
@@ -6547,19 +6547,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path67 = getSignalPath(target);
-  if (!path67) return;
+  const path69 = getSignalPath(target);
+  if (!path69) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path67), { recursive: true });
-  writeFileSync18(path67, JSON.stringify(signal));
+  mkdirSync8(dirname15(path69), { recursive: true });
+  writeFileSync18(path69, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path67 = getSignalPath();
-  if (!path67 || !existsSync22(path67)) return void 0;
+  const path69 = getSignalPath();
+  if (!path69 || !existsSync22(path69)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path67, "utf8"));
+    return JSON.parse(readFileSync16(path69, "utf8"));
   } catch {
     return void 0;
   }
@@ -6692,13 +6692,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path67 = activityPath(sessionId);
-  mkdirSync9(dirname16(path67), { recursive: true });
-  writeFileSync19(path67, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path69 = activityPath(sessionId);
+  mkdirSync9(dirname16(path69), { recursive: true });
+  writeFileSync19(path69, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path67) {
+function readActivity(path69) {
   try {
-    return JSON.parse(readFileSync17(path67, "utf8"));
+    return JSON.parse(readFileSync17(path69, "utf8"));
   } catch {
     return void 0;
   }
@@ -6708,9 +6708,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path67 = activityPath(sessionId);
-  mkdirSync9(dirname16(path67), { recursive: true });
-  writeFileSync19(path67, JSON.stringify(activity2));
+  const path69 = activityPath(sessionId);
+  mkdirSync9(dirname16(path69), { recursive: true });
+  writeFileSync19(path69, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -7949,8 +7949,8 @@ async function loadItemSummaries(orm, origin) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path67 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path67.split("/").filter(Boolean);
+    const path69 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path69.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -8354,7 +8354,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname20(branchKeyPath);
   const branchPrefix = basename5(branchKeyPath);
   if (!existsSync25(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path67) => existsSync25(path67)).map((path67) => ({ path: path67, mtime: statSync2(path67).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path69) => existsSync25(path69)).map((path69) => ({ path: path69, mtime: statSync2(path69).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -8408,12 +8408,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path67 = await resolveSynthesisPath(cwd);
-    if (!path67) {
+    const path69 = await resolveSynthesisPath(cwd);
+    if (!path69) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync19(path67, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync19(path69, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -8560,10 +8560,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path67 = getStorePath(filename);
-  if (existsSync26(path67)) {
+  const path69 = getStorePath(filename);
+  if (existsSync26(path69)) {
     try {
-      return JSON.parse(readFileSync20(path67, "utf8"));
+      return JSON.parse(readFileSync20(path69, "utf8"));
     } catch {
       return {};
     }
@@ -11914,9 +11914,9 @@ var __dirname4 = dirname21(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path67) {
-  if (!existsSync27(path67)) return [];
-  return readFileSync23(path67, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path69) {
+  if (!existsSync27(path69)) return [];
+  return readFileSync23(path69, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -12408,14 +12408,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path67, description, depth, p) {
-  showProgress(p, path67.join(" "));
-  const subHelp = await runHelp([cli, ...path67]);
+async function resolveCommand(cli, path69, description, depth, p) {
+  showProgress(p, path69.join(" "));
+  const subHelp = await runHelp([cli, ...path69]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path67, description }];
+    return [{ path: path69, description }];
   }
-  const children = await discoverAt(cli, path67, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path67, description }];
+  const children = await discoverAt(cli, path69, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path69, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -12563,9 +12563,9 @@ function logPath(cli) {
   return join30(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path67 = logPath(cli);
-  if (!existsSync29(path67)) return void 0;
-  return readFileSync25(path67, "utf8");
+  const path69 = logPath(cli);
+  if (!existsSync29(path69)) return void 0;
+  return readFileSync25(path69, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join30(homedir16(), ".assist");
@@ -12737,9 +12737,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path67 = join32(dir, entry);
+    const path69 = join32(dir, entry);
     try {
-      if (statSync3(path67).mtimeMs < cutoff) unlinkSync7(path67);
+      if (statSync3(path69).mtimeMs < cutoff) unlinkSync7(path69);
     } catch {
       continue;
     }
@@ -12749,10 +12749,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
 function readPinState(pin) {
-  const path67 = getPinStatePath(pin);
-  if (!existsSync30(path67)) return void 0;
+  const path69 = getPinStatePath(pin);
+  if (!existsSync30(path69)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path67, "utf8"));
+    const state = JSON.parse(readFileSync26(path69, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -13301,8 +13301,73 @@ Analyzed ${results.length} functions across ${files.length} files`
   });
 }
 
+// src/commands/complexity/maintainability/aggregateResults.ts
+function aggregateResults(fileMetrics) {
+  const results = [];
+  for (const [file, metrics] of fileMetrics) {
+    if (metrics.functions.length === 0) continue;
+    const avgMaintainability = metrics.functions.reduce((a, b) => a + b, 0) / metrics.functions.length;
+    const minMaintainability = Math.min(...metrics.functions);
+    results.push({
+      file,
+      avgMaintainability,
+      minMaintainability,
+      override: metrics.override,
+      largestFunction: metrics.largestFunction
+    });
+  }
+  results.sort((a, b) => a.minMaintainability - b.minMaintainability);
+  return results;
+}
+
+// src/commands/complexity/maintainability/collectFileMetrics.ts
+import fs21 from "fs";
+
+// src/commands/complexity/maintainability/calculateMaintainabilityIndex.ts
+function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
+  if (halsteadVolume === 0 || sloc2 === 0) {
+    return 100;
+  }
+  const mi = 171 - 5.2 * Math.log(halsteadVolume) - 0.23 * cyclomaticComplexity - 16.2 * Math.log(sloc2);
+  return Math.max(0, Math.min(100, mi));
+}
+
+// src/commands/complexity/maintainability/collectFileMetrics.ts
+function collectFileMetrics(files) {
+  const fileMetrics = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const content = fs21.readFileSync(file, "utf8");
+    fileMetrics.set(file, {
+      sloc: countSloc(content),
+      functions: [],
+      override: parseMaintainabilityOverride(content),
+      largestFunction: "",
+      largestFunctionSize: -1
+    });
+  }
+  forEachFunction(files, (file, name, node) => {
+    const metrics = fileMetrics.get(file);
+    if (metrics) {
+      const complexity = calculateCyclomaticComplexity(node);
+      const halstead2 = calculateHalstead(node);
+      const mi = calculateMaintainabilityIndex(
+        halstead2.volume,
+        complexity,
+        metrics.sloc
+      );
+      metrics.functions.push(mi);
+      const size = node.end - node.pos;
+      if (size > metrics.largestFunctionSize) {
+        metrics.largestFunctionSize = size;
+        metrics.largestFunction = name;
+      }
+    }
+  });
+  return fileMetrics;
+}
+
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-import chalk117 from "chalk";
+import chalk118 from "chalk";
 
 // src/commands/complexity/maintainability/formatResultLine.ts
 import chalk115 from "chalk";
@@ -13313,28 +13378,101 @@ function formatResultLine(entry, failing) {
   return `${name} \u2192 avg: ${chalk115.cyan(avgMaintainability.toFixed(1))}, min: ${chalk115.yellow(minMaintainability.toFixed(1))}${suffix}`;
 }
 
+// src/commands/complexity/maintainability/getMaintainabilityGitState.ts
+import { execSync as execSync32 } from "child_process";
+import path28 from "path";
+function git2(command) {
+  return execSync32(command, { encoding: "utf8" });
+}
+function toAbsolute(root, repoRelative) {
+  return path28.resolve(root, repoRelative);
+}
+function collectShrunkFiles(root) {
+  const shrunk = /* @__PURE__ */ new Set();
+  const numstat = git2("git diff --numstat HEAD").trim();
+  if (numstat === "") return shrunk;
+  for (const line of numstat.split("\n")) {
+    const [addedRaw, removedRaw, ...rest] = line.split("	");
+    const file = rest.join("	");
+    const added = Number.parseInt(addedRaw, 10);
+    const removed = Number.parseInt(removedRaw, 10);
+    if (Number.isNaN(added) || Number.isNaN(removed)) continue;
+    if (removed > added) shrunk.add(toAbsolute(root, file));
+  }
+  return shrunk;
+}
+function hasNewSourceFile() {
+  const status3 = git2("git status --porcelain --untracked-files=all").trim();
+  if (status3 === "") return false;
+  for (const line of status3.split("\n")) {
+    const code = line.slice(0, 2);
+    const file = line.slice(3);
+    const isNew = code.includes("A") || code.includes("?");
+    if (isNew && (file.endsWith(".ts") || file.endsWith(".tsx"))) return true;
+  }
+  return false;
+}
+function getMaintainabilityGitState() {
+  try {
+    const root = git2("git rev-parse --show-toplevel").trim();
+    return {
+      shrunkFiles: collectShrunkFiles(root),
+      newFileCreated: hasNewSourceFile()
+    };
+  } catch {
+    return { shrunkFiles: /* @__PURE__ */ new Set(), newFileCreated: false };
+  }
+}
+
 // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
+import path29 from "path";
 import chalk116 from "chalk";
-function printMaintainabilityFailure(failingCount, threshold) {
-  const thresholdLabel = threshold !== void 0 ? ` ${threshold}` : "";
+function suggestDestination(file, functionName) {
+  return path29.join(path29.dirname(file), `${functionName}.ts`);
+}
+function remediationLine(entry) {
+  const { file, largestFunction } = entry;
+  if (largestFunction === "" || largestFunction.startsWith("<"))
+    return `  Move the largest responsibility out of ${chalk116.bold(file)} into a new file with 'assist refactor extract'.`;
+  const dest = suggestDestination(file, largestFunction);
+  const command = `assist refactor extract ${file} ${largestFunction} ${dest} --apply`;
+  return `  ${chalk116.bold(file)} \u2192 extract '${largestFunction}' to a new file:
+    ${chalk116.cyan(command)}`;
+}
+function cheatLine(entry, gitState) {
+  const shrank = gitState.shrunkFiles.has(path29.resolve(entry.file));
+  if (!shrank || gitState.newFileCreated) return "";
+  return `
+    ${chalk116.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
+}
+function printMaintainabilityFailure(failing, gitState) {
+  const blocks = failing.map((entry) => `${remediationLine(entry)}${cheatLine(entry, gitState)}`).join("\n");
   console.error(
     chalk116.red(
       `
-Fail: ${failingCount} file(s) below threshold${thresholdLabel} (files marked "(override: N)" were judged against their own marker). Maintainability index (0\u2013100) is derived from Halstead volume, cyclomatic complexity, and lines of code.
+Fail: ${failing.length} file(s) below threshold \u2192 extract a responsibility to a new file.
 
-\u26A0\uFE0F  ${chalk116.bold("Diagnose and fix one file at a time")} \u2014 do not investigate or fix multiple files in parallel.
+${blocks}
 
-The score is a property of the whole file, not your diff: any existing logic counts, so the fix is to shrink the file \u2014 not to revert or micro-optimize the lines you just changed. Identify the largest cohesive responsibility (often the biggest function, or a related group of functions) and move it to a new file with 'assist refactor extract'. Run 'assist complexity <file>' for per-function metrics only to locate that responsibility, not to tweak individual lines.`
+${chalk116.bold("Diagnose and fix one file at a time.")} Only a new file (Write) or 'assist refactor extract' clears this gate \u2014 editing the existing lines does not.`
     )
   );
 }
 
+// src/commands/complexity/maintainability/printMaintainabilityFormula.ts
+import chalk117 from "chalk";
+var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
+function printMaintainabilityFormula() {
+  console.log(chalk117.dim(MI_FORMULA));
+}
+
 // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
-function displayMaintainabilityResults(results, threshold) {
+function displayMaintainabilityResults(results, threshold, gitState = getMaintainabilityGitState()) {
   const gating = threshold !== void 0 || results.some((r) => r.override !== void 0);
   if (!gating) {
+    printMaintainabilityFormula();
     for (const entry of results) console.log(formatResultLine(entry, false));
-    console.log(chalk117.dim(`
+    console.log(chalk118.dim(`
 Analyzed ${results.length} files`));
     return;
   }
@@ -13343,90 +13481,23 @@ Analyzed ${results.length} files`));
     return limit !== void 0 && r.minMaintainability < limit;
   });
   if (failing.length === 0) {
-    console.log(chalk117.green("All files pass maintainability threshold"));
-  } else {
-    for (const entry of failing) console.log(formatResultLine(entry, true));
+    console.log(chalk118.green("All files pass maintainability threshold"));
   }
   const passingOverrides = results.filter(
     (r) => r.override !== void 0 && !failing.includes(r)
   );
   for (const entry of passingOverrides)
     console.log(formatResultLine(entry, false));
-  console.log(chalk117.dim(`
+  console.log(chalk118.dim(`
 Analyzed ${results.length} files`));
   if (failing.length > 0) {
-    printMaintainabilityFailure(failing.length, threshold);
+    printMaintainabilityFailure(failing, gitState);
     process.exit(1);
   }
 }
 
-// src/commands/complexity/maintainability/printMaintainabilityFormula.ts
-import chalk118 from "chalk";
-var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
-function printMaintainabilityFormula() {
-  console.log(chalk118.dim(MI_FORMULA));
-}
-
-// src/commands/complexity/maintainability/collectFileMetrics.ts
-import fs21 from "fs";
-
-// src/commands/complexity/maintainability/calculateMaintainabilityIndex.ts
-function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
-  if (halsteadVolume === 0 || sloc2 === 0) {
-    return 100;
-  }
-  const mi = 171 - 5.2 * Math.log(halsteadVolume) - 0.23 * cyclomaticComplexity - 16.2 * Math.log(sloc2);
-  return Math.max(0, Math.min(100, mi));
-}
-
-// src/commands/complexity/maintainability/collectFileMetrics.ts
-function collectFileMetrics(files) {
-  const fileMetrics = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const content = fs21.readFileSync(file, "utf8");
-    fileMetrics.set(file, {
-      sloc: countSloc(content),
-      functions: [],
-      override: parseMaintainabilityOverride(content)
-    });
-  }
-  forEachFunction(files, (file, _name, node) => {
-    const metrics = fileMetrics.get(file);
-    if (metrics) {
-      const complexity = calculateCyclomaticComplexity(node);
-      const halstead2 = calculateHalstead(node);
-      const mi = calculateMaintainabilityIndex(
-        halstead2.volume,
-        complexity,
-        metrics.sloc
-      );
-      metrics.functions.push(mi);
-    }
-  });
-  return fileMetrics;
-}
-
-// src/commands/complexity/maintainability/aggregateResults.ts
-function aggregateResults(fileMetrics) {
-  const results = [];
-  for (const [file, metrics] of fileMetrics) {
-    if (metrics.functions.length === 0) continue;
-    const avgMaintainability = metrics.functions.reduce((a, b) => a + b, 0) / metrics.functions.length;
-    const minMaintainability = Math.min(...metrics.functions);
-    results.push({
-      file,
-      avgMaintainability,
-      minMaintainability,
-      override: metrics.override
-    });
-  }
-  results.sort((a, b) => a.minMaintainability - b.minMaintainability);
-  return results;
-}
-
 // src/commands/complexity/maintainability/index.ts
 async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
-  printMaintainabilityFormula();
   withSourceFiles(
     pattern2,
     (files) => {
@@ -13577,8 +13648,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path67, value) {
-  const keys = path67.split(".");
+function setNestedValue(obj, path69, value) {
+  const keys = path69.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -13658,9 +13729,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path67) {
+function getNestedValue(obj, path69) {
   let current = obj;
-  for (const key of path67.split(".")) current = stepInto(current, key);
+  for (const key of path69.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -13776,10 +13847,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync32, readFileSync as readFileSync28 } from "fs";
 function readMigrationPinState(pin) {
-  const path67 = getMigrationPinPath(pin);
-  if (!existsSync32(path67)) return void 0;
+  const path69 = getMigrationPinPath(pin);
+  if (!existsSync32(path69)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path67, "utf8"));
+    const state = JSON.parse(readFileSync28(path69, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -13918,7 +13989,7 @@ function loadBlogSkipDays(repoName) {
 }
 
 // src/commands/devlog/shared.ts
-import { execSync as execSync32 } from "child_process";
+import { execSync as execSync33 } from "child_process";
 import chalk127 from "chalk";
 
 // src/shared/getRepoName.ts
@@ -14010,7 +14081,7 @@ function loadAllDevlogLatestDates() {
 // src/commands/devlog/shared.ts
 function getCommitFiles(hash) {
   try {
-    const output = execSync32(`git show --name-only --format="" ${hash}`, {
+    const output = execSync33(`git show --name-only --format="" ${hash}`, {
       encoding: "utf8"
     });
     return output.trim().split("\n").filter(Boolean);
@@ -14106,11 +14177,11 @@ function list3(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execFileSync as execFileSync3, execSync as execSync33 } from "child_process";
+import { execFileSync as execFileSync3, execSync as execSync34 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
-    const content = execSync33(`git show ${hash}:package.json`, {
+    const content = execSync34(`git show ${hash}:package.json`, {
       encoding: "utf8"
     });
     const pkg = JSON.parse(content);
@@ -14283,7 +14354,7 @@ function next2(options2) {
 }
 
 // src/commands/devlog/repos/index.ts
-import { execSync as execSync34 } from "child_process";
+import { execSync as execSync35 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
 import chalk131 from "chalk";
@@ -14318,7 +14389,7 @@ function getStatus(lastPush, lastDevlog) {
   return lastDevlog < lastPush ? "outdated" : "ok";
 }
 function fetchRepos(days, all) {
-  const json = execSync34(
+  const json = execSync35(
     "gh repo list staff0rd --json name,pushedAt,isArchived --limit 200",
     { encoding: "utf8" }
   );
@@ -14452,14 +14523,14 @@ import chalk134 from "chalk";
 
 // src/shared/findRepoRoot.ts
 import { existsSync as existsSync35 } from "fs";
-import path28 from "path";
+import path30 from "path";
 function findRepoRoot(dir) {
   let current = dir;
-  while (current !== path28.dirname(current)) {
-    if (existsSync35(path28.join(current, ".git"))) {
+  while (current !== path30.dirname(current)) {
+    if (existsSync35(path30.join(current, ".git"))) {
       return current;
     }
-    current = path28.dirname(current);
+    current = path30.dirname(current);
   }
   return null;
 }
@@ -14523,7 +14594,7 @@ async function checkBuildLocksCommand() {
 
 // src/commands/dotnet/buildTree.ts
 import { readFileSync as readFileSync32 } from "fs";
-import path29 from "path";
+import path31 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
   const content = readFileSync32(csprojPath, "utf8");
@@ -14534,14 +14605,14 @@ function getProjectRefs(csprojPath) {
   return refs;
 }
 function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
-  const abs = path29.resolve(csprojPath);
-  const rel = path29.relative(repoRoot, abs);
+  const abs = path31.resolve(csprojPath);
+  const rel = path31.relative(repoRoot, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
-  const dir = path29.dirname(abs);
+  const dir = path31.dirname(abs);
   for (const ref of getProjectRefs(abs)) {
-    const childAbs = path29.resolve(dir, ref);
+    const childAbs = path31.resolve(dir, ref);
     try {
       readFileSync32(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
@@ -14569,7 +14640,7 @@ function collectAllDeps(node) {
 
 // src/commands/dotnet/findContainingSolutions.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync33, statSync as statSync4 } from "fs";
-import path30 from "path";
+import path32 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
@@ -14582,7 +14653,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules" || entry === "packages")
       continue;
-    const full = path30.join(dir, entry);
+    const full = path32.join(dir, entry);
     try {
       const stat2 = statSync4(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
@@ -14596,8 +14667,8 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   return results;
 }
 function findContainingSolutions(csprojPath, repoRoot) {
-  const csprojAbs = path30.resolve(csprojPath);
-  const csprojBasename = path30.basename(csprojAbs);
+  const csprojAbs = path32.resolve(csprojPath);
+  const csprojBasename = path32.basename(csprojAbs);
   const slnFiles = findSlnFiles(repoRoot, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
@@ -14605,7 +14676,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
     try {
       const content = readFileSync33(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path30.relative(repoRoot, sln));
+        matches.push(path32.relative(repoRoot, sln));
       }
     } catch {
     }
@@ -14668,15 +14739,15 @@ function printJson(tree, totalCount, solutions) {
 
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync36 } from "fs";
-import path31 from "path";
+import path33 from "path";
 import chalk136 from "chalk";
 function resolveCsproj(csprojPath) {
-  const resolved = path31.resolve(csprojPath);
+  const resolved = path33.resolve(csprojPath);
   if (!existsSync36(resolved)) {
     console.error(chalk136.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot = findRepoRoot(path31.dirname(resolved));
+  const repoRoot = findRepoRoot(path33.dirname(resolved));
   if (!repoRoot) {
     console.error(chalk136.red("Could not find git repository root"));
     process.exit(1);
@@ -14698,7 +14769,7 @@ async function deps(csprojPath, options2) {
 }
 
 // src/commands/dotnet/getChangedCsFiles.ts
-import { execSync as execSync35 } from "child_process";
+import { execSync as execSync36 } from "child_process";
 var SCOPE_ALL = "all";
 var SCOPE_BASE = "base:";
 var SCOPE_COMMIT = "commit:";
@@ -14722,7 +14793,7 @@ function getChangedCsFiles(scope) {
   } else {
     cmd = "git diff --name-only HEAD";
   }
-  const output = execSync35(cmd, { encoding: "utf8" }).trim();
+  const output = execSync36(cmd, { encoding: "utf8" }).trim();
   if (output === "") return [];
   return output.split("\n").filter((f) => f.toLowerCase().endsWith(".cs"));
 }
@@ -14841,7 +14912,7 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync37 } from "fs";
-import path32 from "path";
+import path34 from "path";
 import chalk140 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
@@ -14880,7 +14951,7 @@ function findSolution() {
 // src/commands/dotnet/resolveSolution.ts
 function resolveSolution(sln) {
   if (sln) {
-    const resolved = path32.resolve(sln);
+    const resolved = path34.resolve(sln);
     if (!existsSync37(resolved)) {
       console.error(chalk140.red(`Solution file not found: ${resolved}`));
       process.exit(1);
@@ -14920,14 +14991,14 @@ function parseInspectReport(json) {
 }
 
 // src/commands/dotnet/runInspectCode.ts
-import { execSync as execSync36 } from "child_process";
+import { execSync as execSync37 } from "child_process";
 import { existsSync as existsSync38, readFileSync as readFileSync34, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import path33 from "path";
+import path35 from "path";
 import chalk141 from "chalk";
 function assertJbInstalled() {
   try {
-    execSync36("jb inspectcode --version", { stdio: "pipe" });
+    execSync37("jb inspectcode --version", { stdio: "pipe" });
   } catch {
     console.error(chalk141.red("jb is not installed. Install with:"));
     console.error(
@@ -14937,11 +15008,11 @@ function assertJbInstalled() {
   }
 }
 function runInspectCode(slnPath, include, swea) {
-  const reportPath = path33.join(tmpdir3(), `inspect-${Date.now()}.xml`);
+  const reportPath = path35.join(tmpdir3(), `inspect-${Date.now()}.xml`);
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
-    execSync36(
+    execSync37(
       `jb inspectcode "${slnPath}" -o="${reportPath}"${includeFlag}${sweaFlag} --verbosity=OFF`,
       { stdio: "pipe" }
     );
@@ -14962,7 +15033,7 @@ function runInspectCode(slnPath, include, swea) {
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
-import { execSync as execSync37 } from "child_process";
+import { execSync as execSync38 } from "child_process";
 import chalk142 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
@@ -14973,7 +15044,7 @@ function resolveMsbuildPath() {
 function assertMsbuildInstalled() {
   const msbuild = resolveMsbuildPath();
   try {
-    execSync37(`"${msbuild}" -version`, { stdio: "pipe" });
+    execSync38(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
     console.error(chalk142.red(`msbuild not found at: ${msbuild}`));
     console.error(
@@ -14999,7 +15070,7 @@ function runRoslynInspect(slnPath) {
   const msbuild = resolveMsbuildPath();
   let output;
   try {
-    output = execSync37(
+    output = execSync38(
       `"${msbuild}" "${slnPath}" -t:Build -v:minimal -maxcpucount -p:EnforceCodeStyleInBuild=true -p:RunAnalyzersDuringBuild=true 2>&1`,
       { encoding: "utf8", stdio: "pipe", maxBuffer: 50 * 1024 * 1024 }
     );
@@ -15218,10 +15289,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync39, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path67 = getMigrationApprovalPath(migrationId);
-  if (!existsSync39(path67)) return false;
+  const path69 = getMigrationApprovalPath(migrationId);
+  if (!existsSync39(path69)) return false;
   try {
-    unlinkSync11(path67);
+    unlinkSync11(path69);
     return true;
   } catch {
     return false;
@@ -15846,7 +15917,7 @@ function acceptanceCriteria(issueKey) {
 }
 
 // src/commands/jira/jiraAuth.ts
-import { execSync as execSync38 } from "child_process";
+import { execSync as execSync39 } from "child_process";
 
 // src/shared/promptInput.ts
 import Enquirer from "enquirer";
@@ -15881,7 +15952,7 @@ async function jiraAuth() {
       console.error("All fields are required.");
       process.exit(1);
     }
-    execSync38(`acli jira auth login --site ${site} --email "${email}" --token`, {
+    execSync39(`acli jira auth login --site ${site} --email "${email}" --token`, {
       encoding: "utf8",
       input: token,
       stdio: ["pipe", "inherit", "inherit"]
@@ -16395,9 +16466,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path67] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path69] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path67) {
+    for (const key of path69) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -16966,7 +17037,7 @@ function registerPrompts(program2) {
 }
 
 // src/commands/prs/shared.ts
-import { execSync as execSync39 } from "child_process";
+import { execSync as execSync40 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -16984,12 +17055,12 @@ function getRepoInfo() {
   const preferred = getPreferredRemoteRepo();
   if (preferred) return preferred;
   const repoInfo = JSON.parse(
-    execSync39("gh repo view --json owner,name", { encoding: "utf8" })
+    execSync40("gh repo view --json owner,name", { encoding: "utf8" })
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
 function getCurrentBranch2() {
-  return execSync39("git rev-parse --abbrev-ref HEAD", {
+  return execSync40("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -16997,7 +17068,7 @@ function viewCurrentPr(fields) {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch2();
   return JSON.parse(
-    execSync39(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
+    execSync40(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf8"
     })
   );
@@ -17081,15 +17152,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path67, line, body, startLine) {
+function comment2(path69, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path67, line, startLine });
+    postComment({ prId, body, path: path69, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path67}:${range}`);
+    console.log(`Added review comment on ${path69}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -17299,10 +17370,10 @@ function edit(options2) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync42 } from "child_process";
+import { execSync as execSync43 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync41 } from "child_process";
+import { execSync as execSync42 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join50 } from "path";
@@ -17331,9 +17402,9 @@ function deleteCommentsCache(prNumber) {
 }
 
 // src/commands/prs/replyToComment.ts
-import { execSync as execSync40 } from "child_process";
+import { execSync as execSync41 } from "child_process";
 function replyToComment(org, repo, prNumber, commentId, message) {
-  execSync40(
+  execSync41(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
@@ -17345,7 +17416,7 @@ function resolveThread(threadId) {
   const queryFile = join50(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync33(queryFile, mutation);
   try {
-    execSync41(
+    execSync42(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
@@ -17397,7 +17468,7 @@ function resolveCommentWithReply(commentId, message) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync42(`git rev-parse --verify ${sha}`, {
+    return execSync43(`git rev-parse --verify ${sha}`, {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -17411,7 +17482,7 @@ function fixed(commentId, sha) {
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
     const message = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
-    execSync42("git push", { stdio: "inherit" });
+    execSync43("git push", { stdio: "inherit" });
     resolveCommentWithReply(commentId, message);
   } catch (error) {
     if (isGhNotInstalled(error)) {
@@ -17429,7 +17500,7 @@ import { join as join52 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync43 } from "child_process";
+import { execSync as execSync44 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync34 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join51 } from "path";
@@ -17438,7 +17509,7 @@ function fetchThreadIds(org, repo, prNumber) {
   const queryFile = join51(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync34(queryFile, THREAD_QUERY);
   try {
-    const result = execSync43(
+    const result = execSync44(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf8" }
     );
@@ -17460,9 +17531,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync44 } from "child_process";
+import { execSync as execSync45 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync44(`gh api --paginate ${endpoint}`, {
+  const result = execSync45(`gh api --paginate ${endpoint}`, {
     encoding: "utf8"
   });
   if (!result.trim()) return [];
@@ -17601,7 +17672,7 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync45 } from "child_process";
+import { execSync as execSync46 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer9 from "enquirer";
@@ -17708,7 +17779,7 @@ async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
     const { org, repo } = getRepoInfo();
-    const result = execSync45(
+    const result = execSync46(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100 -R ${org}/${repo}`,
       { encoding: "utf8" }
     );
@@ -17763,16 +17834,16 @@ function buildCreateArgs(title, body, options2) {
 }
 
 // src/commands/prs/readSessionPrRef.ts
-import { execSync as execSync46 } from "child_process";
+import { execSync as execSync47 } from "child_process";
 function readSessionPrRef() {
   try {
-    const branch2 = execSync46("git rev-parse --abbrev-ref HEAD", {
+    const branch2 = execSync47("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!branch2 || branch2 === "HEAD") return null;
     const pr = JSON.parse(
-      execSync46(`gh pr view ${branch2} --json number,title,url,state`, {
+      execSync47(`gh pr view ${branch2} --json number,title,url,state`, {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       })
@@ -17850,7 +17921,7 @@ function reply(commentId, body) {
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync47 } from "child_process";
+import { execSync as execSync48 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -17867,7 +17938,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync47(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync48(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -17968,8 +18039,8 @@ function registerPrs(program2) {
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path67, line, body) => {
-    comment2(path67, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path69, line, body) => {
+    comment2(path69, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -18044,10 +18115,10 @@ import chalk161 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync48 } from "child_process";
+import { execSync as execSync49 } from "child_process";
 import chalk160 from "chalk";
 function opExec(args) {
-  return execSync48(`op ${args}`, {
+  return execSync49(`op ${args}`, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -18199,7 +18270,7 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync49 } from "child_process";
+import { execSync as execSync50 } from "child_process";
 import chalk165 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
@@ -18207,7 +18278,7 @@ function resolveOpSecret(reference) {
     process.exit(1);
   }
   try {
-    return execSync49(`op read "${reference}"`, {
+    return execSync50(`op read "${reference}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -18222,10 +18293,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path67) {
+async function ravenFetch(connection, path69) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path67}`;
+  const url = `${connection.url}${path69}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -18329,16 +18400,16 @@ import chalk169 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path67;
+  let path69;
   if (opts.collection) {
-    path67 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path69 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path67 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path69 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path67 += `&query=${encodeURIComponent(opts.query)}`;
+    path69 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path67;
+  return path69;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -18347,7 +18418,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path67 = buildQueryPath({
+    const path69 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -18355,7 +18426,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path67);
+    const data = await ravenFetch(connection, path69);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -18413,7 +18484,7 @@ function registerRavendb(program2) {
 
 // src/commands/refactor/check/index.ts
 import { spawn as spawn5 } from "child_process";
-import * as path34 from "path";
+import * as path36 from "path";
 
 // src/commands/refactor/logViolations.ts
 import chalk171 from "chalk";
@@ -18471,7 +18542,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync50 } from "child_process";
+import { execSync as execSync51 } from "child_process";
 import fs25 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
@@ -18521,7 +18592,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync50("git diff --cached --name-only", {
+    const staged = execSync51("git diff --cached --name-only", {
       encoding: "utf8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -18529,7 +18600,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync50("git diff --name-only", { encoding: "utf8" });
+    const unstaged = execSync51("git diff --name-only", { encoding: "utf8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -18590,7 +18661,7 @@ ${failed2.length} verify script(s) failed:`);
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return true;
-  const packageDir = path34.dirname(result.packageJsonPath);
+  const packageDir = path36.dirname(result.packageJsonPath);
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
@@ -18616,7 +18687,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path41 from "path";
+import path43 from "path";
 import chalk174 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -19093,9 +19164,9 @@ function buildDestinationContent(functionTexts, imports, sourceRelativePath, sou
 }
 
 // src/commands/refactor/extract/getRelativeImportPath.ts
-import path35 from "path";
+import path37 from "path";
 function getRelativeImportPath(from, to) {
-  let rel = path35.relative(path35.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  let rel = path37.relative(path37.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
@@ -19119,9 +19190,9 @@ function findImporters(functionName, sourceFile, destPath, project) {
 }
 
 // src/commands/refactor/extract/resolveBarrel.ts
-import path36 from "path";
+import path38 from "path";
 function resolveBarrel(functionName, sourcePath, destPath, project) {
-  const indexPath = path36.join(path36.dirname(destPath), "index.ts");
+  const indexPath = path38.join(path38.dirname(destPath), "index.ts");
   const barrel = project.getSourceFile(indexPath);
   if (!barrel) return { barrel: void 0, barrelRelPath: "" };
   const sourceRelFromBarrel = getRelativeImportPath(indexPath, sourcePath);
@@ -19139,15 +19210,15 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/rewriteImportPaths.ts
-import path37 from "path";
+import path39 from "path";
 function rewriteImportPaths(imports, sourcePath, destPath) {
-  const sourceDir = path37.dirname(sourcePath);
-  const destDir = path37.dirname(destPath);
+  const sourceDir = path39.dirname(sourcePath);
+  const destDir = path39.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute = path37.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path37.relative(destDir, absolute).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path37.basename(absolute)}`;
+    const absolute = path39.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path39.relative(destDir, absolute).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path39.basename(absolute)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -19215,7 +19286,7 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path38 from "path";
+import path40 from "path";
 import chalk172 from "chalk";
 function section2(title) {
   return `
@@ -19225,7 +19296,7 @@ function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
-    const rel = path38.relative(cwd, imp.file.getFilePath());
+    const rel = path40.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk172.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -19265,16 +19336,16 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path40 from "path";
+import path42 from "path";
 import chalk173 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
 import fs26 from "fs";
-import path39 from "path";
+import path41 from "path";
 import { Project as Project3 } from "ts-morph";
 function findTsConfig(sourcePath) {
-  const rootConfig = path39.resolve("tsconfig.json");
+  const rootConfig = path41.resolve("tsconfig.json");
   if (!fs26.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
@@ -19283,7 +19354,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludes(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs26.readdirSync(path39.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path39.resolve(path39.dirname(rootConfig), f));
+  const siblings = fs26.readdirSync(path41.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path41.resolve(path41.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -19302,10 +19373,10 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path39.dirname(configPath);
+  const cwd = path41.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path39.resolve(cwd, ref.path);
-    return fs26.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path39.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path41.resolve(cwd, ref.path);
+    return fs26.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path41.join(refPath, "tsconfig.json") : refPath;
   }).filter((p) => fs26.existsSync(p));
 }
 function projectIncludes(configPath, sourcePath) {
@@ -19319,7 +19390,7 @@ function projectIncludes(configPath, sourcePath) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path40.resolve(file);
+  const sourcePath = path42.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -19334,10 +19405,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path41.resolve(file);
-  const destPath = path41.resolve(destination);
+  const sourcePath = path43.resolve(file);
+  const destPath = path43.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path41.relative(cwd, destPath);
+  const relDest = path43.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -19385,16 +19456,16 @@ function ignore2(file) {
 
 // src/commands/refactor/rename/index.ts
 import fs30 from "fs";
-import path46 from "path";
+import path48 from "path";
 import chalk178 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs29 from "fs";
-import path43 from "path";
+import path45 from "path";
 import chalk176 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path42 from "path";
+import path44 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs28 from "fs";
@@ -19448,7 +19519,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path42.relative(path42.dirname(fromFile), toFile));
+  return normalizeSpecifier(path44.relative(path44.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -19496,20 +19567,20 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs29.writeFileSync(file, content, "utf8");
-    console.log(chalk176.cyan(`  Updated imports in ${path43.relative(cwd, file)}`));
+    console.log(chalk176.cyan(`  Updated imports in ${path45.relative(cwd, file)}`));
   }
-  const destDir = path43.dirname(destPath);
+  const destDir = path45.dirname(destPath);
   if (!fs29.existsSync(destDir)) fs29.mkdirSync(destDir, { recursive: true });
   fs29.renameSync(sourcePath, destPath);
   console.log(
     chalk176.white(
-      `  Moved ${path43.relative(cwd, sourcePath)} \u2192 ${path43.relative(cwd, destPath)}`
+      `  Moved ${path45.relative(cwd, sourcePath)} \u2192 ${path45.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path44 from "path";
+import path46 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -19536,7 +19607,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path44.dirname(tsConfigPath)
+    path46.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -19552,7 +19623,7 @@ function resolveImport(specifier, filePath, options2) {
   const resolved = ts7.resolveModuleName(specifier, filePath, options2, ts7.sys);
   const resolvedPath = resolved.resolvedModule?.resolvedFileName;
   if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
-  return path44.resolve(resolvedPath);
+  return path46.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -19561,7 +19632,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path44.resolve(sourceFile.fileName);
+    const filePath = path46.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -19588,13 +19659,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path45 from "path";
+import path47 from "path";
 import chalk177 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk177.dim(
-        `  ${path45.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path47.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -19603,11 +19674,11 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path46.resolve(source);
-  const destPath = path46.resolve(destination);
+  const sourcePath = path48.resolve(source);
+  const destPath = path48.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path46.relative(cwd, sourcePath);
-  const relDest = path46.relative(cwd, destPath);
+  const relSource = path48.relative(cwd, sourcePath);
+  const relDest = path48.relative(cwd, destPath);
   if (!fs30.existsSync(sourcePath)) {
     console.log(chalk178.red(`File not found: ${source}`));
     process.exit(1);
@@ -19662,12 +19733,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path47 from "path";
+import path49 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path47.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path49.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -19706,16 +19777,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path54 from "path";
+import path56 from "path";
 import chalk182 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path48 from "path";
+import path50 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path48.dirname(edge.source);
-    const targetDir = path48.dirname(edge.target);
+    const sourceDir = path50.dirname(edge.source);
+    const targetDir = path50.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -19743,20 +19814,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path48.relative(ancestor, descendant);
+  const rel = path50.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path49 from "path";
+import path51 from "path";
 function findRootParent(file, importedBy, visited) {
   const importers = importedBy.get(file);
   if (!importers || importers.size !== 1) return file;
   const parent = [...importers][0];
-  const parentDir = path49.dirname(parent);
-  const fileDir = path49.dirname(file);
+  const parentDir = path51.dirname(parent);
+  const fileDir = path51.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path49.basename(parent, path49.extname(parent)) === "index") return file;
+  if (path51.basename(parent, path51.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -19764,16 +19835,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename14 = path49.basename(file, path49.extname(file));
+    const basename14 = path51.basename(file, path51.extname(file));
     if (basename14 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
     if (!graph.files.has(parent)) continue;
-    const parentDir = path49.dirname(parent);
-    const fileDir = path49.dirname(file);
+    const parentDir = path51.dirname(parent);
+    const fileDir = path51.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path49.basename(parent, path49.extname(parent));
+    const parentBasename = path51.basename(parent, path51.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -19785,10 +19856,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path50 from "path";
+import path52 from "path";
 import chalk180 from "chalk";
 function relPath(filePath) {
-  return path50.relative(process.cwd(), filePath);
+  return path52.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -19838,33 +19909,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs31 from "fs";
-import path51 from "path";
+import path53 from "path";
 import chalk181 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs31.writeFileSync(file, content, "utf8");
     console.log(
-      chalk181.cyan(`  Rewrote imports in ${path51.relative(process.cwd(), file)}`)
+      chalk181.cyan(`  Rewrote imports in ${path53.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs31.mkdirSync(dir, { recursive: true });
-    console.log(chalk181.green(`  Created ${path51.relative(process.cwd(), dir)}/`));
+    console.log(chalk181.green(`  Created ${path53.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path51.dirname(move2.to);
+    const targetDir = path53.dirname(move2.to);
     if (!fs31.existsSync(targetDir)) {
       fs31.mkdirSync(targetDir, { recursive: true });
     }
     fs31.renameSync(move2.from, move2.to);
     console.log(
       chalk181.white(
-        `  Moved ${path51.relative(process.cwd(), move2.from)} \u2192 ${path51.relative(process.cwd(), move2.to)}`
+        `  Moved ${path53.relative(process.cwd(), move2.from)} \u2192 ${path53.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path51.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path53.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -19875,7 +19946,7 @@ function removeEmptyDirectories(dirs) {
       fs31.rmdirSync(dir);
       console.log(
         chalk181.dim(
-          `  Removed empty directory ${path51.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path53.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -19883,7 +19954,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path53 from "path";
+import path55 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs32 from "fs";
@@ -19898,9 +19969,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs33 from "fs";
-import path52 from "path";
+import path54 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path52.join(dir, entry.name);
+  const full = path54.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
@@ -19914,15 +19985,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path52.relative(childDir, file);
-    moves.push({ from: file, to: path52.join(newLocation, rel), reason });
+    const rel = path54.relative(childDir, file);
+    moves.push({ from: file, to: path54.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path52.join(parentDir, path52.basename(childDir));
+  return path54.join(parentDir, path54.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path52.basename(parentDir)}/`;
+  return `Directory only imported from ${path54.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -19947,7 +20018,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path53.join(newDir, path53.basename(child));
+  const to = path55.join(newDir, path55.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -19955,15 +20026,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path53.basename(filePath, path53.extname(filePath));
+  return path55.basename(filePath, path55.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path53.join(path53.dirname(parent), getBaseName(parent));
+  return path55.join(path55.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path53.join(newDir, `index${path53.extname(parent)}`),
+    to: path55.join(newDir, `index${path55.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -19987,7 +20058,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path54.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path56.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -20010,7 +20081,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk182.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path54.resolve("tsconfig.json");
+  const tsConfigPath = path56.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk182.green("No restructuring needed"));
@@ -20207,9 +20278,9 @@ function buildReviewPaths(repoRoot, key) {
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync51 } from "child_process";
+import { execSync as execSync52 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync51(
+  const out = execSync52(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -20240,14 +20311,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync54 } from "child_process";
+import { execSync as execSync55 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync52 } from "child_process";
+import { execSync as execSync53 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync52(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync53(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -20262,19 +20333,19 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync52(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync53(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync52(`git diff ${baseSha}...${headSha}`, {
+  return execSync53(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
 // src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync53 } from "child_process";
+import { execSync as execSync54 } from "child_process";
 function getCurrentBranch3() {
-  return execSync53("git rev-parse --abbrev-ref HEAD", {
+  return execSync54("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -20282,7 +20353,7 @@ function fetchPrDiffInfo() {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch3();
   const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
-  const raw = execSync53(
+  const raw = execSync54(
     `gh pr list --state open --head ${branch2} --json ${fields} -R ${org}/${repo}`,
     {
       encoding: "utf8",
@@ -20307,7 +20378,7 @@ function fetchPrDiffInfo() {
 }
 function fetchPrChangedFiles(prNumber) {
   const { org, repo } = getRepoInfo();
-  const out = execSync53(
+  const out = execSync54(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
     {
       encoding: "utf8",
@@ -20319,11 +20390,11 @@ function fetchPrChangedFiles(prNumber) {
 
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch2 = execSync54("git rev-parse --abbrev-ref HEAD", {
+  const branch2 = execSync55("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
-  const sha = execSync54("git rev-parse HEAD", { encoding: "utf8" }).trim();
-  const shortSha = execSync54("git rev-parse --short=7 HEAD", {
+  const sha = execSync55("git rev-parse HEAD", { encoding: "utf8" }).trim();
+  const shortSha = execSync55("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -20743,8 +20814,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync43, mkdirSync as mkdirSync18, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path67 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync43(path67)) unlinkSync16(path67);
+  for (const path69 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync43(path69)) unlinkSync16(path69);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -21892,8 +21963,8 @@ import chalk190 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk187 from "chalk";
-async function fetchSeq(conn, path67, params) {
-  const url = `${conn.url}${path67}?${params}`;
+async function fetchSeq(conn, path69, params) {
+  const url = `${conn.url}${path69}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -22973,7 +23044,7 @@ import { mkdirSync as mkdirSync21 } from "fs";
 import { join as join59 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync55 } from "child_process";
+import { execSync as execSync56 } from "child_process";
 import { existsSync as existsSync49, mkdirSync as mkdirSync20, readFileSync as readFileSync43, writeFileSync as writeFileSync39 } from "fs";
 import { join as join58 } from "path";
 function isProcessAlive2(pid) {
@@ -23002,7 +23073,7 @@ function bootstrapVenv() {
   if (existsSync49(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync55(
+  execSync56(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -23380,9 +23451,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path67 = join61(roamDir, name);
+    const path69 = join61(roamDir, name);
     try {
-      return { path: path67, mtimeMs: statSync8(path67).mtimeMs };
+      return { path: path69, mtimeMs: statSync8(path69).mtimeMs };
     } catch {
       return void 0;
     }
@@ -23598,11 +23669,11 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync56 } from "child_process";
+import { execSync as execSync57 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync56(cmd, { stdio: "inherit", cwd });
+      execSync57(cmd, { stdio: "inherit", cwd });
     } catch (error) {
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
@@ -23801,11 +23872,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path67 = process.argv[idx + 1];
+  const path69 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path67, prefix: prefix2 };
+  return { path: path69, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -23903,7 +23974,7 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync57 } from "child_process";
+import { execSync as execSync58 } from "child_process";
 import { existsSync as existsSync54, mkdirSync as mkdirSync24, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join65, resolve as resolve15 } from "path";
@@ -24046,7 +24117,7 @@ function runPowerShellScript(processName, outputPath) {
   const scriptPath = join65(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync42(scriptPath, captureWindowPs1, "utf8");
   try {
-    execSync57(
+    execSync58(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
@@ -24521,14 +24592,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync55, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path55 from "path";
+import path57 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path55.join(path55.dirname(require4.resolve("node-pty")), "..");
-  const helper = path55.join(
+  const ptyRoot = path57.join(path57.dirname(require4.resolve("node-pty")), "..");
+  const helper = path57.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -24590,12 +24661,12 @@ import { randomUUID as randomUUID4 } from "crypto";
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs34 from "fs";
-import * as path56 from "path";
+import * as path58 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname6 = path56.dirname(__filename4);
+var __dirname6 = path58.dirname(__filename4);
 function readDesignSystemPrompt() {
-  const promptPath = path56.join(__dirname6, "..", "claude", "system-prompt.md");
+  const promptPath = path58.join(__dirname6, "..", "claude", "system-prompt.md");
   return fs34.readFileSync(promptPath, "utf8");
 }
 
@@ -25132,8 +25203,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path67 = activityPath(session.id);
-  const dir = dirname29(path67);
+  const path69 = activityPath(session.id);
+  const dir = dirname29(path69);
   try {
     mkdirSync25(dir, { recursive: true });
   } catch {
@@ -25143,7 +25214,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path67);
+    const activity2 = readActivity(path69);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -25153,11 +25224,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path67.endsWith(filename)) return;
+    if (filename && !path69.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync56(path67)) read();
+  if (existsSync56(path69)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -27209,16 +27280,16 @@ async function statusLine() {
 // src/commands/sync.ts
 import * as fs45 from "fs";
 import * as os4 from "os";
-import * as path65 from "path";
+import * as path67 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs39 from "fs";
-import * as path57 from "path";
+import * as path59 from "path";
 import chalk202 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path57.join(claudeDir, "CLAUDE.md");
-  const target = path57.join(targetBase, "CLAUDE.md");
+  const source = path59.join(claudeDir, "CLAUDE.md");
+  const target = path59.join(targetBase, "CLAUDE.md");
   const sourceContent = fs39.readFileSync(source, "utf8");
   if (fs39.existsSync(target)) {
     const targetContent = fs39.readFileSync(target, "utf8");
@@ -27243,33 +27314,33 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path60 from "path";
+import * as path62 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
 import * as fs40 from "fs";
-import * as path58 from "path";
+import * as path60 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path58.join(claudeDir, "commands");
+  const commandsSource = path60.join(claudeDir, "commands");
   const files = fs40.readdirSync(commandsSource);
   let synced = 0;
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
-    const content = fs40.readFileSync(path58.join(commandsSource, file), "utf8");
-    const target = path58.join(harness.homeDir, harness.sync.commandDest(name));
-    fs40.mkdirSync(path58.dirname(target), { recursive: true });
+    const content = fs40.readFileSync(path60.join(commandsSource, file), "utf8");
+    const target = path60.join(harness.homeDir, harness.sync.commandDest(name));
+    fs40.mkdirSync(path60.dirname(target), { recursive: true });
     fs40.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path58.join(harness.homeDir, harness.sync.agentsFile);
-  fs40.mkdirSync(path58.dirname(agentsTarget), { recursive: true });
-  fs40.copyFileSync(path58.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path60.join(harness.homeDir, harness.sync.agentsFile);
+  fs40.mkdirSync(path60.dirname(agentsTarget), { recursive: true });
+  fs40.copyFileSync(path60.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced };
 }
 
 // src/commands/sync/syncCodexHooks.ts
 import * as fs41 from "fs";
-import * as path59 from "path";
+import * as path61 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -27300,9 +27371,9 @@ ${rest}
 }
 function syncCodexHooks(sourcePath) {
   const body = fs41.readFileSync(sourcePath, "utf8");
-  const configPath = path59.join(harnesses.codex.homeDir, "config.toml");
+  const configPath = path61.join(harnesses.codex.homeDir, "config.toml");
   const existing = fs41.existsSync(configPath) ? fs41.readFileSync(configPath, "utf8") : "";
-  fs41.mkdirSync(path59.dirname(configPath), { recursive: true });
+  fs41.mkdirSync(path61.dirname(configPath), { recursive: true });
   fs41.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
@@ -27334,7 +27405,7 @@ function syncCodex(claudeDir) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path60.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path62.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
@@ -27342,33 +27413,33 @@ function syncCodex(claudeDir) {
 
 // src/commands/sync/syncDesign.ts
 import * as fs42 from "fs";
-import * as path61 from "path";
+import * as path63 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path61.join(claudeDir, "system-prompt.md");
-  const systemPromptTarget = path61.join(targetBase, "system-prompt.md");
+  const systemPromptSource = path63.join(claudeDir, "system-prompt.md");
+  const systemPromptTarget = path63.join(targetBase, "system-prompt.md");
   fs42.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log("Copied system-prompt.md to ~/.claude/system-prompt.md");
-  const skillsSource = path61.join(claudeDir, "skills");
-  const skillsTarget = path61.join(targetBase, "skills");
+  const skillsSource = path63.join(claudeDir, "skills");
+  const skillsTarget = path63.join(targetBase, "skills");
   fs42.mkdirSync(skillsTarget, { recursive: true });
   const files = fs42.readdirSync(skillsSource);
   for (const file of files) {
     fs42.copyFileSync(
-      path61.join(skillsSource, file),
-      path61.join(skillsTarget, file)
+      path63.join(skillsSource, file),
+      path63.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path63 from "path";
+import * as path65 from "path";
 
 // src/commands/sync/syncPiHooks.ts
 import * as fs43 from "fs";
-import * as path62 from "path";
+import * as path64 from "path";
 function piExtensionsDir() {
-  return path62.join(harnesses.pi.homeDir, "extensions");
+  return path64.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
@@ -27376,8 +27447,8 @@ function syncPiHooks(sourceDir) {
   const files = fs43.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     fs43.copyFileSync(
-      path62.join(sourceDir, file),
-      path62.join(target, `assist-${file}`)
+      path64.join(sourceDir, file),
+      path64.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -27414,7 +27485,7 @@ function syncPi(claudeDir) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path63.join(claudeDir, "..", "pi"));
+  syncPiHooks(path65.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
@@ -27422,11 +27493,11 @@ function syncPi(claudeDir) {
 
 // src/commands/sync/syncSettings.ts
 import * as fs44 from "fs";
-import * as path64 from "path";
+import * as path66 from "path";
 import chalk203 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path64.join(claudeDir, "settings.json");
-  const target = path64.join(targetBase, "settings.json");
+  const source = path66.join(claudeDir, "settings.json");
+  const target = path66.join(targetBase, "settings.json");
   const sourceContent = fs44.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs44.existsSync(target);
@@ -27465,12 +27536,12 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path65.dirname(__filename5);
+var __dirname7 = path67.dirname(__filename5);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path65.join(__dirname7, "..", "claude");
-  const targetBase = path65.join(os4.homedir(), ".claude");
+  const claudeDir = path67.join(__dirname7, "..", "claude");
+  const targetBase = path67.join(os4.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -27479,20 +27550,20 @@ async function sync(options2) {
   syncPi(claudeDir);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path65.join(claudeDir, "commands");
-  const targetDir = path65.join(targetBase, "commands");
+  const sourceDir = path67.join(claudeDir, "commands");
+  const targetDir = path67.join(targetBase, "commands");
   fs45.mkdirSync(targetDir, { recursive: true });
   const files = fs45.readdirSync(sourceDir);
   for (const file of files) {
-    fs45.copyFileSync(path65.join(sourceDir, file), path65.join(targetDir, file));
+    fs45.copyFileSync(path67.join(sourceDir, file), path67.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
 }
 
 // src/commands/update.ts
-import { execSync as execSync58 } from "child_process";
-import * as path66 from "path";
+import { execSync as execSync59 } from "child_process";
+import * as path68 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -27511,12 +27582,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path66.resolve(dir);
-    if (resolved.split(path66.sep).includes("node_modules")) {
+    const resolved = path68.resolve(dir);
+    if (resolved.split(path68.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync58("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path66.resolve(globalPrefix).toLowerCase());
+    const globalPrefix = execSync59("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    return resolved.toLowerCase().startsWith(path68.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -27526,18 +27597,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync58("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync59("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync58("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync59("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync58("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync59("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync58("assist sync", { stdio: "inherit" });
+    execSync59("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync58("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync59("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync58("assist sync", { stdio: "inherit" });
+    execSync59("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."