ctxloom-pro 1.5.5 → 1.5.6

package/dist/{chunk-5R4P7VEE.js → chunk-FPMNXF4D.js}

@@ -1,10 +1,10 @@
 import {
   VectorStore
-} from "./chunk-R56D54Y7.js";
+} from "./chunk-JULFFD7O.js";
 import {
   collectFiles,
   generateEmbedding
-} from "./chunk-COH5WYZS.js";
+} from "./chunk-WDX4PJGL.js";
 import {
   diskSink,
   readEvents
@@ -2757,12 +2757,12 @@ var DependencyGraph = class {
       symbolIndex: Object.fromEntries(this.symbolIndex.entries())
     };
     const snapshotPath = this.getSnapshotPath();
-    const tmpPath = snapshotPath + ".tmp";
+    const tmpPath = `${snapshotPath}.${process.pid}.tmp`;
     fs6.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
     fs6.renameSync(tmpPath, snapshotPath);
     const callData = this.callGraphIndex.toJSON();
     const callPath = path6.join(this.snapshotDir, "call-graph-snapshot.json");
-    const callTmp = callPath + ".tmp";
+    const callTmp = `${callPath}.${process.pid}.tmp`;
     fs6.writeFileSync(callTmp, JSON.stringify(callData));
     fs6.renameSync(callTmp, callPath);
   }
