@staff0rd/assist 0.288.1 → 0.288.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.288.1",
+  version: "0.288.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -124,10 +124,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path54) {
-  if (!existsSync(path54)) return {};
+function loadRawYaml(path56) {
+  if (!existsSync(path56)) return {};
   try {
-    const content = readFileSync(path54, "utf-8");
+    const content = readFileSync(path56, "utf-8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -3110,9 +3110,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path54 = join11(dir, ".assist", name);
-    if (existsSync15(path54)) {
-      renameSync(path54, `${path54}.bak`);
+    const path56 = join11(dir, ".assist", name);
+    if (existsSync15(path56)) {
+      renameSync(path56, `${path56}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -3402,8 +3402,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path54) {
-  const content = readFileSync10(path54, "utf-8").trim();
+function parseBacklogJsonl(path56) {
+  const content = readFileSync10(path56, "utf-8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -3478,8 +3478,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path54) {
-  return path54.replace(/^\/+/, "");
+function stripLeadingSlashes(path56) {
+  return path56.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -3746,13 +3746,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path54 = activityPath(sessionId);
-  mkdirSync6(dirname14(path54), { recursive: true });
-  writeFileSync13(path54, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path56 = activityPath(sessionId);
+  mkdirSync6(dirname14(path56), { recursive: true });
+  writeFileSync13(path56, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path54) {
+function readActivity(path56) {
   try {
-    return JSON.parse(readFileSync11(path54, "utf-8"));
+    return JSON.parse(readFileSync11(path56, "utf-8"));
   } catch {
     return void 0;
   }
@@ -3912,10 +3912,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path54 = getSignalPath();
-  if (!existsSync19(path54)) return void 0;
+  const path56 = getSignalPath();
+  if (!existsSync19(path56)) return void 0;
   try {
-    return JSON.parse(readFileSync12(path54, "utf-8"));
+    return JSON.parse(readFileSync12(path56, "utf-8"));
   } catch {
     return void 0;
   }
@@ -6254,8 +6254,8 @@ import chalk57 from "chalk";
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path54 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path54.split("/").filter(Boolean);
+    const path56 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path56.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -7558,9 +7558,9 @@ var __dirname5 = dirname17(__filename3);
 function packageRoot() {
   return __dirname5;
 }
-function readLines(path54) {
-  if (!existsSync22(path54)) return [];
-  return readFileSync16(path54, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path56) {
+  if (!existsSync22(path56)) return [];
+  return readFileSync16(path56, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -8025,14 +8025,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, path54, description, depth, p) {
-  showProgress(p, path54.join(" "));
-  const subHelp = await runHelp([cli, ...path54]);
+async function resolveCommand(cli, path56, description, depth, p) {
+  showProgress(p, path56.join(" "));
+  const subHelp = await runHelp([cli, ...path56]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path54, description }];
+    return [{ path: path56, description }];
   }
-  const children = await discoverAt(cli, path54, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path54, description }];
+  const children = await discoverAt(cli, path56, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path56, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -8180,9 +8180,9 @@ function logPath(cli) {
   return join22(homedir9(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path54 = logPath(cli);
-  if (!existsSync24(path54)) return void 0;
-  return readFileSync18(path54, "utf-8");
+  const path56 = logPath(cli);
+  if (!existsSync24(path56)) return void 0;
+  return readFileSync18(path56, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join22(homedir9(), ".assist");
@@ -8871,8 +8871,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path54, value) {
-  const keys = path54.split(".");
+function setNestedValue(obj, path56, value) {
+  const keys = path56.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -8952,9 +8952,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path54) {
+function getNestedValue(obj, path56) {
   let current = obj;
-  for (const key of path54.split(".")) current = stepInto(current, key);
+  for (const key of path56.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -10742,10 +10742,10 @@ function getStorePath(filename) {
   return join32(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path54 = getStorePath(filename);
-  if (existsSync33(path54)) {
+  const path56 = getStorePath(filename);
+  if (existsSync33(path56)) {
     try {
-      return JSON.parse(readFileSync27(path54, "utf-8"));
+      return JSON.parse(readFileSync27(path56, "utf-8"));
     } catch {
       return {};
     }
@@ -11203,15 +11203,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path54, line, body, startLine) {
+function comment2(path56, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path54, line, startLine });
+    postComment({ prId, body, path: path56, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path54}:${range}`);
+    console.log(`Added review comment on ${path56}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -11953,8 +11953,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path54, line, body) => {
-    comment2(path54, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path56, line, body) => {
+    comment2(path56, Number.parseInt(line, 10), body);
   });
 }
 
@@ -12206,10 +12206,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path54) {
+async function ravenFetch(connection, path56) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path54}`;
+  const url = `${connection.url}${path56}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -12299,16 +12299,16 @@ import chalk132 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path54;
+  let path56;
   if (opts.collection) {
-    path54 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path56 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path54 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path56 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path54 += `&query=${encodeURIComponent(opts.query)}`;
+    path56 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path54;
+  return path56;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -12317,7 +12317,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 path54 = buildQueryPath({
+    const path56 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -12325,7 +12325,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path54);
+    const data = await ravenFetch(connection, path56);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -13329,99 +13329,130 @@ function ignore(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import path34 from "path";
+import fs23 from "fs";
+import path38 from "path";
+import chalk141 from "chalk";
+
+// src/commands/refactor/rename/applyRename.ts
+import fs22 from "fs";
+import path35 from "path";
 import chalk139 from "chalk";
-async function rename(source, destination, options2 = {}) {
-  const destPath = path34.resolve(destination);
-  const cwd = process.cwd();
-  const relSource = path34.relative(cwd, path34.resolve(source));
-  const relDest = path34.relative(cwd, destPath);
-  const { project, sourceFile } = loadProjectFile(source);
-  console.log(chalk139.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  if (options2.apply) {
-    sourceFile.move(destPath);
-    await project.save();
-    console.log(chalk139.green("Done"));
-  } else {
-    console.log(chalk139.dim("Dry run. Use --apply to execute."));
-  }
-}
 
-// src/commands/refactor/renameSymbol/index.ts
-import chalk140 from "chalk";
+// src/commands/refactor/restructure/computeRewrites/index.ts
+import path34 from "path";
 
-// src/commands/refactor/renameSymbol/findSymbol.ts
-import { SyntaxKind as SyntaxKind14 } from "ts-morph";
-var declarationKinds = [
-  SyntaxKind14.VariableDeclaration,
-  SyntaxKind14.FunctionDeclaration,
-  SyntaxKind14.ClassDeclaration,
-  SyntaxKind14.InterfaceDeclaration,
-  SyntaxKind14.TypeAliasDeclaration,
-  SyntaxKind14.EnumDeclaration,
-  SyntaxKind14.PropertyDeclaration,
-  SyntaxKind14.MethodDeclaration,
-  SyntaxKind14.Parameter
-];
-function isDeclaration(identifier) {
-  const parent = identifier.getParent();
-  return parent !== void 0 && declarationKinds.includes(parent.getKind());
+// src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
+import fs21 from "fs";
+function getOrCreateList(map, key) {
+  const list4 = map.get(key) ?? [];
+  if (!map.has(key)) map.set(key, list4);
+  return list4;
 }
-function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
-    if (id.getText() === symbolName && isDeclaration(id)) return id;
+function groupByFile2(rewrites) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const rewrite of rewrites) {
+    getOrCreateList(grouped, rewrite.file).push(rewrite);
   }
-  return void 0;
+  return grouped;
+}
+function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
+  const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
+  return content.replace(pattern2, `$1${newSpecifier}$2`);
+}
+function applyFileRewrites(file, fileRewrites) {
+  let content = fs21.readFileSync(file, "utf-8");
+  for (const { oldSpecifier, newSpecifier } of fileRewrites) {
+    content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
+  }
+  return content;
+}
+function applyRewrites(rewrites) {
+  const updatedContents = /* @__PURE__ */ new Map();
+  for (const [file, fileRewrites] of groupByFile2(rewrites)) {
+    updatedContents.set(file, applyFileRewrites(file, fileRewrites));
+  }
+  return updatedContents;
 }
 
-// src/commands/refactor/renameSymbol/groupReferences.ts
-import path35 from "path";
-function groupReferences(symbol, cwd) {
-  const refs = symbol.findReferencesAsNodes();
-  const grouped = /* @__PURE__ */ new Map();
-  for (const ref of refs) {
-    const refFile = path35.relative(cwd, ref.getSourceFile().getFilePath());
-    const lines = grouped.get(refFile) ?? [];
-    if (!grouped.has(refFile)) grouped.set(refFile, lines);
-    lines.push(ref.getStartLineNumber());
+// src/commands/refactor/restructure/computeRewrites/index.ts
+function buildMoveMap(moves) {
+  const map = /* @__PURE__ */ new Map();
+  for (const move of moves) map.set(move.from, move.to);
+  return map;
+}
+function stripTrailingIndex(specifier) {
+  return specifier.endsWith("/index") ? specifier.slice(0, -"/index".length) : specifier;
+}
+function ensureRelative(specifier) {
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function normalizeSpecifier(rel) {
+  return ensureRelative(
+    stripTrailingIndex(rel.replace(/\\/g, "/").replace(/\.tsx?$/, ""))
+  );
+}
+function computeSpecifier(fromFile, toFile) {
+  return normalizeSpecifier(path34.relative(path34.dirname(fromFile), toFile));
+}
+function isAffected(edge, moveMap) {
+  return moveMap.has(edge.target) || moveMap.has(edge.source);
+}
+function resolveTarget(edge, moveMap) {
+  return moveMap.get(edge.target) ?? edge.target;
+}
+function createRewrite(edge, newSpecifier) {
+  return { file: edge.source, oldSpecifier: edge.specifier, newSpecifier };
+}
+function rewriteIfChanged(edge, newSpecifier) {
+  return newSpecifier === edge.specifier ? null : createRewrite(edge, newSpecifier);
+}
+function rewriteEdge(edge, newFile, moveMap) {
+  if (!isAffected(edge, moveMap)) return null;
+  return rewriteIfChanged(
+    edge,
+    computeSpecifier(newFile, resolveTarget(edge, moveMap))
+  );
+}
+function fileEdges(edges, file) {
+  return edges.filter((e) => e.source === file);
+}
+function collectRewrites(edges, newFile, moveMap) {
+  const rewrites = [];
+  for (const edge of edges) {
+    const rewrite = rewriteEdge(edge, newFile, moveMap);
+    if (rewrite) rewrites.push(rewrite);
   }
-  return grouped;
+  return rewrites;
+}
+function rewriteEdgesForFile(file, edges, moveMap) {
+  const newFile = moveMap.get(file) ?? file;
+  return collectRewrites(fileEdges(edges, file), newFile, moveMap);
+}
+function computeRewrites(moves, edges, allProjectFiles) {
+  const moveMap = buildMoveMap(moves);
+  return [...allProjectFiles].flatMap(
+    (file) => rewriteEdgesForFile(file, edges, moveMap)
+  );
 }
 
-// src/commands/refactor/renameSymbol/index.ts
-async function renameSymbol(file, oldName, newName, options2 = {}) {
-  const cwd = process.cwd();
-  const { project, sourceFile } = loadProjectFile(file);
-  const symbol = findSymbol(sourceFile, oldName);
-  if (!symbol) {
-    console.log(chalk140.red(`Symbol "${oldName}" not found in ${file}`));
-    process.exit(1);
+// src/commands/refactor/rename/applyRename.ts
+function applyRename(rewrites, sourcePath, destPath, cwd) {
+  const updatedContents = applyRewrites(rewrites);
+  for (const [file, content] of updatedContents) {
+    fs22.writeFileSync(file, content, "utf-8");
+    console.log(chalk139.cyan(`  Updated imports in ${path35.relative(cwd, file)}`));
   }
-  const grouped = groupReferences(symbol, cwd);
-  const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
+  const destDir = path35.dirname(destPath);
+  if (!fs22.existsSync(destDir)) fs22.mkdirSync(destDir, { recursive: true });
+  fs22.renameSync(sourcePath, destPath);
   console.log(
-    chalk140.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
-`)
+    chalk139.white(
+      `  Moved ${path35.relative(cwd, sourcePath)} \u2192 ${path35.relative(cwd, destPath)}`
+    )
   );
-  for (const [refFile, lines] of grouped) {
-    console.log(
-      `  ${chalk140.dim(refFile)}: lines ${chalk140.cyan(lines.join(", "))}`
-    );
-  }
-  if (options2.apply) {
-    symbol.rename(newName);
-    await project.save();
-    console.log(chalk140.green(`
-Renamed ${oldName} \u2192 ${newName}`));
-  } else {
-    console.log(chalk140.dim("\nDry run. Use --apply to execute."));
-  }
 }
 
-// src/commands/refactor/restructure/index.ts
-import path44 from "path";
-import chalk143 from "chalk";
-
 // src/commands/refactor/restructure/buildImportGraph/index.ts
 import path36 from "path";
 import ts7 from "typescript";
@@ -13488,13 +13519,148 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   return { files: candidateFiles, edges, importedBy, imports };
 }
 
-// src/commands/refactor/restructure/clusterDirectories.ts
+// src/commands/refactor/rename/computeRenameRewrites.ts
+function computeRenameRewrites(sourcePath, destPath) {
+  const tsConfigPath = findTsConfig(sourcePath);
+  const graph = buildImportGraph(/* @__PURE__ */ new Set([sourcePath]), tsConfigPath);
+  const allProjectFiles = /* @__PURE__ */ new Set([
+    ...graph.importedBy.keys(),
+    ...graph.imports.keys(),
+    sourcePath
+  ]);
+  const move = { from: sourcePath, to: destPath, reason: "rename" };
+  return computeRewrites([move], graph.edges, allProjectFiles);
+}
+
+// src/commands/refactor/rename/printRenamePreview.ts
 import path37 from "path";
+import chalk140 from "chalk";
+function printRenamePreview(rewrites, cwd) {
+  for (const rewrite of rewrites) {
+    console.log(
+      chalk140.dim(
+        `  ${path37.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+      )
+    );
+  }
+  console.log(chalk140.dim("Dry run. Use --apply to execute."));
+}
+
+// src/commands/refactor/rename/index.ts
+async function rename(source, destination, options2 = {}) {
+  const sourcePath = path38.resolve(source);
+  const destPath = path38.resolve(destination);
+  const cwd = process.cwd();
+  const relSource = path38.relative(cwd, sourcePath);
+  const relDest = path38.relative(cwd, destPath);
+  if (!fs23.existsSync(sourcePath)) {
+    console.log(chalk141.red(`File not found: ${source}`));
+    process.exit(1);
+  }
+  if (destPath !== sourcePath && fs23.existsSync(destPath)) {
+    console.log(chalk141.red(`Destination already exists: ${destination}`));
+    process.exit(1);
+  }
+  console.log(chalk141.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk141.dim("Loading project..."));
+  console.log(chalk141.dim("Scanning imports across the project..."));
+  const rewrites = computeRenameRewrites(sourcePath, destPath);
+  const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
+  console.log(
+    chalk141.dim(
+      `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
+    )
+  );
+  if (!options2.apply) {
+    printRenamePreview(rewrites, cwd);
+    return;
+  }
+  applyRename(rewrites, sourcePath, destPath, cwd);
+  console.log(chalk141.green("Done"));
+}
+
+// src/commands/refactor/renameSymbol/index.ts
+import chalk142 from "chalk";
+
+// src/commands/refactor/renameSymbol/findSymbol.ts
+import { SyntaxKind as SyntaxKind14 } from "ts-morph";
+var declarationKinds = [
+  SyntaxKind14.VariableDeclaration,
+  SyntaxKind14.FunctionDeclaration,
+  SyntaxKind14.ClassDeclaration,
+  SyntaxKind14.InterfaceDeclaration,
+  SyntaxKind14.TypeAliasDeclaration,
+  SyntaxKind14.EnumDeclaration,
+  SyntaxKind14.PropertyDeclaration,
+  SyntaxKind14.MethodDeclaration,
+  SyntaxKind14.Parameter
+];
+function isDeclaration(identifier) {
+  const parent = identifier.getParent();
+  return parent !== void 0 && declarationKinds.includes(parent.getKind());
+}
+function findSymbol(sourceFile, symbolName) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
+    if (id.getText() === symbolName && isDeclaration(id)) return id;
+  }
+  return void 0;
+}
+
+// src/commands/refactor/renameSymbol/groupReferences.ts
+import path39 from "path";
+function groupReferences(symbol, cwd) {
+  const refs = symbol.findReferencesAsNodes();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const refFile = path39.relative(cwd, ref.getSourceFile().getFilePath());
+    const lines = grouped.get(refFile) ?? [];
+    if (!grouped.has(refFile)) grouped.set(refFile, lines);
+    lines.push(ref.getStartLineNumber());
+  }
+  return grouped;
+}
+
+// src/commands/refactor/renameSymbol/index.ts
+async function renameSymbol(file, oldName, newName, options2 = {}) {
+  const cwd = process.cwd();
+  const { project, sourceFile } = loadProjectFile(file);
+  const symbol = findSymbol(sourceFile, oldName);
+  if (!symbol) {
+    console.log(chalk142.red(`Symbol "${oldName}" not found in ${file}`));
+    process.exit(1);
+  }
+  const grouped = groupReferences(symbol, cwd);
+  const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
+  console.log(
+    chalk142.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+`)
+  );
+  for (const [refFile, lines] of grouped) {
+    console.log(
+      `  ${chalk142.dim(refFile)}: lines ${chalk142.cyan(lines.join(", "))}`
+    );
+  }
+  if (options2.apply) {
+    symbol.rename(newName);
+    await project.save();
+    console.log(chalk142.green(`
+Renamed ${oldName} \u2192 ${newName}`));
+  } else {
+    console.log(chalk142.dim("\nDry run. Use --apply to execute."));
+  }
+}
+
+// src/commands/refactor/restructure/index.ts
+import path46 from "path";
+import chalk145 from "chalk";
+
+// src/commands/refactor/restructure/clusterDirectories.ts
+import path40 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path37.dirname(edge.source);
-    const targetDir = path37.dirname(edge.target);
+    const sourceDir = path40.dirname(edge.source);
+    const targetDir = path40.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -13522,20 +13688,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path37.relative(ancestor, descendant);
+  const rel = path40.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path38 from "path";
+import path41 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 = path38.dirname(parent);
-  const fileDir = path38.dirname(file);
+  const parentDir = path41.dirname(parent);
+  const fileDir = path41.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path38.basename(parent, path38.extname(parent)) === "index") return file;
+  if (path41.basename(parent, path41.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -13543,16 +13709,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename12 = path38.basename(file, path38.extname(file));
+    const basename12 = path41.basename(file, path41.extname(file));
     if (basename12 === "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 = path38.dirname(parent);
-    const fileDir = path38.dirname(file);
+    const parentDir = path41.dirname(parent);
+    const fileDir = path41.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path38.basename(parent, path38.extname(parent));
+    const parentBasename = path41.basename(parent, path41.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -13563,150 +13729,52 @@ function clusterFiles(graph) {
   return clusters;
 }
 
-// src/commands/refactor/restructure/computeRewrites/index.ts
-import path39 from "path";
-
-// src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs21 from "fs";
-function getOrCreateList(map, key) {
-  const list4 = map.get(key) ?? [];
-  if (!map.has(key)) map.set(key, list4);
-  return list4;
-}
-function groupByFile2(rewrites) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const rewrite of rewrites) {
-    getOrCreateList(grouped, rewrite.file).push(rewrite);
-  }
-  return grouped;
-}
-function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
-  const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
-  return content.replace(pattern2, `$1${newSpecifier}$2`);
-}
-function applyFileRewrites(file, fileRewrites) {
-  let content = fs21.readFileSync(file, "utf-8");
-  for (const { oldSpecifier, newSpecifier } of fileRewrites) {
-    content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
-  }
-  return content;
-}
-function applyRewrites(rewrites) {
-  const updatedContents = /* @__PURE__ */ new Map();
-  for (const [file, fileRewrites] of groupByFile2(rewrites)) {
-    updatedContents.set(file, applyFileRewrites(file, fileRewrites));
-  }
-  return updatedContents;
-}
-
-// src/commands/refactor/restructure/computeRewrites/index.ts
-function buildMoveMap(moves) {
-  const map = /* @__PURE__ */ new Map();
-  for (const move of moves) map.set(move.from, move.to);
-  return map;
-}
-function stripTrailingIndex(specifier) {
-  return specifier.endsWith("/index") ? specifier.slice(0, -"/index".length) : specifier;
-}
-function ensureRelative(specifier) {
-  return specifier.startsWith(".") ? specifier : `./${specifier}`;
-}
-function normalizeSpecifier(rel) {
-  return ensureRelative(
-    stripTrailingIndex(rel.replace(/\\/g, "/").replace(/\.tsx?$/, ""))
-  );
-}
-function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path39.relative(path39.dirname(fromFile), toFile));
-}
-function isAffected(edge, moveMap) {
-  return moveMap.has(edge.target) || moveMap.has(edge.source);
-}
-function resolveTarget(edge, moveMap) {
-  return moveMap.get(edge.target) ?? edge.target;
-}
-function createRewrite(edge, newSpecifier) {
-  return { file: edge.source, oldSpecifier: edge.specifier, newSpecifier };
-}
-function rewriteIfChanged(edge, newSpecifier) {
-  return newSpecifier === edge.specifier ? null : createRewrite(edge, newSpecifier);
-}
-function rewriteEdge(edge, newFile, moveMap) {
-  if (!isAffected(edge, moveMap)) return null;
-  return rewriteIfChanged(
-    edge,
-    computeSpecifier(newFile, resolveTarget(edge, moveMap))
-  );
-}
-function fileEdges(edges, file) {
-  return edges.filter((e) => e.source === file);
-}
-function collectRewrites(edges, newFile, moveMap) {
-  const rewrites = [];
-  for (const edge of edges) {
-    const rewrite = rewriteEdge(edge, newFile, moveMap);
-    if (rewrite) rewrites.push(rewrite);
-  }
-  return rewrites;
-}
-function rewriteEdgesForFile(file, edges, moveMap) {
-  const newFile = moveMap.get(file) ?? file;
-  return collectRewrites(fileEdges(edges, file), newFile, moveMap);
-}
-function computeRewrites(moves, edges, allProjectFiles) {
-  const moveMap = buildMoveMap(moves);
-  return [...allProjectFiles].flatMap(
-    (file) => rewriteEdgesForFile(file, edges, moveMap)
-  );
-}
-
 // src/commands/refactor/restructure/displayPlan.ts
-import path40 from "path";
-import chalk141 from "chalk";
+import path42 from "path";
+import chalk143 from "chalk";
 function relPath(filePath) {
-  return path40.relative(process.cwd(), filePath);
+  return path42.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk141.bold("\nFile moves:"));
+  console.log(chalk143.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk141.red(relPath(move.from))} \u2192 ${chalk141.green(relPath(move.to))}`
+      `  ${chalk143.red(relPath(move.from))} \u2192 ${chalk143.green(relPath(move.to))}`
     );
-    console.log(chalk141.dim(`    ${move.reason}`));
+    console.log(chalk143.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk141.bold(`
+  console.log(chalk143.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk141.cyan(relPath(file))}:`);
+    console.log(`  ${chalk143.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk141.red(`"${oldSpecifier}"`)} \u2192 ${chalk141.green(`"${newSpecifier}"`)}`
+        `    ${chalk143.red(`"${oldSpecifier}"`)} \u2192 ${chalk143.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk141.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk141.yellow(`  ${w}`));
+    console.log(chalk143.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk143.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk141.bold("\nNew directories:"));
+    console.log(chalk143.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk141.green(`  ${dir}/`));
+      console.log(chalk143.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk141.dim(
+    chalk143.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -13714,45 +13782,45 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs22 from "fs";
-import path41 from "path";
-import chalk142 from "chalk";
+import fs24 from "fs";
+import path43 from "path";
+import chalk144 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs22.writeFileSync(file, content, "utf-8");
+    fs24.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk142.cyan(`  Rewrote imports in ${path41.relative(process.cwd(), file)}`)
+      chalk144.cyan(`  Rewrote imports in ${path43.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs22.mkdirSync(dir, { recursive: true });
-    console.log(chalk142.green(`  Created ${path41.relative(process.cwd(), dir)}/`));
+    fs24.mkdirSync(dir, { recursive: true });
+    console.log(chalk144.green(`  Created ${path43.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
-    const targetDir = path41.dirname(move.to);
-    if (!fs22.existsSync(targetDir)) {
-      fs22.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path43.dirname(move.to);
+    if (!fs24.existsSync(targetDir)) {
+      fs24.mkdirSync(targetDir, { recursive: true });
     }
-    fs22.renameSync(move.from, move.to);
+    fs24.renameSync(move.from, move.to);
     console.log(
-      chalk142.white(
-        `  Moved ${path41.relative(process.cwd(), move.from)} \u2192 ${path41.relative(process.cwd(), move.to)}`
+      chalk144.white(
+        `  Moved ${path43.relative(process.cwd(), move.from)} \u2192 ${path43.relative(process.cwd(), move.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path41.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path43.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs22.existsSync(dir)) continue;
-    const entries = fs22.readdirSync(dir);
+    if (!fs24.existsSync(dir)) continue;
+    const entries = fs24.readdirSync(dir);
     if (entries.length === 0) {
-      fs22.rmdirSync(dir);
+      fs24.rmdirSync(dir);
       console.log(
-        chalk142.dim(
-          `  Removed empty directory ${path41.relative(process.cwd(), dir)}`
+        chalk144.dim(
+          `  Removed empty directory ${path43.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -13760,46 +13828,46 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path43 from "path";
+import path45 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs23 from "fs";
+import fs25 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs23.existsSync(dir)) return false;
+  if (!fs25.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs24 from "fs";
-import path42 from "path";
+import fs26 from "fs";
+import path44 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path42.join(dir, entry.name);
+  const full = path44.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs24.existsSync(dir)) return [];
+  if (!fs26.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs26.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path42.relative(childDir, file);
-    moves.push({ from: file, to: path42.join(newLocation, rel), reason });
+    const rel = path44.relative(childDir, file);
+    moves.push({ from: file, to: path44.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path42.join(parentDir, path42.basename(childDir));
+  return path44.join(parentDir, path44.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path42.basename(parentDir)}/`;
+  return `Directory only imported from ${path44.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -13824,7 +13892,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path43.join(newDir, path43.basename(child));
+  const to = path45.join(newDir, path45.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -13832,15 +13900,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path43.basename(filePath, path43.extname(filePath));
+  return path45.basename(filePath, path45.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path43.join(path43.dirname(parent), getBaseName(parent));
+  return path45.join(path45.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path43.join(newDir, `index${path43.extname(parent)}`),
+    to: path45.join(newDir, `index${path45.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -13864,7 +13932,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path44.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path46.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -13884,22 +13952,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk143.yellow("No files found matching pattern"));
+    console.log(chalk145.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path44.resolve("tsconfig.json");
+  const tsConfigPath = path46.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk143.green("No restructuring needed"));
+    console.log(chalk145.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk143.bold("\nApplying changes..."));
+    console.log(chalk145.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk143.green("\nRestructuring complete"));
+    console.log(chalk145.green("\nRestructuring complete"));
   } else {
-    console.log(chalk143.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk145.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -14468,18 +14536,18 @@ function partitionFindingsByDiff(findings, index2) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk144 from "chalk";
+import chalk146 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk144.yellow(
+    chalk146.yellow(
       `Skipped ${outOfDiff.length} finding(s) whose lines fall outside the PR diff (GitHub would silently drop these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk144.yellow("\xB7")} ${finding.title} ${chalk144.dim(
+      `  ${chalk146.yellow("\xB7")} ${finding.title} ${chalk146.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -14498,18 +14566,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk145 from "chalk";
+import chalk147 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk145.yellow(
+    chalk147.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk145.dim("missing");
+    const where = finding.location || chalk147.dim("missing");
     console.warn(
-      `  ${chalk145.yellow("\xB7")} ${finding.title} ${chalk145.dim(`(${where})`)}`
+      `  ${chalk147.yellow("\xB7")} ${finding.title} ${chalk147.dim(`(${where})`)}`
     );
   }
 }
@@ -14606,8 +14674,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync36, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync26 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path54 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync36(path54)) unlinkSync12(path54);
+  for (const path56 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync36(path56)) unlinkSync12(path56);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -15682,7 +15750,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk147 from "chalk";
+import chalk149 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -15711,10 +15779,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk146 from "chalk";
+import chalk148 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk146.red(`Connection "${name}" already exists.`));
+    console.error(chalk148.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -15732,18 +15800,18 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk147.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk149.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk151 from "chalk";
+import chalk153 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk148 from "chalk";
-async function fetchSeq(conn, path54, params) {
-  const url = `${conn.url}${path54}?${params}`;
+import chalk150 from "chalk";
+async function fetchSeq(conn, path56, params) {
+  const url = `${conn.url}${path56}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -15752,7 +15820,7 @@ async function fetchSeq(conn, path54, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk148.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk150.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -15807,23 +15875,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk149 from "chalk";
+import chalk151 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk149.bgRed.white;
+      return chalk151.bgRed.white;
     case "Error":
-      return chalk149.red;
+      return chalk151.red;
     case "Warning":
-      return chalk149.yellow;
+      return chalk151.yellow;
     case "Information":
-      return chalk149.cyan;
+      return chalk151.cyan;
     case "Debug":
-      return chalk149.gray;
+      return chalk151.gray;
     case "Verbose":
-      return chalk149.dim;
+      return chalk151.dim;
     default:
-      return chalk149.white;
+      return chalk151.white;
   }
 }
 function levelAbbrev(level) {
@@ -15864,12 +15932,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk149.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk151.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk149.red(`  ${line}`));
+      lines.push(chalk151.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -15902,11 +15970,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk150 from "chalk";
+import chalk152 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk150.red(
+      chalk152.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -15915,7 +15983,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk150.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk152.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -15944,7 +16012,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk151.yellow("No events found."));
+    console.log(chalk153.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -15955,11 +16023,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk151.dim(`
+  console.log(chalk153.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk151.yellow(
+      chalk153.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -15967,10 +16035,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk152 from "chalk";
+import chalk154 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk152.red(`Connection "${name}" not found.`));
+    console.error(chalk154.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -16018,7 +16086,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk154 from "chalk";
+import chalk156 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -16047,7 +16115,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk153 from "chalk";
+import chalk155 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -16055,7 +16123,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk153.red(`Invalid port "${portStr}".`));
+    console.error(chalk155.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -16068,13 +16136,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk154.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk156.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk155 from "chalk";
+import chalk157 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -16083,7 +16151,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk155.yellow("(no rows)"));
+    console.log(chalk157.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -16091,13 +16159,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk155.dim(header));
-  console.log(chalk155.dim("-".repeat(header.length)));
+  console.log(chalk157.dim(header));
+  console.log(chalk157.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk155.dim(`
+  console.log(chalk157.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -16157,7 +16225,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk156 from "chalk";
+import chalk158 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -16191,7 +16259,7 @@ function isMutation(sql4) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk156.red(
+      chalk158.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -16201,18 +16269,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk156.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk158.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk157 from "chalk";
+import chalk159 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk157.red(
+      chalk159.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -16227,7 +16295,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk157.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk159.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -16807,14 +16875,14 @@ import {
 import { dirname as dirname22, join as join42 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk158 from "chalk";
+import chalk160 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk158.red(
+      chalk160.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -16823,7 +16891,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk158.red(
+      chalk160.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -17220,7 +17288,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk159 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer2 } from "http";
@@ -17351,13 +17419,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk159.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk161.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk159.white("http://localhost:14523/callback\n"));
-  console.log(chalk159.blue("Opening browser for authorization..."));
-  console.log(chalk159.dim("Waiting for authorization callback..."));
+  console.log(chalk161.white("http://localhost:14523/callback\n"));
+  console.log(chalk161.blue("Opening browser for authorization..."));
+  console.log(chalk161.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk159.dim("Exchanging code for tokens..."));
+  console.log(chalk161.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -17373,7 +17441,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk159.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk161.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -17389,9 +17457,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path54 = join49(roamDir, name);
+    const path56 = join49(roamDir, name);
     try {
-      return { path: path54, mtimeMs: statSync5(path54).mtimeMs };
+      return { path: path56, mtimeMs: statSync5(path56).mtimeMs };
     } catch {
       return void 0;
     }
@@ -17734,11 +17802,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path54 = process.argv[idx + 1];
+  const path56 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path54, prefix: prefix2 };
+  return { path: path56, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -17825,7 +17893,7 @@ import { execSync as execSync48 } from "child_process";
 import { existsSync as existsSync50, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join53, resolve as resolve13 } from "path";
-import chalk160 from "chalk";
+import chalk162 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -17976,13 +18044,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve13(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk160.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk162.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk160.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk162.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk160.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk162.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -18215,14 +18283,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync51, statSync as statSync6 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path45 from "path";
+import path47 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path45.join(path45.dirname(require4.resolve("node-pty")), "..");
-  const helper = path45.join(
+  const ptyRoot = path47.join(path47.dirname(require4.resolve("node-pty")), "..");
+  const helper = path47.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -18465,8 +18533,8 @@ import { dirname as dirname26 } from "path";
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path54 = activityPath(session.id);
-  const dir = dirname26(path54);
+  const path56 = activityPath(session.id);
+  const dir = dirname26(path56);
   try {
     mkdirSync22(dir, { recursive: true });
   } catch {
@@ -18475,7 +18543,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path54);
+    const activity2 = readActivity(path56);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -18483,11 +18551,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path54.endsWith(filename)) return;
+    if (filename && !path56.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync52(path54)) read();
+  if (existsSync52(path56)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -19007,17 +19075,17 @@ var WindowsProxy = class {
 };
 
 // src/commands/sessions/daemon/watchClaudeSessionId.ts
-import * as fs27 from "fs";
-import * as path48 from "path";
+import * as fs29 from "fs";
+import * as path50 from "path";
 
 // src/commands/sessions/shared/discoverSessions.ts
-import * as fs26 from "fs";
+import * as fs28 from "fs";
 import * as os from "os";
-import * as path47 from "path";
+import * as path49 from "path";
 
 // src/commands/sessions/shared/parseSessionFile.ts
-import * as fs25 from "fs";
-import * as path46 from "path";
+import * as fs27 from "fs";
+import * as path48 from "path";
 
 // src/commands/sessions/shared/deriveHistoryFields.ts
 var KNOWN = ["draft", "next", "bug", "refine", "run"];
@@ -19106,10 +19174,10 @@ function matchMarker(text3, tag) {
 async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
-    handle = await fs25.promises.open(filePath, "r");
+    handle = await fs27.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp = meta.timestamp || (await fs25.promises.stat(filePath)).mtime.toISOString();
+    const timestamp = meta.timestamp || (await fs27.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
@@ -19132,10 +19200,10 @@ async function readHeadLines(handle) {
 }
 function deriveProject(cwd, filePath, origin) {
   if (!cwd) return dirNameToProject(filePath);
-  return origin === "windows" ? path46.win32.basename(cwd) : path46.basename(cwd);
+  return origin === "windows" ? path48.win32.basename(cwd) : path48.basename(cwd);
 }
 function dirNameToProject(filePath) {
-  const dirName = path46.basename(path46.dirname(filePath));
+  const dirName = path48.basename(path48.dirname(filePath));
   const parts = dirName.split("--");
   return parts[parts.length - 1].replace(/-/g, "/");
 }
@@ -19143,7 +19211,7 @@ function dirNameToProject(filePath) {
 // src/commands/sessions/shared/discoverSessions.ts
 function sessionRoots() {
   const roots = [
-    { dir: path47.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
+    { dir: path49.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
   ];
   const windowsRoot = loadConfig().sessions?.windowsProjectsRoot;
   if (windowsRoot) roots.push({ dir: windowsRoot, origin: "windows" });
@@ -19155,22 +19223,22 @@ async function discoverSessionJsonlPaths() {
     sessionRoots().map(async ({ dir, origin }) => {
       let projectDirs;
       try {
-        projectDirs = await fs26.promises.readdir(dir);
+        projectDirs = await fs28.promises.readdir(dir);
       } catch {
         return;
       }
       await Promise.all(
         projectDirs.map(async (dirName) => {
-          const dirPath = path47.join(dir, dirName);
+          const dirPath = path49.join(dir, dirName);
           let entries;
           try {
-            entries = await fs26.promises.readdir(dirPath);
+            entries = await fs28.promises.readdir(dirPath);
           } catch {
             return;
           }
           for (const file of entries) {
             if (file.endsWith(".jsonl"))
-              results.push({ path: path47.join(dirPath, file), origin });
+              results.push({ path: path49.join(dirPath, file), origin });
           }
         })
       );
@@ -19217,7 +19285,7 @@ async function findLatestSessionId(options2) {
     if (createdMs === null) continue;
     const meta = await parseSessionFile(filePath, origin);
     if (!meta?.cwd || options2.isClaimed(meta.sessionId)) continue;
-    if (path48.resolve(meta.cwd) !== path48.resolve(options2.cwd)) continue;
+    if (path50.resolve(meta.cwd) !== path50.resolve(options2.cwd)) continue;
     if (!latest || createdMs > latest.createdMs)
       latest = { sessionId: meta.sessionId, createdMs };
   }
@@ -19225,7 +19293,7 @@ async function findLatestSessionId(options2) {
 }
 async function createdSince(filePath, sinceMs) {
   try {
-    const stat = await fs27.promises.stat(filePath);
+    const stat = await fs29.promises.stat(filePath);
     const createdMs = stat.birthtimeMs || stat.mtimeMs;
     return createdMs >= sinceMs ? createdMs : null;
   } catch {
@@ -19403,7 +19471,7 @@ import * as net3 from "net";
 import { createInterface as createInterface7 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs28 from "fs";
+import * as fs30 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -19451,11 +19519,11 @@ function cleanUserText(value) {
 }
 
 // src/commands/sessions/shared/findSessionJsonlPath.ts
-import * as path49 from "path";
+import * as path51 from "path";
 async function findSessionJsonlPath(sessionId) {
   const paths = await discoverSessionJsonlPaths();
   const direct = paths.find(
-    (p) => path49.basename(p.path, ".jsonl") === sessionId
+    (p) => path51.basename(p.path, ".jsonl") === sessionId
   );
   if (direct) return direct.path;
   for (const p of paths) {
@@ -19470,7 +19538,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs28.promises.readFile(filePath, "utf8");
+    const raw = await fs30.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -19732,17 +19800,17 @@ function registerDaemon(program2) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs31 from "fs";
-import chalk161 from "chalk";
+import * as fs33 from "fs";
+import chalk163 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs29 from "fs";
+import * as fs31 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs29.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs31.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs29.existsSync(summaryPathFor(jsonlPath2));
+  return fs31.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -19752,17 +19820,17 @@ function summaryPathFor(jsonlPath2) {
 import { execFileSync as execFileSync11 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs30 from "fs";
+import * as fs32 from "fs";
 function* iterateUserMessages(filePath, maxBytes = 65536) {
   let content;
   try {
-    const fd = fs30.openSync(filePath, "r");
+    const fd = fs32.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs30.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs32.readSync(fd, buf, 0, buf.length, 0);
       content = buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs30.closeSync(fd);
+      fs32.closeSync(fd);
     }
   } catch {
     return;
@@ -19860,29 +19928,29 @@ ${firstMessage}`);
 async function summarise4(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk161.yellow("No sessions found."));
+    console.log(chalk163.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk161.green("All sessions already summarised."));
+    console.log(chalk163.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk161.cyan(
+    chalk163.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk161.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk161.yellow(`, ${failed2} skipped`) : "")
+    chalk163.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk163.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs31.statSync(b).mtimeMs - fs31.statSync(a).mtimeMs;
+      return fs33.statSync(b).mtimeMs - fs33.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -19895,16 +19963,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk161.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk163.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk161.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk163.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk161.yellow("skip")}
+      process.stdout.write(` ${chalk163.yellow("skip")}
 `);
     }
   }
@@ -19919,10 +19987,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk163 from "chalk";
+import chalk165 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk162 from "chalk";
+import chalk164 from "chalk";
 var FIVE_HOUR_SECONDS = 5 * 3600;
 var SEVEN_DAY_SECONDS = 7 * 86400;
 function formatTimeLeft(resetsAt) {
@@ -19945,10 +20013,10 @@ function projectUsage(pct, resetsAt, windowSeconds) {
 function colorizeRateLimit(pct, resetsAt, windowSeconds) {
   const label2 = `${Math.round(pct)}%`;
   const projected = projectUsage(pct, resetsAt, windowSeconds);
-  if (projected == null) return chalk162.green(label2);
-  if (projected > 100) return chalk162.red(label2);
-  if (projected > 75) return chalk162.yellow(label2);
-  return chalk162.green(label2);
+  if (projected == null) return chalk164.green(label2);
+  if (projected > 100) return chalk164.red(label2);
+  if (projected > 75) return chalk164.yellow(label2);
+  return chalk164.green(label2);
 }
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel) {
   const timeLabel = resetsAt ? formatTimeLeft(resetsAt) : fallbackLabel;
@@ -19974,14 +20042,14 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk163.level = 3;
+chalk165.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk163.red(label2);
-  if (pct > 40) return chalk163.yellow(label2);
+  if (pct > 80) return chalk165.red(label2);
+  if (pct > 40) return chalk165.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -19996,29 +20064,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs34 from "fs";
+import * as fs36 from "fs";
 import * as os2 from "os";
-import * as path52 from "path";
+import * as path54 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs32 from "fs";
-import * as path50 from "path";
-import chalk164 from "chalk";
+import * as fs34 from "fs";
+import * as path52 from "path";
+import chalk166 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path50.join(claudeDir, "CLAUDE.md");
-  const target = path50.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs32.readFileSync(source, "utf-8");
-  if (fs32.existsSync(target)) {
-    const targetContent = fs32.readFileSync(target, "utf-8");
+  const source = path52.join(claudeDir, "CLAUDE.md");
+  const target = path52.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs34.readFileSync(source, "utf-8");
+  if (fs34.existsSync(target)) {
+    const targetContent = fs34.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk164.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk166.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk164.red("Overwrite existing CLAUDE.md?"),
+        chalk166.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -20027,21 +20095,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs32.copyFileSync(source, target);
+  fs34.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs33 from "fs";
-import * as path51 from "path";
-import chalk165 from "chalk";
+import * as fs35 from "fs";
+import * as path53 from "path";
+import chalk167 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path51.join(claudeDir, "settings.json");
-  const target = path51.join(targetBase, "settings.json");
-  const sourceContent = fs33.readFileSync(source, "utf-8");
+  const source = path53.join(claudeDir, "settings.json");
+  const target = path53.join(targetBase, "settings.json");
+  const sourceContent = fs35.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs33.existsSync(target)) {
-    const targetContent = fs33.readFileSync(target, "utf-8");
+  if (fs35.existsSync(target)) {
+    const targetContent = fs35.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -20050,14 +20118,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk165.yellow(
+          chalk167.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk165.red("Overwrite existing settings.json?"),
+          chalk167.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -20067,29 +20135,29 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs33.writeFileSync(target, mergedContent);
+  fs35.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path52.dirname(__filename4);
+var __dirname7 = path54.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path52.join(__dirname7, "..", "claude");
-  const targetBase = path52.join(os2.homedir(), ".claude");
+  const claudeDir = path54.join(__dirname7, "..", "claude");
+  const targetBase = path54.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path52.join(claudeDir, "commands");
-  const targetDir = path52.join(targetBase, "commands");
-  fs34.mkdirSync(targetDir, { recursive: true });
-  const files = fs34.readdirSync(sourceDir);
+  const sourceDir = path54.join(claudeDir, "commands");
+  const targetDir = path54.join(targetBase, "commands");
+  fs36.mkdirSync(targetDir, { recursive: true });
+  const files = fs36.readdirSync(sourceDir);
   for (const file of files) {
-    fs34.copyFileSync(path52.join(sourceDir, file), path52.join(targetDir, file));
+    fs36.copyFileSync(path54.join(sourceDir, file), path54.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -20097,15 +20165,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync49 } from "child_process";
-import * as path53 from "path";
+import * as path55 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path53.resolve(dir);
-    if (resolved.split(path53.sep).includes("node_modules")) {
+    const resolved = path55.resolve(dir);
+    if (resolved.split(path55.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync49("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path53.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path55.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }