ctxloom-pro 1.5.5 → 1.7.0

package/apps/dashboard/dist/server/index.js

@@ -79,6 +79,27 @@ var init_logger = __esm({
 // ../../packages/core/src/indexer/embedder.ts
 import fs3 from "fs";
 import path3 from "path";
+function resolveEmbeddingModel(env = process.env) {
+  const envModel = env.CTXLOOM_EMBEDDING_MODEL?.trim();
+  if (!envModel) return MODEL_REGISTRY.minilm;
+  const registered = MODEL_REGISTRY[envModel];
+  if (registered) return registered;
+  const envDim = env.CTXLOOM_EMBEDDING_DIM ? Number.parseInt(env.CTXLOOM_EMBEDDING_DIM, 10) : NaN;
+  if (!Number.isFinite(envDim) || envDim <= 0) {
+    throw new Error(
+      `CTXLOOM_EMBEDDING_MODEL=${envModel} is not a known alias. Either use one of [${Object.keys(MODEL_REGISTRY).join(", ")}] or set CTXLOOM_EMBEDDING_DIM=<vector-length> alongside a raw HF id.`
+    );
+  }
+  return {
+    hfId: envModel,
+    dim: envDim,
+    // Without a known artifact size we can't enforce the truncated-download
+    // guard. Use 1 MB as the minimum; the worst case is a redundant retry
+    // rather than a hung process.
+    minBytes: 1024 * 1024,
+    description: `User-supplied model: ${envModel} (${envDim}-dim)`
+  };
+}
 function collectFiles(dir, results = []) {
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     // Build artifacts + dependency caches
@@ -144,12 +165,37 @@ function collectFiles(dir, results = []) {
   }
   return results;
 }
-var MIN_MODEL_BYTES;
+var MODEL_REGISTRY, ACTIVE_MODEL, EMBEDDING_DIMENSION, MODEL_ID, MIN_MODEL_BYTES;
 var init_embedder = __esm({
   "../../packages/core/src/indexer/embedder.ts"() {
     "use strict";
     init_logger();
-    MIN_MODEL_BYTES = 80 * 1024 * 1024;
+    MODEL_REGISTRY = {
+      // The historical default. General English, 384-dim, ~90 MB.
+      // Kept as the free-tier default so existing users see zero change.
+      minilm: {
+        hfId: "sentence-transformers/all-MiniLM-L6-v2",
+        dim: 384,
+        minBytes: 80 * 1024 * 1024,
+        description: "General-purpose English sentence embedder (2020). 384-dim. The legacy default."
+      },
+      // Code-specific embedding model (Jina AI). 768-dim, ~140 MB.
+      // Empirically 20-40% better recall on code-similarity queries than
+      // MiniLM — the upgrade path recommended in the v1.7.0 analysis.
+      // Runs through the same @huggingface/transformers pipeline so the
+      // privacy story (fully local, no network at inference time) is
+      // preserved.
+      "jina-code": {
+        hfId: "jinaai/jina-embeddings-v2-base-code",
+        dim: 768,
+        minBytes: 130 * 1024 * 1024,
+        description: "Code-specific embedder (Jina, 2024). 768-dim. Better recall on code-similarity tasks."
+      }
+    };
+    ACTIVE_MODEL = resolveEmbeddingModel();
+    EMBEDDING_DIMENSION = ACTIVE_MODEL.dim;
+    MODEL_ID = ACTIVE_MODEL.hfId;
+    MIN_MODEL_BYTES = ACTIVE_MODEL.minBytes;
   }
 });
 
@@ -160,18 +206,19 @@ var init_VectorStore = __esm({
   "../../packages/core/src/db/VectorStore.ts"() {
     "use strict";
     init_logger();
+    init_embedder();
   }
 });
 
 // server/index.ts
 import express from "express";
 import cors from "cors";
-import path46 from "path";
-import fs34 from "fs";
+import path47 from "path";
+import fs35 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // server/loader.ts
-import path40 from "path";
+import path41 from "path";
 
 // ../../packages/core/src/graph/DependencyGraph.ts
 import fs7 from "fs";
@@ -657,6 +704,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) {
@@ -828,6 +882,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) {
@@ -934,10 +1038,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
           });
