@wrongstack/tools 0.299.0 → 0.300.0

package/dist/codebase-index/project-server.js

@@ -31,7 +31,10 @@ function detectLang(file) {
 function isIndexablePath(file) {
   return detectLang(file) !== null;
 }
-var EXT_TO_LANG, INDEXABLE_EXTENSIONS, SPECIAL_FILENAMES;
+function languageFamily(lang) {
+  return LANG_FAMILY[lang] ?? "other";
+}
+var EXT_TO_LANG, INDEXABLE_EXTENSIONS, SPECIAL_FILENAMES, LANG_FAMILY, LANG_FAMILY_ENTRIES;
 var init_languages = __esm({
   "src/codebase-index/languages.ts"() {
     "use strict";
@@ -122,6 +125,52 @@ var init_languages = __esm({
       procfile: "other",
       justfile: "other"
     };
+    LANG_FAMILY = {
+      // Single-compilation-unit family: a .vue/.svelte script block is JS/TS and
+      // imports from — and is imported by — plain .ts files.
+      ts: "js",
+      tsx: "js",
+      js: "js",
+      jsx: "js",
+      vue: "js",
+      svelte: "js",
+      go: "go",
+      py: "py",
+      rs: "rs",
+      // The JVM resolves across languages: Kotlin and Scala call Java directly.
+      java: "jvm",
+      kotlin: "jvm",
+      scala: "jvm",
+      csharp: "dotnet",
+      // A .h header is consumed by both C and C++ translation units.
+      c: "c",
+      cpp: "c",
+      ruby: "ruby",
+      php: "php",
+      swift: "swift",
+      dart: "dart",
+      elixir: "elixir",
+      haskell: "haskell",
+      zig: "zig",
+      lua: "lua",
+      r: "r",
+      shell: "shell",
+      sql: "sql",
+      json: "data",
+      yaml: "data",
+      toml: "data",
+      html: "web",
+      css: "web",
+      proto: "proto",
+      graphql: "graphql",
+      md: "other",
+      other: "other"
+    };
+    LANG_FAMILY_ENTRIES = Object.freeze(
+      Object.entries(LANG_FAMILY).map(
+        ([lang, family]) => Object.freeze([lang, family])
+      )
+    );
   }
 });
 
@@ -286,7 +335,7 @@ function getTypeName(name) {
 function deduplicateRefs(refs) {
   const seen = /* @__PURE__ */ new Set();
   return refs.filter((r) => {
-    const key = `${r.toName}:${r.callType}:${r.line}`;
+    const key = `${r.toName}:${r.callType}:${r.line}:${r.module ?? ""}`;
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -296,10 +345,16 @@ function getImportSpecifierName(spec) {
   return spec.propertyName?.text ?? spec.name.text;
 }
 function emitImportSpecifierRefs(node, refs, lineNum) {
+  const module = moduleSpecifierOf(node.moduleSpecifier);
   const clause = node.importClause;
-  if (!clause) return;
+  if (!clause) {
+    if (module) {
+      refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
+    }
+    return;
+  }
   if (clause.name) {
-    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
   }
   const bindings = clause.namedBindings;
   if (!bindings) return;
@@ -309,26 +364,40 @@ function emitImportSpecifierRefs(node, refs, lineNum) {
         fromId: 0,
         toName: getImportSpecifierName(element),
         callType: "import",
-        line: lineNum
+        line: lineNum,
+        module
       });
     }
   } else if (ts.isNamespaceImport(bindings)) {
-    refs.push({ fromId: 0, toName: bindings.name.text, callType: "import", line: lineNum });
+    refs.push({
+      fromId: 0,
+      toName: bindings.name.text,
+      callType: "import",
+      line: lineNum,
+      module
+    });
   }
 }
+function moduleSpecifierOf(node) {
+  return node && ts.isStringLiteral(node) ? node.text : void 0;
+}
 function emitExportSpecifierRefs(node, refs, lineNum) {
+  const module = moduleSpecifierOf(node.moduleSpecifier);
   const clause = node.exportClause;
   if (clause && ts.isNamespaceExport(clause)) {
-    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
     return;
   }
   if (clause && ts.isNamedExports(clause)) {
     for (const element of clause.elements) {
       const originalName = element.propertyName?.text ?? element.name.text;
-      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum });
+      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum, module });
     }
     return;
   }