@@ -3547,8 +3547,8 @@ var CoChangeIndex = class _CoChangeIndex {
     if (event.isBulk || event.isMerge) return;
     const paths = event.files.map((f) => f.path);
     if (paths.length === 0) return;
-    for (const path37 of paths) {
-      this.nodeCounts.set(path37, (this.nodeCounts.get(path37) ?? 0) + 1);
+    for (const path38 of paths) {
+      this.nodeCounts.set(path38, (this.nodeCounts.get(path38) ?? 0) + 1);
     }
     for (let i = 0; i < paths.length; i++) {
       for (let j = i + 1; j < paths.length; j++) {
@@ -3695,8 +3695,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path37, raw] of this.nodes) {
-      nodes[path37] = {
+    for (const [path38, raw] of this.nodes) {
+      nodes[path38] = {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3711,8 +3711,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   static load(s) {
     const idx = new _ChurnIndex();
-    for (const [path37, raw] of Object.entries(s.nodes)) {
-      idx.nodes.set(path37, {
+    for (const [path38, raw] of Object.entries(s.nodes)) {
+      idx.nodes.set(path38, {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3725,8 +3725,8 @@ var ChurnIndex = class _ChurnIndex {
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path37) {
-    const existing = this.nodes.get(path37);
+  getOrCreate(path38) {
+    const existing = this.nodes.get(path38);
     if (existing !== void 0) return existing;
     const fresh = {
       commits: 0,
@@ -3735,7 +3735,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path37, fresh);
+    this.nodes.set(path38, fresh);
     return fresh;
   }
 };
@@ -3816,12 +3816,12 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path37, raw] of this.nodes) {
+    for (const [path38, raw] of this.nodes) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      nodes[path37] = { authorWeights, lastTouch: raw.lastTouch };
+      nodes[path38] = { authorWeights, lastTouch: raw.lastTouch };
     }
     return { version: 1, nodes };
   }
@@ -3830,23 +3830,23 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   static load(s) {
     const idx = new _OwnershipIndex();
-    for (const [path37, raw] of Object.entries(s.nodes)) {
+    for (const [path38, raw] of Object.entries(s.nodes)) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      idx.nodes.set(path37, { authorWeights, lastTouch: raw.lastTouch });
+      idx.nodes.set(path38, { authorWeights, lastTouch: raw.lastTouch });
     }
     return idx;
   }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path37) {
-    const existing = this.nodes.get(path37);
+  getOrCreate(path38) {
+    const existing = this.nodes.get(path38);
     if (existing !== void 0) return existing;
     const fresh = { authorWeights: {}, lastTouch: 0 };
-    this.nodes.set(path37, fresh);
+    this.nodes.set(path38, fresh);
     return fresh;
   }
 };
@@ -4599,6 +4599,61 @@ ${methodLines.join("\n")}
   }
 };
 
+// packages/core/src/db/vectorsCleanup.ts
+import fs14 from "fs";
+import path14 from "path";
+var VECTOR_DB_REL = path14.join(".ctxloom", "vectors.lancedb");
+var TABLE_DIR = "code_embeddings.lance";
+function inspectVectorsDb(rootDir) {
+  const tablePath = path14.join(rootDir, VECTOR_DB_REL, TABLE_DIR);
+  const counts = {
+    txn: 0,
+    manifest: 0,
+    lance: 0,
+    totalBytes: 0
+  };
+  if (!fs14.existsSync(tablePath)) return counts;
+  for (const sub of ["_transactions", "_versions", "data"]) {
+    const dir = path14.join(tablePath, sub);
+    if (!fs14.existsSync(dir)) continue;
+    for (const name of fs14.readdirSync(dir)) {
+      const full = path14.join(dir, name);
+      try {
+        const st = fs14.statSync(full);
+        if (!st.isFile()) continue;
+        counts.totalBytes += st.size;
+        if (name.endsWith(".txn")) counts.txn += 1;
+        else if (name.endsWith(".manifest")) counts.manifest += 1;
+        else if (name.endsWith(".lance")) counts.lance += 1;
+      } catch {
+      }
+    }
+  }
+  return counts;
+}
+function cleanupVectors(options = {}, activePids = []) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const dbPath = path14.join(rootDir, VECTOR_DB_REL);
+  if (!fs14.existsSync(dbPath)) {
+    return { cleaned: false, reason: "no-db" };
+  }
+  if (activePids.length > 0) {
+    return {
+      cleaned: false,
+      reason: "in-use",
+      conflictingPids: [...activePids]
+    };
+  }
+  const before = inspectVectorsDb(rootDir);
+  if (options.dryRun) {
+    return { cleaned: true, before };
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.bak-${stamp}`;
+  fs14.renameSync(dbPath, backupPath);
+  return { cleaned: true, before, backupPath };
+}
+
 // packages/core/src/tools/status.ts
 import { z as z2 } from "zod";
 
@@ -5624,7 +5679,7 @@ function registerFileTool(registry, ctx) {
 
 // packages/core/src/tools/context-packet.ts
 import { z as z5 } from "zod";
-import path14 from "path";
+import path15 from "path";
 var DEFAULT_MAX_RESPONSE_TOKENS3 = 6e3;
 var Schema3 = z5.object({
   target_file: z5.string().describe("Relative path to the primary file"),
@@ -5693,7 +5748,7 @@ function registerContextPacketTool(registry, ctx) {
       const skeletons = await Promise.all(
         imports.map(async (dep) => {
           try {
-            const absDep = path14.resolve(ctx.projectRoot, dep);
+            const absDep = path15.resolve(ctx.projectRoot, dep);
             const sk = await skeletonizer.skeletonize(absDep);
             return `
 <!-- ${dep} -->
@@ -5735,7 +5790,7 @@ ${sk}`;
 import { z as z6 } from "zod";
 
 // packages/core/src/tools/findCallers.ts
-import path15 from "path";
+import path16 from "path";
 function escapeXML4(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -6597,7 +6652,7 @@ function registerArchitectureOverviewTool(registry, ctx) {
 
 // packages/core/src/tools/knowledge-gaps.ts
 import { z as z15 } from "zod";
-import path16 from "path";
+import path17 from "path";
 var Schema13 = z15.object({
   min_importers: z15.number().min(1).max(50).optional().default(3).describe(
     "Minimum importers to qualify as an untested hub (default: 3)"
@@ -6648,7 +6703,7 @@ function registerKnowledgeGapsTool(registry, ctx) {
       const testFiles = new Set(files.filter((f) => TEST_PATTERN2.test(f)));
       const testedBases = /* @__PURE__ */ new Set();
       for (const tf of testFiles) {
-        const base = path16.basename(tf).replace(/\.(test|spec)\.[^.]+$/, "").replace(/\.[^.]+$/, "");
+        const base = path17.basename(tf).replace(/\.(test|spec)\.[^.]+$/, "").replace(/\.[^.]+$/, "");
         if (base) testedBases.add(base);
       }
       const isolated = [];
@@ -6666,7 +6721,7 @@ function registerKnowledgeGapsTool(registry, ctx) {
           deadCode.push(file);
         }
         if (importers >= min_importers) {
-          const base = path16.basename(file).replace(/\.[^.]+$/, "");
+          const base = path17.basename(file).replace(/\.[^.]+$/, "");
           if (!testedBases.has(base)) {
             untestedHubs.push({ file, importers });
           }
@@ -6853,7 +6908,7 @@ function registerSurprisingConnectionsTool(registry, ctx) {
 
 // packages/core/src/tools/wiki-generate.ts
 import { z as z17 } from "zod";
-import fs14 from "fs";
+import fs15 from "fs";
 var DEFAULT_MAX_RESPONSE_TOKENS5 = 12e3;
 var Schema15 = z17.object({
   force: z17.boolean().optional().default(false).describe(
@@ -6873,7 +6928,7 @@ function escapeXML14(text) {
 }
 function safeFileSize(filePath) {
   try {
-    return fs14.statSync(filePath).size;
+    return fs15.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -7163,8 +7218,8 @@ function registerGitDiffReviewTool(registry, ctx) {
 
 // packages/core/src/tools/refactor-preview.ts
 import { z as z20 } from "zod";
-import fs15 from "fs";
-import path17 from "path";
+import fs16 from "fs";
+import path18 from "path";
 var DEFAULT_MAX_RESPONSE_TOKENS7 = 4e3;
 var Schema18 = z20.object({
   symbol: z20.string().min(1).describe("Symbol name to rename (exact match, case-sensitive)"),
@@ -7184,7 +7239,7 @@ function escapeXML17(text) {
 function scanFile(filePath, symbol, newName) {
   let content;
   try {
-    content = fs15.readFileSync(filePath, "utf-8");
+    content = fs16.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -7251,7 +7306,7 @@ function registerRefactorPreviewTool(registry, ctx) {
       const fileChanges = [];
       let totalOccurrences = 0;
       for (const relPath of candidates) {
-        const absPath = path17.join(ctx.projectRoot, relPath);
+        const absPath = path18.join(ctx.projectRoot, relPath);
         const occurrences = scanFile(absPath, symbol, new_name);
         if (occurrences.length > 0) {
           fileChanges.push({ filePath: relPath, occurrences });
@@ -7456,8 +7511,8 @@ function registerExecutionFlowTool(registry, ctx) {
 
 // packages/core/src/tools/cross-repo-search.ts
 import { z as z22 } from "zod";
-import fs16 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path19 from "path";
 var DEFAULT_MAX_RESPONSE_TOKENS9 = 4e3;
 var ALIAS_REGEX = /^[a-z0-9-]{1,40}$/;
 var RESERVED_ALIASES = /* @__PURE__ */ new Set([
@@ -7499,16 +7554,16 @@ var RepoRegistry = class {
   }
   load() {
     try {
-      if (!fs16.existsSync(this.filePath)) return [];
-      return JSON.parse(fs16.readFileSync(this.filePath, "utf-8"));
+      if (!fs17.existsSync(this.filePath)) return [];
+      return JSON.parse(fs17.readFileSync(this.filePath, "utf-8"));
     } catch {
       return [];
     }
   }
   save() {
-    const dir = path18.dirname(this.filePath);
-    if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-    fs16.writeFileSync(this.filePath, JSON.stringify(this.repos, null, 2), "utf-8");
+    const dir = path19.dirname(this.filePath);
+    if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(this.filePath, JSON.stringify(this.repos, null, 2), "utf-8");
   }
   list() {
     return [...this.repos];
@@ -7517,15 +7572,15 @@ var RepoRegistry = class {
     return this.repos.find((r) => r.alias === alias) ?? null;
   }
   findByPath(absPath) {
-    const canonical = path18.resolve(absPath);
-    return this.repos.find((r) => path18.resolve(r.root) === canonical) ?? null;
+    const canonical = path19.resolve(absPath);
+    return this.repos.find((r) => path19.resolve(r.root) === canonical) ?? null;
   }
   register(root, dbPath, opts = {}) {
     if (opts.alias !== void 0) {
       const v = validateAlias(opts.alias);
       if (!v.ok) throw new Error(`Invalid alias: ${v.reason}`);
       const colliding = this.repos.find(
-        (r) => r.alias === opts.alias && path18.resolve(r.root) !== path18.resolve(root)
+        (r) => r.alias === opts.alias && path19.resolve(r.root) !== path19.resolve(root)
       );
       if (colliding) {
         throw new Error(
@@ -7533,11 +7588,11 @@ var RepoRegistry = class {
         );
       }
     }
-    const existingIdx = this.repos.findIndex((r) => path18.resolve(r.root) === path18.resolve(root));
+    const existingIdx = this.repos.findIndex((r) => path19.resolve(r.root) === path19.resolve(root));
     const entry = {
       root,
       dbPath,
-      name: path18.basename(root),
+      name: path19.basename(root),
       alias: opts.alias,
       registeredAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -7549,7 +7604,7 @@ var RepoRegistry = class {
     this.save();
   }
   unregister(root) {
-    this.repos = this.repos.filter((r) => path18.resolve(r.root) !== path18.resolve(root));
+    this.repos = this.repos.filter((r) => path19.resolve(r.root) !== path19.resolve(root));
     this.save();
   }
 };
@@ -7571,7 +7626,7 @@ function escapeXML19(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function registerCrossRepoSearchTool(registry, ctx, registryFilePath) {
-  const repoRegistryPath = registryFilePath ?? path18.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".ctxloom", "repos.json");
+  const repoRegistryPath = registryFilePath ?? path19.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".ctxloom", "repos.json");
   registry.register(
     "ctx_cross_repo_search",
     {
@@ -7692,8 +7747,8 @@ function registerCrossRepoSearchTool(registry, ctx, registryFilePath) {
 
 // packages/core/src/tools/apply-refactor.ts
 import { z as z23 } from "zod";
-import fs17 from "fs";
-import path19 from "path";
+import fs18 from "fs";
+import path20 from "path";
 var DEFAULT_MAX_RESPONSE_TOKENS10 = 2e3;
 var Schema21 = z23.object({
   symbol: z23.string().min(1).describe("Symbol name to rename (exact, case-sensitive)"),
@@ -7716,7 +7771,7 @@ function escapeXML20(text) {
 function applyToFile(absPath, symbol, newName, dryRun) {
   let content;
   try {
-    content = fs17.readFileSync(absPath, "utf-8");
+    content = fs18.readFileSync(absPath, "utf-8");
   } catch {
     return 0;
   }
@@ -7725,7 +7780,7 @@ function applyToFile(absPath, symbol, newName, dryRun) {
   const occurrences = (content.match(regex) ?? []).length;
   if (occurrences === 0) return 0;
   if (!dryRun) {
-    fs17.writeFileSync(absPath, content.replace(regex, newName), "utf-8");
+    fs18.writeFileSync(absPath, content.replace(regex, newName), "utf-8");
   }
   return occurrences;
 }
@@ -7769,7 +7824,7 @@ function registerApplyRefactorTool(registry, ctx) {
       const results = [];
       let totalOccurrences = 0;
       for (const relPath of candidates) {
-        const absPath = path19.join(ctx.projectRoot, relPath);
+        const absPath = path20.join(ctx.projectRoot, relPath);
         const count = applyToFile(absPath, symbol, new_name, dry_run);
         if (count > 0) {
           results.push({ filePath: relPath, occurrences: count, written: !dry_run });
@@ -7913,8 +7968,8 @@ function registerDetectChangesTool(registry, ctx) {
 
 // packages/core/src/tools/full-text-search.ts
 import { z as z25 } from "zod";
-import fs18 from "fs";
-import path20 from "path";
+import fs19 from "fs";
+import path21 from "path";
 var DEFAULT_MAX_RESPONSE_TOKENS11 = 4e3;
 var Schema23 = z25.object({
   query: z25.string().min(1).describe("Search term \u2014 literal or /regex/"),
@@ -7945,7 +8000,7 @@ function buildPattern(query, caseSensitive) {
 function scanFile2(absPath, pattern, contextLines) {
   let content;
   try {
-    content = fs18.readFileSync(absPath, "utf-8");
+    content = fs19.readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -8017,7 +8072,7 @@ function registerFullTextSearchTool(registry, ctx) {
       };
       if (mode === "semantic") {
         try {
-          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-7YOG4DFN.js");
+          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-3AE4CSR7.js");
           const store = await ctx.getStore(project_root);
           const embedding = await generateEmbedding2(query);
           const results = await store.search(embedding, limit);
@@ -8039,7 +8094,7 @@ function registerFullTextSearchTool(registry, ctx) {
       const files = graph.allFiles();
       const keywordResults = [];
       for (const relPath of files) {
-        const absPath = path20.join(ctx.projectRoot, relPath);
+        const absPath = path21.join(ctx.projectRoot, relPath);
         const hit = scanFile2(absPath, pattern, context_lines);
         if (hit) {
           keywordResults.push({
@@ -8054,7 +8109,7 @@ function registerFullTextSearchTool(registry, ctx) {
       let merged = keywordResults.slice(0, limit);
       if (mode === "hybrid") {
         try {
-          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-7YOG4DFN.js");
+          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-3AE4CSR7.js");
           const store = await ctx.getStore(project_root);
           const embedding = await generateEmbedding2(query);
           const vectorResults = await store.search(embedding, Math.ceil(limit / 2));
@@ -8273,8 +8328,8 @@ function registerGetWorkflowTool(registry, _ctx) {
 }
 
 // packages/core/src/tools/graph-snapshot.ts
-import fs19 from "fs";
-import path21 from "path";
+import fs20 from "fs";
+import path22 from "path";
 import { z as z28 } from "zod";
 var schema = z28.object({
   name: z28.string().min(1).max(64).regex(/^[\w.-]+$/, "Name may only contain letters, digits, dots, underscores, hyphens").describe(
@@ -8286,13 +8341,13 @@ var schema = z28.object({
   project_root: ProjectRootField
 });
 function saveNamedSnapshot(graph, name, rootDir, overwrite = false) {
-  const snapshotsDir = path21.resolve(rootDir, ".ctxloom", "snapshots");
-  fs19.mkdirSync(snapshotsDir, { recursive: true });
-  const snapshotPath = path21.resolve(snapshotsDir, `${name}.json`);
-  if (!snapshotPath.startsWith(snapshotsDir + path21.sep)) {
+  const snapshotsDir = path22.resolve(rootDir, ".ctxloom", "snapshots");
+  fs20.mkdirSync(snapshotsDir, { recursive: true });
+  const snapshotPath = path22.resolve(snapshotsDir, `${name}.json`);
+  if (!snapshotPath.startsWith(snapshotsDir + path22.sep)) {
     throw new Error(`Invalid snapshot name: "${name}"`);
   }
-  if (fs19.existsSync(snapshotPath) && !overwrite) {
+  if (fs20.existsSync(snapshotPath) && !overwrite) {
     throw new Error(`Snapshot "${name}" already exists. Pass overwrite: true to replace it.`);
   }
   const files = graph.allFiles();
@@ -8307,14 +8362,14 @@ function saveNamedSnapshot(graph, name, rootDir, overwrite = false) {
     edgeCount: graph.edgeCount(),
     forwardEdges
   };
-  const tmp = snapshotPath + ".tmp";
-  fs19.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-  fs19.renameSync(tmp, snapshotPath);
+  const tmp = `${snapshotPath}.${process.pid}.tmp`;
+  fs20.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  fs20.renameSync(tmp, snapshotPath);
 }
 function listNamedSnapshots(rootDir) {
-  const snapshotsDir = path21.join(rootDir, ".ctxloom", "snapshots");
-  if (!fs19.existsSync(snapshotsDir)) return [];
-  return fs19.readdirSync(snapshotsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).sort();
+  const snapshotsDir = path22.join(rootDir, ".ctxloom", "snapshots");
+  if (!fs20.existsSync(snapshotsDir)) return [];
+  return fs20.readdirSync(snapshotsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).sort();
 }
 function registerGraphSnapshotTool(registry, ctx) {
   registry.register(
@@ -8363,8 +8418,8 @@ function registerGraphSnapshotTool(registry, ctx) {
 }
 
 // packages/core/src/tools/graph-diff.ts
-import fs20 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path23 from "path";
 import { z as z29 } from "zod";
 var schema2 = z29.object({
   baseline: z29.string().min(1).describe('Name of the baseline snapshot (the "before" state).'),
@@ -8372,16 +8427,16 @@ var schema2 = z29.object({
   project_root: ProjectRootField
 });
 function loadSnapshot(name, rootDir) {
-  const snapshotsDir = path22.resolve(rootDir, ".ctxloom", "snapshots");
-  const snapshotPath = path22.resolve(snapshotsDir, `${name}.json`);
-  if (!snapshotPath.startsWith(snapshotsDir + path22.sep)) {
+  const snapshotsDir = path23.resolve(rootDir, ".ctxloom", "snapshots");
+  const snapshotPath = path23.resolve(snapshotsDir, `${name}.json`);
+  if (!snapshotPath.startsWith(snapshotsDir + path23.sep)) {
     throw new Error(`Invalid snapshot name: "${name}"`);
   }
-  if (!fs20.existsSync(snapshotPath)) {
+  if (!fs21.existsSync(snapshotPath)) {
     throw new Error(`Snapshot "${name}" not found. Run ctx_graph_snapshot first.`);
   }
   try {
-    return JSON.parse(fs20.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs21.readFileSync(snapshotPath, "utf-8"));
   } catch (e) {
     throw new Error(`Snapshot "${name}" is corrupted: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -8775,8 +8830,8 @@ var RulesConfigError = class extends Error {
 };
 
 // packages/core/src/rules/loadConfig.ts
-import fs21 from "fs/promises";
-import path23 from "path";
+import fs22 from "fs/promises";
+import path24 from "path";
 import yaml from "js-yaml";
 import { z as z33 } from "zod";
 var RuleSchema = z33.object({
@@ -8791,10 +8846,10 @@ var RulesConfigSchema = z33.object({
   rules: z33.array(RuleSchema).default([])
 });
 async function loadRulesConfig(rootDir) {
-  const filePath = path23.join(rootDir, ".ctxloom", "rules.yml");
+  const filePath = path24.join(rootDir, ".ctxloom", "rules.yml");
   let raw;
   try {
-    raw = await fs21.readFile(filePath, "utf-8");
+    raw = await fs22.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new RulesConfigError(`Failed to read rules config: ${String(err)}`);
@@ -9206,11 +9261,11 @@ function readRecentChanges(projectRoot) {
     return lines.slice(0, 20).map((line) => {
       const x = line[0];
       const y = line[1];
-      const path37 = line.slice(3).trim();
+      const path38 = line.slice(3).trim();
       let status = "?";
       const xy = x === " " ? y : x;
       if (xy === "M" || xy === "A" || xy === "D" || xy === "R") status = xy;
-      return { file: path37, status };
+      return { file: path38, status };
     });
   } catch {
     return [];
@@ -9437,8 +9492,8 @@ function createToolRegistry(ctx) {
 }
 
 // packages/core/src/tools/ruleManager.ts
-import fs22 from "fs";
-import path24 from "path";
+import fs23 from "fs";
+import path25 from "path";
 var RULE_FILES = [
   ".cursorrules",
   "CLAUDE.md",
@@ -9462,30 +9517,30 @@ var RuleManager = class {
     if (this.cachedRules) return this.cachedRules;
     const rules = [];
     for (const ruleFile of RULE_FILES) {
-      const fullPath = path24.join(this.projectRoot, ruleFile);
+      const fullPath = path25.join(this.projectRoot, ruleFile);
       try {
         this.pathValidator.validate(fullPath);
-        if (fs22.existsSync(fullPath)) {
-          const stat = fs22.statSync(fullPath);
+        if (fs23.existsSync(fullPath)) {
+          const stat = fs23.statSync(fullPath);
           if (stat.isFile()) {
-            const content = fs22.readFileSync(fullPath, "utf-8");
+            const content = fs23.readFileSync(fullPath, "utf-8");
             rules.push({
               name: ruleFile,
               path: ruleFile,
               content
             });
           } else if (stat.isDirectory()) {
-            const dirEntries = fs22.readdirSync(fullPath);
+            const dirEntries = fs23.readdirSync(fullPath);
             for (const entry of dirEntries) {
-              const entryPath = path24.join(fullPath, entry);
+              const entryPath = path25.join(fullPath, entry);
               try {
                 this.pathValidator.validate(entryPath);
               } catch {
                 continue;
               }
-              const entryStat = fs22.statSync(entryPath);
+              const entryStat = fs23.statSync(entryPath);
               if (entryStat.isFile()) {
-                const content = fs22.readFileSync(entryPath, "utf-8");
+                const content = fs23.readFileSync(entryPath, "utf-8");
                 rules.push({
                   name: `${ruleFile}/${entry}`,
                   path: `${ruleFile}/${entry}`,
@@ -9528,8 +9583,8 @@ var RuleManager = class {
 };
 
 // packages/core/src/review/AuthorResolver.ts
-import fs23 from "fs/promises";
-import path25 from "path";
+import fs24 from "fs/promises";
+import path26 from "path";
 import yaml2 from "js-yaml";
 var AuthorResolver = class {
   constructor(ctxloomDir) {
@@ -9554,8 +9609,8 @@ var AuthorResolver = class {
   /** Write a new mapping to the cache file. */
   async writeCache(email, handle) {
     this.cache = { ...this.cache, [email]: handle };
-    await fs23.writeFile(
-      path25.join(this.ctxloomDir, "authors-cache.json"),
+    await fs24.writeFile(
+      path26.join(this.ctxloomDir, "authors-cache.json"),
       JSON.stringify(this.cache, null, 2)
     );
   }
@@ -9564,9 +9619,9 @@ var AuthorResolver = class {
     return emails.filter((e) => this.resolve(e) === void 0);
   }
   async loadYml() {
-    const file = path25.join(this.ctxloomDir, "authors.yml");
+    const file = path26.join(this.ctxloomDir, "authors.yml");
     try {
-      const raw = await fs23.readFile(file, "utf8");
+      const raw = await fs24.readFile(file, "utf8");
       const parsed = yaml2.load(raw);
       if (!parsed) return;
       this.mappings = parsed.mappings ?? {};
@@ -9575,9 +9630,9 @@ var AuthorResolver = class {
     }
   }
   async loadCache() {
-    const file = path25.join(this.ctxloomDir, "authors-cache.json");
+    const file = path26.join(this.ctxloomDir, "authors-cache.json");
     try {
-      const raw = await fs23.readFile(file, "utf8");
+      const raw = await fs24.readFile(file, "utf8");
       this.cache = JSON.parse(raw);
     } catch {
     }
@@ -9602,8 +9657,8 @@ async function resolveViaGitHubApi(email, owner, repo, token) {
 }
 
 // packages/core/src/review/CodeownersWriter.ts
-import fs24 from "fs/promises";
-import path26 from "path";
+import fs25 from "fs/promises";
+import path27 from "path";
 var MARKER_START = "# <ctxloom:start> \u2014 managed by ctxloom review-suggest; do not edit between markers";
 var MARKER_START_DETECT = "# <ctxloom:start>";
 var MARKER_END = "# <ctxloom:end>";
@@ -9635,15 +9690,15 @@ ${block}
 async function generateCODEOWNERS(codeownersPath, rules) {
   let existing = "";
   try {
-    existing = await fs24.readFile(codeownersPath, "utf8");
+    existing = await fs25.readFile(codeownersPath, "utf8");
   } catch {
   }
   const block = buildCodeownersBlock(rules);
   return mergeIntoFile(existing, block);
 }
 async function writeCODEOWNERS(codeownersPath, content) {
-  await fs24.mkdir(path26.dirname(codeownersPath), { recursive: true });
-  await fs24.writeFile(codeownersPath, content, "utf8");
+  await fs25.mkdir(path27.dirname(codeownersPath), { recursive: true });
+  await fs25.writeFile(codeownersPath, content, "utf8");
 }
 
 // packages/core/src/review/types.ts
@@ -9828,8 +9883,8 @@ function matchGlob(pattern, value) {
 }
 
 // packages/core/src/review/loadConfig.ts
-import fs25 from "fs/promises";
-import path27 from "path";
+import fs26 from "fs/promises";
+import path28 from "path";
 import yaml3 from "js-yaml";
 function freshDefaults() {
   return {
@@ -9840,9 +9895,9 @@ function freshDefaults() {
   };
 }
 async function loadReviewConfig(root) {
-  const file = path27.join(root, ".ctxloom", "review.yml");
+  const file = path28.join(root, ".ctxloom", "review.yml");
   try {
-    const raw = await fs25.readFile(file, "utf8");
+    const raw = await fs26.readFile(file, "utf8");
     const parsed = yaml3.load(raw);
     if (!parsed) return freshDefaults();
     return {
@@ -9857,13 +9912,13 @@ async function loadReviewConfig(root) {
 }
 
 // packages/core/src/security/PathValidator.ts
-import path28 from "path";
-import fs26 from "fs";
+import path29 from "path";
+import fs27 from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var PathValidator = class {
   canonicalRoot;
   constructor(projectRoot) {
-    this.canonicalRoot = fs26.realpathSync(path28.resolve(projectRoot));
+    this.canonicalRoot = fs27.realpathSync(path29.resolve(projectRoot));
   }
   /**
    * Validates that the given input path resolves within the project root.
@@ -9873,14 +9928,14 @@ var PathValidator = class {
    * @throws Error if the path escapes the project root
    */
   validate(inputPath) {
-    const resolved = path28.resolve(this.canonicalRoot, inputPath);
+    const resolved = path29.resolve(this.canonicalRoot, inputPath);
     let canonical;
     try {
-      canonical = fs26.realpathSync(resolved);
+      canonical = fs27.realpathSync(resolved);
     } catch {
       canonical = resolved;
     }
-    if (!canonical.startsWith(this.canonicalRoot + path28.sep) && canonical !== this.canonicalRoot) {
+    if (!canonical.startsWith(this.canonicalRoot + path29.sep) && canonical !== this.canonicalRoot) {
       throw new Error(
         `Path traversal blocked: "${inputPath}" resolves outside of the project root`
       );
@@ -9897,7 +9952,7 @@ var PathValidator = class {
    * Converts an absolute path to a relative path from the project root.
    */
   toRelative(absolutePath) {
-    return path28.relative(this.canonicalRoot, absolutePath);
+    return path29.relative(this.canonicalRoot, absolutePath);
   }
   /**
    * Validates and reads a file, returning its content.
@@ -9905,11 +9960,11 @@ var PathValidator = class {
    */
   readFile(inputPath) {
     const absPath = this.validate(inputPath);
-    const stat = fs26.statSync(absPath);
+    const stat = fs27.statSync(absPath);
     if (stat.size > MAX_FILE_SIZE) {
       throw new Error(`File too large: ${inputPath} (${Math.round(stat.size / 1024)}KB, max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
     }
-    return fs26.readFileSync(absPath, "utf-8");
+    return fs27.readFileSync(absPath, "utf-8");
   }
   /**
    * Checks if a path exists and is within the project root.
@@ -10062,7 +10117,7 @@ var EmailAlreadyUsedError = class extends Error {
 
 // packages/core/src/license/LicenseStore.ts
 import { readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync, existsSync } from "fs";
-import path29 from "path";
+import path30 from "path";
 
 // packages/core/src/license/types.ts
 import { z as z37 } from "zod";
@@ -10083,7 +10138,7 @@ var LicenseFileSchema = z37.object({
 
 // packages/core/src/license/LicenseStore.ts
 function licenseFilePath(home) {
-  return path29.join(home, ".ctxloom", "license.json");
+  return path30.join(home, ".ctxloom", "license.json");
 }
 var LicenseStore = class {
   filePath;
@@ -10106,7 +10161,7 @@ var LicenseStore = class {
     }
   }
   async write(license) {
-    mkdirSync(path29.dirname(this.filePath), { recursive: true });
+    mkdirSync(path30.dirname(this.filePath), { recursive: true });
     writeFileSync(this.filePath, JSON.stringify(license, null, 2), {
       encoding: "utf8",
       mode: 384
@@ -10237,11 +10292,11 @@ import os5 from "os";
 
 // packages/core/src/license/DistinctIdStore.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import os3 from "os";
 var UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function distinctIdPath(home) {
-  return path30.join(home ?? os3.homedir(), ".ctxloom", "distinct_id");
+  return path31.join(home ?? os3.homedir(), ".ctxloom", "distinct_id");
 }
 function isValidV4(id) {
   return typeof id === "string" && UUID_V4_REGEX.test(id);
@@ -10262,7 +10317,7 @@ function getOrCreateDistinctId(home) {
     id: crypto.randomUUID(),
     alias_pending: os3.hostname()
   };
-  mkdirSync2(path30.dirname(filePath), { recursive: true });
+  mkdirSync2(path31.dirname(filePath), { recursive: true });
   writeFileSync2(filePath, JSON.stringify(record), { mode: 384 });
   return record;
 }
@@ -10291,7 +10346,7 @@ var TELEMETRY_DISABLED = TELEMETRY_LEVEL === "off";
 function getTelemetryLevel() {
   return TELEMETRY_LEVEL;
 }
-var CTXLOOM_VERSION = "1.5.5".length > 0 ? "1.5.5" : "dev";
+var CTXLOOM_VERSION = "1.5.6".length > 0 ? "1.5.6" : "dev";
 var POSTHOG_HOST = "https://eu.i.posthog.com";
 var POSTHOG_KEY = process.env["POSTHOG_API_KEY"] ?? (true ? "phc_CiDkmFLcZ2K6uCpcoSUQLmFrnnUvsyXGhSxopX5TVKE6" : "");
 var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (true ? "https://81c94a0f04a8e242dee493ac1e17f733@o4508531702497280.ingest.de.sentry.io/4511256875368528\u2028" : "");
@@ -10424,17 +10479,17 @@ function parseStack(stack) {
 
 // packages/core/src/license/FunnelMilestones.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import path31 from "path";
+import path32 from "path";
 import os4 from "os";
 var INSTALL_MARKER = "installed_at";
 var FIRST_REVIEW_MARKER = "first_review_at";
 function writeMarker(filePath) {
-  mkdirSync3(path31.dirname(filePath), { recursive: true });
+  mkdirSync3(path32.dirname(filePath), { recursive: true });
   writeFileSync3(filePath, (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
 }
 function shouldEmitInstallCompleted(home) {
   const root = home ?? os4.homedir();
-  const marker = path31.join(root, ".ctxloom", INSTALL_MARKER);
+  const marker = path32.join(root, ".ctxloom", INSTALL_MARKER);
   if (existsSync3(marker)) return false;
   try {
     writeMarker(marker);
@@ -10443,7 +10498,7 @@ function shouldEmitInstallCompleted(home) {
   return true;
 }
 function shouldEmitFirstReviewRun(projectRoot) {
-  const marker = path31.join(projectRoot, ".ctxloom", FIRST_REVIEW_MARKER);
+  const marker = path32.join(projectRoot, ".ctxloom", FIRST_REVIEW_MARKER);
   if (existsSync3(marker)) return false;
   try {
     writeMarker(marker);
@@ -10561,16 +10616,16 @@ async function startTrial(email, opts = {}) {
 
 // packages/core/src/license/TelemetryNotice.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import path32 from "path";
+import path33 from "path";
 import os6 from "os";
 function noticePath(home) {
-  return path32.join(home ?? os6.homedir(), ".ctxloom", "telemetry_notice_shown");
+  return path33.join(home ?? os6.homedir(), ".ctxloom", "telemetry_notice_shown");
 }
 function shouldShowTelemetryNotice(home) {
   const filePath = noticePath(home);
   if (existsSync4(filePath)) return false;
   try {
-    mkdirSync4(path32.dirname(filePath), { recursive: true });
+    mkdirSync4(path33.dirname(filePath), { recursive: true });
     writeFileSync4(filePath, (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
   } catch {
   }
@@ -10578,13 +10633,13 @@ function shouldShowTelemetryNotice(home) {
 }
 
 // packages/core/src/server/ProjectState.ts
-import path34 from "path";
+import path35 from "path";
 
 // packages/core/src/server/projectId.ts
 import crypto5 from "crypto";
-import path33 from "path";
+import path34 from "path";
 function hashProjectRoot(absPath) {
-  const canonical = path33.resolve(absPath);
+  const canonical = path34.resolve(absPath);
   return crypto5.createHash("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 
@@ -10592,7 +10647,7 @@ function hashProjectRoot(absPath) {
 function createProjectState(projectRoot, opts = {}) {
   return {
     projectRoot,
-    dbPath: path34.join(projectRoot, ".ctxloom", "vectors.lancedb"),
+    dbPath: path35.join(projectRoot, ".ctxloom", "vectors.lancedb"),
     pinned: opts.pinned ?? false,
     lastTouchedAt: Date.now(),
     vectorsInitialized: false,
@@ -10744,8 +10799,8 @@ var ProjectStateManager = class {
 };
 
 // packages/core/src/server/resolveProjectRoot.ts
-import fs27 from "fs";
-import path35 from "path";
+import fs28 from "fs";
+import path36 from "path";
 var PATH_SEPARATOR_PATTERN = /[/\\~]|^[A-Za-z]:/;
 function looksLikePath(value) {
   return PATH_SEPARATOR_PATTERN.test(value);
@@ -10770,13 +10825,13 @@ function resolvePathSafely(p, cwd) {
   let expanded = p;
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    expanded = p === "~" ? home : path35.join(home, p.slice(2));
+    expanded = p === "~" ? home : path36.join(home, p.slice(2));
   }
-  return path35.isAbsolute(expanded) ? path35.resolve(expanded) : path35.resolve(cwd, expanded);
+  return path36.isAbsolute(expanded) ? path36.resolve(expanded) : path36.resolve(cwd, expanded);
 }
 function realpathOrSame(p) {
   try {
-    return fs27.realpathSync(p);
+    return fs28.realpathSync(p);
   } catch {
     return p;
   }
@@ -10801,7 +10856,7 @@ function resolveProjectRoot(input) {
       };
     }
     const resolved2 = resolvePathSafely(arg, cwd);
-    if (!fs27.existsSync(resolved2)) {
+    if (!fs28.existsSync(resolved2)) {
       return {
         kind: "project_root_not_found",
         attemptedPath: resolved2,
@@ -10812,7 +10867,7 @@ function resolveProjectRoot(input) {
   }
   if (env !== void 0 && env !== "") {
     const resolved2 = resolvePathSafely(env, cwd);
-    if (!fs27.existsSync(resolved2)) {
+    if (!fs28.existsSync(resolved2)) {
       return {
         kind: "project_root_not_found",
         attemptedPath: resolved2,
@@ -10839,12 +10894,12 @@ var FILESYSTEM_ROOTS = /* @__PURE__ */ new Set(["/", "C:\\", "D:\\", "E:\\", "F:
 function validateDefaultRoot(candidate) {
   if (FILESYSTEM_ROOTS.has(candidate)) return false;
   try {
-    const stat = fs27.statSync(candidate);
+    const stat = fs28.statSync(candidate);
     if (!stat.isDirectory()) return false;
   } catch {
     return false;
   }
-  return PROJECT_MARKERS.some((m) => fs27.existsSync(path35.join(candidate, m)));
+  return PROJECT_MARKERS.some((m) => fs28.existsSync(path36.join(candidate, m)));
 }
 
 // packages/core/src/server/structuredErrors.ts
@@ -10916,8 +10971,8 @@ var EmittedOnceTracker = class {
 };
 
 // packages/core/src/install/installer.ts
-import fs28 from "fs";
-import path36 from "path";
+import fs29 from "fs";
+import path37 from "path";
 
 // packages/core/src/install/templates.ts
 var RULES_BLOCK_NAME = "CTXLOOM-RULES";
@@ -11542,8 +11597,8 @@ function skillFilePath(name) {
 // packages/core/src/install/installer.ts
 function installHarness(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const projectRoot = path36.resolve(cwd);
-  const stat = fs28.statSync(projectRoot);
+  const projectRoot = path37.resolve(cwd);
+  const stat = fs29.statSync(projectRoot);
   if (!stat.isDirectory()) {
     throw new Error(`installHarness: ${projectRoot} is not a directory`);
   }
@@ -11591,20 +11646,20 @@ function resolveExtraHosts(ids, warnings) {
   return HOST_ADAPTERS.filter((a) => requested.has(a.id));
 }
 function safeJoin(root, name) {
-  const target = path36.resolve(root, name);
-  const rootResolved = path36.resolve(root);
+  const target = path37.resolve(root, name);
+  const rootResolved = path37.resolve(root);
   const caseFold = process.platform === "darwin" || process.platform === "win32";
   const t = caseFold ? target.toLowerCase() : target;
   const r = caseFold ? rootResolved.toLowerCase() : rootResolved;
-  if (!t.startsWith(r + path36.sep) && t !== r) {
+  if (!t.startsWith(r + path37.sep) && t !== r) {
     throw new Error(`installHarness: refusing to write outside project root: ${target}`);
   }
   return target;
 }
 function writeRulesBlock(projectRoot, filename, opts) {
   const filePath = safeJoin(projectRoot, filename);
-  const existed = fs28.existsSync(filePath);
-  const existing = existed ? fs28.readFileSync(filePath, "utf-8") : "";
+  const existed = fs29.existsSync(filePath);
+  const existing = existed ? fs29.readFileSync(filePath, "utf-8") : "";
   if (existed) {
     const block = extractBlock(existing, RULES_BLOCK_NAME);
     if (block) {
@@ -11622,7 +11677,7 @@ function writeRulesBlock(projectRoot, filename, opts) {
   }
   const next = upsertBlock(existing, RULES_BLOCK_NAME, RULES_BLOCK_CONTENT);
   if (!opts.dryRun) {
-    fs28.writeFileSync(filePath, next, "utf-8");
+    fs29.writeFileSync(filePath, next, "utf-8");
   }
   return {
     path: filePath,
@@ -11635,15 +11690,15 @@ function writeRulesBlock(projectRoot, filename, opts) {
 function writeHooksJson(projectRoot, opts) {
   const dir = safeJoin(projectRoot, ".claude");
   const filePath = safeJoin(projectRoot, ".claude/hooks.json");
-  const existed = fs28.existsSync(filePath);
+  const existed = fs29.existsSync(filePath);
   let current = {};
   if (existed) {
     try {
-      const text = fs28.readFileSync(filePath, "utf-8");
+      const text = fs29.readFileSync(filePath, "utf-8");
       current = JSON.parse(text);
     } catch (err) {
       opts.warnings.push(
-        `Could not parse existing ${path36.relative(projectRoot, filePath)}; treating as empty. (${err instanceof Error ? err.message : String(err)})`
+        `Could not parse existing ${path37.relative(projectRoot, filePath)}; treating as empty. (${err instanceof Error ? err.message : String(err)})`
       );
       current = {};
     }
@@ -11660,12 +11715,12 @@ function writeHooksJson(projectRoot, opts) {
   const nextJson = JSON.stringify(merged, null, 2) + "\n";
   let alreadyCorrect = false;
   if (existed) {
-    const currentText = fs28.readFileSync(filePath, "utf-8");
+    const currentText = fs29.readFileSync(filePath, "utf-8");
     if (currentText === nextJson) alreadyCorrect = true;
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs28.mkdirSync(dir, { recursive: true });
-    fs28.writeFileSync(filePath, nextJson, "utf-8");
+    fs29.mkdirSync(dir, { recursive: true });
+    fs29.writeFileSync(filePath, nextJson, "utf-8");
   }
   return {
     path: filePath,
@@ -11687,19 +11742,19 @@ function isCtxloomEntry(entry, expectedMatcher) {
 }
 function writeHostAdapter(projectRoot, adapter, opts) {
   const filePath = safeJoin(projectRoot, adapter.path);
-  const dir = path36.dirname(filePath);
-  const existed = fs28.existsSync(filePath);
+  const dir = path37.dirname(filePath);
+  const existed = fs29.existsSync(filePath);
   const rendered = adapter.render();
   let alreadyCorrect = false;
   if (existed) {
-    const current = fs28.readFileSync(filePath, "utf-8");
+    const current = fs29.readFileSync(filePath, "utf-8");
     if (adapter.isCanonical(current)) {
       alreadyCorrect = true;
     }
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs28.mkdirSync(dir, { recursive: true });
-    fs28.writeFileSync(filePath, rendered, "utf-8");
+    fs29.mkdirSync(dir, { recursive: true });
+    fs29.writeFileSync(filePath, rendered, "utf-8");
   }
   return {
     path: filePath,
@@ -11712,16 +11767,16 @@ function writeHostAdapter(projectRoot, adapter, opts) {
 function writeSkill(projectRoot, skill, opts) {
   const dir = safeJoin(projectRoot, `.claude/skills/${skill.name}`);
   const filePath = safeJoin(projectRoot, skillFilePath(skill.name));
-  const existed = fs28.existsSync(filePath);
+  const existed = fs29.existsSync(filePath);
   let alreadyCorrect = false;
   if (existed) {
-    if (fs28.readFileSync(filePath, "utf-8") === skill.content) {
+    if (fs29.readFileSync(filePath, "utf-8") === skill.content) {
       alreadyCorrect = true;
     }
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs28.mkdirSync(dir, { recursive: true });
-    fs28.writeFileSync(filePath, skill.content, "utf-8");
+    fs29.mkdirSync(dir, { recursive: true });
+    fs29.writeFileSync(filePath, skill.content, "utf-8");
   }
   return {
     path: filePath,
@@ -11734,17 +11789,17 @@ function writeSkill(projectRoot, skill, opts) {
 function writeSessionStartScript(projectRoot, opts) {
   const dir = safeJoin(projectRoot, ".claude/hooks");
   const filePath = safeJoin(projectRoot, ".claude/hooks/session-start.sh");
-  const existed = fs28.existsSync(filePath);
+  const existed = fs29.existsSync(filePath);
   let alreadyCorrect = false;
   if (existed) {
-    const current = fs28.readFileSync(filePath, "utf-8");
+    const current = fs29.readFileSync(filePath, "utf-8");
     if (current === SESSION_START_FULL) alreadyCorrect = true;
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs28.mkdirSync(dir, { recursive: true });
-    fs28.writeFileSync(filePath, SESSION_START_FULL, "utf-8");
+    fs29.mkdirSync(dir, { recursive: true });
+    fs29.writeFileSync(filePath, SESSION_START_FULL, "utf-8");
     try {
-      fs28.chmodSync(filePath, 493);
+      fs29.chmodSync(filePath, 493);
     } catch {
     }
   }
@@ -11793,6 +11848,8 @@ export {
   loadTrendSeries,
   loadFileRiskHistory,
   Skeletonizer,
+  inspectVectorsDb,
+  cleanupVectors,
   renderStatusXml,
   __resetLearnedSuggestionsCacheForTests,
   learnSuggestionsFromTelemetry,
@@ -11889,4 +11946,4 @@ export {
   skillFilePath,
   installHarness
 };
-//# sourceMappingURL=chunk-5R4P7VEE.js.map
+//# sourceMappingURL=chunk-FPMNXF4D.js.map