@@ -1807,6 +1935,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.
@@ -1893,48 +2093,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 = path4.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 = path4.dirname(fromFile);
     const absTarget = path4.resolve(fromDir, importSpec);
     const subPath = path4.relative(this.rootDir, absTarget);
-    return this.firstGoFileInDir(absTarget, subPath);
+    return this.allGoFilesInDir(
+      absTarget,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
-  firstGoFileInDir(absDir, relDir) {
-    if (!fs4.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 (!fs4.existsSync(absDir)) return [];
     let entries;
     try {
       entries = fs4.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 path4.join(relDir, goFiles[0]).replace(/\\/g, "/");
+    return goFiles.map((f) => path4.join(relDir, f).replace(/\\/g, "/"));
   }
 };
 
@@ -1976,6 +2228,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 [];
   }
@@ -1995,8 +2265,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;
@@ -2283,6 +2559,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 = path5.resolve(rootDir);
+  const candidates = [
+    path5.resolve(fromDir, raw.specifier),
+    path5.resolve(rootDir, raw.specifier)
+  ];
+  for (const c of candidates) {
+    if (!c.startsWith(rootResolved + path5.sep) && c !== rootResolved) continue;
+    if (fs5.existsSync(c)) return path5.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, path5.sep);
+  const candidates = [
+    path5.join(rootDir, "src", "main", "scala", asPath + ".scala"),
+    path5.join(rootDir, asPath + ".scala")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.relative(rootDir, c);
+  }
+  const className = raw.specifier.split(".").pop() ?? raw.specifier;
+  const local = path5.join(fromDir, className + ".scala");
+  if (fs5.existsSync(local)) return path5.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, path5.sep);
+  const candidates = [
+    path5.join(fromDir, asPath + ".lua"),
+    path5.join(rootDir, asPath + ".lua"),
+    // Lua's package convention also supports init.lua as a directory
+    // entry point — analogous to Python's __init__.py.
+    path5.join(rootDir, asPath, "init.lua")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.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(path5.sep);
+  const candidates = [
+    path5.join(rootDir, "lib", asPath + ".ex"),
+    path5.join(rootDir, "lib", asPath + ".exs"),
+    path5.join(rootDir, asPath + ".ex"),
+    path5.join(rootDir, asPath + ".exs")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.relative(rootDir, c);
+  }
+  const tail = segments[segments.length - 1];
+  const local = path5.join(fromDir, tail + ".ex");
+  if (fs5.existsSync(local)) return path5.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 = path5.resolve(rootDir);
+  const candidate = path5.resolve(fromDir, raw.specifier);
+  if (!candidate.startsWith(rootResolved + path5.sep) && candidate !== rootResolved) {
+    return null;
+  }
+  if (fs5.existsSync(candidate)) return path5.relative(rootDir, candidate);
+  return null;
+}
 
 // ../../packages/core/src/utils/TsConfigPathsResolver.ts
 import fs6 from "fs";