+  if (module) {
+    refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
+  }
 }
 var ts, tsLoad, kindMapCache;
 var init_ts_parser = __esm({
@@ -341,21 +410,21 @@ var init_ts_parser = __esm({
 });
 
 // src/_win32-resolve.ts
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path5 from "node:path";
 function resolveWin32Command(cmd) {
   if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path3.extname(cmd.replace(/\//g, "\\"))) {
+  if (cmd.includes("/") || cmd.includes("\\") || path5.extname(cmd.replace(/\//g, "\\"))) {
     return cmd;
   }
   const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path3.delimiter);
+  const pathDirs = (process.env["PATH"] ?? "").split(path5.delimiter);
   for (const dir of pathDirs) {
-    const base = path3.join(dir, cmd);
+    const base = path5.join(dir, cmd);
     for (const ext of pathext) {
       const full = `${base}${ext}`;
       try {
-        fs2.accessSync(full, fs2.constants.X_OK);
+        fs3.accessSync(full, fs3.constants.X_OK);
         return full;
       } catch {
       }
@@ -369,6 +438,82 @@ var init_win32_resolve = __esm({
   }
 });
 
+// src/codebase-index/parser-output.ts
+function coerceSymbols(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const candidate = entry;
+    if (typeof candidate.name !== "string" || typeof candidate.kind !== "string") return [];
+    return [
+      {
+        name: candidate.name,
+        kind: candidate.kind,
+        line: typeof candidate.line === "number" ? candidate.line : 1,
+        col: typeof candidate.col === "number" ? candidate.col : 0,
+        signature: typeof candidate.signature === "string" ? candidate.signature : "",
+        scope: typeof candidate.scope === "string" ? candidate.scope : ""
+      }
+    ];
+  });
+}
+function coerceRefs(value, lang) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const candidate = entry;
+    if (typeof candidate.toName !== "string" || !candidate.toName) return [];
+    if (typeof candidate.callType !== "string" || !CALL_TYPES.has(candidate.callType)) return [];
+    const module = typeof candidate.module === "string" && candidate.module ? candidate.module : void 0;
+    return [
+      {
+        fromId: 0,
+        toName: candidate.toName,
+        callType: candidate.callType,
+        line: typeof candidate.line === "number" ? candidate.line : 1,
+        lang,
+        module
+      }
+    ];
+  });
+}
+function parseParserOutput(stdout, lang) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { symbols: [], refs: [] };
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(trimmed);
+  } catch {
+    return { symbols: [], refs: [] };
+  }
+  if (Array.isArray(parsed2)) return { symbols: coerceSymbols(parsed2), refs: [] };
+  const record = parsed2;
+  return {
+    symbols: coerceSymbols(record.symbols),
+    refs: dedupeRefs(coerceRefs(record.refs, lang))
+  };
+}
+function dedupeRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((ref) => {
+    const key = `${ref.toName}:${ref.callType}:${ref.line}:${ref.module ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+var CALL_TYPES;
+var init_parser_output = __esm({
+  "src/codebase-index/parser-output.ts"() {
+    "use strict";
+    CALL_TYPES = /* @__PURE__ */ new Set([
+      "call",
+      "type_ref",
+      "inherit",
+      "implement",
+      "import"
+    ]);
+  }
+});
+
 // src/codebase-index/spawn-gate.ts
 function withSpawnGate(fn) {
   const run = chain.then(fn, fn);
@@ -394,8 +539,8 @@ __export(go_parser_exports, {
 });
 import { spawn } from "node:child_process";
 import * as os from "node:os";
-import * as path4 from "node:path";
-import * as fs3 from "node:fs/promises";
+import * as path6 from "node:path";
+import * as fs4 from "node:fs/promises";
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
@@ -403,7 +548,8 @@ async function parseSymbols2(opts) {
     if (parsed2.symbols.length > 0) {
       return parsed2;
     }
-    return fallbackParse(file, content, lang);
+    const fallback = fallbackParse(file, content, lang);
+    return parsed2.refs?.length ? { ...fallback, refs: parsed2.refs } : fallback;
   } catch {
     return fallbackParse(file, content, lang);
   }
@@ -467,9 +613,9 @@ async function syncGoParse(filePath, content, lang) {
   try {
     let scriptPath = _cachedGoScriptPath;
     if (!scriptPath) {
-      const tmpDir = await fs3.mkdtemp(path4.join(os.tmpdir(), "ws-go-parse-"));
-      scriptPath = path4.join(tmpDir, "parse.go");
-      await fs3.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+      const tmpDir = await fs4.mkdtemp(path6.join(os.tmpdir(), "ws-go-parse-"));
+      scriptPath = path6.join(tmpDir, "parse.go");
+      await fs4.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
       _cachedGoScriptPath = scriptPath;
     }
     const goBinary = resolveWin32Command("go");
@@ -511,8 +657,8 @@ async function syncGoParse(filePath, content, lang) {
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
-    const raw = JSON.parse(stdout.trim());
-    const symbols = raw.map((s) => ({
+    const { symbols: rawSymbols, refs } = parseParserOutput(stdout, lang);
+    const symbols = rawSymbols.map((s) => ({
       id: 0,
       lang,
       kind: s.kind,
@@ -525,7 +671,7 @@ async function syncGoParse(filePath, content, lang) {
       scope: s.scope ?? "",
       text: `${s.name} ${s.signature ?? ""}`.trim()
     }));
-    return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
   } catch {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -535,6 +681,7 @@ var init_go_parser = __esm({
   "src/codebase-index/go-parser.ts"() {
     "use strict";
     init_win32_resolve();
+    init_parser_output();
     init_spawn_gate();
     init_languages();
     GO_PARSE_SCRIPT = `
@@ -548,6 +695,7 @@ import (
 	"go/token"
 	"io"
 	"os"
+	"strconv"
 	"strings"
 )
 
@@ -560,16 +708,34 @@ type Sym struct {
 	Scope     string \`json:"scope"\`
 }
 
+// Ref is a cross-reference emitted alongside the symbols, so one \`go run\`
+// yields both. Module is the import path for CallType "import", else empty.
+type Ref struct {
+	ToName   string \`json:"toName"\`
+	CallType string \`json:"callType"\`
+	Line     int    \`json:"line"\`
+	Module   string \`json:"module"\`
+}
+
+type Result struct {
+	Symbols []Sym \`json:"symbols"\`
+	Refs    []Ref \`json:"refs"\`
+}
+
+func emptyResult() string {
+	return "{\\"symbols\\":[],\\"refs\\":[]}"
+}
+
 func main() {
 	src, err := io.ReadAll(os.Stdin)
 	if err != nil {
-		fmt.Print("[]")
+		fmt.Print(emptyResult())
 		return
 	}
 	fset := token.NewFileSet()
 	node, err := parser.ParseFile(fset, "src.go", src, 0)
 	if err != nil {
-		fmt.Print("[]")
+		fmt.Print(emptyResult())
 		return
 	}
 
@@ -633,9 +799,43 @@ func main() {
 		}
 	}
 
-	data, err := json.Marshal(syms)
+	refs := []Ref{}
+	ast.Inspect(node, func(n ast.Node) bool {
+		switch expr := n.(type) {
+		case *ast.CallExpr:
+			line := fset.Position(expr.Pos()).Line
+			switch fun := expr.Fun.(type) {
+			case *ast.Ident:
+				refs = append(refs, Ref{ToName: fun.Name, CallType: "call", Line: line})
+			case *ast.SelectorExpr:
+				// Record the selected name (\`Join\` of \`filepath.Join\`): it is the
+				// declared symbol name, so it resolves the same way the TypeScript
+				// and Python extractors' call refs do.
+				refs = append(refs, Ref{ToName: fun.Sel.Name, CallType: "call", Line: line})
+			}
+		case *ast.ImportSpec:
+			if expr.Path != nil {
+				if importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {
+					line := fset.Position(expr.Pos()).Line
+					// A Go import names a package, not a symbol; the package's
+					// last path segment is the name it is referenced by.
+					name := importPath
+					if idx := strings.LastIndex(importPath, "/"); idx >= 0 {
+						name = importPath[idx+1:]
+					}
+					refs = append(refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
+				}
+			}
+		}
+		return true
+	})
+
+	if syms == nil {
+		syms = []Sym{}
+	}
+	data, err := json.Marshal(Result{Symbols: syms, Refs: refs})
 	if err != nil {
-		fmt.Print("[]")
+		fmt.Print(emptyResult())
 		return
 	}
 	fmt.Print(string(data))
@@ -987,9 +1187,13 @@ var init_generic_parser = __esm({
       ],
       elixir: [
         { re: /\bdef(?:p|macro|macrop)?\s+([A-Za-z_]\w*[!?]?)/g, kind: "function" },
-        { re: /\bdefmodule\s+([A-Za-z_.]\w*)/g, kind: "namespace" }
+        // Dotted module names must be captured whole: `alias Foo.Bar` resolves
+        // against this symbol, and a `Foo`-only capture never matches it.
+        { re: /\bdefmodule\s+([A-Z][\w.]*)/g, kind: "namespace" }
       ],
       haskell: [
+        // Target of `import Data.List`.
+        { re: /^module\s+([A-Z][\w.]*)/gm, kind: "namespace" },
         { re: /^([A-Za-z_]\w*)\s*::/gm, kind: "function" },
         { re: /\bdata\s+([A-Za-z_]\w*)/g, kind: "type" },
         { re: /\btype\s+(?:family\s+)?([A-Za-z_]\w*)/g, kind: "type" },
@@ -1080,9 +1284,9 @@ __export(py_parser_exports, {
   parseSymbols: () => parseSymbols4
 });
 import { spawn as spawn2 } from "node:child_process";
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path5 from "node:path";
+import * as path7 from "node:path";
 async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1160,10 +1364,10 @@ function spawnPyParser(pyBinary, scriptPath, filePath, content) {
 async function syncPyParse(filePath, content, lang) {
   try {
     if (!_cachedScriptPath) {
-      const tmpDir = path5.join(os2.tmpdir(), "ws-py-parse");
-      await fs4.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path5.join(tmpDir, "parse.py");
-      await fs4.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+      const tmpDir = path7.join(os2.tmpdir(), "ws-py-parse");
+      await fs5.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path7.join(tmpDir, "parse.py");
+      await fs5.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
     }
     cachedPyBinary ??= resolvePython();
     const pyBinary = await cachedPyBinary;
@@ -1177,7 +1381,7 @@ async function syncPyParse(filePath, content, lang) {
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
-    const raw = JSON.parse(stdout.trim());
+    const { symbols: raw, refs } = parseParserOutput(stdout, lang);
     const symbols = raw.map((s) => ({
       id: 0,
       lang,
@@ -1191,7 +1395,7 @@ async function syncPyParse(filePath, content, lang) {
       scope: s.scope ?? "",
       text: `${s.name} ${s.signature ?? ""}`.trim()
     }));
-    return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
   } catch {
     return null;
   }
@@ -1202,6 +1406,7 @@ var init_py_parser = __esm({
     "use strict";
     init_win32_resolve();
     init_generic_parser();
+    init_parser_output();
     init_spawn_gate();
     init_languages();
     PY_PARSE_SCRIPT = `import ast, json, sys, os
@@ -1263,7 +1468,18 @@ class Sym:
 def is_private(name):
     return name.startswith("__") and not name.endswith("__")
 
+def leaf_name(node):
+    # Declared name of the callee: \`join\` of \`os.path.join\`. Matches how the
+    # TypeScript and Go extractors record call refs, so resolution behaves the
+    # same across languages.
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    if isinstance(node, ast.Name):
+        return node.id
+    return get_name(node).split(".")[-1]
+
 syms = []
+refs = []
 errors = []
 
 try:
@@ -1271,7 +1487,7 @@ try:
     tree = ast.parse(source, filename=sys.argv[1])
 except Exception as e:
     errors.append(str(e))
-    print("[]")
+    print(json.dumps({"symbols": [], "refs": []}))
     sys.exit(0)
 
 # Module-level scope
@@ -1405,7 +1621,42 @@ class ModuleVisitor(ast.NodeVisitor):
 visitor = ModuleVisitor()
 visitor.visit(tree)
 
-print(json.dumps([s.to_dict() for s in syms]))
+# Refs need a separate full walk: ModuleVisitor deliberately does not descend
+# into function bodies (it would index locals as symbols), but that is exactly
+# where the calls are.
+for node in ast.walk(tree):
+    if isinstance(node, ast.Call):
+        name = leaf_name(node.func)
+        if name:
+            refs.append({"toName": name, "callType": "call", "line": node.lineno})
+    elif isinstance(node, ast.Import):
+        for alias in node.names:
+            refs.append({
+                "toName": alias.name.split(".")[-1],
+                "callType": "import",
+                "line": node.lineno,
+                "module": alias.name,
+            })
+    elif isinstance(node, ast.ImportFrom):
+        # PEP 328: node.level is the number of leading dots. Preserving them is
+        # what lets the resolver walk up from the importing file's package \u2014
+        # dropping them made \`from .foo import X\` indistinguishable from an
+        # absolute \`foo\`.
+        module = ("." * (node.level or 0)) + (node.module or "")
+        for alias in node.names:
+            refs.append({
+                "toName": alias.name,
+                "callType": "import",
+                "line": node.lineno,
+                "module": module,
+            })
+    elif isinstance(node, ast.ClassDef):
+        for base in node.bases:
+            name = leaf_name(base)
+            if name:
+                refs.append({"toName": name, "callType": "inherit", "line": node.lineno})
+
+print(json.dumps({"symbols": [s.to_dict() for s in syms], "refs": refs}))
 `;
     _cachedScriptPath = null;
   }
@@ -1418,107 +1669,10 @@ __export(rs_parser_exports, {
   parseSymbols: () => parseSymbols5
 });
 import { expectDefined } from "@wrongstack/core/utils";
-import { execFile, spawn as spawn3 } from "node:child_process";
-import * as fs5 from "node:fs/promises";
-import * as path6 from "node:path";
 async function parseSymbols5(opts) {
   const { file, content, lang } = opts;
-  const nativeAvailable = await checkNativeParser();
-  if (nativeAvailable) {
-    const result = await withSpawnGate(() => tryNativeParse(file, content));
-    if (result) return result;
-  }
   return regexParse({ file, content, lang });
 }
-function probe(command, args) {
-  return new Promise((resolve4, reject) => {
-    execFile(command, args, { timeout: 1e4, windowsHide: true }, (error) => {
-      if (error) reject(error);
-      else resolve4();
-    });
-  });
-}
-function checkNativeParser() {
-  nativeParserAvailability ??= (async () => {
-    try {
-      await probe("rustc", ["--version"]);
-      const toolsDir = path6.join(process.cwd(), "tools");
-      await probe(
-        "cargo",
-        [
-          "metadata",
-          "--no-deps",
-          "--format-version",
-          "1",
-          "--manifest-path",
-          path6.join(toolsDir, "Cargo.toml")
-        ]
-      );
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  return nativeParserAvailability;
-}
-async function tryNativeParse(file, content) {
-  try {
-    const toolsDir = path6.join(process.cwd(), "tools");
-    const crateDir = path6.join(toolsDir, "syn-parser");
-    const tmpFile = path6.join(crateDir, "src", "input.rs");
-    await fs5.writeFile(tmpFile, content, "utf8");
-    const cargoBinary = resolveWin32Command("cargo");
-    const result = await new Promise(
-      (resolve4, reject) => {
-        let settled = false;
-        const proc = spawn3(
-          cargoBinary,
-          ["run", "--manifest-path", path6.join(toolsDir, "Cargo.toml")],
-          {
-            cwd: process.cwd(),
-            stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true
-          }
-        );
-        proc.on("error", (err) => {
-          if (settled) return;
-          settled = true;
-          reject(err);
-        });
-        let stdout2 = "";
-        proc.stdout?.on("data", (chunk) => {
-          stdout2 += chunk.toString();
-        });
-        proc.stderr?.resume();
-        const timer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3);
-        timer.unref?.();
-        proc.on("close", (c) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          resolve4({ code: c, stdout: stdout2 });
-        });
-      }
-    );
-    const { code, stdout } = result;
-    if (code === 0 && stdout.trim()) {
-      const symbols = JSON.parse(stdout.trim());
-      return {
-        file,
-        lang: "rs",
-        symbols: symbols.map((s) => ({ ...s, id: 0, lang: "rs" })),
-        mtimeMs: Date.now()
-      };
-    }
-  } catch {
-  }
-  return null;
-}
 function regexParse(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
@@ -1574,12 +1728,10 @@ function regexParse(opts) {
   });
   return { file, lang, symbols: deduped, mtimeMs: Date.now() };
 }
-var nativeParserAvailability, RS_PATTERNS;
+var RS_PATTERNS;
 var init_rs_parser = __esm({
   "src/codebase-index/rs-parser.ts"() {
     "use strict";
-    init_win32_resolve();
-    init_spawn_gate();
     init_languages();
     RS_PATTERNS = [
       { regex: /fn\s+(\w+)\s*\([^)]*\)/g, kind: "function" },
@@ -1602,7 +1754,7 @@ __export(json_parser_exports, {
   parseSymbols: () => parseSymbols6
 });
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function parseSymbols6(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1614,7 +1766,7 @@ function parseSymbols6(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename6 = path7.basename(file).toLowerCase();
+  const basename6 = path8.basename(file).toLowerCase();
   const isPackageJson = basename6 === "package.json";
   const isTsconfig = basename6 === "tsconfig.json" || basename6 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
@@ -1640,11 +1792,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path7.basename(file),
+        name: path8.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path7.basename(file)}" = { ... }`,
+        signature: `"${path8.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -1985,7 +2137,7 @@ import {
 
 // src/codebase-index/indexer.ts
 import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
-import { execFile as execFile2 } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as fs8 from "node:fs/promises";
 import { availableParallelism } from "node:os";
 import * as path11 from "node:path";
@@ -2053,8 +2205,738 @@ async function loadGitignoreMatcher(projectRoot2) {
 // src/codebase-index/indexer.ts
 init_languages();
 
+// src/codebase-index/module-resolver.ts
+init_languages();
+import * as path4 from "node:path";
+
+// src/codebase-index/module-roots.ts
+init_languages();
+import * as fs2 from "node:fs/promises";
+import * as path3 from "node:path";
+function toPortablePath(file) {
+  return file.replace(/\\/g, "/");
+}
+async function readTextIfPresent(file) {
+  try {
+    return await fs2.readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function parsePackageJsonName(source) {
+  try {
+    const parsed2 = JSON.parse(source);
+    return typeof parsed2.name === "string" && parsed2.name ? parsed2.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseGoModulePath(source) {
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.replace(/\/\/.*$/, "").trim();
+    const match = /^module\s+(\S+)/.exec(line);
+    if (match?.[1]) return match[1].replace(/^["']|["']$/g, "");
+  }
+  return void 0;
+}
+function parseTomlTableName(source, tables) {
+  let current = "";
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*$/, "").trim();
+    if (line.startsWith("[[")) {
+      current = "\0";
+      continue;
+    }
+    const table = /^\[([^\]]+)\]$/.exec(line);
+    if (table?.[1]) {
+      current = table[1].trim();
+      continue;
+    }
+    if (!tables.includes(current)) continue;
+    const match = /^name\s*=\s*["']([^"']+)["']/.exec(line);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+function parsePomArtifactId(source) {
+  const withoutParent = source.replace(/<parent>[\s\S]*?<\/parent>/g, "");
+  return /<artifactId>\s*([^<\s]+)\s*<\/artifactId>/.exec(withoutParent)?.[1];
+}
+var LANGS_BY_KIND = {
+  npm: ["ts", "tsx", "js", "jsx", "vue", "svelte"],
+  cargo: ["rs"],
+  go: ["go"],
+  python: ["py"],
+  maven: ["java", "kotlin", "scala"],
+  gradle: ["java", "kotlin", "scala"],
+  dotnet: ["csharp"]
+};
+function ancestorsOf(dir, stopAt) {
+  const out = [];
+  let current = dir;
+  for (; ; ) {
+    out.push(current);
+    if (current === stopAt || current.length <= stopAt.length) break;
+    const parent = path3.posix.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return out;
+}
+var MARKER_PROBES = [
+  {
+    kind: "npm",
+    file: "package.json",
+    build: (dir, source) => {
+      const name = parsePackageJsonName(source) ?? path3.posix.basename(dir);
+      return { name, importPath: name, sourceRoots: [dir] };
+    }
+  },
+  {
+    kind: "cargo",
+    file: "Cargo.toml",
+    build: (dir, source) => {
+      const name = parseTomlTableName(source, ["package"]);
+      if (!name) return void 0;
+      return {
+        name: `crate:${name}`,
+        // Rust paths use underscores where crate names often use dashes.
+        importPath: name.replace(/-/g, "_"),
+        sourceRoots: [path3.posix.join(dir, "src")]
+      };
+    }
+  },
+  {
+    kind: "go",
+    file: "go.mod",
+    build: (dir, source) => {
+      const modulePath = parseGoModulePath(source);
+      if (!modulePath) return void 0;
+      return { name: `go:${modulePath}`, importPath: modulePath, sourceRoots: [dir] };
+    }
+  },
+  {
+    kind: "python",
+    file: "pyproject.toml",
+    build: (dir, source) => {
+      const name = parseTomlTableName(source, ["project", "tool.poetry"]) ?? path3.posix.basename(dir);
+      return {
+        name: `py:${name}`,
+        importPath: void 0,
+        // `src/` layout is the packaging-guide default; the root itself covers
+        // the flat layout. Both are probed, missing ones simply never match.
+        sourceRoots: [path3.posix.join(dir, "src"), dir]
+      };
+    }
+  },
+  {
+    kind: "python",
+    file: "setup.py",
+    build: (dir) => ({
+      name: `py:${path3.posix.basename(dir)}`,
+      importPath: void 0,
+      sourceRoots: [path3.posix.join(dir, "src"), dir]
+    })
+  },
+  {
+    kind: "maven",
+    file: "pom.xml",
+    build: (dir, source) => {
+      const artifactId = parsePomArtifactId(source) ?? path3.posix.basename(dir);
+      return {
+        name: `mvn:${artifactId}`,
+        importPath: void 0,
+        sourceRoots: [
+          path3.posix.join(dir, "src/main/java"),
+          path3.posix.join(dir, "src/main/kotlin"),
+          path3.posix.join(dir, "src/main/scala"),
+          path3.posix.join(dir, "src/test/java")
+        ]
+      };
+    }
+  },
+  {
+    kind: "gradle",
+    file: "build.gradle",
+    build: (dir) => buildGradleRoot(dir)
+  },
+  {
+    kind: "gradle",
+    file: "build.gradle.kts",
+    build: (dir) => buildGradleRoot(dir)
+  }
+];
+function buildGradleRoot(dir) {
+  return {
+    name: `gradle:${path3.posix.basename(dir)}`,
+    importPath: void 0,
+    sourceRoots: [
+      path3.posix.join(dir, "src/main/java"),
+      path3.posix.join(dir, "src/main/kotlin"),
+      path3.posix.join(dir, "src/main/scala")
+    ]
+  };
+}
+async function probeDotnetRoot(dir) {
+  let entries;
+  try {
+    entries = await fs2.readdir(dir);
+  } catch {
+    return void 0;
+  }
+  const project = entries.find((entry) => entry.toLowerCase().endsWith(".csproj"));
+  if (!project) return void 0;
+  const name = project.slice(0, -".csproj".length);
+  return {
+    dir,
+    kind: "dotnet",
+    name: `csproj:${name}`,
+    importPath: void 0,
+    sourceRoots: [dir]
+  };
+}
+async function detectModuleRoots(projectRoot2, files) {
+  const root = toPortablePath(projectRoot2).replace(/\/+$/, "");
+  const langsByDir = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const portable = toPortablePath(file);
+    const lang = detectLang(portable);
+    if (!lang) continue;
+    const dir = path3.posix.dirname(portable);
+    let langs = langsByDir.get(dir);
+    if (!langs) {
+      langs = /* @__PURE__ */ new Set();
+      langsByDir.set(dir, langs);
+    }
+    langs.add(lang);
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [dir, langs] of langsByDir) {
+    for (const ancestor of ancestorsOf(dir, root)) {
+      let merged = candidates.get(ancestor);
+      if (!merged) {
+        merged = /* @__PURE__ */ new Set();
+        candidates.set(ancestor, merged);
+      }
+      for (const lang of langs) merged.add(lang);
+    }
+  }
+  const roots = [];
+  await Promise.all(
+    [...candidates].map(async ([dir, langs]) => {
+      for (const probe of MARKER_PROBES) {
+        if (!LANGS_BY_KIND[probe.kind].some((lang) => langs.has(lang))) continue;
+        const source = await readTextIfPresent(path3.posix.join(dir, probe.file));
+        if (source === void 0) continue;
+        const built = probe.build(dir, source);
+        if (built) roots.push({ dir, kind: probe.kind, ...built });
+      }
+      if (LANGS_BY_KIND.dotnet.some((lang) => langs.has(lang))) {
+        const dotnet = await probeDotnetRoot(dir);
+        if (dotnet) roots.push(dotnet);
+      }
+    })
+  );
+  roots.sort((a, b) => b.dir.length - a.dir.length || a.dir.localeCompare(b.dir));
+  return { projectRoot: root, roots };
+}
+function findOwningRoot(structure, file, kinds) {
+  const portable = toPortablePath(file);
+  for (const root of structure.roots) {
+    if (kinds && !kinds.includes(root.kind)) continue;
+    if (portable === root.dir || portable.startsWith(`${root.dir}/`)) return root;
+  }
+  return void 0;
+}
+function derivePackageFromLayout(filePath) {
+  const portable = toPortablePath(filePath);
+  const packagesIdx = portable.indexOf("/packages/");
+  if (packagesIdx !== -1) {
+    const segment = portable.slice(packagesIdx + "/packages/".length).split("/")[0];
+    if (segment) return `@wrongstack/${segment}`;
+  }
+  const appsIdx = portable.indexOf("/apps/");
+  if (appsIdx !== -1) {
+    const segment = portable.slice(appsIdx + "/apps/".length).split("/")[0];
+    if (segment) return `app:${segment}`;
+  }
+  return void 0;
+}
+function pythonPackageLabel(structure, file, initDirs) {
+  const portable = toPortablePath(file);
+  const dir = path3.posix.dirname(portable);
+  if (!initDirs.has(dir)) return void 0;
+  const segments = [];
+  let current = dir;
+  while (initDirs.has(current) && current.length > structure.projectRoot.length) {
+    segments.unshift(path3.posix.basename(current));
+    current = path3.posix.dirname(current);
+  }
+  return segments.length > 0 ? `py:${segments.join(".")}` : void 0;
+}
+function assignPackageLabels(structure, files) {
+  const initDirs = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const portable = toPortablePath(file);
+    if (path3.posix.basename(portable) === "__init__.py") {
+      initDirs.add(path3.posix.dirname(portable));
+    }
+  }
+  const labels = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const portable = toPortablePath(file);
+    const lang = detectLang(portable);
+    if (lang === "go") {
+      const owner2 = findOwningRoot(structure, portable, ["go"]);
+      const dir = path3.posix.dirname(portable);
+      if (owner2?.importPath) {
+        const relative3 = path3.posix.relative(owner2.dir, dir);
+        labels.set(file, relative3 ? `${owner2.importPath}/${relative3}` : owner2.importPath);
+      } else {
+        labels.set(file, `go:${path3.posix.relative(structure.projectRoot, dir) || "."}`);
+      }
+      continue;
+    }
+    if (lang === "py") {
+      const dotted = pythonPackageLabel(structure, portable, initDirs);
+      if (dotted) {
+        labels.set(file, dotted);
+        continue;
+      }
+    }
+    const owner = findOwningRoot(structure, portable);
+    const label = owner?.name ?? derivePackageFromLayout(portable) ?? "(root)";
+    labels.set(file, label);
+  }
+  return labels;
+}
+
+// src/codebase-index/module-resolver.ts
+var EXTENSIONS = {
+  js: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".svelte"],
+  py: [".py", ".pyi"],
+  rs: [".rs"],
+  jvm: [".java", ".kt", ".scala"],
+  c: [".h", ".hpp", ".hh", ".hxx", ".c", ".cpp", ".cc", ".cxx"],
+  ruby: [".rb"],
+  go: [".go"]
+};
+var DIRECTORY_ENTRIES = {
+  js: ["index"],
+  py: ["__init__"],
+  rs: ["mod"],
+  ruby: ["index"]
+};
+function normalizeNamespace(value) {
+  return value.replace(/::|[\\/]/g, ".").replace(/^\.+|\.+$/g, "").toLowerCase();
+}
+var ModuleResolver = class {
+  structure;
+  /** Lowercased portable path → the path as indexed (case is preserved). */
+  byPath;
+  /** Lowercased portable directory → files directly inside it, as indexed. */
+  byDir;
+  /** Normalized namespace → the file declaring it (first by path, stable). */
+  byNamespace;
+  constructor(structure, files, namespaces = []) {
+    this.structure = structure;
+    this.byPath = /* @__PURE__ */ new Map();
+    this.byDir = /* @__PURE__ */ new Map();
+    this.byNamespace = /* @__PURE__ */ new Map();
+    const dirsByKey = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const portable = toPortablePath(file);
+      const pathKey = portable.toLowerCase();
+      const priorPath = this.byPath.get(pathKey);
+      if (priorPath !== void 0 && priorPath !== file) this.byPath.delete(pathKey);
+      else this.byPath.set(pathKey, file);
+      const dir = path4.posix.dirname(portable);
+      const dirKey = dir.toLowerCase();
+      const knownDir = dirsByKey.get(dirKey);
+      if (knownDir === void 0) {
+        dirsByKey.set(dirKey, dir);
+        this.byDir.set(dirKey, [file]);
+      } else if (knownDir === dir) {
+        this.byDir.get(dirKey)?.push(file);
+      } else {
+        dirsByKey.delete(dirKey);
+        this.byDir.delete(dirKey);
+      }
+    }
+    for (const { name, file } of namespaces) {
+      const lang = detectLang(file);
+      if (!lang) continue;
+      const key = `${languageFamily(lang)}:${normalizeNamespace(name)}`;
+      if (normalizeNamespace(name) && !this.byNamespace.has(key)) {
+        this.byNamespace.set(key, file);
+      }
+    }
+  }
+  /**
+   * Resolve `specifier` as written in `fromFile`.
+   * Returns the indexed target path, or `undefined` when it is external or
+   * cannot be located.
+   */
+  resolve(fromFile, lang, specifier) {
+    const spec = specifier.trim().replace(/\\/g, "/");
+    if (!spec) return void 0;
+    const from = toPortablePath(fromFile);
+    switch (languageFamily(lang)) {
+      case "js":
+        return this.resolveJs(from, spec);
+      case "go":
+        return this.resolveGo(spec);
+      case "py":
+        return this.resolvePython(from, spec);
+      case "rs":
+        return this.resolveRust(from, spec);
+      case "jvm":
+        return this.resolveJvm(spec);
+      case "c":
+        return this.resolveInclude(from, spec);
+      case "ruby":
+        return this.resolveRuby(from, spec);
+      case "dotnet":
+      case "php":
+      case "elixir":
+      case "haskell":
+        return this.resolveNamespace(lang, spec);
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Resolve a namespace specifier to the file declaring it.
+   *
+   * Tried whole first, then with the trailing segment dropped: `using Foo.Bar`
+   * names a namespace outright, while PHP's `use App\Models\User` names a
+   * *class* inside `App\Models`, so the prefix is what was declared.
+   */
+  resolveNamespace(lang, spec) {
+    const family = languageFamily(lang);
+    const normalized = normalizeNamespace(spec);
+    const exact = this.byNamespace.get(`${family}:${normalized}`);
+    if (exact) return exact;
+    const segments = normalized.split(".").filter(Boolean);
+    if (segments.length < 2) return void 0;
+    return this.byNamespace.get(`${family}:${segments.slice(0, -1).join(".")}`);
+  }
+  // ─── Lookup primitives ──────────────────────────────────────────────────────
+  lookup(candidate) {
+    return this.byPath.get(path4.posix.normalize(candidate).toLowerCase());
+  }
+  /**
+   * Try `base` verbatim, then `base` + each extension, then each directory
+   * entry point inside `base`.
+   */
+  lookupWithExtensions(base, family) {
+    const direct = this.lookup(base);
+    if (direct) return direct;
+    const extensions = EXTENSIONS[family] ?? [];
+    const suffix = path4.posix.extname(base);
+    const stem = suffix && extensions.includes(suffix) ? base.slice(0, -suffix.length) : base;
+    for (const ext of extensions) {
+      const hit = this.lookup(`${stem}${ext}`);
+      if (hit) return hit;
+    }
+    for (const entry of DIRECTORY_ENTRIES[family] ?? []) {
+      for (const ext of extensions) {
+        const hit = this.lookup(path4.posix.join(base, `${entry}${ext}`));
+        if (hit) return hit;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * A representative indexed file inside `dir`, for ecosystems whose import
+   * unit is a directory rather than a file (Go packages, JVM wildcard imports).
+   *
+   * The choice is deterministic — a file named after the directory, else the
+   * first by name — so the same import always produces the same edge. Package
+   * grouping is unaffected either way: every file in the directory carries the
+   * same package label, so the package-level edge is exact regardless of which
+   * member represents it.
+   */
+  representativeIn(dir, family) {
+    const members = this.byDir.get(path4.posix.normalize(dir).toLowerCase());
+    if (!members?.length) return void 0;
+    const extensions = EXTENSIONS[family] ?? [];
+    const eligible = members.filter((file) => extensions.includes(path4.posix.extname(toPortablePath(file)).toLowerCase())).sort((a, b) => toPortablePath(a).localeCompare(toPortablePath(b)));
+    if (eligible.length === 0) return void 0;
+    const base = path4.posix.basename(path4.posix.normalize(dir)).toLowerCase();
+    const named = eligible.find(
+      (file) => path4.posix.basename(toPortablePath(file)).split(".")[0]?.toLowerCase() === base
+    );
+    return named ?? eligible[0];
+  }
+  // ─── Per-family resolution ──────────────────────────────────────────────────
+  /** Relative specifiers, then workspace package names and their subpaths. */
+  resolveJs(fromFile, spec) {
+    if (spec.startsWith(".")) {
+      const absolute = path4.posix.join(path4.posix.dirname(fromFile), spec);
+      return this.lookupWithExtensions(absolute, "js");
+    }
+    const owner = this.structure.roots.find(
+      (root) => root.kind === "npm" && root.importPath !== void 0 && (spec === root.importPath || spec.startsWith(`${root.importPath}/`))
+    );
+    if (!owner?.importPath) return void 0;
+    const subpath = spec.slice(owner.importPath.length).replace(/^\//, "");
+    if (!subpath) {
+      return this.lookupWithExtensions(path4.posix.join(owner.dir, "src/index"), "js") ?? this.lookupWithExtensions(path4.posix.join(owner.dir, "index"), "js");
+    }
+    return this.lookupWithExtensions(path4.posix.join(owner.dir, subpath), "js") ?? this.lookupWithExtensions(path4.posix.join(owner.dir, "src", subpath), "js");
+  }
+  /** Go import paths are absolute module paths; a package is a directory. */
+  resolveGo(spec) {
+    const owner = this.structure.roots.find(
+      (root) => root.kind === "go" && root.importPath !== void 0 && (spec === root.importPath || spec.startsWith(`${root.importPath}/`))
+    );
+    if (!owner?.importPath) return void 0;
+    const subpath = spec.slice(owner.importPath.length).replace(/^\//, "");
+    return this.representativeIn(path4.posix.join(owner.dir, subpath), "go");
+  }
+  /**
+   * `import a.b.c` / `from a.b import c`, plus PEP 328 relative imports whose
+   * leading dots the extractor preserves (`.sibling`, `..parent.mod`).
+   */
+  resolvePython(fromFile, spec) {
+    const leadingDots = /^\.*/.exec(spec)?.[0].length ?? 0;
+    if (leadingDots > 0) {
+      let base = path4.posix.dirname(fromFile);
+      for (let i = 1; i < leadingDots; i++) base = path4.posix.dirname(base);
+      const rest = spec.slice(leadingDots).split(".").filter(Boolean);
+      return this.lookupWithExtensions(path4.posix.join(base, ...rest), "py");
+    }
+    const segments = spec.split(".").filter(Boolean);
+    if (segments.length === 0) return void 0;
+    const sourceRoots = this.structure.roots.filter((root) => root.kind === "python").flatMap((root) => root.sourceRoots);
+    for (const base of [...sourceRoots, this.structure.projectRoot]) {
+      const hit = this.lookupWithExtensions(path4.posix.join(base, ...segments), "py");
+      if (hit) return hit;
+      if (segments.length > 1) {
+        const parent = this.lookupWithExtensions(
+          path4.posix.join(base, ...segments.slice(0, -1)),
+          "py"
+        );
+        if (parent) return parent;
+      }
+    }
+    return void 0;
+  }
+  /** `use crate::a::b`, `use super::x`, `use self::y`, `use other_crate::z`. */
+  resolveRust(fromFile, spec) {
+    const segments = spec.split("::").filter(Boolean);
+    if (segments.length === 0) return void 0;
+    const head = segments[0];
+    if (head === "self" || head === "super") {
+      let base = path4.posix.dirname(fromFile);
+      for (const segment of segments) {
+        if (segment === "super") base = path4.posix.dirname(base);
+        else if (segment !== "self") break;
+      }
+      const rest2 = segments.filter((segment) => segment !== "self" && segment !== "super");
+      return this.lookupWithExtensions(path4.posix.join(base, ...rest2), "rs");
+    }
+    const owningCrate = findOwningRoot(this.structure, fromFile, ["cargo"]);
+    const crate = head === "crate" ? owningCrate : this.structure.roots.find(
+      (root) => root.kind === "cargo" && root.importPath === head?.replace(/-/g, "_")
+    );
+    if (!crate) {
+      return this.lookupWithExtensions(
+        path4.posix.join(path4.posix.dirname(fromFile), ...segments),
+        "rs"
+      );
+    }
+    const rest = segments.slice(1);
+    for (const base of crate.sourceRoots) {
+      const parent = rest.length > 1 ? this.lookupWithExtensions(path4.posix.join(base, ...rest.slice(0, -1)), "rs") : void 0;
+      const exact = this.lookupWithExtensions(path4.posix.join(base, ...rest), "rs");
+      const hit = exact ?? parent ?? this.lookupWithExtensions(path4.posix.join(base, "lib"), "rs");
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  /** `com.example.Thing` and `com.example.*` against JVM source roots. */
+  resolveJvm(spec) {
+    const segments = spec.split(".").filter(Boolean);
+    if (segments.length === 0) return void 0;
+    const sourceRoots = this.structure.roots.filter((root) => root.kind === "maven" || root.kind === "gradle").flatMap((root) => root.sourceRoots);
+    const wildcard = segments[segments.length - 1] === "*";
+    const parts = wildcard ? segments.slice(0, -1) : segments;
+    for (const base of [...sourceRoots, this.structure.projectRoot]) {
+      const target = path4.posix.join(base, ...parts);
+      const hit = wildcard ? this.representativeIn(target, "jvm") : this.lookupWithExtensions(target, "jvm");
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  /** `#include "foo/bar.h"` — quoted form only; `<…>` is a system header. */
+  resolveInclude(fromFile, spec) {
+    const relative3 = this.lookupWithExtensions(
+      path4.posix.join(path4.posix.dirname(fromFile), spec),
+      "c"
+    );
+    if (relative3) return relative3;
+    for (const base of [
+      path4.posix.join(this.structure.projectRoot, "include"),
+      this.structure.projectRoot
+    ]) {
+      const hit = this.lookupWithExtensions(path4.posix.join(base, spec), "c");
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  /** `require_relative 'x'` is relative; `require 'x'` is looked up under lib/. */
+  resolveRuby(fromFile, spec) {
+    const relative3 = this.lookupWithExtensions(
+      path4.posix.join(path4.posix.dirname(fromFile), spec),
+      "ruby"
+    );
+    if (relative3) return relative3;
+    for (const base of [
+      path4.posix.join(this.structure.projectRoot, "lib"),
+      this.structure.projectRoot
+    ]) {
+      const hit = this.lookupWithExtensions(path4.posix.join(base, spec), "ruby");
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+};
+
+// src/codebase-index/import-extractor.ts
+var IMPORT_MAX_FILE_CHARS = 512 * 1024;
+var IMPORT_MAX_PER_FILE = 400;
+var DOTTED_IMPORT = [
+  { re: /^[ \t]*import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;?\s*$/gm }
+];
+var LANG_IMPORTS = {
+  // Go and Python have real AST extractors; these patterns are the fallback for
+  // machines with no Go toolchain or Python interpreter installed, where the
+  // parser degrades to regex symbols and would otherwise contribute no edges.
+  go: [
+    { re: /^[ \t]*import\s+(?:[\w.]+\s+)?"([^"]+)"/gm },
+    // Grouped form: inside `import ( … )` each line is an optional alias plus a
+    // quoted path. A stray match elsewhere resolves to no file and is dropped.
+    { re: /^[ \t]*(?:[A-Za-z_.]\w*\s+)?"([^"]+)"\s*$/gm }
+  ],
+  py: [
+    { re: /^[ \t]*import\s+([\w.]+)/gm },
+    { re: /^[ \t]*from\s+([.\w]+)\s+import\b/gm }
+  ],
+  rs: [
+    // use a::b::C;  |  use a::b::{C, D};  → the path before any brace
+    { re: /^[ \t]*(?:pub\s+)?use\s+([\w:]+?)(?:::\{|\s*;|\s+as\b)/gm },
+    // mod foo;  (a declaration *and* a dependency on foo.rs / foo/mod.rs)
+    { re: /^[ \t]*(?:pub\s+)?mod\s+(\w+)\s*;/gm }
+  ],
+  java: DOTTED_IMPORT,
+  kotlin: DOTTED_IMPORT,
+  scala: [{ re: /^[ \t]*import\s+([\w.]+(?:\.[_*])?)\s*$/gm }],
+  csharp: [
+    // using Foo.Bar;  |  using static Foo.Bar;  |  using Alias = Foo.Bar;
+    { re: /^[ \t]*global\s+using\s+(?:static\s+)?([\w.]+)\s*;/gm, name: "full" },
+    { re: /^[ \t]*using\s+(?:static\s+)?(?:\w+\s*=\s*)?([\w.]+)\s*;/gm, name: "full" }
+  ],
+  // Quoted includes only: <stdio.h> is a system header with no indexed file.
+  c: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
+  cpp: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
+  ruby: [{ re: /^[ \t]*(?:require|require_relative|load)\s*\(?\s*['"]([^'"]+)['"]/gm }],
+  php: [
+    // `use A\B\C` imports the class C, which is what the index has a symbol
+    // for — the namespace symbol only covers the `A\B` prefix.
+    { re: /^[ \t]*use\s+(?:function\s+|const\s+)?([\w\\]+)/gm },
+    { re: /^[ \t]*(?:require|require_once|include|include_once)\s*\(?\s*['"]([^'"]+)['"]/gm }
+  ],
+  swift: [{ re: /^[ \t]*import\s+(?:struct\s+|class\s+|func\s+)?([\w.]+)\s*$/gm }],
+  dart: [{ re: /^[ \t]*(?:import|export|part)\s+['"]([^'"]+)['"]/gm }],
+  lua: [{ re: /\brequire\s*\(?\s*['"]([^'"]+)['"]/g }],
+  elixir: [{ re: /^[ \t]*(?:alias|import|require|use)\s+([A-Z][\w.]*)/gm, name: "full" }],
+  haskell: [{ re: /^[ \t]*import\s+(?:qualified\s+)?([\w.]+)/gm, name: "full" }],
+  zig: [{ re: /@import\s*\(\s*"([^"]+)"\s*\)/g }],
+  proto: [{ re: /^[ \t]*import\s+(?:public\s+|weak\s+)?"([^"]+)"\s*;/gm }],
+  // `@import "x"`, `@use "x"`, `@forward "x"` — Sass and plain CSS alike.
+  css: [{ re: /^[ \t]*@(?:import|use|forward)\s+(?:url\()?\s*['"]([^'"]+)['"]/gm }],
+  // A .vue/.svelte file's <script> block is JS; the same ESM syntax applies.
+  vue: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
+  svelte: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
+  html: [
+    { re: /<script[^>]+src\s*=\s*['"]([^'"]+)['"]/g },
+    { re: /<link[^>]+href\s*=\s*['"]([^'"]+)['"]/g }
+  ],
+  shell: [{ re: /^[ \t]*(?:source|\.)\s+(\S+)/gm }],
+  r: [{ re: /\b(?:source|library|require)\s*\(\s*['"]?([\w./-]+)['"]?\s*\)/g }]
+};
+function lastSegment(specifier) {
+  const pathLike = /[/\\]|::/.test(specifier);
+  const segments = specifier.split(/[/\\]|::/).filter(Boolean);
+  let last = segments[segments.length - 1] ?? specifier;
+  if (last === "*" || last === "_") {
+    last = segments[segments.length - 2] ?? specifier;
+  }
+  if (pathLike) return last.replace(/\.[A-Za-z0-9]{1,8}$/, "") || last;
+  const dotted = last.split(".").filter((part) => part && part !== "*" && part !== "_");
+  return dotted[dotted.length - 1] ?? last;
+}
+function newlineOffsets(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
+  }
+  return offsets;
+}
+function lineAt(offsets, index) {
+  let low = 0;
+  let high = offsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((offsets[mid] ?? 0) < index) low = mid + 1;
+    else high = mid;
+  }
+  return low + 1;
+}
+function hasImportPatterns(lang) {
+  return LANG_IMPORTS[lang] !== void 0;
+}
+function extractImports(opts) {
+  const patterns = LANG_IMPORTS[opts.lang];
+  if (!patterns || !opts.content) return [];
+  const limit = opts.maxImports ?? IMPORT_MAX_PER_FILE;
+  const content = opts.content.length > IMPORT_MAX_FILE_CHARS ? opts.content.slice(0, IMPORT_MAX_FILE_CHARS) : opts.content;
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const offsets = newlineOffsets(content);
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.re.source, pattern.re.flags);
+    for (const match of content.matchAll(re)) {
+      if (refs.length >= limit) return refs;
+      const specifier = match[1]?.trim();
+      if (!specifier) continue;
+      const module = specifier;
+      const toName = pattern.name === "full" ? module : lastSegment(module);
+      if (!toName) continue;
+      const key = `${module}\0${toName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      refs.push({
+        fromId: 0,
+        toName,
+        callType: "import",
+        line: lineAt(offsets, match.index ?? 0),
+        lang: opts.lang,
+        module
+      });
+    }
+  }
+  return refs;
+}
+
 // src/codebase-index/parser-dispatch.ts
 async function parseFileContent(file, content, lang) {
+  const parsed2 = await dispatch(file, content, lang);
+  return withRelations(parsed2, content, lang);
+}
+async function dispatch(file, content, lang) {
   switch (lang) {
     case "ts":
     case "tsx":
@@ -2089,6 +2971,13 @@ async function parseFileContent(file, content, lang) {
     }
   }
 }
+function withRelations(parsed2, content, lang) {
+  let refs = parsed2.refs ?? [];
+  if (refs.length === 0 && hasImportPatterns(lang)) {
+    refs = extractImports({ content, lang });
+  }
+  return { ...parsed2, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
+}
 
 // src/codebase-index/writer.ts
 import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
@@ -2184,6 +3073,9 @@ var Bm25Index = class {
   }
 };
 
+// src/codebase-index/writer.ts
+init_languages();
+
 // src/codebase-index/lsp-kind.ts
 function lspKindToInternalKind(k) {
   switch (k) {
@@ -2218,7 +3110,7 @@ function lspKindToInternalKind(k) {
 }
 
 // src/codebase-index/schema.ts
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 
 // src/codebase-index/sqlite-runtime.ts
 import { createRequire } from "node:module";
@@ -2365,7 +3257,7 @@ function runSqliteWithRetry(fn) {
 
 // src/codebase-index/writer-admin.ts
 import * as fs6 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var DB_FILE = "index.db";
 function getAllIndexableWithStatement(stmt) {
   return stmt("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
@@ -2424,7 +3316,7 @@ function getAllFileMetasWithStatement(stmt) {
 }
 function getIndexDbSizeBytes(indexDir2) {
   try {
-    return fs6.statSync(path8.join(indexDir2, DB_FILE)).size;
+    return fs6.statSync(path9.join(indexDir2, DB_FILE)).size;
   } catch {
     return 0;
   }
@@ -2475,49 +3367,43 @@ function bulkInsertFtsWithStatement(stmt, maxSqlVars, ftsAvailable, rows) {
 }
 function bulkInsertRefsWithStatement(stmt, maxSqlVars, refs) {
   if (refs.length === 0) return;
-  const chunkSize = Math.max(1, Math.floor(maxSqlVars / 5));
+  const chunkSize = Math.max(1, Math.floor(maxSqlVars / 8));
   for (let i = 0; i < refs.length; i += chunkSize) {
     const chunk = refs.slice(i, i + chunkSize);
-    const placeholders = chunk.map(() => "(?, ?, ?, ?, ?)").join(", ");
+    const placeholders = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
     const insert = stmt(
-      `INSERT INTO refs(from_id, to_name, to_id, call_type, line) VALUES ${placeholders}`
+      `INSERT INTO refs(from_id, to_name, to_id, call_type, line, lang, module, to_file)
+       VALUES ${placeholders}`
     );
     const binds = [];
     for (const ref of chunk) {
-      binds.push(ref.fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
+      binds.push(
+        ref.fromId,
+        ref.toName,
+        ref.toId ?? null,
+        ref.callType,
+        ref.line,
+        ref.lang ?? "",
+        ref.module ?? null,
+        ref.toFile ?? null
+      );
     }
     insert.run(...binds);
   }
 }
 
+// src/codebase-index/writer-graph-reader.ts
+init_languages();
+
 // src/codebase-index/writer-graph-helpers.ts
-import * as path9 from "node:path";
-function derivePackage(filePath) {
-  const f = filePath.replace(/\\/g, "/");
-  const pkgsIdx = f.indexOf("/packages/");
-  if (pkgsIdx !== -1) {
-    const rest = f.slice(pkgsIdx + "/packages/".length);
-    const seg = rest.split("/")[0];
-    return seg ? `@wrongstack/${seg}` : void 0;
-  }
-  const appsIdx = f.indexOf("/apps/");
-  if (appsIdx !== -1) {
-    const rest = f.slice(appsIdx + "/apps/".length);
-    const seg = rest.split("/")[0];
-    return seg ? `app:${seg}` : void 0;
-  }
-  return void 0;
-}
-function packageFromImport(moduleName) {
-  if (!moduleName.startsWith("@wrongstack/")) return void 0;
-  const parts = moduleName.split("/");
-  return parts[1] ? `@wrongstack/${parts[1]}` : void 0;
+function createPackageLabeller(stored) {
+  return (file) => stored.get(file) ?? derivePackageFromLayout(file) ?? "(root)";
 }
-function buildPackageGraphNodes(fileCounts, files) {
+function buildPackageGraphNodes(fileCounts, files, packageOf) {
   const pkgNodes = /* @__PURE__ */ new Map();
   const fileToPkg = /* @__PURE__ */ new Map();
   for (const { file, n } of fileCounts) {
-    const pkg = derivePackage(file) ?? "(root)";
+    const pkg = packageOf(file);
     fileToPkg.set(file, pkg);
     const node = pkgNodes.get(pkg);
     if (node) {
@@ -2534,7 +3420,7 @@ function buildPackageGraphNodes(fileCounts, files) {
     }
   }
   for (const { file } of files) {
-    const pkg = derivePackage(file) ?? "(root)";
+    const pkg = packageOf(file);
     fileToPkg.set(file, pkg);
     const node = pkgNodes.get(pkg);
     if (node) {
@@ -2552,7 +3438,7 @@ function buildPackageGraphNodes(fileCounts, files) {
   }
   return { pkgNodes, fileToPkg };
 }
-function buildFileGraphNodeState(pkgSyms, localFiles) {
+function buildFileGraphNodeState(pkgSyms, localFiles, packageOf) {
   const fileNodes = /* @__PURE__ */ new Map();
   const symToFile = /* @__PURE__ */ new Map();
   const fileStats = /* @__PURE__ */ new Map();
@@ -2571,7 +3457,7 @@ function buildFileGraphNodeState(pkgSyms, localFiles) {
       id: `file:${file}`,
       label: file.replace(/\\/g, "/").split("/").pop() ?? file,
       kind: "file",
-      package: derivePackage(file) ?? "(root)",
+      package: packageOf(file),
       file,
       symbolCount: stats?.count ?? 0,
       lang: stats?.lang,
@@ -2583,7 +3469,7 @@ function buildFileGraphNodeState(pkgSyms, localFiles) {
   }
   return { fileNodes, symToFile, fileStats, ensureFileNode };
 }
-function buildSymbolGraphNodes(symById, relatedIds, fileFilter) {
+function buildSymbolGraphNodes(symById, relatedIds, fileFilter, packageOf) {
   return [...relatedIds].map((id) => symById.get(id)).filter((symbol) => symbol !== void 0).sort((a, b) => {
     const aExternal = a.file === fileFilter ? 0 : 1;
     const bExternal = b.file === fileFilter ? 0 : 1;
@@ -2595,7 +3481,7 @@ function buildSymbolGraphNodes(symById, relatedIds, fileFilter) {
     symbolId: s.id,
     symbolKind: s.kind,
     file: s.file,
-    package: derivePackage(s.file) ?? "(root)",
+    package: packageOf(s.file),
     lang: s.lang,
     line: s.line,
     signature: s.signature,
@@ -2603,29 +3489,6 @@ function buildSymbolGraphNodes(symById, relatedIds, fileFilter) {
     external: s.file !== fileFilter
   }));
 }
-function resolveRelativeImport(fromFile, moduleName, indexedFiles) {
-  if (!moduleName.startsWith(".")) return void 0;
-  const normalizedFrom = fromFile.replace(/\\/g, "/");
-  const absolute = path9.posix.normalize(
-    path9.posix.join(path9.posix.dirname(normalizedFrom), moduleName)
-  );
-  const extension = path9.posix.extname(absolute);
-  const base = extension ? absolute.slice(0, -extension.length) : absolute;
-  const candidates = [
-    absolute,
-    ...[".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"].map((ext) => `${base}${ext}`),
-    ...[".ts", ".tsx", ".js", ".jsx"].map((ext) => path9.posix.join(absolute, `index${ext}`)),
-    ...[".ts", ".tsx", ".js", ".jsx"].map((ext) => path9.posix.join(base, `index${ext}`))
-  ];
-  const indexedByPortablePath = new Map(
-    [...indexedFiles].map((file) => [file.replace(/\\/g, "/").toLocaleLowerCase(), file])
-  );
-  for (const candidate of candidates) {
-    const indexed = indexedByPortablePath.get(candidate.toLocaleLowerCase());
-    if (indexed) return indexed;
-  }
-  return void 0;
-}
 function addWeightedEdge(edgeMap, source, target, callType, weight) {
   const key = `${source}\0${target}`;
   let edge = edgeMap.get(key);
@@ -2666,7 +3529,12 @@ function mapWriterRefRow(row) {
     toName: row.to_name,
     toId: row.to_id ?? void 0,
     callType: row.call_type,
-    line: row.line
+    line: row.line,
+    // `lang`/`module`/`to_file` are absent from the narrower column lists some
+    // queries select; `undefined` keeps those rows valid Refs.
+    lang: row.lang || void 0,
+    module: row.module ?? void 0,
+    toFile: row.to_file ?? void 0
   };
 }
 
@@ -2814,7 +3682,8 @@ function findRefsFromWithStatement(stmt, symbolId) {
 function getPackageGraphWithStatement(stmt) {
   const fileCounts = stmt("SELECT file, COUNT(*) AS n FROM symbols GROUP BY file").all();
   const files = stmt("SELECT DISTINCT file FROM files").all();
-  const { pkgNodes, fileToPkg } = buildPackageGraphNodes(fileCounts, files);
+  const packageOf = readPackageLabeller(stmt);
+  const { pkgNodes, fileToPkg } = buildPackageGraphNodes(fileCounts, files, packageOf);
   const refRows = stmt(
     `SELECT r.call_type, sf.file AS from_file, st.file AS to_file, COUNT(*) AS n
        FROM refs r
@@ -2825,32 +3694,42 @@ function getPackageGraphWithStatement(stmt) {
   ).all();
   const edgeMap = /* @__PURE__ */ new Map();
   for (const r of refRows) {
-    const fromPkg = fileToPkg.get(r.from_file) ?? derivePackage(r.from_file) ?? "(root)";
-    const toPkg = fileToPkg.get(r.to_file) ?? derivePackage(r.to_file) ?? "(root)";
+    const fromPkg = fileToPkg.get(r.from_file) ?? packageOf(r.from_file);
+    const toPkg = fileToPkg.get(r.to_file) ?? packageOf(r.to_file);
     if (fromPkg === toPkg) continue;
     const n = Number(r.n) || 0;
     addWeightedEdge(edgeMap, fromPkg, toPkg, r.call_type, n);
   }
   const importRows = stmt(
-    `SELECT r.to_name, s.file AS from_file, COUNT(*) AS n
+    `SELECT s.file AS from_file,
+            COALESCE(r.to_file, st.file) AS to_file,
+            COUNT(*) AS n
        FROM refs r
        JOIN symbols s ON s.id = r.from_id
+       LEFT JOIN symbols st ON st.id = r.to_id
        WHERE r.call_type = 'import'
-       GROUP BY r.to_name, s.file`
+         AND COALESCE(r.to_file, st.file) IS NOT NULL
+       GROUP BY s.file, COALESCE(r.to_file, st.file)`
   ).all();
   for (const r of importRows) {
-    const fromPkg = fileToPkg.get(r.from_file) ?? derivePackage(r.from_file) ?? "(root)";
-    const toPkg = packageFromImport(r.to_name);
-    if (!fromPkg || !toPkg || fromPkg === toPkg || !pkgNodes.has(toPkg)) continue;
+    const fromPkg = fileToPkg.get(r.from_file) ?? packageOf(r.from_file);
+    const toPkg = fileToPkg.get(r.to_file) ?? packageOf(r.to_file);
+    if (fromPkg === toPkg || !pkgNodes.has(toPkg)) continue;
     const n = Number(r.n) || 0;
     addWeightedEdge(edgeMap, fromPkg, toPkg, "import", n);
   }
   const edges = materializeWeightedEdges(edgeMap, "pkg");
   return { nodes: [...pkgNodes.values()], edges };
 }
+function readPackageLabeller(stmt) {
+  const rows = stmt("SELECT file, package FROM files WHERE package != ''").all();
+  return createPackageLabeller(new Map(rows.map((row) => [row.file, row.package])));
+}
 function getFileGraphWithStatement(stmt, packageFilter) {
   const allFiles = stmt("SELECT DISTINCT file FROM symbols").all();
-  const pkgFilePaths = allFiles.filter((f) => (derivePackage(f.file) ?? "(root)") === packageFilter).map((f) => f.file);
+  const packageOf = readPackageLabeller(stmt);
+  const langOf = (file) => detectLang(file) ?? "other";
+  const pkgFilePaths = allFiles.filter((f) => packageOf(f.file) === packageFilter).map((f) => f.file);
   const localFiles = new Set(pkgFilePaths);
   if (localFiles.size === 0) return { nodes: [], edges: [] };
   const filePlaceholders = [...localFiles].map(() => "?").join(",");
@@ -2859,9 +3738,9 @@ function getFileGraphWithStatement(stmt, packageFilter) {
   ).all(...pkgFilePaths);
   const { fileNodes, symToFile, fileStats, ensureFileNode } = buildFileGraphNodeState(
     pkgSyms,
-    localFiles
+    localFiles,
+    packageOf
   );
-  const indexedFiles = new Set(allFiles.map((f) => f.file));
   const refRows = stmt(
     `SELECT r.from_id, r.to_id, r.call_type, COUNT(*) AS n
        FROM refs r
@@ -2884,7 +3763,7 @@ function getFileGraphWithStatement(stmt, packageFilter) {
     for (const x of extras) {
       symToFile.set(x.id, x.file);
       if (!fileStats.has(x.file)) {
-        fileStats.set(x.file, { count: 0, lang: "ts" });
+        fileStats.set(x.file, { count: 0, lang: langOf(x.file) });
       }
     }
   }
@@ -2901,17 +3780,22 @@ function getFileGraphWithStatement(stmt, packageFilter) {
     addWeightedEdge(edgeMap, fromFile, toFile, r.call_type, n);
   }
   const importRows = stmt(
-    `SELECT r.from_id, r.to_name, COUNT(*) AS n
+    `SELECT r.from_id, COALESCE(r.to_file, st.file) AS to_file, COUNT(*) AS n
        FROM refs r
+       LEFT JOIN symbols st ON st.id = r.to_id
        WHERE r.call_type = 'import'
+         AND COALESCE(r.to_file, st.file) IS NOT NULL
          AND r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))
-       GROUP BY r.from_id, r.to_name`
+       GROUP BY r.from_id, COALESCE(r.to_file, st.file)`
   ).all(...pkgFilePaths);
   for (const r of importRows) {
     const fromFile = symToFile.get(r.from_id);
     if (!fromFile || !localFiles.has(fromFile)) continue;
-    const toFile = resolveRelativeImport(fromFile, r.to_name, indexedFiles);
+    const toFile = r.to_file;
     if (!toFile || fromFile === toFile) continue;
+    if (!fileStats.has(toFile)) {
+      fileStats.set(toFile, { count: 0, lang: langOf(toFile) });
+    }
     ensureFileNode(fromFile);
     ensureFileNode(toFile);
     const n = Number(r.n) || 0;
@@ -2961,7 +3845,7 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
     ).all(...missingIds);
     for (const s of extras) symById.set(s.id, s);
   }
-  const nodes = buildSymbolGraphNodes(symById, relatedIds, fileFilter);
+  const nodes = buildSymbolGraphNodes(symById, relatedIds, fileFilter, readPackageLabeller(stmt));
   return { nodes, edges };
 }
 
@@ -2983,7 +3867,7 @@ function assignRefsToSymbols(refs, symbols) {
     }
     if (!owner && ref.callType === "import") owner = ordered[0];
     if (!owner || owner.id <= 0) continue;
-    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}:${ref.module ?? ""}`;
     if (seen.has(key)) continue;
     seen.add(key);
     assigned.push({ ...ref, fromId: owner.id });
@@ -3025,7 +3909,11 @@ var CORE_TABLES_SQL = `
     lang TEXT NOT NULL,
     mtime_ms INTEGER NOT NULL,
     symbol_count INTEGER NOT NULL DEFAULT 0,
-    last_indexed INTEGER NOT NULL
+    last_indexed INTEGER NOT NULL,
+    -- Code Atlas grouping label, computed at index time from the ecosystem's
+    -- own manifests (package.json, go.mod, Cargo.toml, \u2026). Stored rather than
+    -- re-derived per query because the evidence lives on disk, not in the DB.
+    package TEXT NOT NULL DEFAULT ''
   );
   CREATE TABLE IF NOT EXISTS symbols (
     id INTEGER PRIMARY KEY,
@@ -3042,6 +3930,9 @@ var CORE_TABLES_SQL = `
     file_fk TEXT NOT NULL
   );
 `;
+var FILE_INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_f_package ON files(package)"
+];
 var SYMBOL_INDEX_SQL = [
   "CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)",
   "CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)",
@@ -3058,15 +3949,32 @@ var REFS_TABLE_SQL = `
     to_name TEXT NOT NULL,
     to_id INTEGER,
     call_type TEXT NOT NULL,
-    line INTEGER NOT NULL
+    line INTEGER NOT NULL,
+    lang TEXT NOT NULL DEFAULT '',
+    module TEXT,
+    to_file TEXT
   );
 `;
 var REFS_INDEX_SQL = [
   "CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)",
   "CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)",
   "CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)",
-  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)"
+  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)",
+  // Name resolution matches (to_name, lang) pairs; the composite keeps the
+  // language-scoped UPDATE from degrading into a scan of every same-named row.
+  "CREATE INDEX IF NOT EXISTS idx_r_to_name_lang ON refs(to_name, lang)",
+  // The post-index module resolution pass groups unresolved import refs by
+  // (module, lang); graph readers then read to_file back.
+  "CREATE INDEX IF NOT EXISTS idx_r_module ON refs(module)",
+  "CREATE INDEX IF NOT EXISTS idx_r_to_file ON refs(to_file)"
 ];
+var LANG_FAMILY_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS lang_family (
+    lang TEXT PRIMARY KEY,
+    family TEXT NOT NULL
+  );
+`;
+var LANG_FAMILY_WILDCARD = "*";
 var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
 
 // src/codebase-index/writer-search-helpers.ts
@@ -3287,6 +4195,60 @@ var IndexStore = class _IndexStore {
   runWithRetry(fn) {
     return runSqliteWithRetry(fn);
   }
+  /**
+   * Mirror the in-process language→family map into SQLite.
+   *
+   * Rewritten on every open rather than only on schema bumps: the mapping is
+   * static lookup data, so a code-side change (a new language, a language
+   * moving families) must take effect without forcing a full reindex.
+   */
+  seedLangFamilies() {
+    const insert = this.stmt("INSERT OR REPLACE INTO lang_family(lang, family) VALUES (?, ?)");
+    for (const [lang, family] of LANG_FAMILY_ENTRIES) insert.run(lang, family);
+    insert.run("", LANG_FAMILY_WILDCARD);
+  }
+  /**
+   * Add any column the current schema expects but the on-disk table lacks.
+   *
+   * `CREATE TABLE IF NOT EXISTS` silently keeps an existing table's old shape,
+   * and the version check above only rebuilds on a version *mismatch*. That
+   * leaves a real gap: several wstack processes share this database, and while
+   * a version upgrade is rolling out one of them may still be running the
+   * previous build. That older process sees the newer version number, drops the
+   * tables, and recreates them from *its* DDL — without the newer columns —
+   * while the metadata row still reads the new version. Every later query for
+   * one of those columns then fails with `no such column`, and no amount of
+   * reindexing fixes it, because the version numbers already agree.
+   *
+   * Repairing column-by-column makes the schema self-healing from any of those
+   * states. Table and column names are compile-time literals from this module,
+   * never user input.
+   */
+  repairMissingColumns() {
+    const expected = [
+      { table: "files", columns: [["package", "TEXT NOT NULL DEFAULT ''"]] },
+      {
+        table: "refs",
+        columns: [
+          ["lang", "TEXT NOT NULL DEFAULT ''"],
+          ["module", "TEXT"],
+          ["to_file", "TEXT"]
+        ]
+      }
+    ];
+    for (const { table, columns } of expected) {
+      const present = new Set(
+        this.db.prepare(`PRAGMA table_info(${table})`).all().flatMap(
+          (row) => typeof row.name === "string" ? [row.name] : []
+        )
+      );
+      if (present.size === 0) continue;
+      for (const [name, type] of columns) {
+        if (present.has(name)) continue;
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${type}`);
+      }
+    }
+  }
   initSchema() {
     this.db.exec(METADATA_TABLE_SQL);
     const storedRows = this.stmt("SELECT value FROM metadata WHERE key = ?").all("version");
@@ -3309,9 +4271,13 @@ var IndexStore = class _IndexStore {
       );
     }
     this.db.exec(CORE_TABLES_SQL);
-    for (const sql of SYMBOL_INDEX_SQL) this.db.exec(sql);
     this.db.exec(REFS_TABLE_SQL);
+    this.repairMissingColumns();
+    for (const sql of FILE_INDEX_SQL) this.db.exec(sql);
+    for (const sql of SYMBOL_INDEX_SQL) this.db.exec(sql);
     for (const sql of REFS_INDEX_SQL) this.db.exec(sql);
+    this.db.exec(LANG_FAMILY_TABLE_SQL);
+    this.seedLangFamilies();
     try {
       this.db.exec(SYMBOLS_FTS_SQL);
       this.ftsAvailable = true;
@@ -3346,6 +4312,18 @@ var IndexStore = class _IndexStore {
   static NEXT_SYMBOL_ID_KEY = "next_symbol_id";
   /** Stay under typical SQLite SQLITE_MAX_VARIABLE_NUMBER (often 999). */
   static MAX_SQL_VARS = 900;
+  /**
+   * Correlated predicate: the ref in `refs` and the candidate symbol aliased
+   * `sym` belong to the same language family — or the ref carries no language,
+   * in which case the wildcard bind matches everything.
+   *
+   * Each textual occurrence consumes one `?` bind of {@link LANG_FAMILY_WILDCARD}.
+   */
+  static FAMILY_MATCH_SQL = `(
+    (SELECT family FROM lang_family WHERE lang = refs.lang) = ?
+    OR (SELECT family FROM lang_family WHERE lang = sym.lang)
+       = (SELECT family FROM lang_family WHERE lang = refs.lang)
+  )`;
   /**
    * Ensure `metadata.next_symbol_id` exists. Safe to call outside a write
    * transaction on open; the first concurrent writer under BEGIN IMMEDIATE
@@ -3409,9 +4387,12 @@ var IndexStore = class _IndexStore {
       const placeholders = chunk.map(() => "?").join(",");
       const result = this.stmt(
         `UPDATE refs
-         SET to_id = (SELECT MIN(id) FROM symbols WHERE name = refs.to_name)
+         SET to_id = (
+           SELECT MIN(sym.id) FROM symbols sym
+            WHERE sym.name = refs.to_name AND ${_IndexStore.FAMILY_MATCH_SQL}
+         )
          WHERE to_name IN (${placeholders})`
-      ).run(...chunk);
+      ).run(LANG_FAMILY_WILDCARD, ...chunk);
       changes += result.changes ?? 0;
     }
     return changes;
@@ -3538,6 +4519,115 @@ var IndexStore = class _IndexStore {
   getAllFileMetas() {
     return getAllFileMetasWithStatement((sql) => this.stmt(sql));
   }
+  // ─── Project structure & module resolution ──────────────────────────────────
+  /** Store the Code Atlas grouping label for each indexed file. */
+  setFilePackages(entries) {
+    if (entries.size === 0) return;
+    this.runWithRetry(() => {
+      const update = this.stmt("UPDATE files SET package = ? WHERE file = ?");
+      for (const [file, label] of entries) update.run(label, file);
+    });
+  }
+  /**
+   * Every indexed `namespace`/`module` declaration, for ecosystems whose import
+   * specifiers name a namespace rather than a path (C#, PHP, Elixir, Haskell).
+   * Ordered so the resolver's choice among duplicate declarations is stable.
+   */
+  getNamespaceDeclarations() {
+    return this.stmt(
+      `SELECT name, file FROM symbols WHERE kind = 'namespace' ORDER BY file, id`
+    ).all();
+  }
+  /** `file → package` for every indexed file that has a label. */
+  getFilePackages() {
+    const rows = this.stmt("SELECT file, package FROM files WHERE package != ''").all();
+    return new Map(rows.map((row) => [row.file, row.package]));
+  }
+  /**
+   * Distinct `(fromFile, lang, module)` triples needing module resolution.
+   *
+   * Distinct rather than per-ref because resolution depends only on these three
+   * values: a file importing the same module twenty times resolves it once.
+   */
+  getUnresolvedImports(onlyFiles) {
+    const base = `SELECT DISTINCT s.file AS fromFile, r.lang AS lang, r.module AS module
+                    FROM refs r
+                    JOIN symbols s ON s.id = r.from_id
+                   WHERE r.call_type = 'import' AND r.module IS NOT NULL`;
+    if (!onlyFiles?.length) {
+      return this.stmt(base).all();
+    }
+    const out = [];
+    for (let i = 0; i < onlyFiles.length; i += _IndexStore.MAX_SQL_VARS) {
+      const chunk = onlyFiles.slice(i, i + _IndexStore.MAX_SQL_VARS);
+      const placeholders = chunk.map(() => "?").join(",");
+      out.push(
+        ...this.stmt(`${base} AND s.file IN (${placeholders})`).all(...chunk)
+      );
+    }
+    return out;
+  }
+  /**
+   * Write resolved import targets back onto `refs.to_file`.
+   *
+   * Applied through a temp table and a single UPDATE: one statement per
+   * resolution would mean thousands of round-trips on a first index.
+   */
+  applyImportResolutions(resolutions) {
+    if (resolutions.length === 0) return 0;
+    return this.runWithRetry(() => {
+      this.db.exec("DROP TABLE IF EXISTS temp.import_resolution");
+      this.db.exec(
+        `CREATE TEMP TABLE import_resolution (
+           from_file TEXT NOT NULL,
+           lang TEXT NOT NULL,
+           module TEXT NOT NULL,
+           to_file TEXT NOT NULL
+         )`
+      );
+      const chunkSize = Math.max(1, Math.floor(_IndexStore.MAX_SQL_VARS / 4));
+      for (let i = 0; i < resolutions.length; i += chunkSize) {
+        const chunk = resolutions.slice(i, i + chunkSize);
+        const placeholders = chunk.map(() => "(?, ?, ?, ?)").join(", ");
+        const binds = [];
+        for (const entry of chunk) {
+          binds.push(entry.fromFile, entry.lang, entry.module, entry.toFile);
+        }
+        this.stmt(
+          `INSERT INTO temp.import_resolution(from_file, lang, module, to_file)
+           VALUES ${placeholders}`
+        ).run(...binds);
+      }
+      this.db.exec(
+        `CREATE INDEX IF NOT EXISTS temp.idx_ir
+           ON import_resolution(module, lang, from_file)`
+      );
+      const result = this.stmt(
+        `UPDATE refs
+            SET to_file = (
+              SELECT ir.to_file
+                FROM temp.import_resolution ir
+                JOIN symbols s ON s.id = refs.from_id
+               WHERE ir.module = refs.module
+                 AND ir.lang = refs.lang
+                 AND ir.from_file = s.file
+               LIMIT 1
+            )
+          WHERE refs.call_type = 'import'
+            AND refs.module IS NOT NULL
+            AND EXISTS (
+              SELECT 1
+                FROM temp.import_resolution ir
+                JOIN symbols s ON s.id = refs.from_id
+               WHERE ir.module = refs.module
+                 AND ir.lang = refs.lang
+                 AND ir.from_file = s.file
+            )`
+      ).run();
+      this.db.exec("DROP TABLE IF EXISTS temp.import_resolution");
+      return result.changes ?? 0;
+    });
+  }
   // ─── Search ──────────────────────────────────────────────────────────────────
   search(query, filter, opts) {
     const built = this.buildSearchWhere(query, filter);
@@ -3924,9 +5014,12 @@ var IndexStore = class _IndexStore {
    * Resolve `to_name` → `to_id` for all refs that have a name but no id.
    * Call this after all symbols have been inserted to fill in cross-references.
    *
-   * Single statement: the `to_name IN (SELECT name FROM symbols)` guard restricts
-   * the UPDATE to refs that will actually resolve, so `.changes` counts only refs
-   * that found a target — matching the previous per-row loop's return value.
+   * A match additionally requires the referencing ref and the target symbol to
+   * be in the same {@link LangFamily}. Without that guard a name match is a
+   * cross-language accident waiting to happen — `main`, `New`, `Parse` and
+   * `Config` are declared in most languages at once, and each collision draws a
+   * Code Atlas edge between files that never reference each other. Refs stored
+   * without a language keep the old global behaviour via the `'*'` wildcard row.
    */
   resolveRefs() {
     return this.runWithRetry(() => {
@@ -3935,20 +5028,35 @@ var IndexStore = class _IndexStore {
           `UPDATE refs
            SET to_id = s.id
            FROM (
-             SELECT name, MIN(id) AS id FROM symbols GROUP BY name
-           ) AS s
+                 SELECT sym.name AS name, lf.family AS family, MIN(sym.id) AS id
+                   FROM symbols sym
+                   JOIN lang_family lf ON lf.lang = sym.lang
+                  GROUP BY sym.name, lf.family
+                 UNION ALL
+                 SELECT sym.name AS name, '${LANG_FAMILY_WILDCARD}' AS family, MIN(sym.id) AS id
+                   FROM symbols sym
+                  GROUP BY sym.name
+               ) AS s,
+               lang_family AS rf
            WHERE refs.to_id IS NULL
              AND refs.to_name IS NOT NULL
-             AND refs.to_name = s.name`
+             AND rf.lang = refs.lang
+             AND s.name = refs.to_name
+             AND s.family = rf.family`
         ).run();
         return result.changes ?? 0;
       } catch {
         const result = this.stmt(
           `UPDATE refs SET to_id = (
-             SELECT id FROM symbols WHERE name = refs.to_name LIMIT 1
+             SELECT sym.id FROM symbols sym
+              WHERE sym.name = refs.to_name AND ${_IndexStore.FAMILY_MATCH_SQL}
+              ORDER BY sym.id LIMIT 1
            ) WHERE to_id IS NULL AND to_name IS NOT NULL
-             AND to_name IN (SELECT name FROM symbols)`
-        ).run();
+             AND EXISTS (
+               SELECT 1 FROM symbols sym
+                WHERE sym.name = refs.to_name AND ${_IndexStore.FAMILY_MATCH_SQL}
+             )`
+        ).run(LANG_FAMILY_WILDCARD, LANG_FAMILY_WILDCARD);
         return result.changes ?? 0;
       }
     });
@@ -4166,7 +5274,7 @@ function normalizeComparablePath(value) {
 }
 function gitOutput(projectRoot2, args) {
   return new Promise((resolve4, reject) => {
-    execFile2(
+    execFile(
       "git",
       ["-C", projectRoot2, ...args],
       {
@@ -4297,13 +5405,40 @@ function assignRefsToSymbols2(refs, symbols) {
     }
     if (!owner && ref.callType === "import") owner = ordered[0];
     if (!owner || owner.id <= 0) continue;
-    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}:${ref.module ?? ""}`;
     if (seen.has(key)) continue;
     seen.add(key);
     assigned.push({ ...ref, fromId: owner.id });
   }
   return assigned;
 }
+async function resolveProjectRelations(store, projectRoot2, opts) {
+  if (opts.signal?.aborted) return;
+  try {
+    const indexedFiles = store.getAllFileMetas().map((meta) => meta.file);
+    if (indexedFiles.length === 0) return;
+    const structure = await detectModuleRoots(projectRoot2, indexedFiles);
+    if (opts.signal?.aborted) return;
+    store.setFilePackages(assignPackageLabels(structure, indexedFiles));
+    const resolver = new ModuleResolver(
+      structure,
+      indexedFiles,
+      store.getNamespaceDeclarations()
+    );
+    const pending = store.getUnresolvedImports(opts.onlyFiles);
+    const resolutions = [];
+    for (const entry of pending) {
+      const toFile = resolver.resolve(entry.fromFile, entry.lang, entry.module);
+      if (toFile && toFile !== entry.fromFile) {
+        resolutions.push({ ...entry, toFile });
+      }
+    }
+    if (opts.signal?.aborted) return;
+    store.applyImportResolutions(resolutions);
+  } catch (err) {
+    opts.errors.push(`relation resolution: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 async function runIndexerWithStore(store, opts) {
   const { projectRoot: projectRoot2, langs, ignore = [], signal } = opts;
   const relationGraphVersion = "2";
@@ -4548,6 +5683,14 @@ async function runIndexerWithStore(store, opts) {
     }
   }
   if (needsFullRefResolution) store.resolveRefs();
+  await resolveProjectRelations(store, projectRoot2, {
+    // A watcher run re-resolves only what it touched; a full run (or a contract
+    // bump) re-resolves everything, because a newly indexed file can be the
+    // target of imports written long before it.
+    onlyFiles: needsFullRefResolution ? void 0 : opts.files,
+    errors,
+    signal
+  });
   store.setMetadata("ref_resolution_version", refResolutionVersion);
   store.setMetadata("relation_graph_version", relationGraphVersion);
   if (!opts.files || filesIndexed >= 50) store.optimize();