ctxloom-pro 1.5.5 → 1.7.0

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

@@ -1,10 +1,11 @@
 import {
   VectorStore
-} from "./chunk-R56D54Y7.js";
+} from "./chunk-7S2ELKNU.js";
 import {
+  INDEXER_IGNORED_DIRS,
   collectFiles,
   generateEmbedding
-} from "./chunk-COH5WYZS.js";
+} from "./chunk-6FGTNOCP.js";
 import {
   diskSink,
   readEvents
@@ -503,6 +504,13 @@ var ASTParser = class {
   extractTSNodes(rootNode, _filePath, lines) {
     const nodes = [];
     const processedIds = /* @__PURE__ */ new Set();
+    const hasCallableRight = (n) => {
+      const right = n.childForFieldName?.("right") ?? n.children[n.children.length - 1];
+      if (!right) return false;
+      if (right.type === "function" || right.type === "function_expression" || right.type === "arrow_function" || right.type === "function_declaration") return true;
+      if (right.type === "assignment_expression") return hasCallableRight(right);
+      return false;
+    };
     const walk = (node) => {
       if (processedIds.has(node.id)) return;
       switch (node.type) {
@@ -674,6 +682,56 @@ var ASTParser = class {
           processedIds.add(node.id);
           return;
         }
+        // ─── Prototype / object method assignments ──────────────────────
+        // CommonJS libraries (and pre-class-syntax ES) attach their public
+        // API via assignment expressions:
+        //
+        //   res.send = function send(body) { ... }
+        //   res.json = function (obj) { ... }
+        //   res.contentType = res.type = function (type) { ... }    // chained
+        //   exports.foo = function foo() { ... }
+        //   MyClass.prototype.bar = function () { ... }
+        //
+        // Without this case, none of those names enter the symbol index,
+        // so `lookupSymbolsByFile()` returns empty for libraries like
+        // express, and any downstream tool that wants to attribute callers
+        // to a file (blast-radius symbolCallers, ctx_get_definition, etc.)
+        // falls flat. The call graph itself already records callers of
+        // `send`/`json`/etc. — this case bridges the gap so we can match
+        // them back to the file that defines them.
+        //
+        // Heuristic:
+        //   - left  = member_expression  → use the FINAL property as symbol
+        //   - right = function | arrow_function | function_expression
+        //   - right = assignment_expression → recurse for chained pattern
+        // Anything else (constants, identifiers being aliased) is skipped
+        // intentionally — those aren't callable API surface.
+        case "assignment_expression": {
+          const left = node.childForFieldName?.("left") ?? node.children.find(
+            (c) => c?.type === "member_expression" || c?.type === "identifier"
+          );
+          const right = node.childForFieldName?.("right") ?? node.children[node.children.length - 1];
+          if (left?.type === "member_expression" && right) {
+            const prop = left.childForFieldName?.("property") ?? left.children[left.children.length - 1];
+            const propName = prop?.text;
+            if (right.type === "assignment_expression") {
+              walk(right);
+            }
+            const rightIsCallable = right.type === "function" || right.type === "function_expression" || right.type === "arrow_function" || right.type === "function_declaration" || right.type === "assignment_expression" && hasCallableRight(right);
+            if (propName && rightIsCallable && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName)) {
+              const sig = lines[node.startPosition.row] ?? "";
+              nodes.push({
+                type: "method",
+                name: propName,
+                signature: sig.trim().slice(0, 200),
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1
+              });
+            }
+          }
+          processedIds.add(node.id);
+          return;
+        }
         // ─── Lexical declarations (const fn = () => {}) ────────────────
         case "lexical_declaration": {
           for (const child of node.children) {
@@ -780,10 +838,34 @@ var ASTParser = class {
         }
         case "import_from_statement": {
           const moduleNode = node.children.find((c) => c?.type === "dotted_name" || c?.type === "relative_import");
+          const sourceText = moduleNode?.text ?? "";
+          const importedNames = [];
+          let pastImportKeyword = false;
+          for (const child of node.children) {
+            if (!child) continue;
+            if (child.text === "import" && (child.type === "import" || child.children.length === 0)) {
+              pastImportKeyword = true;
+              continue;
+            }
+            if (!pastImportKeyword) continue;
+            if (child.type === "wildcard_import") continue;
+            if (child.type === "dotted_name") {
+              importedNames.push(child.text);
+            } else if (child.type === "aliased_import") {
+              const alias = child.childForFieldName?.("alias");
+              const aliasName = alias?.text;
+              if (aliasName) importedNames.push(aliasName);
+              else {
+                const name = child.childForFieldName?.("name")?.text;
+                if (name) importedNames.push(name);
+              }
+            }
+          }
           nodes.push({
             type: "import",
-            name: moduleNode?.text ?? "",
-            source: moduleNode?.text ?? "",
+            name: sourceText,
+            source: sourceText,
+            importedNames: importedNames.length > 0 ? importedNames : void 0,
             startLine: node.startPosition.row + 1,
             endLine: node.endPosition.row + 1
           });
@@ -1653,6 +1735,78 @@ var ASTParser = class {
       tree.delete();
     }
   }
+  /**
+   * Extract all call edges in a Python (.py / .ipynb) file. Mirrors
+   * `parseAllCallEdges` but uses tree-sitter-python node types.
+   *
+   * Tree-sitter-python relevant shapes:
+   *   - call.function = identifier "foo"         → callee = "foo"
+   *   - call.function = attribute (obj.method)   → callee = "method"
+   *   - call.function = call (chained)           → recurse into inner
+   *
+   * Enclosing-context tracking follows the same pattern: track the
+   * innermost `function_definition`. Methods inside a class are also
+   * function_definitions, so the same handler covers them.
+   */
+  async parseAllPythonCallEdges(filePath) {
+    if (!this.pyLang) await this.loadPython();
+    if (!this.pyLang) return [];
+    const parser = this.getParser(this.pyLang);
+    let source;
+    try {
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      source = filePath.endsWith(".ipynb") ? extractNotebookPythonSource(raw) : raw;
+    } catch {
+      return [];
+    }
+    if (!source.trim()) return [];
+    const tree = parser.parse(source);
+    if (!tree) return [];
+    const results = [];
+    const extractCalleeName = (fn) => {
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "attribute") {
+        const right = fn.childForFieldName?.("attribute") ?? fn.children[fn.children.length - 1];
+        return right?.text ?? "";
+      }
+      if (fn.type === "call") {
+        const innerFn = fn.childForFieldName?.("function");
+        return innerFn ? extractCalleeName(innerFn) : "";
+      }
+      return "";
+    };
+    const walk = (node, contextStack) => {
+      let newStack = contextStack;
+      if (node.type === "function_definition") {
+        const nameNode = node.childForFieldName?.("name");
+        if (nameNode?.text) {
+          newStack = [...contextStack, nameNode.text];
+        }
+      }
+      if (node.type === "call") {
+        const fn = node.childForFieldName?.("function") ?? node.children.find((c) => c?.type === "identifier" || c?.type === "attribute" || c?.type === "call");
+        if (fn) {
+          const name = extractCalleeName(fn);
+          if (name && name.length > 0) {
+            results.push({
+              callerSymbol: newStack[newStack.length - 1] ?? "",
+              calleeSymbol: name,
+              line: node.startPosition.row + 1
+            });
+          }
+        }
+      }
+      for (const child of node.children) {
+        if (child) walk(child, newStack);
+      }
+    };
+    try {
+      walk(tree.rootNode, []);
+      return results;
+    } finally {
+      tree.delete();
+    }
+  }
   /**
    * Extract all call edges in a TypeScript/TSX file.
    * Tracks the enclosing function/method context for each call site.
@@ -1735,48 +1889,100 @@ var GoModuleResolver = class {
   }
   /**
    * Resolve a module-path import (e.g. `github.com/myorg/myapp/internal/auth`)
-   * to a relative project path (e.g. `internal/auth/auth.go`).
+   * to the FIRST relative project path (e.g. `internal/auth/auth.go`).
    *
    * Returns null for:
    *   - Third-party imports (different module prefix)
    *   - Relative imports (use resolveRelative() instead)
    *   - Imports where no .go files are found
+   *
+   * NOTE: A Go import imports a PACKAGE (a directory of .go files), not a
+   * single file. Use `resolveAll()` to get every file in the package — that
+   * matches Go's compile-unit semantics and is what the graph wants for
+   * accurate reachability. `resolve()` is kept for back-compat callers
+   * that only need a representative file.
    */
   resolve(importPath) {
-    if (!this.modulePath) return null;
-    if (importPath.startsWith(".")) return null;
-    if (!importPath.startsWith(this.modulePath)) return null;
+    const all = this.resolveAll(importPath);
+    return all[0] ?? null;
+  }
+  /**
+   * Resolve a module-path import to ALL non-test .go files in the target
+   * package directory. This matches Go's compile-unit semantics: a single
+   * `import "github.com/foo/bar/pkg"` statement brings the entire `pkg/`
+   * directory into the dependency graph — every exported symbol from
+   * every .go file in that directory is accessible to the caller.
+   *
+   * Pre-fix the resolver returned only ONE file per import, which made
+   * gin's `binding/` package (~20 files) appear to be a single file from
+   * the graph's perspective. The bench's graphReachability on gin
+   * collapsed to 0.32 because PRs that touched 4 files in `binding/`
+   * had only ONE of them in the graph reach of the entry-point file.
+   * Returning ALL package files fixes the structural model.
+   *
+   * Test files (_test.go) are intentionally excluded — they're not part
+   * of a package's public API and aren't imported by callers. The
+   * test↔source link is handled separately by per-directory sibling
+   * edges (see DependencyGraph's Go intra-package pass).
+   */
+  resolveAll(importPath) {
+    if (!this.modulePath) return [];
+    if (importPath.startsWith(".")) return [];
+    if (!importPath.startsWith(this.modulePath)) return [];
     const suffix = importPath.slice(this.modulePath.length);
-    if (!suffix) return null;
+    if (!suffix) return [];
     const subPath = suffix.startsWith("/") ? suffix.slice(1) : suffix;
     const absDir = path3.join(this.rootDir, subPath);
-    return this.firstGoFileInDir(absDir, subPath);
+    return this.allGoFilesInDir(
+      absDir,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
   /**
    * Resolve a relative import (`./config`, `../pkg`) from a given Go source file.
    * Returns the relative project path to the first .go file found, or null.
+   * Kept for back-compat — most callers should prefer `resolveRelativeAll()`.
    */
   resolveRelative(fromFile, importSpec) {
+    const all = this.resolveRelativeAll(fromFile, importSpec);
+    return all[0] ?? null;
+  }
+  /**
+   * Resolve a relative import to ALL non-test .go files in the target
+   * package directory. See `resolveAll()` for rationale.
+   */
+  resolveRelativeAll(fromFile, importSpec) {
     const fromDir = path3.dirname(fromFile);
     const absTarget = path3.resolve(fromDir, importSpec);
     const subPath = path3.relative(this.rootDir, absTarget);
-    return this.firstGoFileInDir(absTarget, subPath);
+    return this.allGoFilesInDir(
+      absTarget,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
-  firstGoFileInDir(absDir, relDir) {
-    if (!fs3.existsSync(absDir)) return null;
+  /**
+   * Enumerate every .go file in a directory, returning project-relative
+   * paths sorted with non-test files first. Used by both the single-file
+   * and all-files resolvers.
+   */
+  allGoFilesInDir(absDir, relDir, includeTests) {
+    if (!fs3.existsSync(absDir)) return [];
     let entries;
     try {
       entries = fs3.readdirSync(absDir);
     } catch {
-      return null;
+      return [];
     }
-    const goFiles = entries.filter((f) => f.endsWith(".go")).sort((a, b) => {
+    const goFiles = entries.filter((f) => f.endsWith(".go")).filter((f) => includeTests || !f.endsWith("_test.go")).sort((a, b) => {
       const aTest = a.endsWith("_test.go") ? 1 : 0;
       const bTest = b.endsWith("_test.go") ? 1 : 0;
       return aTest - bTest || a.localeCompare(b);
     });
-    if (goFiles.length === 0) return null;
-    return path3.join(relDir, goFiles[0]).replace(/\\/g, "/");
+    return goFiles.map((f) => path3.join(relDir, f).replace(/\\/g, "/"));
   }
 };
 
@@ -1818,6 +2024,24 @@ function extractImports(filePath, content) {
       return extractNotebookImports(filePath, content);
     case ".vue":
       return extractVueImports(content);
+    case ".c":
+    case ".cc":
+    case ".cpp":
+    case ".cxx":
+    case ".h":
+    case ".hh":
+    case ".hpp":
+    case ".hxx":
+      return extractCppImports(content);
+    case ".scala":
+      return extractScalaImports(content);
+    case ".lua":
+      return extractLuaImports(content);
+    case ".ex":
+    case ".exs":
+      return extractElixirImports(content);
+    case ".zig":
+      return extractZigImports(content);
     default:
       return [];
   }
@@ -1837,8 +2061,14 @@ function resolveImport(fromAbs, raw, rootDir) {
   if (ext === ".dart") return resolveDartImport(fromAbs, fromDir, raw, rootDir);
   if (ext === ".ipynb") return resolvePythonImport(fromAbs, fromDir, raw, rootDir);
   if (ext === ".vue") return resolveVueImport(fromAbs, fromDir, raw, rootDir);
+  if (CPP_EXTENSIONS.has(ext)) return resolveCppImport(fromDir, raw, rootDir);
+  if (ext === ".scala") return resolveScalaImport(fromDir, raw, rootDir);
+  if (ext === ".lua") return resolveLuaImport(fromDir, raw, rootDir);
+  if (ext === ".ex" || ext === ".exs") return resolveElixirImport(fromDir, raw, rootDir);
+  if (ext === ".zig") return resolveZigImport(fromAbs, fromDir, raw, rootDir);
   return null;
 }
+var CPP_EXTENSIONS = /* @__PURE__ */ new Set([".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"]);
 function extractPythonImports(content) {
   const results = [];
   let m;
@@ -2125,6 +2355,124 @@ function resolveVueImport(fromAbs, fromDir, raw, rootDir) {
   }
   return null;
 }
+function extractCppImports(content) {
+  const results = [];
+  const localInclude = /^\s*#\s*include\s+"([^"]+)"/gm;
+  let m;
+  while ((m = localInclude.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: true });
+  }
+  return results;
+}
+function resolveCppImport(fromDir, raw, rootDir) {
+  const rootResolved = path4.resolve(rootDir);
+  const candidates = [
+    path4.resolve(fromDir, raw.specifier),
+    path4.resolve(rootDir, raw.specifier)
+  ];
+  for (const c of candidates) {
+    if (!c.startsWith(rootResolved + path4.sep) && c !== rootResolved) continue;
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  return null;
+}
+function extractScalaImports(content) {
+  const results = [];
+  const importRe = /^\s*import\s+((?:\w+\.)*\w+)(?:\.\{[^}]+\})?/gm;
+  let m;
+  while ((m = importRe.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveScalaImport(fromDir, raw, rootDir) {
+  const asPath = raw.specifier.replace(/\./g, path4.sep);
+  const candidates = [
+    path4.join(rootDir, "src", "main", "scala", asPath + ".scala"),
+    path4.join(rootDir, asPath + ".scala")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  const className = raw.specifier.split(".").pop() ?? raw.specifier;
+  const local = path4.join(fromDir, className + ".scala");
+  if (fs4.existsSync(local)) return path4.relative(rootDir, local);
+  return null;
+}
+function extractLuaImports(content) {
+  const results = [];
+  const requireRe = /\brequire\s*\(?\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = requireRe.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveLuaImport(fromDir, raw, rootDir) {
+  const asPath = raw.specifier.replace(/\./g, path4.sep);
+  const candidates = [
+    path4.join(fromDir, asPath + ".lua"),
+    path4.join(rootDir, asPath + ".lua"),
+    // Lua's package convention also supports init.lua as a directory
+    // entry point — analogous to Python's __init__.py.
+    path4.join(rootDir, asPath, "init.lua")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  return null;
+}
+function extractElixirImports(content) {
+  const results = [];
+  const re = /^\s*(?:alias|import|use|require)\s+([A-Z][\w.]*)/gm;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveElixirImport(fromDir, raw, rootDir) {
+  const segments = raw.specifier.split(".").map(
+    (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase()
+  );
+  const asPath = segments.join(path4.sep);
+  const candidates = [
+    path4.join(rootDir, "lib", asPath + ".ex"),
+    path4.join(rootDir, "lib", asPath + ".exs"),
+    path4.join(rootDir, asPath + ".ex"),
+    path4.join(rootDir, asPath + ".exs")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  const tail = segments[segments.length - 1];
+  const local = path4.join(fromDir, tail + ".ex");
+  if (fs4.existsSync(local)) return path4.relative(rootDir, local);
+  return null;
+}
+function extractZigImports(content) {
+  const results = [];
+  const importRe = /@import\s*\(\s*"([^"]+)"\s*\)/g;
+  let m;
+  while ((m = importRe.exec(content)) !== null) {
+    const spec = m[1];
+    if (spec.endsWith(".zig")) {
+      const isRelative = spec.startsWith(".") || !spec.includes("/");
+      results.push({ specifier: spec, isRelative });
+    }
+  }
+  return results;
+}
+function resolveZigImport(fromAbs, fromDir, raw, rootDir) {
+  void fromAbs;
+  const rootResolved = path4.resolve(rootDir);
+  const candidate = path4.resolve(fromDir, raw.specifier);
+  if (!candidate.startsWith(rootResolved + path4.sep) && candidate !== rootResolved) {
+    return null;
+  }
+  if (fs4.existsSync(candidate)) return path4.relative(rootDir, candidate);
+  return null;
+}
 
 // packages/core/src/utils/TsConfigPathsResolver.ts
 import fs5 from "fs";
@@ -2355,6 +2703,7 @@ var CallGraphIndex = class _CallGraphIndex {
 
 // packages/core/src/graph/DependencyGraph.ts
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".vue"]);
+var PY_EXTENSIONS = /* @__PURE__ */ new Set([".py", ".ipynb"]);
 var AST_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs", ".java", ".cs", ".rb", ".kt", ".kts", ".swift", ".ipynb", ".php", ".dart"]);
 var DependencyGraph = class {
   /** file → set of files it imports (forward edges) */
@@ -2364,6 +2713,31 @@ var DependencyGraph = class {
   /** Symbol index: symbolName → { filePath, type, signature, startLine?, endLine? } */
   symbolIndex = /* @__PURE__ */ new Map();
   callGraphIndex = new CallGraphIndex();
+  /**
+   * Re-export tracing (v1.6.x):
+   *   reExportMap[barrelFile][symbol] = sourceFile
+   *
+   * Built during graph construction from `from .submodule import Name`
+   * statements (Python). When file C imports `from <barrel> import Name`,
+   * the import resolver consults this map and emits a parallel edge
+   * C → sourceFile so blast-radius queries against sourceFile can find
+   * C as a transitive consumer through the barrel.
+   *
+   * Concrete fastapi case:
+   *   tests/test_routing.py has `from fastapi import APIRouter`
+   *   fastapi/__init__.py has `from .routing import APIRouter`
+   *   → reExportMap['fastapi/__init__.py']['APIRouter'] = 'fastapi/routing.py'
+   *   → emit edge tests/test_routing.py → fastapi/routing.py
+   */
+  reExportMap = /* @__PURE__ */ new Map();
+  /**
+   * Pending re-export queries. Populated during pass 1 (parse all
+   * files, extract their imports); resolved in pass 2 once the
+   * reExportMap is fully built. Required because file ordering would
+   * otherwise miss re-exports whose source files are parsed AFTER the
+   * consumer file.
+   */
+  pendingReExportQueries = [];
   parser = null;
   rootDir = "";
   snapshotDir = "";
@@ -2418,8 +2792,10 @@ var DependencyGraph = class {
             for (const imp of importNodes) {
               const spec = imp.source ?? imp.name;
               const isRelative = spec.startsWith(".");
-              const resolved = isRelative ? goResolver.resolveRelative(absPath, spec) : goResolver.resolve(spec);
-              if (resolved) this.addEdge(relPath, resolved);
+              const resolvedAll = isRelative ? goResolver.resolveRelativeAll(absPath, spec) : goResolver.resolveAll(spec);
+              for (const resolved of resolvedAll) {
+                this.addEdge(relPath, resolved);
+              }
             }
           } else {
             const importNodes = nodes.filter((n) => n.type === "import");
@@ -2428,7 +2804,26 @@ var DependencyGraph = class {
                 const specifier = imp.source ?? imp.name;
                 const isRelative = specifier.startsWith(".");
                 const resolved = resolveImport(absPath, { specifier, isRelative }, rootDir);
-                if (resolved) this.addEdge(relPath, resolved);
+                if (resolved) {
+                  this.addEdge(relPath, resolved);
+                  if (ext === ".py" && imp.importedNames && imp.importedNames.length > 0) {
+                    if (isRelative) {
+                      let map = this.reExportMap.get(relPath);
+                      if (!map) {
+                        map = /* @__PURE__ */ new Map();
+                        this.reExportMap.set(relPath, map);
+                      }
+                      for (const name of imp.importedNames) {
+                        map.set(name, resolved);
+                      }
+                    }
+                    this.pendingReExportQueries.push({
+                      caller: relPath,
+                      barrel: resolved,
+                      symbols: imp.importedNames
+                    });
+                  }
+                }
               }
             } else {
               const content = fs6.readFileSync(absPath, "utf-8");
@@ -2440,7 +2835,7 @@ var DependencyGraph = class {
             }
           }
           for (const node of nodes) {
-            if (node.type === "function" || node.type === "class" || node.type === "interface") {
+            if (node.type === "function" || node.type === "class" || node.type === "interface" || node.type === "method") {
               const existing = this.symbolIndex.get(node.name) ?? [];
               existing.push({
                 filePath: relPath,
@@ -2457,6 +2852,11 @@ var DependencyGraph = class {
             for (const edge of callEdges) {
               this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
             }
+          } else if (PY_EXTENSIONS.has(ext)) {
+            const callEdges = await this.parser.parseAllPythonCallEdges(absPath);
+            for (const edge of callEdges) {
+              this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
+            }
           }
         } else {
           const content = fs6.readFileSync(absPath, "utf-8");
@@ -2470,6 +2870,49 @@ var DependencyGraph = class {
         logger.error("Failed to parse", { file: relPath, detail: err instanceof Error ? err.message : String(err) });
       }
     }
+    let reExportEdgesAdded = 0;
+    for (const { caller, barrel, symbols } of this.pendingReExportQueries) {
+      const map = this.reExportMap.get(barrel);
+      if (!map) continue;
+      for (const sym of symbols) {
+        const source = map.get(sym);
+        if (source && source !== caller && source !== barrel) {
+          this.addEdge(caller, source);
+          reExportEdgesAdded += 1;
+        }
+      }
+    }
+    this.pendingReExportQueries = [];
+    if (reExportEdgesAdded > 0) {
+      logger.info("Re-export tracing added parallel edges", { count: reExportEdgesAdded });
+    }
+    let goTestEdgesAdded = 0;
+    for (const relPath of this.forwardEdges.keys()) {
+      if (!relPath.endsWith("_test.go")) continue;
+      const dir = path6.dirname(relPath);
+      const base = path6.basename(relPath, "_test.go");
+      const namesake = path6.join(dir, base + ".go").replace(/\\/g, "/");
+      if (this.forwardEdges.has(namesake)) {
+        this.addEdge(relPath, namesake);
+        this.addEdge(namesake, relPath);
+        goTestEdgesAdded += 2;
+        continue;
+      }
+      const absDir = path6.join(this.rootDir, dir);
+      try {
+        const siblings = fs6.readdirSync(absDir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+        for (const sib of siblings) {
+          const sibRel = path6.join(dir, sib).replace(/\\/g, "/");
+          this.addEdge(relPath, sibRel);
+          this.addEdge(sibRel, relPath);
+          goTestEdgesAdded += 2;
+        }
+      } catch {
+      }
+    }
+    if (goTestEdgesAdded > 0) {
+      logger.info("Go test\u2194source linkage added edges", { count: goTestEdgesAdded });
+    }
     await this.saveSnapshot();
     logger.info("Graph built", { files: files.length, edges: this.edgeCount() });
     if (options?.afterReady) {
@@ -2662,8 +3105,10 @@ var DependencyGraph = class {
           for (const imp of importNodes) {
             const spec = imp.source ?? imp.name;
             const isRelative = spec.startsWith(".");
-            const resolved = isRelative ? goResolver.resolveRelative(absPath, spec) : goResolver.resolve(spec);
-            if (resolved) this.addEdge(relPath, resolved);
+            const resolvedAll = isRelative ? goResolver.resolveRelativeAll(absPath, spec) : goResolver.resolveAll(spec);
+            for (const resolved of resolvedAll) {
+              this.addEdge(relPath, resolved);
+            }
           }
         } else {
           const importNodes = nodes.filter((n) => n.type === "import");
@@ -2684,7 +3129,7 @@ var DependencyGraph = class {
           }
         }
         for (const node of nodes) {
-          if (node.type === "function" || node.type === "class" || node.type === "interface") {
+          if (node.type === "function" || node.type === "class" || node.type === "interface" || node.type === "method") {
             const existing = this.symbolIndex.get(node.name) ?? [];
             existing.push({
               filePath: relPath,
@@ -2701,6 +3146,11 @@ var DependencyGraph = class {
           for (const edge of callEdges) {
             this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
           }
+        } else if (PY_EXTENSIONS.has(ext)) {
+          const callEdges = await this.parser.parseAllPythonCallEdges(absPath);
+          for (const edge of callEdges) {
+            this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
+          }
         }
       } else {
         const content = fs6.readFileSync(absPath, "utf-8");
@@ -2757,12 +3207,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 +3997,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 +4145,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 +4161,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 +4175,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 +4185,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path37, fresh);
+    this.nodes.set(path38, fresh);
     return fresh;
   }
 };
@@ -3816,12 +4266,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 +4280,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 +5049,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 +6129,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 +6198,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 +6240,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;");
 }
@@ -6078,7 +6583,7 @@ function buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) {
   const now = Math.floor(Date.now() / 1e3);
   const coupling = [];
   for (const seedFile of changedFiles) {
-    const coupled = overlay.coChange.topFor({ node: seedFile, limit: 10, minConfidence: 0.2 });
+    const coupled = overlay.coChange.topFor({ node: seedFile, limit: 25, minConfidence: 0.1 });
     for (const hit of coupled) {
       const sibling = hit.nodeA === seedFile ? hit.nodeB : hit.nodeA;
       if (!staticSet.has(sibling) && !coupling.some((h) => h.node === sibling)) {
@@ -6095,25 +6600,143 @@ function buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) {
   coupling.splice(10);
   return coupling;
 }
+function collectImportees(changedFiles, graph) {
+  const changedSet = new Set(changedFiles);
+  const importees = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const imp of graph.getImports(file)) {
+      if (!changedSet.has(imp)) importees.add(imp);
+    }
+  }
+  return importees;
+}
+var SYMBOL_CALLERS_TOP_K = 25;
+var PATH_PROXIMITY_BONUS = 1;
+var SYMBOL_CALLERS_MIN_SCORE = 1;
+function pathProximityScore(callerFile, seedFile) {
+  const lastSlash = seedFile.lastIndexOf("/");
+  const lastDot = seedFile.lastIndexOf(".");
+  const stem = seedFile.slice(
+    lastSlash + 1,
+    lastDot > lastSlash ? lastDot : seedFile.length
+  );
+  if (stem.length < 3) return 0;
+  const shortPrefix = stem.slice(0, 3);
+  const tokens = stem === shortPrefix ? [stem] : [stem, shortPrefix];
+  const caller = callerFile.toLowerCase();
+  for (const t of tokens) {
+    const token = t.toLowerCase();
+    const re = new RegExp(`(?:^|[/_.\\-])${token}(?:[/_.\\-]|$)`);
+    if (re.test(caller)) return PATH_PROXIMITY_BONUS;
+  }
+  return 0;
+}
+function collectSymbolCallers(changedFiles, graph) {
+  const changedSet = new Set(changedFiles);
+  const callGraph = graph.getCallGraphIndex();
+  const callerScores = /* @__PURE__ */ new Map();
+  const callersWithProximityApplied = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    const symbols = graph.lookupSymbolsByFile(file);
+    for (const sym of symbols) {
+      const defs = graph.lookupSymbol(sym);
+      const definedInSeed = defs.some((d) => changedSet.has(d.filePath));
+      if (!definedInSeed) continue;
+      const specificity = 1 / defs.length;
+      const seenForSym = /* @__PURE__ */ new Set();
+      for (const caller of callGraph.getCallers(sym)) {
+        if (changedSet.has(caller.file)) continue;
+        if (seenForSym.has(caller.file)) continue;
+        seenForSym.add(caller.file);
+        const prev = callerScores.get(caller.file) ?? 0;
+        const next = prev + specificity;
+        callerScores.set(caller.file, next);
+      }
+    }
+    for (const callerFile of callerScores.keys()) {
+      if (callersWithProximityApplied.has(callerFile)) continue;
+      const bonus = pathProximityScore(callerFile, file);
+      if (bonus > 0) {
+        callerScores.set(callerFile, (callerScores.get(callerFile) ?? 0) + bonus);
+      }
+      callersWithProximityApplied.add(callerFile);
+    }
+  }
+  const ranked = Array.from(callerScores.entries()).filter(([, score]) => score >= SYMBOL_CALLERS_MIN_SCORE).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  });
+  return new Set(ranked.slice(0, SYMBOL_CALLERS_TOP_K).map(([file]) => file));
+}
+var SEMANTIC_TOP_K = 10;
+var SEMANTIC_DIST_THRESHOLD = 0.5;
+async function computeSemanticSimilar(changedFiles, vectorStore, staticSet) {
+  return collectSemanticSimilar(changedFiles, vectorStore, staticSet);
+}
+async function collectSemanticSimilar(changedFiles, vectorStore, staticSet) {
+  const changedSet = new Set(changedFiles);
+  const scores = /* @__PURE__ */ new Map();
+  for (const seedFile of changedFiles) {
+    let embedding;
+    try {
+      embedding = await vectorStore.findEmbeddingByPath(seedFile);
+    } catch {
+      continue;
+    }
+    if (embedding === null) continue;
+    let results;
+    try {
+      results = await vectorStore.search(embedding, SEMANTIC_TOP_K + 5);
+    } catch {
+      continue;
+    }
+    for (const r of results) {
+      if (changedSet.has(r.filePath)) continue;
+      if (staticSet.has(r.filePath)) continue;
+      if (r.score >= SEMANTIC_DIST_THRESHOLD) continue;
+      const prev = scores.get(r.filePath);
+      if (prev === void 0 || r.score < prev) {
+        scores.set(r.filePath, r.score);
+      }
+    }
+  }
+  return Array.from(scores.entries()).sort((a, b) => a[1] - b[1]).slice(0, SEMANTIC_TOP_K).map(([node, score]) => ({ node, score }));
+}
 function getImpactRadius(input) {
-  const { graph, overlay, changedFiles, depth = 3 } = input;
+  const {
+    graph,
+    overlay,
+    changedFiles,
+    depth = 3,
+    includeImportees = false,
+    includeSymbolCallers = false
+  } = input;
   const { directImporters, allReachable } = traverseImporters(changedFiles, graph, depth);
   const transitiveImporters = [];
   for (const file of allReachable) {
     if (!directImporters.has(file)) transitiveImporters.push(file);
   }
+  const importeesSet = includeImportees ? collectImportees(changedFiles, graph) : /* @__PURE__ */ new Set();
+  const directImportees = Array.from(importeesSet);
+  const symbolCallersSet = includeSymbolCallers ? collectSymbolCallers(changedFiles, graph) : /* @__PURE__ */ new Set();
+  const symbolCallers = Array.from(symbolCallersSet);
   const staticSet = /* @__PURE__ */ new Set([
     ...changedFiles,
     ...directImporters,
-    ...transitiveImporters
+    ...transitiveImporters,
+    ...directImportees,
+    ...symbolCallers
   ]);
   const historicalCoupling = overlay !== void 0 ? buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) : [];
-  const totalImpacted = directImporters.size + transitiveImporters.length;
+  const totalImpacted = directImporters.size + transitiveImporters.length + directImportees.length + symbolCallers.length;
   return {
     seedFiles: [...changedFiles],
     directImporters: Array.from(directImporters),
     transitiveImporters,
+    directImportees,
+    symbolCallers,
     historicalCoupling,
+    semanticSimilar: [],
     totalImpacted
   };
 }
@@ -6597,7 +7220,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 +7271,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 +7289,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 +7476,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 +7496,7 @@ function escapeXML14(text) {
 }
 function safeFileSize(filePath) {
   try {
-    return fs14.statSync(filePath).size;
+    return fs15.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -7163,8 +7786,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 +7807,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 +7874,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 +8079,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 +8122,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 +8140,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 +8156,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 +8172,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 +8194,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 +8315,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 +8339,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 +8348,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 +8392,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 +8536,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 +8568,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 +8640,7 @@ function registerFullTextSearchTool(registry, ctx) {
       };
       if (mode === "semantic") {
         try {
-          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-7YOG4DFN.js");
+          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-2JWDJUE2.js");
           const store = await ctx.getStore(project_root);
           const embedding = await generateEmbedding2(query);
           const results = await store.search(embedding, limit);
@@ -8039,7 +8662,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 +8677,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-2JWDJUE2.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 +8896,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 +8909,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 +8930,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 +8986,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 +8995,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 +9398,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 +9414,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 +9829,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 +10060,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 +10085,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 +10151,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 +10177,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 +10187,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 +10198,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 +10225,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 +10258,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 +10451,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 +10463,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 +10480,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 +10496,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 +10520,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 +10528,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.
@@ -9926,16 +10549,14 @@ var PathValidator = class {
 
 // packages/core/src/watcher/FileWatcher.ts
 import chokidar from "chokidar";
-var IGNORED = [
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.ctxloom/**",
-  "**/coverage/**",
-  "**/.next/**",
-  "**/.cache/**"
-];
+function isIgnoredPath(absPath) {
+  const segments = absPath.split(/[\\/]/);
+  for (const seg of segments) {
+    if (INDEXER_IGNORED_DIRS.has(seg)) return true;
+  }
+  return false;
+}
+var IGNORED = isIgnoredPath;
 var FileWatcher = class {
   root;
   onChange;
@@ -10062,7 +10683,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 +10704,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 +10727,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 +10858,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 +10883,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,10 +10912,10 @@ 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.7.0".length > 0 ? "1.7.0" : "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" : "");
+var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (true ? "https://81c94a0f04a8e242dee493ac1e17f733@o4508531702497280.ingest.de.sentry.io/4511256875368528" : "");
 var cachedDistinctId = null;
 function resolveDistinctId() {
   if (cachedDistinctId) return cachedDistinctId;
@@ -10424,17 +11045,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 +11064,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 +11182,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 +11199,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 +11213,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 +11365,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 +11391,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 +11422,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 +11433,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 +11460,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 +11537,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";
@@ -10929,6 +11550,27 @@ The graph is faster, cheaper (fewer tokens), and gives you
 structural context (callers, dependents, test coverage) that file
 scanning cannot.
 
+### Operating principles
+
+ctxloom's tools exist to operationalize four principles for working
+with an AI coding agent. They're the *why* behind every tool below.
+Adapted from Karpathy's LLM-coding-pitfalls notes
+(<https://github.com/multica-ai/andrej-karpathy-skills>, MIT).
+
+1. **Think before coding** \u2014 read the relevant graph slice before
+   editing. \`ctx_blast_radius\`, \`ctx_get_call_graph\`,
+   \`ctx_get_review_context\` are how you do this without re-reading
+   whole files.
+2. **Simplicity first** \u2014 prefer the smallest viable change. Use
+   \`ctx_refactor_preview\` to see the full diff *before* applying;
+   if the preview is sprawling, the plan is too big.
+3. **Surgical changes** \u2014 every changed line should trace directly
+   to the user's request. \`ctx_detect_changes\` after each edit
+   confirms scope hasn't drifted.
+4. **Goal-driven execution** \u2014 stop when the goal is met. Don't
+   "polish" beyond the request. \`ctx_knowledge_gaps\` flags real
+   risk surfaces; everything else is yak-shaving.
+
 ### Start every workflow with \`ctx_get_minimal_context\`
 
 The first MCP call into ctxloom should always be
@@ -11174,9 +11816,18 @@ description: Orient yourself to an unfamiliar codebase using ctxloom's structura
 
 # Explore Codebase
 
+**Principle: Think Before Coding.** Exploration is "think" with a
+budget. The trap is reading every file in sight; the discipline is
+to read the *graph*, then the few files the graph nominates. This
+skill caps you at 5 tool calls and 2000 tokens \u2014 enough to ground
+the next edit, not enough to procrastinate.
+
 Use this when you need to understand a codebase you haven't worked in
 before, or when re-orienting after time away.
 
+**Skip when:** you already know which files matter \u2014 just open them.
+Reserve this skill for "I don't know where to start" situations.
+
 ## Steps
 
 1. **Orientation anchor**: call \`ctx_get_minimal_context(task="explore this codebase")\`.
@@ -11225,9 +11876,17 @@ argument-hint: "<symbol-name | file-path>"
 
 # Blast Radius
 
+**Principle: Think Before Coding.** You can't make a surgical change
+if you don't know who depends on the symbol. This skill is the
+"think" phase \u2014 read the graph slice before editing anything.
+
 Use this before any change to a public function, type, or file
 where you're not sure who depends on it.
 
+**Skip when:** the change is purely internal to a private helper
+with no callers outside the file, OR you've already run this skill
+for the same symbol in the current task.
+
 ## Inputs
 
 - \`$ARGUMENTS\` \u2014 the symbol name (e.g. \`emitTelemetry\`) or file
@@ -11276,9 +11935,18 @@ argument-hint: "<old-name> <new-name>"
 
 # Refactor Safely
 
+**Principle: Surgical Changes.** A rename touches every call site \u2014
+done blindly it's the opposite of surgical. This skill enforces
+"see the full diff before applying" so the change stays scoped to
+the user's request and doesn't accidentally rewrite tangents.
+
 Use this for renames, signature changes, or function moves. The
 skill enforces preview-before-apply.
 
+**Skip when:** the symbol is local to a single file (just edit it),
+OR the user wants a behavior change, not a rename (use the regular
+edit flow with \`ctx_blast_radius\` for impact awareness).
+
 ## Inputs
 
 - \`$1\` \u2014 current symbol name (e.g. \`emitTelemetry\`)
@@ -11331,9 +11999,18 @@ description: Identify code that lacks test coverage, prioritized by caller frequ
 
 # Coverage Gap Analysis
 
+**Principle: Goal-Driven Execution.** "Add tests everywhere" is
+yak-shaving. The goal is to add tests where they pay back the
+investment: high-caller, high-churn, low-coverage code. This skill
+ranks gaps so you write tests with intent, not by reflex.
+
 Use this to find untested code that genuinely matters \u2014 the
 intersection of "no tests" + "many callers" + "high risk score."
 
+**Skip when:** the user asked for tests on a specific symbol \u2014
+write them directly. Reserve this skill for "where should we
+invest in tests next?" queries.
+
 ## Steps
 
 1. **Orientation**: call \`ctx_get_minimal_context(task="check test coverage")\`.
@@ -11381,10 +12058,20 @@ argument-hint: "<PR number | branch name>"
 
 # Review PR
 
+**Principle: Think Before Coding.** A code review *is* the "think"
+phase for the author and the reviewer alike. This skill structures
+that thinking around graph slices rather than naive file-by-file
+reading, so you spot blast-radius and coverage risks the diff alone
+hides.
+
 Comprehensive PR review using ctxloom's graph. Mirrors the
 multi-agent review the ctxloom-bot posts automatically \u2014 useful
 when reviewing manually or when the bot isn't wired up.
 
+**Skip when:** the PR is one-file, \u226430 lines, with full test
+coverage \u2014 read the diff directly. Reserve this skill for changes
+where the structural impact isn't obvious from the diff.
+
 ## Inputs
 
 - \`$ARGUMENTS\` \u2014 PR number (e.g. \`142\`) or branch name (e.g. \`feat/foo\`).
@@ -11472,6 +12159,11 @@ description: Inspect ctxloom's per-tool budget telemetry \u2014 fallback distrib
 
 # Budget Stats
 
+**Principle: Simplicity First.** Don't guess what \`DEFAULT_MAX_RESPONSE_TOKENS\`
+should be \u2014 measure. This skill turns real telemetry into the
+simplest viable constant: the p75 of actual usage. Tune what hurts;
+leave the rest alone.
+
 Wrapper around \`ctxloom budget-stats\` for inline use inside a
 Claude Code session. Useful when:
 
@@ -11480,6 +12172,10 @@ Claude Code session. Useful when:
 - Diagnosing why a tool keeps falling back to skeleton mode
 - Understanding which tools dominate the user's token budget
 
+**Skip when:** there's no budget complaint to investigate \u2014 telemetry
+exists for tuning, not browsing. Reserve this skill for "this tool
+keeps hitting the budget" or scheduled tuning passes.
+
 ## Steps
 
 1. **Orientation**: call \`ctx_get_minimal_context(task="inspect budget telemetry")\`.
@@ -11542,8 +12238,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 +12287,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 +12318,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 +12331,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 +12356,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 +12383,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 +12408,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 +12430,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 +12489,8 @@ export {
   loadTrendSeries,
   loadFileRiskHistory,
   Skeletonizer,
+  inspectVectorsDb,
+  cleanupVectors,
   renderStatusXml,
   __resetLearnedSuggestionsCacheForTests,
   learnSuggestionsFromTelemetry,
@@ -11805,6 +12503,7 @@ export {
   emitTaskBudgetBreached,
   ToolRegistry,
   detectChanges,
+  computeSemanticSimilar,
   getImpactRadius,
   buildBlastRadiusXml,
   validateAlias,
@@ -11889,4 +12588,4 @@ export {
   skillFilePath,
   installHarness
 };
-//# sourceMappingURL=chunk-5R4P7VEE.js.map
+//# sourceMappingURL=chunk-FFCLVZCO.js.map