@@ -2513,6 +2907,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) */
@@ -2522,6 +2917,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 = "";
@@ -2576,8 +2996,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");
@@ -2586,7 +3008,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 map2 = this.reExportMap.get(relPath);
+                      if (!map2) {
+                        map2 = /* @__PURE__ */ new Map();
+                        this.reExportMap.set(relPath, map2);
+                      }
+                      for (const name of imp.importedNames) {
+                        map2.set(name, resolved);
+                      }
+                    }
+                    this.pendingReExportQueries.push({
+                      caller: relPath,
+                      barrel: resolved,
+                      symbols: imp.importedNames
+                    });
+                  }
+                }
               }
             } else {
               const content = fs7.readFileSync(absPath, "utf-8");
@@ -2598,7 +3039,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,
@@ -2615,6 +3056,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 = fs7.readFileSync(absPath, "utf-8");
@@ -2628,6 +3074,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 map2 = this.reExportMap.get(barrel);
+      if (!map2) continue;
+      for (const sym of symbols) {
+        const source = map2.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 = path7.dirname(relPath);
+      const base = path7.basename(relPath, "_test.go");
+      const namesake = path7.join(dir, base + ".go").replace(/\\/g, "/");
+      if (this.forwardEdges.has(namesake)) {
+        this.addEdge(relPath, namesake);
+        this.addEdge(namesake, relPath);
+        goTestEdgesAdded += 2;
+        continue;
+      }
+      const absDir = path7.join(this.rootDir, dir);
+      try {
+        const siblings = fs7.readdirSync(absDir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+        for (const sib of siblings) {
+          const sibRel = path7.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) {
@@ -2820,8 +3309,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");
@@ -2842,7 +3333,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,
@@ -2859,6 +3350,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 = fs7.readFileSync(absPath, "utf-8");
@@ -2915,12 +3411,12 @@ var DependencyGraph = class {
       symbolIndex: Object.fromEntries(this.symbolIndex.entries())
     };
     const snapshotPath = this.getSnapshotPath();
-    const tmpPath = snapshotPath + ".tmp";
+    const tmpPath = `${snapshotPath}.${process.pid}.tmp`;
     fs7.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
     fs7.renameSync(tmpPath, snapshotPath);
     const callData = this.callGraphIndex.toJSON();
     const callPath = path7.join(this.snapshotDir, "call-graph-snapshot.json");
-    const callTmp = callPath + ".tmp";
+    const callTmp = `${callPath}.${process.pid}.tmp`;
     fs7.writeFileSync(callTmp, JSON.stringify(callData));
     fs7.renameSync(callTmp, callPath);
   }
@@ -3267,8 +3763,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 path47 of paths) {
-      this.nodeCounts.set(path47, (this.nodeCounts.get(path47) ?? 0) + 1);
+    for (const path48 of paths) {
+      this.nodeCounts.set(path48, (this.nodeCounts.get(path48) ?? 0) + 1);
     }
     for (let i = 0; i < paths.length; i++) {
       for (let j = i + 1; j < paths.length; j++) {
@@ -3415,8 +3911,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path47, raw] of this.nodes) {
-      nodes[path47] = {
+    for (const [path48, raw] of this.nodes) {
+      nodes[path48] = {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3431,8 +3927,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   static load(s) {
     const idx = new _ChurnIndex();
-    for (const [path47, raw] of Object.entries(s.nodes)) {
-      idx.nodes.set(path47, {
+    for (const [path48, raw] of Object.entries(s.nodes)) {
+      idx.nodes.set(path48, {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3445,8 +3941,8 @@ var ChurnIndex = class _ChurnIndex {
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path47) {
-    const existing = this.nodes.get(path47);
+  getOrCreate(path48) {
+    const existing = this.nodes.get(path48);
     if (existing !== void 0) return existing;
     const fresh = {
       commits: 0,
@@ -3455,7 +3951,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path47, fresh);
+    this.nodes.set(path48, fresh);
     return fresh;
   }
 };
@@ -3536,12 +4032,12 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path47, raw] of this.nodes) {
+    for (const [path48, raw] of this.nodes) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      nodes[path47] = { authorWeights, lastTouch: raw.lastTouch };
+      nodes[path48] = { authorWeights, lastTouch: raw.lastTouch };
     }
     return { version: 1, nodes };
   }
@@ -3550,23 +4046,23 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   static load(s) {
     const idx = new _OwnershipIndex();
-    for (const [path47, raw] of Object.entries(s.nodes)) {
+    for (const [path48, raw] of Object.entries(s.nodes)) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      idx.nodes.set(path47, { authorWeights, lastTouch: raw.lastTouch });
+      idx.nodes.set(path48, { authorWeights, lastTouch: raw.lastTouch });
     }
     return idx;
   }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path47) {
-    const existing = this.nodes.get(path47);
+  getOrCreate(path48) {
+    const existing = this.nodes.get(path48);
     if (existing !== void 0) return existing;
     const fresh = { authorWeights: {}, lastTouch: 0 };
-    this.nodes.set(path47, fresh);
+    this.nodes.set(path48, fresh);
     return fresh;
   }
 };
@@ -4326,6 +4822,11 @@ ${methodLines.join("\n")}
 init_embedder();
 init_VectorStore();
 
+// ../../packages/core/src/db/vectorsCleanup.ts
+import fs16 from "fs";
+import path16 from "path";
+var VECTOR_DB_REL = path16.join(".ctxloom", "vectors.lancedb");
+
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -4804,8 +5305,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path47, errorMaps, issueData } = params;
-  const fullPath = [...path47, ...issueData.path || []];
+  const { data, path: path48, errorMaps, issueData } = params;
+  const fullPath = [...path48, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4921,11 +5422,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path47, key) {
+  constructor(parent, value, path48, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path47;
+    this._path = path48;
     this._key = key;
   }
   get path() {
@@ -8379,13 +8880,13 @@ init_logger();
 
 // ../../packages/core/src/budget/eventCollector.ts
 init_logger();
-import fs16 from "fs";
+import fs17 from "fs";
 import os2 from "os";
-import path16 from "path";
-var DEFAULT_TELEMETRY_DIR = path16.join(os2.homedir(), ".ctxloom", "telemetry");
+import path17 from "path";
+var DEFAULT_TELEMETRY_DIR = path17.join(os2.homedir(), ".ctxloom", "telemetry");
 function telemetryDir() {
   const raw = process.env.CTXLOOM_TELEMETRY_DIR ?? DEFAULT_TELEMETRY_DIR;
-  if (raw.includes("..") || !path16.isAbsolute(raw)) {
+  if (raw.includes("..") || !path17.isAbsolute(raw)) {
     if (!telemetryDirWarned) {
       telemetryDirWarned = true;
       logger.warn('CTXLOOM_TELEMETRY_DIR rejected \u2014 must be an absolute path with no ".." segments; using default', {
@@ -8395,7 +8896,7 @@ function telemetryDir() {
     }
     return DEFAULT_TELEMETRY_DIR;
   }
-  return path16.resolve(raw);
+  return path17.resolve(raw);
 }
 var telemetryDirWarned = false;
 function filenameForDate(date) {
@@ -8408,12 +8909,12 @@ function readEvents(opts = {}) {
   const until = opts.until ?? /* @__PURE__ */ new Date();
   const since = opts.since ?? new Date(until.getTime() - 14 * 24 * 60 * 60 * 1e3);
   const dir = telemetryDir();
-  if (!fs16.existsSync(dir)) return [];
+  if (!fs17.existsSync(dir)) return [];
   const out = [];
   for (let cursor = new Date(Date.UTC(since.getUTCFullYear(), since.getUTCMonth(), since.getUTCDate())); cursor.getTime() <= until.getTime(); cursor = new Date(cursor.getTime() + 24 * 60 * 60 * 1e3)) {
-    const file = path16.join(dir, filenameForDate(cursor));
-    if (!fs16.existsSync(file)) continue;
-    const text = fs16.readFileSync(file, "utf-8");
+    const file = path17.join(dir, filenameForDate(cursor));
+    if (!fs17.existsSync(file)) continue;
+    const text = fs17.readFileSync(file, "utf-8");
     for (const line of text.split("\n")) {
       if (line.trim() === "") continue;
       let parsed;
@@ -8474,7 +8975,7 @@ var Schema2 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/context-packet.ts
-import path17 from "path";
+import path18 from "path";
 var Schema3 = external_exports.object({
   target_file: external_exports.string().describe("Relative path to the primary file"),
   mode: external_exports.enum(["edit", "read"]).optional().default("edit").describe("Context mode"),
@@ -8486,7 +8987,7 @@ var Schema3 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/findCallers.ts
-import path18 from "path";
+import path19 from "path";
 
 // ../../packages/core/src/tools/call-graph.ts
 var Schema4 = external_exports.object({
@@ -8587,7 +9088,7 @@ var Schema12 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/knowledge-gaps.ts
-import path19 from "path";
+import path20 from "path";
 var Schema13 = external_exports.object({
   min_importers: external_exports.number().min(1).max(50).optional().default(3).describe(
     "Minimum importers to qualify as an untested hub (default: 3)"
@@ -8616,7 +9117,7 @@ var Schema14 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/wiki-generate.ts
-import fs17 from "fs";
+import fs18 from "fs";
 var Schema15 = external_exports.object({
   force: external_exports.boolean().optional().default(false).describe(
     "Regenerate all pages even if content unchanged (default: false)"
@@ -8664,8 +9165,8 @@ var Schema17 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/refactor-preview.ts
-import fs18 from "fs";
-import path20 from "path";
+import fs19 from "fs";
+import path21 from "path";
 var Schema18 = external_exports.object({
   symbol: external_exports.string().min(1).describe("Symbol name to rename (exact match, case-sensitive)"),
   new_name: external_exports.string().min(1).describe("New name for the symbol"),
@@ -8700,8 +9201,8 @@ var Schema19 = external_exports.object({
 init_embedder();
 init_VectorStore();
 init_logger();
-import fs19 from "fs";
-import path21 from "path";
+import fs20 from "fs";
+import path22 from "path";
 var Schema20 = external_exports.object({
   query: external_exports.string().min(1).describe("Search query \u2014 natural language or code fragment"),
   limit: external_exports.number().min(1).max(100).optional().default(10).describe(
@@ -8718,8 +9219,8 @@ var Schema20 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/apply-refactor.ts
-import fs20 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path23 from "path";
 var Schema21 = external_exports.object({
   symbol: external_exports.string().min(1).describe("Symbol name to rename (exact, case-sensitive)"),
   new_name: external_exports.string().min(1).describe("New name for the symbol"),
@@ -8752,8 +9253,8 @@ var Schema22 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/full-text-search.ts
-import fs21 from "fs";
-import path23 from "path";
+import fs22 from "fs";
+import path24 from "path";
 var Schema23 = external_exports.object({
   query: external_exports.string().min(1).describe("Search term \u2014 literal or /regex/"),
   mode: external_exports.enum(["hybrid", "keyword", "semantic"]).optional().default("hybrid"),
@@ -8785,8 +9286,8 @@ var Schema25 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/graph-snapshot.ts
-import fs22 from "fs";
-import path24 from "path";
+import fs23 from "fs";
+import path25 from "path";
 var schema = external_exports.object({
   name: external_exports.string().min(1).max(64).regex(/^[\w.-]+$/, "Name may only contain letters, digits, dots, underscores, hyphens").describe(
     'Snapshot name (e.g. "before-refactor", "v1.0"). Used as the filename.'
@@ -8798,8 +9299,8 @@ var schema = external_exports.object({
 });
 
 // ../../packages/core/src/tools/graph-diff.ts
-import fs23 from "fs";
-import path25 from "path";
+import fs24 from "fs";
+import path26 from "path";
 var schema2 = external_exports.object({
   baseline: external_exports.string().min(1).describe('Name of the baseline snapshot (the "before" state).'),
   current: external_exports.string().min(1).describe('Name of the current snapshot (the "after" state).'),
@@ -8840,8 +9341,8 @@ var Schema27 = external_exports.object({
 });
 
 // ../../packages/core/src/rules/loadConfig.ts
-import fs24 from "fs/promises";
-import path26 from "path";
+import fs25 from "fs/promises";
+import path27 from "path";
 
 // ../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -11482,35 +11983,36 @@ var Schema30 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/ruleManager.ts
-import fs25 from "fs";
-import path27 from "path";
-
-// ../../packages/core/src/review/AuthorResolver.ts
-import fs26 from "fs/promises";
+import fs26 from "fs";
 import path28 from "path";
 
-// ../../packages/core/src/review/CodeownersWriter.ts
+// ../../packages/core/src/review/AuthorResolver.ts
 import fs27 from "fs/promises";
 import path29 from "path";
 
-// ../../packages/core/src/review/loadConfig.ts
+// ../../packages/core/src/review/CodeownersWriter.ts
 import fs28 from "fs/promises";
 import path30 from "path";
 
-// ../../packages/core/src/security/PathValidator.ts
+// ../../packages/core/src/review/loadConfig.ts
+import fs29 from "fs/promises";
 import path31 from "path";
-import fs29 from "fs";
+
+// ../../packages/core/src/security/PathValidator.ts
+import path32 from "path";
+import fs30 from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 
 // ../../packages/core/src/index.ts
 init_logger();
 
 // ../../packages/core/src/watcher/FileWatcher.ts
+init_embedder();
 init_logger();
 
 // ../../packages/core/src/license/LicenseStore.ts
 import { readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync, existsSync } from "fs";
-import path32 from "path";
+import path33 from "path";
 
 // ../../packages/core/src/license/types.ts
 var FINGERPRINT_RE = /^sha256:[0-9a-f]{64}$/;
@@ -11541,11 +12043,11 @@ import os6 from "os";
 
 // ../../packages/core/src/license/DistinctIdStore.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import path33 from "path";
+import path34 from "path";
 import os4 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 path33.join(home ?? os4.homedir(), ".ctxloom", "distinct_id");
+  return path34.join(home ?? os4.homedir(), ".ctxloom", "distinct_id");
 }
 function isValidV4(id) {
   return typeof id === "string" && UUID_V4_REGEX.test(id);
@@ -11566,7 +12068,7 @@ function getOrCreateDistinctId(home) {
     id: crypto.randomUUID(),
     alias_pending: os4.hostname()
   };
-  mkdirSync2(path33.dirname(filePath), { recursive: true });
+  mkdirSync2(path34.dirname(filePath), { recursive: true });
   writeFileSync2(filePath, JSON.stringify(record), { mode: 384 });
   return record;
 }
@@ -11592,10 +12094,10 @@ function resolveTelemetryLevel() {
 }
 var TELEMETRY_LEVEL = resolveTelemetryLevel();
 var TELEMETRY_DISABLED = TELEMETRY_LEVEL === "off";
-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;
@@ -11725,32 +12227,32 @@ function parseStack(stack) {
 
 // ../../packages/core/src/license/FunnelMilestones.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import path34 from "path";
+import path35 from "path";
 import os5 from "os";
 
 // ../../packages/core/src/license/TelemetryNotice.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import path35 from "path";
+import path36 from "path";
 import os7 from "os";
 
 // ../../packages/core/src/server/ProjectState.ts
-import path37 from "path";
+import path38 from "path";
 
 // ../../packages/core/src/server/projectId.ts
 import crypto5 from "crypto";
-import path36 from "path";
+import path37 from "path";
 
 // ../../packages/core/src/server/ProjectStateManager.ts
 init_logger();
 
 // ../../packages/core/src/server/resolveProjectRoot.ts
-import fs30 from "fs";
-import path38 from "path";
-
-// ../../packages/core/src/install/installer.ts
 import fs31 from "fs";
 import path39 from "path";
 
+// ../../packages/core/src/install/installer.ts
+import fs32 from "fs";
+import path40 from "path";
+
 // ../../packages/core/src/install/templates.ts
 var RULES_BLOCK_CONTENT = `## MCP Tools: ctxloom
 
@@ -11760,6 +12262,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
@@ -11989,7 +12512,7 @@ function summarize(events, windowStart, windowEnd) {
 
 // server/loader.ts
 async function loadContext(root) {
-  const absRoot = path40.resolve(root);
+  const absRoot = path41.resolve(root);
   const overlay = new GitOverlayStore(absRoot);
   const gitEnabled = await overlay.loadSnapshot();
   const graph = new DependencyGraph();
@@ -12242,21 +12765,21 @@ function buildOwnershipRouter(ctx) {
 
 // server/routes/file.ts
 import { Router as Router7 } from "express";
-import fs32 from "fs/promises";
-import path41 from "path";
+import fs33 from "fs/promises";
+import path42 from "path";
 function buildFileRouter(ctx) {
   const router = Router7();
   router.get("/", async (req, res) => {
     const rel = req.query.path;
     if (!rel) return res.status(400).json({ error: "missing path" });
-    const abs = path41.resolve(ctx.root, rel);
-    const rootBoundary = ctx.root.endsWith(path41.sep) ? ctx.root : ctx.root + path41.sep;
+    const abs = path42.resolve(ctx.root, rel);
+    const rootBoundary = ctx.root.endsWith(path42.sep) ? ctx.root : ctx.root + path42.sep;
     if (abs !== ctx.root && !abs.startsWith(rootBoundary)) {
       return res.status(403).json({ error: "forbidden" });
     }
     try {
-      const content = await fs32.readFile(abs, "utf-8");
-      const ext = path41.extname(abs).slice(1);
+      const content = await fs33.readFile(abs, "utf-8");
+      const ext = path42.extname(abs).slice(1);
       res.json({ content, lines: content.split("\n").length, ext });
     } catch {
       res.status(404).json({ error: "not found" });
@@ -12268,7 +12791,7 @@ function buildFileRouter(ctx) {
 // server/routes/open.ts
 import { Router as Router8 } from "express";
 import { execFile as execFile2 } from "child_process";
-import path42 from "path";
+import path43 from "path";
 function tryOpen(bin, abs) {
   return new Promise((resolve) => {
     execFile2(bin, [abs], { timeout: 5e3 }, (err) => resolve(!err));
@@ -12279,8 +12802,8 @@ function buildOpenRouter(ctx) {
   router.post("/", async (req, res) => {
     const rel = req.body?.path;
     if (!rel || typeof rel !== "string") return res.status(400).json({ error: "missing path" });
-    const abs = path42.resolve(ctx.root, rel);
-    const rootBoundary = ctx.root.endsWith(path42.sep) ? ctx.root : ctx.root + path42.sep;
+    const abs = path43.resolve(ctx.root, rel);
+    const rootBoundary = ctx.root.endsWith(path43.sep) ? ctx.root : ctx.root + path43.sep;
     if (abs !== ctx.root && !abs.startsWith(rootBoundary)) {
       return res.status(403).json({ error: "forbidden" });
     }
@@ -12292,8 +12815,8 @@ function buildOpenRouter(ctx) {
 
 // server/routes/tokens.ts
 import { Router as Router9 } from "express";
-import path43 from "path";
-import fs33 from "fs";
+import path44 from "path";
+import fs34 from "fs";
 var CHARS_PER_TOKEN = 4;
 var cache = null;
 function buildTokensRouter(ctx) {
@@ -12308,9 +12831,9 @@ function buildTokensRouter(ctx) {
     let fullChars = 0;
     let skeletonChars = 0;
     for (const file of files) {
-      const absPath = path43.join(ctx.root, file);
+      const absPath = path44.join(ctx.root, file);
       try {
-        const content = fs33.readFileSync(absPath, "utf-8");
+        const content = fs34.readFileSync(absPath, "utf-8");
         fullChars += content.length;
         const skeleton = await skeletonizer.skeletonize(absPath);
         skeletonChars += skeleton.length;
@@ -12411,17 +12934,17 @@ function buildFileTrendsRouter(ctx) {
 
 // server/routes/projects.ts
 import { Router as Router12 } from "express";
-import path45 from "path";
+import path46 from "path";
 
 // server/projects.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import os8 from "os";
-import path44 from "path";
+import path45 from "path";
 import crypto7 from "crypto";
 var HOME = os8.homedir();
-var REGISTRY_PATH = path44.join(HOME, ".ctxloom", "repos.json");
+var REGISTRY_PATH = path45.join(HOME, ".ctxloom", "repos.json");
 function slugFor(root) {
-  const abs = path44.resolve(root);
+  const abs = path45.resolve(root);
   return crypto7.createHash("sha1").update(abs).digest("hex").slice(0, 12);
 }
 function readRegistry() {
@@ -12436,27 +12959,27 @@ function readRegistry() {
   }
 }
 function listProjects(defaultRoot) {
-  const absDefault = path44.resolve(defaultRoot);
+  const absDefault = path45.resolve(defaultRoot);
   const out = [
     {
       slug: slugFor(absDefault),
-      name: path44.basename(absDefault) || absDefault,
+      name: path45.basename(absDefault) || absDefault,
       root: absDefault,
       isDefault: true,
-      hasSnapshot: existsSync5(path44.join(absDefault, ".ctxloom"))
+      hasSnapshot: existsSync5(path45.join(absDefault, ".ctxloom"))
     }
   ];
   const seen = /* @__PURE__ */ new Set([absDefault]);
   for (const entry of readRegistry()) {
-    const abs = path44.resolve(entry.root);
+    const abs = path45.resolve(entry.root);
     if (seen.has(abs)) continue;
     seen.add(abs);
     const item = {
       slug: slugFor(abs),
-      name: entry.name ?? (path44.basename(abs) || abs),
+      name: entry.name ?? (path45.basename(abs) || abs),
       root: abs,
       isDefault: false,
-      hasSnapshot: existsSync5(path44.join(abs, ".ctxloom"))
+      hasSnapshot: existsSync5(path45.join(abs, ".ctxloom"))
     };
     if (entry.alias !== void 0) item.alias = entry.alias;
     out.push(item);
@@ -12509,7 +13032,7 @@ function buildProjectsRouter(deps) {
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
       res.status(500).json({
-        error: `failed to switch to ${path45.basename(target.root)}: ${detail}`
+        error: `failed to switch to ${path46.basename(target.root)}: ${detail}`
       });
     }
   });
@@ -12619,7 +13142,7 @@ function buildBudgetEventsRouter() {
 }
 
 // server/index.ts
-var __dirname2 = path46.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path47.dirname(fileURLToPath2(import.meta.url));
 async function startDashboard(options) {
   const { root, port, open } = options;
   console.log(`ctxloom dashboard \u2014 loading context from ${root}...`);
@@ -12679,9 +13202,9 @@ async function startDashboard(options) {
       }
       activeWatcher = null;
     }
-    const snapshotDir = path46.join(targetRoot, ".ctxloom");
+    const snapshotDir = path47.join(targetRoot, ".ctxloom");
     try {
-      activeWatcher = fs34.watch(snapshotDir, (_event, filename) => {
+      activeWatcher = fs35.watch(snapshotDir, (_event, filename) => {
         if (!filename || !filename.includes("snapshot")) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(async () => {
@@ -12710,12 +13233,12 @@ async function startDashboard(options) {
       attachSnapshotWatcher(newRoot);
     }
   }));
-  const clientDist = path46.join(__dirname2, "../dashboard/client");
-  const clientDistExists = fs34.existsSync(path46.join(clientDist, "index.html"));
+  const clientDist = path47.join(__dirname2, "../dashboard/client");
+  const clientDistExists = fs35.existsSync(path47.join(clientDist, "index.html"));
   if (clientDistExists) {
     app.use(express.static(clientDist, { dotfiles: "allow" }));
     app.get(/.*/, (_req, res) => {
-      res.sendFile(path46.join(clientDist, "index.html"), { dotfiles: "allow" });
+      res.sendFile(path47.join(clientDist, "index.html"), { dotfiles: "allow" });
     });
   } else {
     app.get(/^\/(?!api\/).*/, (_req, res) => {