@staff0rd/assist 0.370.1 → 0.372.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.370.1",
+  version: "0.372.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -138,10 +138,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path57) {
-  if (!existsSync(path57)) return {};
+function loadRawYaml(path58) {
+  if (!existsSync(path58)) return {};
   try {
-    const content = readFileSync(path57, "utf8");
+    const content = readFileSync(path58, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -1150,8 +1150,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path57 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path57}/${ref}`;
+  const path58 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path58}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -2521,8 +2521,8 @@ import fs14 from "fs";
 import { minimatch } from "minimatch";
 import { Project as Project2 } from "ts-morph";
 
-// src/commands/verify/blockComments/collectFileComments.ts
-import fs13 from "fs";
+// src/shared/isHashCommentFile.ts
+import path18 from "path";
 
 // src/shared/isYamlFile.ts
 var YAML_EXTENSIONS = [".yml", ".yaml"];
@@ -2531,6 +2531,54 @@ function isYamlFile(filePath) {
   return YAML_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
 
+// src/shared/isHashCommentFile.ts
+function isShellFile(filePath) {
+  if (!filePath) return false;
+  return filePath.endsWith(".sh");
+}
+function isDockerfile(filePath) {
+  if (!filePath) return false;
+  const base = path18.basename(filePath);
+  return base === "Dockerfile" || base.startsWith("Dockerfile.") || base.endsWith(".dockerfile");
+}
+function isEnvFile(filePath) {
+  if (!filePath) return false;
+  const base = path18.basename(filePath);
+  return base === ".env" || base.endsWith(".env") || base.startsWith(".env.");
+}
+function isHashCommentFile(filePath) {
+  return isYamlFile(filePath) || isDockerfile(filePath) || isEnvFile(filePath) || isShellFile(filePath);
+}
+
+// src/commands/verify/blockComments/collectFileComments.ts
+import fs13 from "fs";
+
+// src/commands/verify/blockComments/collectHashComments.ts
+function blankNonNewline(text9) {
+  return text9.replace(/[^\n]/g, " ");
+}
+function isHeaderLine(line) {
+  const trimmed = line.trim();
+  return trimmed === "" || trimmed.startsWith("#");
+}
+function collectHashComments(content, options2) {
+  const lines = content.split("\n");
+  let start3 = 0;
+  if (options2.skipHeader) {
+    while (start3 < lines.length && isHeaderLine(lines[start3])) start3++;
+  }
+  const comments3 = [];
+  for (let i = start3; i < lines.length; i++) {
+    const work = lines[i].replace(
+      /"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'/g,
+      blankNonNewline
+    );
+    const match = work.match(/(?:^|\s)(#.*)/);
+    if (match) comments3.push({ line: i + 1, text: match[1] });
+  }
+  return comments3;
+}
+
 // src/commands/verify/blockComments/collectComments.ts
 function collectComments(sourceFile) {
   const seen = /* @__PURE__ */ new Set();
@@ -2551,18 +2599,6 @@ function collectComments(sourceFile) {
   return comments3;
 }
 
-// src/commands/verify/blockComments/collectYamlComments.ts
-import { Lexer } from "yaml";
-function collectYamlComments(content) {
-  const comments3 = [];
-  let line = 1;
-  for (const token of new Lexer().lex(content)) {
-    if (token.startsWith("#")) comments3.push({ line, text: token });
-    for (const char of token) if (char === "\n") line++;
-  }
-  return comments3;
-}
-
 // src/commands/complexity/maintainability/parseMaintainabilityOverride.ts
 var MAINTAINABILITY_OVERRIDE_MARKER = "assist-maintainability-override";
 var OVERRIDE_MARKER = /^\s*\/\/\s*assist-maintainability-override:?\s*(-?\d+)\s*$/;
@@ -2601,21 +2637,12 @@ function isCommentExempt(text9) {
   return MACHINE_DIRECTIVES.some((d) => lower.includes(d));
 }
 
-// src/commands/verify/blockComments/collectFileComments.ts
+// src/commands/verify/blockComments/collectSourceFindings.ts
 function toSingleLine(text9) {
   return text9.replace(/\s+/g, " ").trim();
 }
-function collectFileComments(file, lines, project) {
+function collectSourceFindings(file, lines, project) {
   const findings = [];
-  if (isYamlFile(file)) {
-    for (const { line, text: text9 } of collectYamlComments(
-      fs13.readFileSync(file, "utf8")
-    )) {
-      if (lines.has(line))
-        findings.push({ file, line, text: toSingleLine(text9) });
-    }
-    return findings;
-  }
   const sourceFile = project.addSourceFileAtPath(file);
   for (const { pos, text: text9 } of collectComments(sourceFile)) {
     const { line } = sourceFile.getLineAndColumnAtPos(pos);
@@ -2626,6 +2653,42 @@ function collectFileComments(file, lines, project) {
   return findings;
 }
 
+// src/commands/verify/blockComments/collectYamlComments.ts
+import { Lexer } from "yaml";
+function collectYamlComments(content) {
+  const comments3 = [];
+  let line = 1;
+  for (const token of new Lexer().lex(content)) {
+    if (token.startsWith("#")) comments3.push({ line, text: token });
+    for (const char of token) if (char === "\n") line++;
+  }
+  return comments3;
+}
+
+// src/commands/verify/blockComments/collectFileComments.ts
+function toFindings(file, lines, raw, exempt) {
+  const findings = [];
+  for (const { line, text: text9 } of raw) {
+    if (!lines.has(line)) continue;
+    if (exempt && isCommentExempt(text9)) continue;
+    findings.push({ file, line, text: text9.replace(/\s+/g, " ").trim() });
+  }
+  return findings;
+}
+function collectFileComments(file, lines, project) {
+  const read = () => fs13.readFileSync(file, "utf8");
+  if (isYamlFile(file))
+    return toFindings(file, lines, collectYamlComments(read()), false);
+  if (isDockerfile(file) || isEnvFile(file) || isShellFile(file))
+    return toFindings(
+      file,
+      lines,
+      collectHashComments(read(), { skipHeader: isShellFile(file) }),
+      true
+    );
+  return collectSourceFindings(file, lines, project);
+}
+
 // src/commands/verify/blockComments/parseDiffAddedLines.ts
 var FILE_HEADER = /^\+\+\+ (?:b\/)?(.+)$/;
 var HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
@@ -2673,7 +2736,8 @@ var SCANNED_EXTENSIONS = [
   ".yaml"
 ];
 function shouldScan(file, ignoreGlobs) {
-  if (!SCANNED_EXTENSIONS.some((ext) => file.endsWith(ext))) return false;
+  if (!SCANNED_EXTENSIONS.some((ext) => file.endsWith(ext)) && !isHashCommentFile(file))
+    return false;
   if (ignoreGlobs.some((glob) => minimatch(file, glob))) return false;
   return fs14.existsSync(file);
 }
@@ -2721,9 +2785,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, path57) {
+function resolveStringsAtPath(data, path58) {
   let current = data;
-  for (const segment of path57.split(".")) {
+  for (const segment of path58.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -2736,10 +2800,10 @@ function resolveStringsAtPath(data, path57) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path57 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path57)) {
+  for (const path58 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path58)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path57, value });
+        violations.push({ file: rule.file, path: path58, value });
     }
   }
   return violations;
@@ -2778,8 +2842,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path57, value } of violations) {
-    console.log(`  ${file} ${path57}: ${value}`);
+  for (const { file, path: path58, value } of violations) {
+    console.log(`  ${file} ${path58}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -2834,7 +2898,7 @@ Total: ${lines.length} hardcoded color(s)`);
 }
 
 // src/commands/verify/run/resolveEntries.ts
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/shared/resolveRunConfigs.ts
 import { dirname as dirname9, relative, resolve as resolve3 } from "path";
@@ -2944,7 +3008,7 @@ function getRunEntries() {
   return configs.filter((r) => r.name.startsWith("verify:")).map((r) => ({
     name: r.name,
     fullCommand: buildFullCommand(r.command, r.args),
-    cwd: r.cwd ? path18.resolve(getConfigDir(), r.cwd) : void 0,
+    cwd: r.cwd ? path19.resolve(getConfigDir(), r.cwd) : void 0,
     env: r.env,
     filter: r.filter,
     quiet: r.quiet
@@ -2953,7 +3017,7 @@ function getRunEntries() {
 function getPackageJsonEntries() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return [];
-  const cwd = path18.dirname(result.packageJsonPath);
+  const cwd = path19.dirname(result.packageJsonPath);
   return result.verifyScripts.map((script) => ({
     name: script,
     fullCommand: `npm run ${script}`,
@@ -3472,11 +3536,11 @@ function detectPlatform() {
 import { spawn as spawn2 } from "child_process";
 import fs15 from "fs";
 import { createRequire } from "module";
-import path19 from "path";
+import path20 from "path";
 var require2 = createRequire(import.meta.url);
 function getSnoreToastPath() {
-  const notifierPath = path19.dirname(require2.resolve("node-notifier"));
-  return path19.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
+  const notifierPath = path20.dirname(require2.resolve("node-notifier"));
+  return path20.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options2) {
   const { title, message, sound } = options2;
@@ -4237,10 +4301,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path57 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path57), { recursive: true });
-  writeFileSync15(path57, JSON.stringify(hooksSettings, null, 2));
-  return path57;
+  const path58 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path58), { recursive: true });
+  writeFileSync15(path58, JSON.stringify(hooksSettings, null, 2));
+  return path58;
 }
 
 // src/shared/spawnClaude.ts
@@ -4429,9 +4493,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path57 = join15(dir, ".assist", name);
-    if (existsSync18(path57)) {
-      renameSync(path57, `${path57}.bak`);
+    const path58 = join15(dir, ".assist", name);
+    if (existsSync18(path58)) {
+      renameSync(path58, `${path58}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -4845,8 +4909,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path57) {
-  const content = readFileSync13(path57, "utf8").trim();
+function parseBacklogJsonl(path58) {
+  const content = readFileSync13(path58, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -4928,8 +4992,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path57) {
-  return path57.replace(/^\/+/, "");
+function stripLeadingSlashes(path58) {
+  return path58.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -5361,13 +5425,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path57 = activityPath(sessionId);
-  mkdirSync7(dirname14(path57), { recursive: true });
-  writeFileSync17(path57, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path58 = activityPath(sessionId);
+  mkdirSync7(dirname14(path58), { recursive: true });
+  writeFileSync17(path58, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path57) {
+function readActivity(path58) {
   try {
-    return JSON.parse(readFileSync14(path57, "utf8"));
+    return JSON.parse(readFileSync14(path58, "utf8"));
   } catch {
     return void 0;
   }
@@ -5377,9 +5441,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path57 = activityPath(sessionId);
-  mkdirSync7(dirname14(path57), { recursive: true });
-  writeFileSync17(path57, JSON.stringify(activity2));
+  const path58 = activityPath(sessionId);
+  mkdirSync7(dirname14(path58), { recursive: true });
+  writeFileSync17(path58, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -5435,20 +5499,20 @@ function getSignalPath() {
   return join19(homedir8(), ".assist", "signals", `signal-${sessionId}.json`);
 }
 function writeSignal(event, data) {
-  const path57 = getSignalPath();
-  if (!path57) return;
+  const path58 = getSignalPath();
+  if (!path58) return;
   const sessionId = process.env.ASSIST_SESSION_ID;
   const signal = { event, ...sessionId && { sessionId }, ...data };
-  mkdirSync8(dirname15(path57), { recursive: true });
-  writeFileSync18(path57, JSON.stringify(signal));
+  mkdirSync8(dirname15(path58), { recursive: true });
+  writeFileSync18(path58, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path57 = getSignalPath();
-  if (!path57 || !existsSync21(path57)) return void 0;
+  const path58 = getSignalPath();
+  if (!path58 || !existsSync21(path58)) return void 0;
   try {
-    return JSON.parse(readFileSync15(path57, "utf8"));
+    return JSON.parse(readFileSync15(path58, "utf8"));
   } catch {
     return void 0;
   }
@@ -6382,8 +6446,8 @@ async function getBacklogExists(req, res) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path57 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path57.split("/").filter(Boolean);
+    const path58 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path58.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -6771,7 +6835,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname18(branchKeyPath);
   const branchPrefix = basename2(branchKeyPath);
   if (!existsSync24(parent)) return null;
-  const synthesisFiles = readdirSync(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join21(parent, name, "synthesis.md")).filter((path57) => existsSync24(path57)).map((path57) => ({ path: path57, mtime: statSync2(path57).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join21(parent, name, "synthesis.md")).filter((path58) => existsSync24(path58)).map((path58) => ({ path: path58, mtime: statSync2(path58).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -6820,12 +6884,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path57 = await resolveSynthesisPath(cwd);
-    if (!path57) {
+    const path58 = await resolveSynthesisPath(cwd);
+    if (!path58) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync17(path57, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync17(path58, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -6903,10 +6967,10 @@ function getStorePath(filename) {
   return join23(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path57 = getStorePath(filename);
-  if (existsSync25(path57)) {
+  const path58 = getStorePath(filename);
+  if (existsSync25(path58)) {
     try {
-      return JSON.parse(readFileSync18(path57, "utf8"));
+      return JSON.parse(readFileSync18(path58, "utf8"));
     } catch {
       return {};
     }
@@ -10037,9 +10101,9 @@ var __dirname4 = dirname19(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path57) {
-  if (!existsSync26(path57)) return [];
-  return readFileSync21(path57, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path58) {
+  if (!existsSync26(path58)) return [];
+  return readFileSync21(path58, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -10504,14 +10568,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, path57, description, depth, p) {
-  showProgress(p, path57.join(" "));
-  const subHelp = await runHelp([cli, ...path57]);
+async function resolveCommand(cli, path58, description, depth, p) {
+  showProgress(p, path58.join(" "));
+  const subHelp = await runHelp([cli, ...path58]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path57, description }];
+    return [{ path: path58, description }];
   }
-  const children = await discoverAt(cli, path57, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path57, description }];
+  const children = await discoverAt(cli, path58, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path58, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -10659,9 +10723,9 @@ function logPath(cli) {
   return join27(homedir13(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path57 = logPath(cli);
-  if (!existsSync28(path57)) return void 0;
-  return readFileSync23(path57, "utf8");
+  const path58 = logPath(cli);
+  if (!existsSync28(path58)) return void 0;
+  return readFileSync23(path58, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join27(homedir13(), ".assist");
@@ -10819,9 +10883,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path57 = join29(dir, entry);
+    const path58 = join29(dir, entry);
     try {
-      if (statSync3(path57).mtimeMs < cutoff) unlinkSync7(path57);
+      if (statSync3(path58).mtimeMs < cutoff) unlinkSync7(path58);
     } catch {
       continue;
     }
@@ -10831,10 +10895,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 function readPinState(pin) {
-  const path57 = getPinStatePath(pin);
-  if (!existsSync29(path57)) return void 0;
+  const path58 = getPinStatePath(pin);
+  if (!existsSync29(path58)) return void 0;
   try {
-    const state = JSON.parse(readFileSync24(path57, "utf8"));
+    const state = JSON.parse(readFileSync24(path58, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -10868,7 +10932,7 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  const marker = isYamlFile(state.file) ? "#" : "//";
+  const marker = isHashCommentFile(state.file) ? "#" : "//";
   const indentSource = lines[index3] ?? "";
   const indent2 = indentSource.match(/^\s*/)?.[0] ?? "";
   lines.splice(index3, 0, `${indent2}${marker} ${state.text}`);
@@ -10886,15 +10950,15 @@ import chalk108 from "chalk";
 
 // src/commands/codeComment/validateCommentText.ts
 var MAX_COMMENT_LENGTH = 50;
-function validateCommentText(raw, isYaml = false) {
-  const text9 = isYaml ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
+function validateCommentText(raw, isHash = false) {
+  const text9 = isHash ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
   if (/[\r\n]/.test(text9)) {
     return {
       ok: false,
       reason: "Comment must be a single line \u2014 multi-line comments are not allowed."
     };
   }
-  if (!isYaml && (text9.includes("/*") || text9.includes("*/"))) {
+  if (!isHash && (text9.includes("/*") || text9.includes("*/"))) {
     return {
       ok: false,
       reason: "Block comments (/* */) are not allowed \u2014 only single-line // comments."
@@ -10937,8 +11001,9 @@ function codeCommentSet(file, line, text9) {
     process.exitCode = 1;
     return;
   }
-  const marker = isYamlFile(file) ? "#" : "//";
-  const validation = validateCommentText(text9, isYamlFile(file));
+  const hash = isHashCommentFile(file);
+  const marker = hash ? "#" : "//";
+  const validation = validateCommentText(text9, hash);
   if (!validation.ok) {
     console.error(chalk108.red(`Refused: ${validation.reason}`));
     console.error(chalk108.red("No pin issued."));
@@ -10990,13 +11055,13 @@ import chalk110 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs17 from "fs";
-import path21 from "path";
+import path22 from "path";
 import chalk109 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
 import fs16 from "fs";
-import path20 from "path";
+import path21 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
   const { complexity } = loadConfig();
@@ -11010,7 +11075,7 @@ function walk(dir, results) {
   const extensions = [".ts", ".tsx"];
   const entries = fs16.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path20.join(dir, entry.name);
+    const fullPath = path21.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "node_modules" && entry.name !== ".git") {
         walk(fullPath, results);
@@ -11232,7 +11297,7 @@ function countSloc(content) {
 function createSourceFromFile(filePath) {
   const content = fs17.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
-    path21.basename(filePath),
+    path22.basename(filePath),
     content,
     ts5.ScriptTarget.Latest,
     true,
@@ -11589,8 +11654,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path57, value) {
-  const keys = path57.split(".");
+function setNestedValue(obj, path58, value) {
+  const keys = path58.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -11670,9 +11735,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path57) {
+function getNestedValue(obj, path58) {
   let current = obj;
-  for (const key of path57.split(".")) current = stepInto(current, key);
+  for (const key of path58.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -12272,14 +12337,14 @@ import chalk128 from "chalk";
 
 // src/shared/findRepoRoot.ts
 import { existsSync as existsSync33 } from "fs";
-import path22 from "path";
+import path23 from "path";
 function findRepoRoot(dir) {
   let current = dir;
-  while (current !== path22.dirname(current)) {
-    if (existsSync33(path22.join(current, ".git"))) {
+  while (current !== path23.dirname(current)) {
+    if (existsSync33(path23.join(current, ".git"))) {
       return current;
     }
-    current = path22.dirname(current);
+    current = path23.dirname(current);
   }
   return null;
 }
@@ -12343,7 +12408,7 @@ async function checkBuildLocksCommand() {
 
 // src/commands/dotnet/buildTree.ts
 import { readFileSync as readFileSync29 } from "fs";
-import path23 from "path";
+import path24 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
   const content = readFileSync29(csprojPath, "utf8");
@@ -12354,14 +12419,14 @@ function getProjectRefs(csprojPath) {
   return refs;
 }
 function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
-  const abs = path23.resolve(csprojPath);
-  const rel = path23.relative(repoRoot, abs);
+  const abs = path24.resolve(csprojPath);
+  const rel = path24.relative(repoRoot, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
-  const dir = path23.dirname(abs);
+  const dir = path24.dirname(abs);
   for (const ref of getProjectRefs(abs)) {
-    const childAbs = path23.resolve(dir, ref);
+    const childAbs = path24.resolve(dir, ref);
     try {
       readFileSync29(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
@@ -12389,7 +12454,7 @@ function collectAllDeps(node) {
 
 // src/commands/dotnet/findContainingSolutions.ts
 import { readdirSync as readdirSync5, readFileSync as readFileSync30, statSync as statSync4 } from "fs";
-import path24 from "path";
+import path25 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
@@ -12402,7 +12467,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules" || entry === "packages")
       continue;
-    const full = path24.join(dir, entry);
+    const full = path25.join(dir, entry);
     try {
       const stat2 = statSync4(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
@@ -12416,8 +12481,8 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   return results;
 }
 function findContainingSolutions(csprojPath, repoRoot) {
-  const csprojAbs = path24.resolve(csprojPath);
-  const csprojBasename = path24.basename(csprojAbs);
+  const csprojAbs = path25.resolve(csprojPath);
+  const csprojBasename = path25.basename(csprojAbs);
   const slnFiles = findSlnFiles(repoRoot, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
@@ -12425,7 +12490,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
     try {
       const content = readFileSync30(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path24.relative(repoRoot, sln));
+        matches.push(path25.relative(repoRoot, sln));
       }
     } catch {
     }
@@ -12488,15 +12553,15 @@ function printJson(tree, totalCount, solutions) {
 
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync34 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import chalk130 from "chalk";
 function resolveCsproj(csprojPath) {
-  const resolved = path25.resolve(csprojPath);
+  const resolved = path26.resolve(csprojPath);
   if (!existsSync34(resolved)) {
     console.error(chalk130.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot = findRepoRoot(path25.dirname(resolved));
+  const repoRoot = findRepoRoot(path26.dirname(resolved));
   if (!repoRoot) {
     console.error(chalk130.red("Could not find git repository root"));
     process.exit(1);
@@ -12661,7 +12726,7 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync35 } from "fs";
-import path26 from "path";
+import path27 from "path";
 import chalk134 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
@@ -12700,7 +12765,7 @@ function findSolution() {
 // src/commands/dotnet/resolveSolution.ts
 function resolveSolution(sln) {
   if (sln) {
-    const resolved = path26.resolve(sln);
+    const resolved = path27.resolve(sln);
     if (!existsSync35(resolved)) {
       console.error(chalk134.red(`Solution file not found: ${resolved}`));
       process.exit(1);
@@ -12743,7 +12808,7 @@ function parseInspectReport(json) {
 import { execSync as execSync31 } from "child_process";
 import { existsSync as existsSync36, readFileSync as readFileSync31, unlinkSync as unlinkSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import path27 from "path";
+import path28 from "path";
 import chalk135 from "chalk";
 function assertJbInstalled() {
   try {
@@ -12757,7 +12822,7 @@ function assertJbInstalled() {
   }
 }
 function runInspectCode(slnPath, include, swea) {
-  const reportPath = path27.join(tmpdir3(), `inspect-${Date.now()}.xml`);
+  const reportPath = path28.join(tmpdir3(), `inspect-${Date.now()}.xml`);
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
@@ -12908,18 +12973,18 @@ function isSourceFile(filePath) {
   if (!filePath) return false;
   return SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
-function blankNonNewline(text9) {
+function blankNonNewline2(text9) {
   return text9.replace(/[^\n]/g, " ");
 }
 function extractComments(text9) {
   const comments3 = [];
   let work = text9.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g,
-    blankNonNewline
+    blankNonNewline2
   );
   work = work.replace(/\/\*[\s\S]*?\*\//g, (match) => {
     comments3.push(match);
-    return blankNonNewline(match);
+    return blankNonNewline2(match);
   });
   for (const match of work.matchAll(/\/\/.*/g)) {
     comments3.push(match[0]);
@@ -12928,13 +12993,13 @@ function extractComments(text9) {
 }
 
 // src/commands/editHook/extractYamlComments.ts
-function blankNonNewline2(text9) {
+function blankNonNewline3(text9) {
   return text9.replace(/[^\n]/g, " ");
 }
 function extractYamlComments(text9) {
   const work = text9.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'/g,
-    blankNonNewline2
+    blankNonNewline3
   );
   const comments3 = [];
   for (const match of work.matchAll(/(?:^|\s)(#.*)/gm)) {
@@ -12943,6 +13008,20 @@ function extractYamlComments(text9) {
   return comments3.map((comment3) => comment3.replace(/\s+/g, " ").trim()).filter((comment3) => comment3.length > 0);
 }
 
+// src/commands/editHook/extractShellComments.ts
+function isHeaderLine2(line) {
+  const trimmed = line.trim();
+  return trimmed === "" || trimmed.startsWith("#");
+}
+function extractShellComments(text9) {
+  const lines = text9.split("\n");
+  let firstCodeLine = 0;
+  while (firstCodeLine < lines.length && isHeaderLine2(lines[firstCodeLine])) {
+    firstCodeLine++;
+  }
+  return extractYamlComments(lines.slice(firstCodeLine).join("\n"));
+}
+
 // src/commands/editHook/introducedComments.ts
 function introducedComments(added, removed) {
   const counts = /* @__PURE__ */ new Map();
@@ -13000,15 +13079,15 @@ function partitionStrings(input, existingContent) {
 }
 function decideCommentGuard(input, existingContent) {
   const filePath = input.tool_input.file_path;
-  const yaml = isYamlFile(filePath);
-  if (!isSourceFile(filePath) && !yaml) return void 0;
-  const extract2 = yaml ? extractYamlComments : extractComments;
+  const hash = isHashCommentFile(filePath);
+  if (!isSourceFile(filePath) && !hash) return void 0;
+  const extract2 = hash ? isShellFile(filePath) ? extractShellComments : extractYamlComments : extractComments;
   const { added, removed } = partitionStrings(input, existingContent);
   const introduced = introducedComments(
     added.flatMap(extract2),
     removed.flatMap(extract2)
   );
-  return introduced.length > 0 ? denyReason(yaml ? "#" : "//") : void 0;
+  return introduced.length > 0 ? denyReason(hash ? "#" : "//") : void 0;
 }
 
 // src/commands/editHook/decideOverrideGuard.ts
@@ -14111,9 +14190,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id2, ...path57] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id2, ...path58] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id2];
-    for (const key of path57) {
+    for (const key of path58) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -14760,15 +14839,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path57, line, body, startLine) {
+function comment2(path58, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path57, line, startLine });
+    postComment({ prId, body, path: path58, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path57}:${range}`);
+    console.log(`Added review comment on ${path58}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -15620,8 +15699,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((path57, line, body) => {
-    comment2(path57, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path58, line, body) => {
+    comment2(path58, Number.parseInt(line, 10), body);
   });
 }
 
@@ -15873,10 +15952,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path57) {
+async function ravenFetch(connection, path58) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path57}`;
+  const url = `${connection.url}${path58}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -15966,16 +16045,16 @@ import chalk163 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path57;
+  let path58;
   if (opts.collection) {
-    path57 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path58 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path57 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path58 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path57 += `&query=${encodeURIComponent(opts.query)}`;
+    path58 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path57;
+  return path58;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -15984,7 +16063,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 path57 = buildQueryPath({
+    const path58 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -15992,7 +16071,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path57);
+    const data = await ravenFetch(connection, path58);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -16049,7 +16128,7 @@ function registerRavendb(program2) {
 
 // src/commands/refactor/check/index.ts
 import { spawn as spawn5 } from "child_process";
-import * as path28 from "path";
+import * as path29 from "path";
 
 // src/commands/refactor/logViolations.ts
 import chalk165 from "chalk";
@@ -16226,7 +16305,7 @@ ${failed2.length} verify script(s) failed:`);
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return true;
-  const packageDir = path28.dirname(result.packageJsonPath);
+  const packageDir = path29.dirname(result.packageJsonPath);
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
@@ -16252,7 +16331,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path35 from "path";
+import path36 from "path";
 import chalk168 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -16705,9 +16784,9 @@ function buildDestinationContent(functionTexts, imports, sourceRelativePath, sou
 }
 
 // src/commands/refactor/extract/getRelativeImportPath.ts
-import path29 from "path";
+import path30 from "path";
 function getRelativeImportPath(from, to) {
-  let rel = path29.relative(path29.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  let rel = path30.relative(path30.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
@@ -16731,9 +16810,9 @@ function findImporters(functionName, sourceFile, destPath, project) {
 }
 
 // src/commands/refactor/extract/resolveBarrel.ts
-import path30 from "path";
+import path31 from "path";
 function resolveBarrel(functionName, sourcePath, destPath, project) {
-  const indexPath = path30.join(path30.dirname(destPath), "index.ts");
+  const indexPath = path31.join(path31.dirname(destPath), "index.ts");
   const barrel = project.getSourceFile(indexPath);
   if (!barrel) return { barrel: void 0, barrelRelPath: "" };
   const sourceRelFromBarrel = getRelativeImportPath(indexPath, sourcePath);
@@ -16751,15 +16830,15 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/rewriteImportPaths.ts
-import path31 from "path";
+import path32 from "path";
 function rewriteImportPaths(imports, sourcePath, destPath) {
-  const sourceDir = path31.dirname(sourcePath);
-  const destDir = path31.dirname(destPath);
+  const sourceDir = path32.dirname(sourcePath);
+  const destDir = path32.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute = path31.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path31.relative(destDir, absolute).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path31.basename(absolute)}`;
+    const absolute = path32.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path32.relative(destDir, absolute).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path32.basename(absolute)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -16827,7 +16906,7 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path32 from "path";
+import path33 from "path";
 import chalk166 from "chalk";
 function section(title) {
   return `
@@ -16837,7 +16916,7 @@ function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
-    const rel = path32.relative(cwd, imp.file.getFilePath());
+    const rel = path33.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk166.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -16877,16 +16956,16 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path34 from "path";
+import path35 from "path";
 import chalk167 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
 import fs23 from "fs";
-import path33 from "path";
+import path34 from "path";
 import { Project as Project3 } from "ts-morph";
 function findTsConfig(sourcePath) {
-  const rootConfig = path33.resolve("tsconfig.json");
+  const rootConfig = path34.resolve("tsconfig.json");
   if (!fs23.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
@@ -16895,7 +16974,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludes(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs23.readdirSync(path33.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path33.resolve(path33.dirname(rootConfig), f));
+  const siblings = fs23.readdirSync(path34.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path34.resolve(path34.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -16914,10 +16993,10 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path33.dirname(configPath);
+  const cwd = path34.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path33.resolve(cwd, ref.path);
-    return fs23.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path33.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path34.resolve(cwd, ref.path);
+    return fs23.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path34.join(refPath, "tsconfig.json") : refPath;
   }).filter((p) => fs23.existsSync(p));
 }
 function projectIncludes(configPath, sourcePath) {
@@ -16931,7 +17010,7 @@ function projectIncludes(configPath, sourcePath) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path34.resolve(file);
+  const sourcePath = path35.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -16946,10 +17025,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path35.resolve(file);
-  const destPath = path35.resolve(destination);
+  const sourcePath = path36.resolve(file);
+  const destPath = path36.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path35.relative(cwd, destPath);
+  const relDest = path36.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -16997,16 +17076,16 @@ function ignore2(file) {
 
 // src/commands/refactor/rename/index.ts
 import fs27 from "fs";
-import path40 from "path";
+import path41 from "path";
 import chalk172 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs26 from "fs";
-import path37 from "path";
+import path38 from "path";
 import chalk170 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path36 from "path";
+import path37 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs25 from "fs";
@@ -17060,7 +17139,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path36.relative(path36.dirname(fromFile), toFile));
+  return normalizeSpecifier(path37.relative(path37.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -17108,20 +17187,20 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs26.writeFileSync(file, content, "utf8");
-    console.log(chalk170.cyan(`  Updated imports in ${path37.relative(cwd, file)}`));
+    console.log(chalk170.cyan(`  Updated imports in ${path38.relative(cwd, file)}`));
   }
-  const destDir = path37.dirname(destPath);
+  const destDir = path38.dirname(destPath);
   if (!fs26.existsSync(destDir)) fs26.mkdirSync(destDir, { recursive: true });
   fs26.renameSync(sourcePath, destPath);
   console.log(
     chalk170.white(
-      `  Moved ${path37.relative(cwd, sourcePath)} \u2192 ${path37.relative(cwd, destPath)}`
+      `  Moved ${path38.relative(cwd, sourcePath)} \u2192 ${path38.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path38 from "path";
+import path39 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -17148,7 +17227,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path38.dirname(tsConfigPath)
+    path39.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -17164,7 +17243,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 path38.resolve(resolvedPath);
+  return path39.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -17173,7 +17252,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path38.resolve(sourceFile.fileName);
+    const filePath = path39.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -17200,13 +17279,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path39 from "path";
+import path40 from "path";
 import chalk171 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk171.dim(
-        `  ${path39.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path40.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -17215,11 +17294,11 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path40.resolve(source);
-  const destPath = path40.resolve(destination);
+  const sourcePath = path41.resolve(source);
+  const destPath = path41.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path40.relative(cwd, sourcePath);
-  const relDest = path40.relative(cwd, destPath);
+  const relSource = path41.relative(cwd, sourcePath);
+  const relDest = path41.relative(cwd, destPath);
   if (!fs27.existsSync(sourcePath)) {
     console.log(chalk172.red(`File not found: ${source}`));
     process.exit(1);
@@ -17274,12 +17353,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path41 from "path";
+import path42 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path41.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path42.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -17318,16 +17397,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path48 from "path";
+import path49 from "path";
 import chalk176 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path42 from "path";
+import path43 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path42.dirname(edge.source);
-    const targetDir = path42.dirname(edge.target);
+    const sourceDir = path43.dirname(edge.source);
+    const targetDir = path43.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -17355,20 +17434,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path42.relative(ancestor, descendant);
+  const rel = path43.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path43 from "path";
+import path44 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 = path43.dirname(parent);
-  const fileDir = path43.dirname(file);
+  const parentDir = path44.dirname(parent);
+  const fileDir = path44.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path43.basename(parent, path43.extname(parent)) === "index") return file;
+  if (path44.basename(parent, path44.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -17376,16 +17455,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename13 = path43.basename(file, path43.extname(file));
+    const basename13 = path44.basename(file, path44.extname(file));
     if (basename13 === "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 = path43.dirname(parent);
-    const fileDir = path43.dirname(file);
+    const parentDir = path44.dirname(parent);
+    const fileDir = path44.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path43.basename(parent, path43.extname(parent));
+    const parentBasename = path44.basename(parent, path44.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -17397,10 +17476,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path44 from "path";
+import path45 from "path";
 import chalk174 from "chalk";
 function relPath(filePath) {
-  return path44.relative(process.cwd(), filePath);
+  return path45.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -17450,33 +17529,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs28 from "fs";
-import path45 from "path";
+import path46 from "path";
 import chalk175 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs28.writeFileSync(file, content, "utf8");
     console.log(
-      chalk175.cyan(`  Rewrote imports in ${path45.relative(process.cwd(), file)}`)
+      chalk175.cyan(`  Rewrote imports in ${path46.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs28.mkdirSync(dir, { recursive: true });
-    console.log(chalk175.green(`  Created ${path45.relative(process.cwd(), dir)}/`));
+    console.log(chalk175.green(`  Created ${path46.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path45.dirname(move2.to);
+    const targetDir = path46.dirname(move2.to);
     if (!fs28.existsSync(targetDir)) {
       fs28.mkdirSync(targetDir, { recursive: true });
     }
     fs28.renameSync(move2.from, move2.to);
     console.log(
       chalk175.white(
-        `  Moved ${path45.relative(process.cwd(), move2.from)} \u2192 ${path45.relative(process.cwd(), move2.to)}`
+        `  Moved ${path46.relative(process.cwd(), move2.from)} \u2192 ${path46.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path45.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path46.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -17487,7 +17566,7 @@ function removeEmptyDirectories(dirs) {
       fs28.rmdirSync(dir);
       console.log(
         chalk175.dim(
-          `  Removed empty directory ${path45.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path46.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -17495,7 +17574,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path47 from "path";
+import path48 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs29 from "fs";
@@ -17510,9 +17589,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs30 from "fs";
-import path46 from "path";
+import path47 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path46.join(dir, entry.name);
+  const full = path47.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
@@ -17526,15 +17605,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path46.relative(childDir, file);
-    moves.push({ from: file, to: path46.join(newLocation, rel), reason });
+    const rel = path47.relative(childDir, file);
+    moves.push({ from: file, to: path47.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path46.join(parentDir, path46.basename(childDir));
+  return path47.join(parentDir, path47.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path46.basename(parentDir)}/`;
+  return `Directory only imported from ${path47.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -17559,7 +17638,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path47.join(newDir, path47.basename(child));
+  const to = path48.join(newDir, path48.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -17567,15 +17646,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path47.basename(filePath, path47.extname(filePath));
+  return path48.basename(filePath, path48.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path47.join(path47.dirname(parent), getBaseName(parent));
+  return path48.join(path48.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path47.join(newDir, `index${path47.extname(parent)}`),
+    to: path48.join(newDir, `index${path48.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -17599,7 +17678,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path48.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path49.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -17622,7 +17701,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk176.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path48.resolve("tsconfig.json");
+  const tsConfigPath = path49.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk176.green("No restructuring needed"));
@@ -18345,8 +18424,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync40, mkdirSync as mkdirSync16, unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path57 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync40(path57)) unlinkSync14(path57);
+  for (const path58 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync40(path58)) unlinkSync14(path58);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -19480,8 +19559,8 @@ import chalk184 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk181 from "chalk";
-async function fetchSeq(conn, path57, params) {
-  const url = `${conn.url}${path57}?${params}`;
+async function fetchSeq(conn, path58, params) {
+  const url = `${conn.url}${path58}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -20835,9 +20914,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path57 = join57(roamDir, name);
+    const path58 = join57(roamDir, name);
     try {
-      return { path: path57, mtimeMs: statSync8(path57).mtimeMs };
+      return { path: path58, mtimeMs: statSync8(path58).mtimeMs };
     } catch {
       return void 0;
     }
@@ -21180,11 +21259,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path57 = process.argv[idx + 1];
+  const path58 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path57, prefix: prefix2 };
+  return { path: path58, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -21854,14 +21933,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync52, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path49 from "path";
+import path50 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path49.join(path49.dirname(require4.resolve("node-pty")), "..");
-  const helper = path49.join(
+  const ptyRoot = path50.join(path50.dirname(require4.resolve("node-pty")), "..");
+  const helper = path50.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -22276,8 +22355,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path57 = activityPath(session.id);
-  const dir = dirname26(path57);
+  const path58 = activityPath(session.id);
+  const dir = dirname26(path58);
   try {
     mkdirSync23(dir, { recursive: true });
   } catch {
@@ -22287,7 +22366,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path57);
+    const activity2 = readActivity(path58);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -22297,11 +22376,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path57.endsWith(filename)) return;
+    if (filename && !path58.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync53(path57)) read();
+  if (existsSync53(path58)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -23523,11 +23602,11 @@ import { createInterface as createInterface9 } from "readline";
 // src/commands/sessions/shared/discoverSessions.ts
 import * as fs32 from "fs";
 import * as os from "os";
-import * as path51 from "path";
+import * as path52 from "path";
 
 // src/commands/sessions/shared/parseSessionFile.ts
 import * as fs31 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 
 // src/commands/sessions/shared/deriveHistoryFields.ts
 var KNOWN = [
@@ -23650,10 +23729,10 @@ async function readHeadLines(handle) {
 }
 function deriveProject(cwd, filePath, origin) {
   if (!cwd) return dirNameToProject(filePath);
-  return origin === "windows" ? path50.win32.basename(cwd) : path50.basename(cwd);
+  return origin === "windows" ? path51.win32.basename(cwd) : path51.basename(cwd);
 }
 function dirNameToProject(filePath) {
-  const dirName = path50.basename(path50.dirname(filePath));
+  const dirName = path51.basename(path51.dirname(filePath));
   const parts = dirName.split("--");
   return parts[parts.length - 1].replace(/-/g, "/");
 }
@@ -23661,7 +23740,7 @@ function dirNameToProject(filePath) {
 // src/commands/sessions/shared/discoverSessions.ts
 function sessionRoots() {
   const roots = [
-    { dir: path51.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
+    { dir: path52.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
   ];
   const windowsRoot = loadConfig().sessions?.windowsProjectsRoot;
   if (windowsRoot) roots.push({ dir: windowsRoot, origin: "windows" });
@@ -23679,7 +23758,7 @@ async function discoverSessionJsonlPaths() {
       }
       await Promise.all(
         projectDirs.map(async (dirName) => {
-          const dirPath = path51.join(dir, dirName);
+          const dirPath = path52.join(dir, dirName);
           let entries;
           try {
             entries = await fs32.promises.readdir(dirPath);
@@ -23688,7 +23767,7 @@ async function discoverSessionJsonlPaths() {
           }
           for (const file of entries) {
             if (file.endsWith(".jsonl"))
-              results.push({ path: path51.join(dirPath, file), origin });
+              results.push({ path: path52.join(dirPath, file), origin });
           }
         })
       );
@@ -23763,11 +23842,11 @@ function cleanUserText(value) {
 }
 
 // src/commands/sessions/shared/findSessionJsonlPath.ts
-import * as path52 from "path";
+import * as path53 from "path";
 async function findSessionJsonlPath(sessionId) {
   const paths = await discoverSessionJsonlPaths();
   const direct = paths.find(
-    (p) => path52.basename(p.path, ".jsonl") === sessionId
+    (p) => path53.basename(p.path, ".jsonl") === sessionId
   );
   if (direct) return direct.path;
   for (const p of paths) {
@@ -24461,16 +24540,16 @@ async function statusLine() {
 // src/commands/sync.ts
 import * as fs39 from "fs";
 import * as os2 from "os";
-import * as path55 from "path";
+import * as path56 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs37 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 import chalk196 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path53.join(claudeDir, "CLAUDE.md");
-  const target = path53.join(targetBase, "CLAUDE.md");
+  const source = path54.join(claudeDir, "CLAUDE.md");
+  const target = path54.join(targetBase, "CLAUDE.md");
   const sourceContent = fs37.readFileSync(source, "utf8");
   if (fs37.existsSync(target)) {
     const targetContent = fs37.readFileSync(target, "utf8");
@@ -24496,11 +24575,11 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 
 // src/commands/sync/syncSettings.ts
 import * as fs38 from "fs";
-import * as path54 from "path";
+import * as path55 from "path";
 import chalk197 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path54.join(claudeDir, "settings.json");
-  const target = path54.join(targetBase, "settings.json");
+  const source = path55.join(claudeDir, "settings.json");
+  const target = path55.join(targetBase, "settings.json");
   const sourceContent = fs38.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs38.existsSync(target);
@@ -24539,23 +24618,23 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname6 = path55.dirname(__filename4);
+var __dirname6 = path56.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path55.join(__dirname6, "..", "claude");
-  const targetBase = path55.join(os2.homedir(), ".claude");
+  const claudeDir = path56.join(__dirname6, "..", "claude");
+  const targetBase = path56.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path55.join(claudeDir, "commands");
-  const targetDir = path55.join(targetBase, "commands");
+  const sourceDir = path56.join(claudeDir, "commands");
+  const targetDir = path56.join(targetBase, "commands");
   fs39.mkdirSync(targetDir, { recursive: true });
   const files = fs39.readdirSync(sourceDir);
   for (const file of files) {
-    fs39.copyFileSync(path55.join(sourceDir, file), path55.join(targetDir, file));
+    fs39.copyFileSync(path56.join(sourceDir, file), path56.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -24563,7 +24642,7 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync55 } from "child_process";
-import * as path56 from "path";
+import * as path57 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -24582,12 +24661,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path56.resolve(dir);
-    if (resolved.split(path56.sep).includes("node_modules")) {
+    const resolved = path57.resolve(dir);
+    if (resolved.split(path57.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync55("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path56.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path57.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }