@wrongstack/tools 0.309.0 → 0.310.0

package/dist/write.js

@@ -173,238 +173,133 @@ var init_languages = __esm({
   }
 });
 
-// src/codebase-index/ts-parser.ts
-var ts_parser_exports = {};
-__export(ts_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols
-});
-function loadTypescript2() {
-  tsLoad2 ??= import("@typescript/typescript6").then((m) => {
-    ts = m.default ?? m;
-    return ts;
-  });
-  return tsLoad2;
-}
-function kindMap() {
-  kindMapCache ??= {
-    [ts.SyntaxKind.ClassDeclaration]: "class",
-    [ts.SyntaxKind.InterfaceDeclaration]: "interface",
-    [ts.SyntaxKind.EnumDeclaration]: "enum",
-    [ts.SyntaxKind.TypeAliasDeclaration]: "type",
-    [ts.SyntaxKind.FunctionDeclaration]: "function",
-    [ts.SyntaxKind.MethodDeclaration]: "method",
-    [ts.SyntaxKind.GetAccessor]: "property",
-    [ts.SyntaxKind.SetAccessor]: "property",
-    [ts.SyntaxKind.PropertyDeclaration]: "property",
-    [ts.SyntaxKind.Parameter]: "parameter",
-    [ts.SyntaxKind.NamespaceExportDeclaration]: "namespace"
-  };
-  return kindMapCache;
-}
-function kindOf(node) {
-  if (ts.isVariableDeclaration(node)) {
-    const parent = node.parent;
-    if (ts.isVariableDeclarationList(parent)) {
-      const flags = parent.flags;
-      if (flags & ts.NodeFlags.Let) return "let";
-      if (flags & ts.NodeFlags.Const) return "const";
-      return "var";
-    }
-  }
-  if (ts.isModuleDeclaration(node)) return "namespace";
-  return kindMap()[node.kind] ?? null;
-}
-function getSignature(printer, node, sourceFile) {
-  const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
-  return raw.replace(/\s+/g, " ").slice(0, 500);
-}
-function getJsDoc(node, sourceFile) {
-  const fullText = sourceFile.getFullText();
-  const nodePos = node.getFullStart();
-  const comments = ts.getLeadingCommentRanges(fullText, nodePos);
-  if (!comments) return "";
-  for (const range of comments) {
-    const commentText = fullText.slice(range.pos, range.end);
-    const trimmed = commentText.trim();
-    if (trimmed.startsWith("/**") && trimmed.endsWith("*/")) {
-      const inner = trimmed.slice(3, -2).replace(/^[ \t]*\*[ ]?/gm, "").trim();
-      return inner.split("\n")[0]?.trim().slice(0, 200) ?? "";
-    }
+// src/codebase-index/import-extractor.ts
+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;
   }
-  return "";
+  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 pushScopeName(node, parts) {
-  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
-    parts.push(node.name?.text ?? "Anon");
-  } else if (ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isPropertyDeclaration(node) || ts.isFunctionDeclaration(node)) {
-    if (node.name && ts.isIdentifier(node.name)) {
-      parts.push(node.name.text);
-    }
+function newlineOffsets(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
   }
+  return offsets;
 }
-async function parseSymbols(opts) {
-  const { file, content, lang } = opts;
-  await loadTypescript2();
-  let sourceFile;
-  try {
-    sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  const symbols = [];
-  const refs = [];
-  const printer = ts.createPrinter({});
-  function visit(node, funcDepth, scopeParts) {
-    const kind = kindOf(node);
-    if (kind) {
-      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && funcDepth > 0) {
-      } else {
-        const nameNode = node.name;
-        if (!nameNode || !ts.isIdentifier(nameNode)) {
-          return;
-        }
-        const name = nameNode.text;
-        const pos2 = nameNode.getStart(sourceFile);
-        const { line: line2, character } = sourceFile.getLineAndCharacterOfPosition(pos2);
-        const scope = scopeParts.join(".");
-        const signature = getSignature(printer, node, sourceFile);
-        const docComment = getJsDoc(node, sourceFile);
-        const text = [name, signature, docComment].filter(Boolean).join(" | ");
-        symbols.push({
-          id: 0,
-          lang,
-          kind,
-          name,
-          file,
-          line: line2 + 1,
-          col: character,
-          signature,
-          docComment,
-          scope,
-          text
-        });
-      }
-    }
-    const pos = node.getStart(sourceFile);
-    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
-    const lineNum = line + 1;
-    if (ts.isCallExpression(node)) {
-      const expr = node.expression;
-      if (ts.isIdentifier(expr)) {
-        refs.push({ fromId: 0, toName: expr.text, callType: "call", line: lineNum });
-      }
-    } else if (ts.isPropertyAccessExpression(node)) {
-      if (ts.isIdentifier(node.expression)) {
-        refs.push({ fromId: 0, toName: node.expression.text, callType: "call", line: lineNum });
-      }
-    } else if (ts.isTypeReferenceNode(node)) {
-      const name = getTypeName(node.typeName);
-      if (name) refs.push({ fromId: 0, toName: name, callType: "type_ref", line: lineNum });
-    } else if (ts.isHeritageClause(node)) {
-      for (const t of node.types) {
-        const name = getTypeName(t.expression);
-        if (name)
-          refs.push({
-            fromId: 0,
-            toName: name,
-            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
-            line: lineNum
-          });
-      }
-    } else if (ts.isImportDeclaration(node)) {
-      emitImportSpecifierRefs(node, refs, lineNum);
-    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
-      emitExportSpecifierRefs(node, refs, lineNum);
-    }
-    const scopeIdx = scopeParts.length;
-    pushScopeName(node, scopeParts);
-    const childFuncDepth = ts.isFunctionLike(node) ? funcDepth + 1 : funcDepth;
-    ts.forEachChild(node, (child) => visit(child, childFuncDepth, scopeParts));
-    scopeParts.length = scopeIdx;
+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;
   }
-  visit(sourceFile, 0, []);
-  return { file, lang, symbols, refs: deduplicateRefs(refs), mtimeMs: Date.now() };
+  return low + 1;
 }
-function getTypeName(name) {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
-  return "";
+function hasImportPatterns(lang) {
+  return LANG_IMPORTS[lang] !== void 0;
 }
-function deduplicateRefs(refs) {
+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();
-  return refs.filter((r) => {
-    const key = `${r.toName}:${r.callType}:${r.line}:${r.module ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-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) {
-    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, module });
-  }
-  const bindings = clause.namedBindings;
-  if (!bindings) return;
-  if (ts.isNamedImports(bindings)) {
-    for (const element of bindings.elements) {
+  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: getImportSpecifierName(element),
+        toName,
         callType: "import",
-        line: lineNum,
+        line: lineAt(offsets, match.index ?? 0),
+        lang: opts.lang,
         module
       });
     }
-  } else if (ts.isNamespaceImport(bindings)) {
-    refs.push({
-      fromId: 0,
-      toName: bindings.name.text,
-      callType: "import",
-      line: lineNum,
-      module
-    });
   }
+  return refs;
 }
-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, 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, module });
-    }
-    return;
-  }
-  if (module) {
-    refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
-  }
-}
-var ts, tsLoad2, kindMapCache;
-var init_ts_parser = __esm({
-  "src/codebase-index/ts-parser.ts"() {
+var IMPORT_MAX_FILE_CHARS, IMPORT_MAX_PER_FILE, DOTTED_IMPORT, LANG_IMPORTS;
+var init_import_extractor = __esm({
+  "src/codebase-index/import-extractor.ts"() {
     "use strict";
-    init_languages();
-    tsLoad2 = null;
-    kindMapCache = null;
+    IMPORT_MAX_FILE_CHARS = 512 * 1024;
+    IMPORT_MAX_PER_FILE = 400;
+    DOTTED_IMPORT = [
+      { re: /^[ \t]*import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;?\s*$/gm }
+    ];
+    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 }]
+    };
   }
 });
 
@@ -490,6 +385,32 @@ function parseParserOutput(stdout, lang) {
     refs: dedupeRefs(coerceRefs(record.refs, lang))
   };
 }
+function parseParserBatchOutput(stdout, lang) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const results = parsed.results;
+  if (!Array.isArray(results)) return [];
+  return results.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+    const candidate = entry;
+    if (typeof candidate.file !== "string" || !candidate.file) return [];
+    return [
+      {
+        file: candidate.file,
+        error: typeof candidate.error === "string" && candidate.error ? candidate.error : void 0,
+        symbols: coerceSymbols(candidate.symbols),
+        refs: dedupeRefs(coerceRefs(candidate.refs, lang))
+      }
+    ];
+  });
+}
 function dedupeRefs(refs) {
   const seen = /* @__PURE__ */ new Set();
   return refs.filter((ref) => {
@@ -530,187 +451,172 @@ var init_spawn_gate = __esm({
   }
 });
 
-// src/codebase-index/go-parser.ts
-var go_parser_exports = {};
-__export(go_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols2
-});
+// src/codebase-index/parser-batch.ts
 import { spawn } from "node:child_process";
+import * as fsSync from "node:fs";
+import * as fs4 from "node:fs/promises";
 import * as os from "node:os";
 import * as path8 from "node:path";
-import * as fs4 from "node:fs/promises";
-async function parseSymbols2(opts) {
-  const { file, content, lang } = opts;
-  try {
-    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
-    if (parsed.symbols.length > 0) {
-      return parsed;
+function chunkBatchFiles(files) {
+  const chunks = [];
+  let current = [];
+  let bytes = 0;
+  for (const file of files) {
+    const size = Buffer.byteLength(file.content, "utf8");
+    if (current.length > 0 && (current.length >= MAX_BATCH_FILES || bytes + size > MAX_BATCH_BYTES)) {
+      chunks.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(file);
+    bytes += size;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+function batchTimeoutMs(fileCount) {
+  return Math.min(12e4, 15e3 + fileCount * 1500);
+}
+async function ensureScriptPath(cached, prefix, fileName, script) {
+  if (cached) return { path: cached, wrote: false };
+  const dir = await fs4.mkdtemp(path8.join(os.tmpdir(), prefix));
+  const scriptPath = path8.join(dir, fileName);
+  await fs4.writeFile(scriptPath, script, { encoding: "utf8", flag: "wx" });
+  process.once("exit", () => {
+    try {
+      fsSync.rmSync(dir, { recursive: true, force: true });
+    } catch {
     }
-    const fallback = fallbackParse(file, content, lang);
-    return parsed.refs?.length ? { ...fallback, refs: parsed.refs } : fallback;
-  } catch {
-    return fallbackParse(file, content, lang);
-  }
+  });
+  return { path: scriptPath, wrote: true };
 }
-function fallbackParse(filePath, content, lang) {
-  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(content) || hasUnbalancedDelimiters(content)) {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  const symbols = [];
-  const packageName = content.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
-  const lines = content.split(/\r?\n/);
-  for (const [idx, line] of lines.entries()) {
-    const trimmed = line.trimStart();
-    const col = line.length - trimmed.length + 1;
-    const fn = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/.exec(trimmed);
-    if (fn?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: trimmed.startsWith("func (") ? "method" : "function",
-        name: fn[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName ? `${packageName}.${fn[1]}` : fn[1]
-      });
-      continue;
-    }
-    const typeDecl = /^type\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (typeDecl?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: "type",
-        name: typeDecl[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
-      continue;
-    }
-    const valueDecl = /^(const|var)\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (valueDecl?.[1] && valueDecl[2]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: valueDecl[1],
-        name: valueDecl[2],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
+function runToolchainChild(binary, args, stdinPayload, timeoutMs) {
+  return new Promise((resolve4) => {
+    let settled = false;
+    let stdout = "";
+    let proc;
+    try {
+      proc = spawn(binary, args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    } catch {
+      resolve4(null);
+      return;
     }
-  }
-  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
-}
-function addFallbackSymbol(symbols, opts) {
-  symbols.push({
-    id: 0,
-    lang: opts.lang,
-    kind: opts.kind,
-    name: opts.name,
-    file: opts.filePath,
-    line: opts.line,
-    col: opts.col,
-    signature: opts.signature,
-    docComment: "",
-    scope: opts.scope,
-    text: `${opts.name} ${opts.signature}`.trim()
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve4(value);
+    };
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      finish(null);
+    }, timeoutMs);
+    timer.unref?.();
+    proc.on("error", () => finish(null));
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr?.resume();
+    proc.stdin?.on("error", () => {
+    });
+    proc.stdin?.write(stdinPayload);
+    proc.stdin?.end();
+    proc.on("close", (code) => finish({ code, stdout }));
   });
 }
-function hasUnbalancedDelimiters(content) {
-  const pairs = { "(": ")", "[": "]", "{": "}" };
-  const closers = new Set(Object.values(pairs));
-  const stack = [];
-  for (const ch of content) {
-    if (pairs[ch]) {
-      stack.push(pairs[ch]);
-    } else if (closers.has(ch) && stack.pop() !== ch) {
-      return true;
-    }
+async function runGoBatch(files, goBinary) {
+  const out = /* @__PURE__ */ new Map();
+  if (files.length === 0) return out;
+  const { path: scriptPath } = await ensureScriptPath(
+    _goBatchScriptPath,
+    "ws-go-parse",
+    "batch.go",
+    GO_BATCH_SCRIPT
+  );
+  _goBatchScriptPath = scriptPath;
+  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
+  const result = await withSpawnGate(
+    () => runToolchainChild(
+      goBinary ?? resolveWin32Command("go"),
+      ["run", scriptPath],
+      payload,
+      batchTimeoutMs(files.length)
+    )
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return out;
+  for (const entry of parseParserBatchOutput(result.stdout, "go")) {
+    if (entry.error !== void 0) continue;
+    out.set(entry.file, {
+      file: entry.file,
+      lang: "go",
+      symbols: entry.symbols.map((s) => ({
+        id: 0,
+        lang: "go",
+        kind: s.kind,
+        name: s.name,
+        file: entry.file,
+        line: s.line,
+        col: s.col,
+        signature: s.signature ?? "",
+        docComment: "",
+        scope: s.scope ?? "",
+        text: `${s.name} ${s.signature ?? ""}`.trim()
+      })),
+      refs: entry.refs,
+      mtimeMs: Date.now()
+    });
   }
-  return stack.length > 0;
+  return out;
 }
-async function syncGoParse(filePath, content, lang) {
-  try {
-    let scriptPath = _cachedGoScriptPath;
-    if (!scriptPath) {
-      const tmpDir = await fs4.mkdtemp(path8.join(os.tmpdir(), "ws-go-parse-"));
-      scriptPath = path8.join(tmpDir, "parse.go");
-      await fs4.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-      _cachedGoScriptPath = scriptPath;
-    }
-    const goBinary = resolveWin32Command("go");
-    const goResult = await new Promise(
-      (resolve4, reject) => {
-        let settled = false;
-        const proc = spawn(goBinary, ["run", scriptPath], {
-          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();
-        proc.stdin?.write(content);
-        proc.stdin?.end();
-        const timer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3);
-        timer.unref?.();
-        proc.on("close", (code2) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          resolve4({ code: code2, stdout: stdout2 });
-        });
-      }
-    );
-    const { code, stdout } = goResult;
-    if (code !== 0 || !stdout.trim()) {
-      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols: rawSymbols, refs } = parseParserOutput(stdout, lang);
-    const symbols = rawSymbols.map((s) => ({
-      id: 0,
-      lang,
-      kind: s.kind,
-      name: s.name,
-      file: filePath,
-      line: s.line,
-      col: s.col,
-      signature: s.signature ?? "",
-      docComment: "",
-      scope: s.scope ?? "",
-      text: `${s.name} ${s.signature ?? ""}`.trim()
-    }));
-    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
-  } catch {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+async function runPyBatch(files, pythonBinary) {
+  const out = /* @__PURE__ */ new Map();
+  if (files.length === 0) return out;
+  const { path: scriptPath } = await ensureScriptPath(
+    _pyBatchScriptPath,
+    "ws-py-parse",
+    "batch.py",
+    PY_BATCH_SCRIPT
+  );
+  _pyBatchScriptPath = scriptPath;
+  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
+  const result = await withSpawnGate(
+    () => runToolchainChild(pythonBinary, [scriptPath], payload, batchTimeoutMs(files.length))
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return out;
+  for (const entry of parseParserBatchOutput(result.stdout, "py")) {
+    if (entry.error !== void 0) continue;
+    out.set(entry.file, {
+      file: entry.file,
+      lang: "py",
+      symbols: entry.symbols.map((s) => ({
+        id: 0,
+        lang: "py",
+        kind: s.kind,
+        name: s.name,
+        file: entry.file,
+        line: s.line,
+        col: s.col,
+        signature: s.signature ?? "",
+        docComment: "",
+        scope: s.scope ?? "",
+        text: `${s.name} ${s.signature ?? ""}`.trim()
+      })),
+      refs: entry.refs,
+      mtimeMs: Date.now()
+    });
   }
+  return out;
 }
-var GO_PARSE_SCRIPT, _cachedGoScriptPath;
-var init_go_parser = __esm({
-  "src/codebase-index/go-parser.ts"() {
+var MAX_BATCH_FILES, MAX_BATCH_BYTES, GO_BATCH_SCRIPT, PY_BATCH_SCRIPT, _goBatchScriptPath, _pyBatchScriptPath;
+var init_parser_batch = __esm({
+  "src/codebase-index/parser-batch.ts"() {
     "use strict";
     init_win32_resolve();
     init_parser_output();
     init_spawn_gate();
-    init_languages();
-    GO_PARSE_SCRIPT = `
+    MAX_BATCH_FILES = 100;
+    MAX_BATCH_BYTES = 8 * 1024 * 1024;
+    GO_BATCH_SCRIPT = `
 package main
 
 import (
@@ -734,8 +640,6 @@ 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"\`
@@ -743,57 +647,53 @@ type Ref struct {
 	Module   string \`json:"module"\`
 }
 
-type Result struct {
-	Symbols []Sym \`json:"symbols"\`
-	Refs    []Ref \`json:"refs"\`
+type FileResult struct {
+	File    string \`json:"file"\`
+	Error   string \`json:"error,omitempty"\`
+	Symbols []Sym  \`json:"symbols"\`
+	Refs    []Ref  \`json:"refs"\`
 }
 
-func emptyResult() string {
-	return "{\\"symbols\\":[],\\"refs\\":[]}"
+type BatchResult struct {
+	Version int          \`json:"version"\`
+	Results []FileResult \`json:"results"\`
 }
 
-func main() {
-	src, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
+type inputFile struct {
+	File    string \`json:"file"\`
+	Content string \`json:"content"\`
+}
+
+func parseOne(name string, src []byte) FileResult {
+	res := FileResult{File: name, Symbols: []Sym{}, Refs: []Ref{}}
 	fset := token.NewFileSet()
 	node, err := parser.ParseFile(fset, "src.go", src, 0)
 	if err != nil {
-		fmt.Print(emptyResult())
-		return
+		res.Error = err.Error()
+		return res
 	}
-
-	var syms []Sym
-
-	// Package-level scope
 	pkgScope := node.Name.Name
-
-	// Collect all top-level declarations
 	for _, decl := range node.Decls {
 		switch d := decl.(type) {
 		case *ast.FuncDecl:
-			name := d.Name.Name
+			symName := d.Name.Name
 			kind := "function"
 			scope := pkgScope
 			if d.Recv != nil && len(d.Recv.List) > 0 {
-				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + name
+				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + symName
 				kind = "method"
 			} else {
-				scope = pkgScope + "." + name
+				scope = pkgScope + "." + symName
 			}
 			pos := fset.Position(d.Pos())
-			sig := formatFuncSig(d)
-			syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: scope})
-
+			res.Symbols = append(res.Symbols, Sym{Name: symName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: formatFuncSig(d), Scope: scope})
 		case *ast.GenDecl:
 			for _, spec := range d.Specs {
 				switch s := spec.(type) {
 				case *ast.TypeSpec:
-					name := s.Name.Name
+					typeName := s.Name.Name
 					pos := fset.Position(s.Pos())
-					sig := "type " + name
+					sig := "type " + typeName
 					if s.TypeParams != nil {
 						sig += formatTypeParams(s.TypeParams)
 					}
@@ -804,64 +704,72 @@ func main() {
 					} else {
 						sig += " = " + formatType(s.Type)
 					}
-					syms = append(syms, Sym{Name: name, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
-
+					res.Symbols = append(res.Symbols, Sym{Name: typeName, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
 				case *ast.ValueSpec:
 					for _, n := range s.Names {
-						name := n.Name
+						valueName := n.Name
 						pos := fset.Position(n.Pos())
 						kind := "var"
 						if d.Tok == token.CONST {
 							kind = "const"
 						}
-						sig := kind + " " + name
+						sig := kind + " " + valueName
 						if s.Type != nil {
 							sig += " " + formatType(s.Type)
 						}
-						syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+						res.Symbols = append(res.Symbols, Sym{Name: valueName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
 					}
 				}
 			}
 		}
 	}
-
-	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})
+				res.Refs = append(res.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})
+				res.Refs = append(res.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})
+					res.Refs = append(res.Refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
 				}
 			}
 		}
 		return true
 	})
+	return res
+}
 
-	if syms == nil {
-		syms = []Sym{}
+func main() {
+	raw, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
+		fmt.Print(string(out))
+		return
 	}
-	data, err := json.Marshal(Result{Symbols: syms, Refs: refs})
+	var inputs []inputFile
+	if err := json.Unmarshal(raw, &inputs); err != nil {
+		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
+		fmt.Print(string(out))
+		return
+	}
+	results := make([]FileResult, 0, len(inputs))
+	for _, in := range inputs {
+		results = append(results, parseOne(in.File, []byte(in.Content)))
+	}
+	data, err := json.Marshal(BatchResult{Version: 1, Results: results})
 	if err != nil {
-		fmt.Print(emptyResult())
+		fmt.Print("{\\"version\\":1,\\"results\\":[]}")
 		return
 	}
 	fmt.Print(string(data))
@@ -981,10 +889,8 @@ func formatType(t ast.Expr) string {
 	case *ast.BasicLit:
 		return v.Value
 	case *ast.IndexExpr:
-		// Generic instantiation with one type arg, e.g. Logger[int].
 		return formatType(v.X) + "[" + formatType(v.Index) + "]"
 	case *ast.IndexListExpr:
-		// Generic instantiation with multiple type args, e.g. Map[K, V].
 		args := make([]string, len(v.Indices))
 		for i, idx := range v.Indices {
 			args[i] = formatType(idx)
@@ -995,7 +901,187 @@ func formatType(t ast.Expr) string {
 	}
 }
 `;
-    _cachedGoScriptPath = null;
+    PY_BATCH_SCRIPT = `import ast, json, sys
+
+def get_name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return get_name(node.value) + "." + node.attr
+    elif isinstance(node, ast.Subscript):
+        return get_name(node.value)
+    elif isinstance(node, ast.Call):
+        return get_name(node.func)
+    elif isinstance(node, ast.Constant):
+        return str(node.value)
+    return ""
+
+def leaf_name(node):
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    if isinstance(node, ast.Name):
+        return node.id
+    return get_name(node).split(".")[-1]
+
+def is_private(name):
+    return name.startswith("__") and not name.endswith("__")
+
+def parse_one(name, source, module_name):
+    result = {"file": name, "symbols": [], "refs": []}
+    try:
+        tree = ast.parse(source, filename=name)
+    except Exception as e:
+        result["error"] = str(e)
+        return result
+    syms = []
+    refs = []
+    scope_stack = [module_name]
+
+    def sym(d):
+        return {
+            "name": d["name"], "kind": d["kind"], "line": d["line"], "col": d["col"],
+            "signature": d["signature"], "scope": d["scope"],
+        }
+
+    class Visitor(ast.NodeVisitor):
+        def visit_ClassDef(self, node):
+            bases = [get_name(b) for b in node.bases]
+            sig = "class " + node.name
+            if bases:
+                sig += "(" + ", ".join(bases) + ")"
+            sig += ": ..."
+            syms.append(sym({
+                "name": node.name, "kind": "class", "line": node.lineno,
+                "col": node.col_offset, "signature": sig,
+                "scope": ".".join(scope_stack) + "." + node.name,
+            }))
+            scope_stack.append(node.name)
+            self.generic_visit(node)
+            scope_stack.pop()
+
+        def visit_FunctionDef(self, node):
+            args = ", ".join(a.arg for a in node.args.args)
+            returns = get_name(node.returns) if node.returns is not None else ""
+            is_async = isinstance(node, ast.AsyncFunctionDef)
+            kind = "function"
+            prefix = "def "
+            for dec in node.decorator_list:
+                d = get_name(dec)
+                if d.endswith(".staticmethod"):
+                    kind = "staticmethod"
+                elif d.endswith(".classmethod"):
+                    kind = "classmethod"
+                elif d == "property":
+                    kind = "property"
+            if is_async:
+                kind = "async_" + kind
+            sig = f"{prefix}{node.name}({args})"
+            if returns:
+                sig += f" -> {returns}"
+            syms.append(sym({
+                "name": node.name, "kind": kind, "line": node.lineno,
+                "col": node.col_offset, "signature": sig,
+                "scope": ".".join(scope_stack) + "." + node.name,
+            }))
+
+        def visit_AsyncFunctionDef(self, node):
+            self.visit_FunctionDef(node)
+
+        def visit_Assign(self, node):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    tname = target.id
+                    if is_private(tname):
+                        continue
+                    kind = "const" if tname.isupper() else "var"
+                    col = target.col_offset if hasattr(target, "col_offset") else 0
+                    syms.append(sym({
+                        "name": tname, "kind": kind, "line": node.lineno, "col": col,
+                        "signature": f"{tname} = ...", "scope": ".".join(scope_stack),
+                    }))
+
+        def visit_AnnAssign(self, node):
+            if isinstance(node.target, ast.Name):
+                tname = node.target.id
+                if is_private(tname):
+                    return
+                kind = "const" if tname.isupper() else "var"
+                col = node.target.col_offset if hasattr(node.target, "col_offset") else 0
+                sig = f"{tname}: {get_name(node.annotation)}"
+                if node.value:
+                    sig += " = ..."
+                syms.append(sym({
+                    "name": tname, "kind": kind, "line": node.lineno, "col": col,
+                    "signature": sig, "scope": ".".join(scope_stack),
+                }))
+
+        def visit_Import(self, node):
+            # Parity with the single-file parser: imports are symbols too.
+            for alias in node.names:
+                name = alias.asname or alias.name
+                syms.append(sym({
+                    "name": name, "kind": "import", "line": node.lineno,
+                    "col": node.col_offset, "signature": f"import {alias.name}",
+                    "scope": ".".join(scope_stack),
+                }))
+
+        def visit_ImportFrom(self, node):
+            module = node.module or ""
+            for alias in node.names:
+                name = alias.asname or alias.name
+                syms.append(sym({
+                    "name": name, "kind": "import", "line": node.lineno,
+                    "col": node.col_offset, "signature": f"from {module} import {alias.name}",
+                    "scope": ".".join(scope_stack),
+                }))
+
+    Visitor().visit(tree)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            cname = leaf_name(node.func)
+            if cname:
+                refs.append({"toName": cname, "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):
+            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:
+                bname = leaf_name(base)
+                if bname:
+                    refs.append({"toName": bname, "callType": "inherit", "line": node.lineno})
+
+    result["symbols"] = syms
+    result["refs"] = refs
+    return result
+
+def main():
+    try:
+        inputs = json.loads(sys.stdin.read())
+    except Exception:
+        print(json.dumps({"version": 1, "results": []}))
+        return
+    results = []
+    for entry in inputs:
+        name = entry.get("file", "")
+        module_name = name.rsplit("/", 1)[-1].rsplit("\\\\", 1)[-1][:-3]
+        results.append(parse_one(name, entry.get("content", ""), module_name))
+    print(json.dumps({"version": 1, "results": results}))
+
+main()
+`;
+    _goBatchScriptPath = null;
+    _pyBatchScriptPath = null;
   }
 });
 
@@ -1005,7 +1091,7 @@ __export(generic_parser_exports, {
   GENERIC_MAX_FILE_CHARS: () => GENERIC_MAX_FILE_CHARS,
   GENERIC_MAX_SYMBOLS_DEFAULT: () => GENERIC_MAX_SYMBOLS_DEFAULT,
   parseGeneric: () => parseGeneric,
-  parseSymbols: () => parseSymbols3
+  parseSymbols: () => parseSymbols
 });
 function patternsFor(lang) {
   return LANG_PATTERNS[lang] ?? LANG_PATTERNS.other ?? [];
@@ -1093,7 +1179,7 @@ function parseGeneric(opts) {
   }
   return { file, lang, symbols, mtimeMs };
 }
-async function parseSymbols3(opts) {
+async function parseSymbols(opts) {
   return parseGeneric(opts);
 }
 var C_LIKE, LANG_PATTERNS, KEYWORDS, GENERIC_MAX_SYMBOLS_DEFAULT, GENERIC_MAX_FILE_CHARS;
@@ -1326,13 +1412,14 @@ var init_generic_parser = __esm({
 var py_parser_exports = {};
 __export(py_parser_exports, {
   detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols4
+  parseSymbols: () => parseSymbols2,
+  resolvePythonBinary: () => resolvePythonBinary
 });
 import { spawn as spawn2 } from "node:child_process";
 import * as fs5 from "node:fs/promises";
 import * as os2 from "node:os";
 import * as path9 from "node:path";
-async function parseSymbols4(opts) {
+async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
     const native = await withSpawnGate(() => syncPyParse(file, content, lang));
@@ -1406,6 +1493,10 @@ function spawnPyParser(pyBinary, scriptPath, filePath, content) {
     });
   });
 }
+function resolvePythonBinary() {
+  cachedPyBinary ??= resolvePython();
+  return cachedPyBinary;
+}
 async function syncPyParse(filePath, content, lang) {
   try {
     if (!_cachedScriptPath) {
@@ -1696,9 +1787,713 @@ for node in ast.walk(tree):
             if name:
                 refs.append({"toName": name, "callType": "inherit", "line": node.lineno})
 
-print(json.dumps({"symbols": [s.to_dict() for s in syms], "refs": refs}))
+print(json.dumps({"symbols": [s.to_dict() for s in syms], "refs": refs}))
+`;
+    _cachedScriptPath = null;
+  }
+});
+
+// src/codebase-index/ts-parser.ts
+var ts_parser_exports = {};
+__export(ts_parser_exports, {
+  detectLang: () => detectLang,
+  parseSymbols: () => parseSymbols3
+});
+function loadTypescript2() {
+  tsLoad2 ??= import("@typescript/typescript6").then((m) => {
+    ts = m.default ?? m;
+    return ts;
+  });
+  return tsLoad2;
+}
+function kindMap() {
+  kindMapCache ??= {
+    [ts.SyntaxKind.ClassDeclaration]: "class",
+    [ts.SyntaxKind.InterfaceDeclaration]: "interface",
+    [ts.SyntaxKind.EnumDeclaration]: "enum",
+    [ts.SyntaxKind.TypeAliasDeclaration]: "type",
+    [ts.SyntaxKind.FunctionDeclaration]: "function",
+    [ts.SyntaxKind.MethodDeclaration]: "method",
+    [ts.SyntaxKind.GetAccessor]: "property",
+    [ts.SyntaxKind.SetAccessor]: "property",
+    [ts.SyntaxKind.PropertyDeclaration]: "property",
+    [ts.SyntaxKind.Parameter]: "parameter",
+    [ts.SyntaxKind.NamespaceExportDeclaration]: "namespace"
+  };
+  return kindMapCache;
+}
+function kindOf(node) {
+  if (ts.isVariableDeclaration(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclarationList(parent)) {
+      const flags = parent.flags;
+      if (flags & ts.NodeFlags.Let) return "let";
+      if (flags & ts.NodeFlags.Const) return "const";
+      return "var";
+    }
+  }
+  if (ts.isModuleDeclaration(node)) return "namespace";
+  return kindMap()[node.kind] ?? null;
+}
+function getSignature(printer, node, sourceFile) {
+  const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+  return raw.replace(/\s+/g, " ").slice(0, 500);
+}
+function getJsDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const nodePos = node.getFullStart();
+  const comments = ts.getLeadingCommentRanges(fullText, nodePos);
+  if (!comments) return "";
+  for (const range of comments) {
+    const commentText = fullText.slice(range.pos, range.end);
+    const trimmed = commentText.trim();
+    if (trimmed.startsWith("/**") && trimmed.endsWith("*/")) {
+      const inner = trimmed.slice(3, -2).replace(/^[ \t]*\*[ ]?/gm, "").trim();
+      return inner.split("\n")[0]?.trim().slice(0, 200) ?? "";
+    }
+  }
+  return "";
+}
+function pushScopeName(node, parts) {
+  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+    parts.push(node.name?.text ?? "Anon");
+  } else if (ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isPropertyDeclaration(node) || ts.isFunctionDeclaration(node)) {
+    if (node.name && ts.isIdentifier(node.name)) {
+      parts.push(node.name.text);
+    }
+  }
+}
+async function parseSymbols3(opts) {
+  const { file, content, lang } = opts;
+  await loadTypescript2();
+  let sourceFile;
+  try {
+    sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  const refs = [];
+  const printer = ts.createPrinter({});
+  function visit(node, funcDepth, scopeParts) {
+    const kind = kindOf(node);
+    if (kind) {
+      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && funcDepth > 0) {
+      } else {
+        const nameNode = node.name;
+        if (!nameNode || !ts.isIdentifier(nameNode)) {
+          return;
+        }
+        const name = nameNode.text;
+        const pos2 = nameNode.getStart(sourceFile);
+        const { line: line2, character } = sourceFile.getLineAndCharacterOfPosition(pos2);
+        const scope = scopeParts.join(".");
+        const signature = getSignature(printer, node, sourceFile);
+        const docComment = getJsDoc(node, sourceFile);
+        const text = [name, signature, docComment].filter(Boolean).join(" | ");
+        symbols.push({
+          id: 0,
+          lang,
+          kind,
+          name,
+          file,
+          line: line2 + 1,
+          col: character,
+          signature,
+          docComment,
+          scope,
+          text
+        });
+      }
+    }
+    const pos = node.getStart(sourceFile);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    const lineNum = line + 1;
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr)) {
+        refs.push({ fromId: 0, toName: expr.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isPropertyAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression)) {
+        refs.push({ fromId: 0, toName: node.expression.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isTypeReferenceNode(node)) {
+      const name = getTypeName(node.typeName);
+      if (name) refs.push({ fromId: 0, toName: name, callType: "type_ref", line: lineNum });
+    } else if (ts.isHeritageClause(node)) {
+      for (const t of node.types) {
+        const name = getTypeName(t.expression);
+        if (name)
+          refs.push({
+            fromId: 0,
+            toName: name,
+            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
+            line: lineNum
+          });
+      }
+    } else if (ts.isImportDeclaration(node)) {
+      emitImportSpecifierRefs(node, refs, lineNum);
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+      emitExportSpecifierRefs(node, refs, lineNum);
+    }
+    const scopeIdx = scopeParts.length;
+    pushScopeName(node, scopeParts);
+    const childFuncDepth = ts.isFunctionLike(node) ? funcDepth + 1 : funcDepth;
+    ts.forEachChild(node, (child) => visit(child, childFuncDepth, scopeParts));
+    scopeParts.length = scopeIdx;
+  }
+  visit(sourceFile, 0, []);
+  return { file, lang, symbols, refs: deduplicateRefs(refs), mtimeMs: Date.now() };
+}
+function getTypeName(name) {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
+  return "";
+}
+function deduplicateRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((r) => {
+    const key = `${r.toName}:${r.callType}:${r.line}:${r.module ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+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) {
+    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, module });
+  }
+  const bindings = clause.namedBindings;
+  if (!bindings) return;
+  if (ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      refs.push({
+        fromId: 0,
+        toName: getImportSpecifierName(element),
+        callType: "import",
+        line: lineNum,
+        module
+      });
+    }
+  } else if (ts.isNamespaceImport(bindings)) {
+    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, 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, module });
+    }
+    return;
+  }
+  if (module) {
+    refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
+  }
+}
+var ts, tsLoad2, kindMapCache;
+var init_ts_parser = __esm({
+  "src/codebase-index/ts-parser.ts"() {
+    "use strict";
+    init_languages();
+    tsLoad2 = null;
+    kindMapCache = null;
+  }
+});
+
+// src/codebase-index/go-parser.ts
+var go_parser_exports = {};
+__export(go_parser_exports, {
+  detectLang: () => detectLang,
+  parseSymbols: () => parseSymbols4
+});
+import { spawn as spawn3 } from "node:child_process";
+import * as os3 from "node:os";
+import * as path10 from "node:path";
+import * as fs6 from "node:fs/promises";
+async function parseSymbols4(opts) {
+  const { file, content, lang } = opts;
+  try {
+    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
+    if (parsed.symbols.length > 0) {
+      return parsed;
+    }
+    const fallback = fallbackParse(file, content, lang);
+    return parsed.refs?.length ? { ...fallback, refs: parsed.refs } : fallback;
+  } catch {
+    return fallbackParse(file, content, lang);
+  }
+}
+function fallbackParse(filePath, content, lang) {
+  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(content) || hasUnbalancedDelimiters(content)) {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  const packageName = content.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
+  const lines = content.split(/\r?\n/);
+  for (const [idx, line] of lines.entries()) {
+    const trimmed = line.trimStart();
+    const col = line.length - trimmed.length + 1;
+    const fn = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/.exec(trimmed);
+    if (fn?.[1]) {
+      addFallbackSymbol(symbols, {
+        filePath,
+        lang,
+        kind: trimmed.startsWith("func (") ? "method" : "function",
+        name: fn[1],
+        line: idx + 1,
+        col,
+        signature: trimmed,
+        scope: packageName ? `${packageName}.${fn[1]}` : fn[1]
+      });
+      continue;
+    }
+    const typeDecl = /^type\s+([A-Za-z_]\w*)\b/.exec(trimmed);
+    if (typeDecl?.[1]) {
+      addFallbackSymbol(symbols, {
+        filePath,
+        lang,
+        kind: "type",
+        name: typeDecl[1],
+        line: idx + 1,
+        col,
+        signature: trimmed,
+        scope: packageName
+      });
+      continue;
+    }
+    const valueDecl = /^(const|var)\s+([A-Za-z_]\w*)\b/.exec(trimmed);
+    if (valueDecl?.[1] && valueDecl[2]) {
+      addFallbackSymbol(symbols, {
+        filePath,
+        lang,
+        kind: valueDecl[1],
+        name: valueDecl[2],
+        line: idx + 1,
+        col,
+        signature: trimmed,
+        scope: packageName
+      });
+    }
+  }
+  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+}
+function addFallbackSymbol(symbols, opts) {
+  symbols.push({
+    id: 0,
+    lang: opts.lang,
+    kind: opts.kind,
+    name: opts.name,
+    file: opts.filePath,
+    line: opts.line,
+    col: opts.col,
+    signature: opts.signature,
+    docComment: "",
+    scope: opts.scope,
+    text: `${opts.name} ${opts.signature}`.trim()
+  });
+}
+function hasUnbalancedDelimiters(content) {
+  const pairs = { "(": ")", "[": "]", "{": "}" };
+  const closers = new Set(Object.values(pairs));
+  const stack = [];
+  for (const ch of content) {
+    if (pairs[ch]) {
+      stack.push(pairs[ch]);
+    } else if (closers.has(ch) && stack.pop() !== ch) {
+      return true;
+    }
+  }
+  return stack.length > 0;
+}
+async function syncGoParse(filePath, content, lang) {
+  try {
+    let scriptPath = _cachedGoScriptPath;
+    if (!scriptPath) {
+      const tmpDir = await fs6.mkdtemp(path10.join(os3.tmpdir(), "ws-go-parse-"));
+      scriptPath = path10.join(tmpDir, "parse.go");
+      await fs6.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+      _cachedGoScriptPath = scriptPath;
+    }
+    const goBinary = resolveWin32Command("go");
+    const goResult = await new Promise(
+      (resolve4, reject) => {
+        let settled = false;
+        const proc = spawn3(goBinary, ["run", scriptPath], {
+          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();
+        proc.stdin?.write(content);
+        proc.stdin?.end();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (code2) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve4({ code: code2, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = goResult;
+    if (code !== 0 || !stdout.trim()) {
+      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { symbols: rawSymbols, refs } = parseParserOutput(stdout, lang);
+    const symbols = rawSymbols.map((s) => ({
+      id: 0,
+      lang,
+      kind: s.kind,
+      name: s.name,
+      file: filePath,
+      line: s.line,
+      col: s.col,
+      signature: s.signature ?? "",
+      docComment: "",
+      scope: s.scope ?? "",
+      text: `${s.name} ${s.signature ?? ""}`.trim()
+    }));
+    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
+  } catch {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+var GO_PARSE_SCRIPT, _cachedGoScriptPath;
+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 = `
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type Sym struct {
+	Name      string \`json:"name"\`
+	Kind      string \`json:"kind"\`
+	Line      int    \`json:"line"\`
+	Col       int    \`json:"col"\`
+	Signature string \`json:"signature"\`
+	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(emptyResult())
+		return
+	}
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, "src.go", src, 0)
+	if err != nil {
+		fmt.Print(emptyResult())
+		return
+	}
+
+	var syms []Sym
+
+	// Package-level scope
+	pkgScope := node.Name.Name
+
+	// Collect all top-level declarations
+	for _, decl := range node.Decls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			name := d.Name.Name
+			kind := "function"
+			scope := pkgScope
+			if d.Recv != nil && len(d.Recv.List) > 0 {
+				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + name
+				kind = "method"
+			} else {
+				scope = pkgScope + "." + name
+			}
+			pos := fset.Position(d.Pos())
+			sig := formatFuncSig(d)
+			syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: scope})
+
+		case *ast.GenDecl:
+			for _, spec := range d.Specs {
+				switch s := spec.(type) {
+				case *ast.TypeSpec:
+					name := s.Name.Name
+					pos := fset.Position(s.Pos())
+					sig := "type " + name
+					if s.TypeParams != nil {
+						sig += formatTypeParams(s.TypeParams)
+					}
+					if st, ok := s.Type.(*ast.StructType); ok {
+						sig += " = struct { " + formatFields(st.Fields.List) + " }"
+					} else if it, ok := s.Type.(*ast.InterfaceType); ok {
+						sig += " = interface { " + formatMethods(it.Methods.List) + " }"
+					} else {
+						sig += " = " + formatType(s.Type)
+					}
+					syms = append(syms, Sym{Name: name, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+
+				case *ast.ValueSpec:
+					for _, n := range s.Names {
+						name := n.Name
+						pos := fset.Position(n.Pos())
+						kind := "var"
+						if d.Tok == token.CONST {
+							kind = "const"
+						}
+						sig := kind + " " + name
+						if s.Type != nil {
+							sig += " " + formatType(s.Type)
+						}
+						syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+					}
+				}
+			}
+		}
+	}
+
+	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(emptyResult())
+		return
+	}
+	fmt.Print(string(data))
+}
+
+func recvTypeName(t ast.Expr) string {
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.StarExpr:
+		return recvTypeName(v.X)
+	default:
+		return "?"
+	}
+}
+
+func formatFuncSig(d *ast.FuncDecl) string {
+	scope := ""
+	if d.Recv != nil && len(d.Recv.List) > 0 {
+		scope = "(" + formatFieldList(d.Recv.List) + ") "
+	}
+	scope += formatFuncType(d.Type)
+	return "func " + scope
+}
+
+func formatFuncType(f *ast.FuncType) string {
+	params := formatFieldList(f.Params.List)
+	results := ""
+	if f.Results != nil {
+		results = " -> " + formatFieldList(f.Results.List)
+	}
+	return params + results
+}
+
+func formatFieldList(fields []*ast.Field) string {
+	if len(fields) == 0 {
+		return "()"
+	}
+	names := make([]string, 0, len(fields))
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			names = append(names, name+" "+t)
+		} else {
+			names = append(names, t)
+		}
+	}
+	return "(" + strings.Join(names, ", ") + ")"
+}
+
+func formatFields(fields []*ast.Field) string {
+	lines := make([]string, 0)
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			lines = append(lines, name+" "+t)
+		} else {
+			lines = append(lines, t)
+		}
+	}
+	return strings.Join(lines, "; ")
+}
+
+func formatMethods(fields []*ast.Field) string {
+	return formatFields(fields)
+}
+
+func formatTypeParams(tp *ast.FieldList) string {
+	if tp == nil || len(tp.List) == 0 {
+		return ""
+	}
+	params := make([]string, len(tp.List))
+	for i, p := range tp.List {
+		if len(p.Names) > 0 {
+			params[i] = p.Names[0].Name
+		} else {
+			params[i] = "T"
+		}
+	}
+	return "[" + strings.Join(params, ", ") + "]"
+}
+
+func formatType(t ast.Expr) string {
+	if t == nil {
+		return "?"
+	}
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.SelectorExpr:
+		return formatType(v.X) + "." + v.Sel.Name
+	case *ast.StarExpr:
+		return "*" + formatType(v.X)
+	case *ast.ArrayType:
+		if v.Len == nil {
+			return "[]" + formatType(v.Elt)
+		}
+		return "[...]" + formatType(v.Elt)
+	case *ast.MapType:
+		return "map[" + formatType(v.Key) + "]" + formatType(v.Value)
+	case *ast.InterfaceType:
+		return "interface{}"
+	case *ast.StructType:
+		return "struct{}"
+	case *ast.FuncType:
+		return formatFuncType(v)
+	case *ast.ChanType:
+		return "chan " + formatType(v.Value)
+	case *ast.BasicLit:
+		return v.Value
+	case *ast.IndexExpr:
+		// Generic instantiation with one type arg, e.g. Logger[int].
+		return formatType(v.X) + "[" + formatType(v.Index) + "]"
+	case *ast.IndexListExpr:
+		// Generic instantiation with multiple type args, e.g. Map[K, V].
+		args := make([]string, len(v.Indices))
+		for i, idx := range v.Indices {
+			args[i] = formatType(idx)
+		}
+		return formatType(v.X) + "[" + strings.Join(args, ", ") + "]"
+	default:
+		return "?"
+	}
+}
 `;
-    _cachedScriptPath = null;
+    _cachedGoScriptPath = null;
   }
 });
 
@@ -1794,7 +2589,7 @@ __export(json_parser_exports, {
   parseSymbols: () => parseSymbols6
 });
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function parseSymbols6(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1806,7 +2601,7 @@ function parseSymbols6(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename7 = path10.basename(file).toLowerCase();
+  const basename7 = path11.basename(file).toLowerCase();
   const isPackageJson = basename7 === "package.json";
   const isTsconfig = basename7 === "tsconfig.json" || basename7 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
@@ -1832,11 +2627,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path10.basename(file),
+        name: path11.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path10.basename(file)}" = { ... }`,
+        signature: `"${path11.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -2164,6 +2959,106 @@ var init_yaml_parser = __esm({
 });
 
 // src/codebase-index/tree-sitter/queries.ts
+function parseGroupedUse(text) {
+  const open = text.indexOf("{");
+  const close = text.lastIndexOf("}");
+  if (open < 0 || close <= open) return null;
+  const prefix = text.slice(0, open).replace(/[\\/]+$/, "");
+  const out = [];
+  for (const rawMember of text.slice(open + 1, close).split(",")) {
+    let member = rawMember.trim();
+    if (!member) continue;
+    member = member.replace(
+      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+      ""
+    ).trim();
+    if (!member) continue;
+    const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(member);
+    if (aliasMatch) member = member.slice(0, aliasMatch.index).trim();
+    if (!member) continue;
+    const module = prefix ? `${prefix}\\${member}` : member;
+    const toName = member.split(/[\\/]/).filter(Boolean).pop();
+    if (toName) out.push({ toName, callType: "import", module });
+  }
+  return out.length ? out : null;
+}
+function importFromText(prefixes) {
+  return (node) => {
+    let text = node.text.replace(/\s+/g, " ").trim();
+    for (const prefix of prefixes) {
+      if (text.startsWith(prefix)) text = text.slice(prefix.length).trim();
+    }
+    text = text.replace(
+      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+      ""
+    ).trim();
+    if (text.includes("{")) return parseGroupedUse(text);
+    if (text.includes(",") && !text.includes("<") && !text.includes("=")) {
+      const out = [];
+      for (const clause of text.split(",")) {
+        const one = oneImportClause(clause.trim());
+        if (one) out.push(one);
+      }
+      return out.length ? out : null;
+    }
+    const single = oneImportClause(text);
+    return single ? [single] : null;
+  };
+}
+function oneImportClause(rawClause) {
+  let text = rawClause;
+  text = text.replace(
+    /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+    ""
+  ).trim();
+  text = text.replace(/[;}]+$/g, "").trim();
+  const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(text);
+  if (aliasMatch) text = text.slice(0, aliasMatch.index).trim();
+  const eqMatch = /^([A-Za-z_]\w*)\s*=\s*(.+)$/.exec(text);
+  if (eqMatch) text = eqMatch[2].trim();
+  if (!text) return null;
+  if (text.endsWith("*")) text = text.slice(0, -1).replace(/[.]$/, "");
+  if (!text) return null;
+  const module = text;
+  const toName = module.split(/[.\\/]/).filter(Boolean).pop()?.replace(/<.*>$/s, "");
+  if (!toName) return null;
+  return { toName, callType: "import", module };
+}
+function heritageLeaf(node, depth) {
+  if (depth > 6) return null;
+  const named = node.childForFieldName("name");
+  if (named) {
+    if (named.type === "scoped_type_identifier" || named.type === "qualified_name" || named.type === "scope_resolution" || named.type === "user_type") {
+      return heritageLeaf(named, depth + 1);
+    }
+    return named.text;
+  }
+  const children = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c) children.push(c);
+  }
+  for (let i = children.length - 1; i >= 0; i--) {
+    const c = children[i];
+    if (c.type === "type_arguments" || c.type === "type_argument_list" || // cpp: (template_type arguments: (template_argument_list …)) — the
+    // descriptor's type_identifier inside it is never the declared base.
+    c.type === "template_argument_list" || c.type === "type_parameter_list" || c.type === "type_projection" || c.type === "value_arguments") {
+      continue;
+    }
+    if (c.type === "type_identifier" || c.type === "identifier" || c.type === "constant" || c.type === "name") {
+      return c.text;
+    }
+    if (c.type === "scoped_type_identifier" || c.type === "qualified_name" || c.type === "scope_resolution" || c.type === "user_type") {
+      return heritageLeaf(c, depth + 1);
+    }
+  }
+  return leafSegment(
+    node.text.replace(/\\/g, ".").replace(/::/g, ".").replace(/<[^<>]*>$/, "")
+  );
+}
+function leafSegment(text) {
+  return text.split(".").filter(Boolean).pop() ?? text;
+}
 function getQueries(lang) {
   return LANG_QUERIES[lang] ?? DEFAULT_QUERIES;
 }
@@ -2175,10 +3070,127 @@ function readFirstString(node) {
   const child = node.namedChild(0);
   return child ? readFirstString(child) : null;
 }
-var DEFAULT_QUERIES, LANG_QUERIES;
+var heritageExtractor, cCallExtractor, rubyCallExtractor, firstIdentifierCallExtractor, cIncludeExtractor, phpConstructorExtractor, DEFAULT_QUERIES, LANG_QUERIES;
 var init_queries = __esm({
   "src/codebase-index/tree-sitter/queries.ts"() {
     "use strict";
+    heritageExtractor = (node) => {
+      const out = [];
+      const SKIP_SUBTREES = /* @__PURE__ */ new Set([
+        "type_arguments",
+        "type_argument_list",
+        // tree-sitter-cpp names its argument subtree template_argument_list —
+        // verified AST: (base_class_clause (template_type name:
+        // (type_identifier) arguments: (template_argument_list
+        // (type_descriptor type: (type_identifier))))). Without this entry
+        // `class D : Base<Foo>` recurses into the descriptor and emits Foo as a
+        // phantom inherit ref.
+        "template_argument_list",
+        "type_parameter_list",
+        "type_projection",
+        "value_arguments"
+      ]);
+      const collect = (current, depth) => {
+        if (depth > 4) return;
+        for (let i = 0; i < current.namedChildCount; i++) {
+          const child = current.namedChild(i);
+          if (!child) continue;
+          if (SKIP_SUBTREES.has(child.type)) continue;
+          if (child.type === "type_identifier" || child.type === "identifier" || child.type === "named_type" || child.type === "type" || // PHP heritage carries `name`; Ruby a `constant`.
+          child.type === "constant" || child.type === "name") {
+            const name = child.type === "named_type" ? leafSegment(child.text) : child.text;
+            if (name) out.push({ toName: name });
+            continue;
+          }
+          if (child.type === "generic_type" || child.type === "generic_name") {
+            for (let j = 0; j < child.namedChildCount; j++) {
+              const inner = child.namedChild(j);
+              if (inner && !SKIP_SUBTREES.has(inner.type) && (inner.type === "type_identifier" || inner.type === "identifier" || inner.type === "name")) {
+                out.push({ toName: inner.text });
+                break;
+              }
+            }
+            continue;
+          }
+          if (child.type === "qualified_name" || child.type === "scoped_type_identifier" || child.type === "user_type" || child.type === "scope_resolution") {
+            const leaf = heritageLeaf(child, 0);
+            if (leaf) out.push({ toName: leaf });
+            continue;
+          }
+          collect(child, depth + 1);
+        }
+      };
+      collect(node, 0);
+      return out;
+    };
+    cCallExtractor = (node) => {
+      const fn = node.childForFieldName("function");
+      if (!fn) return null;
+      if (fn.type === "field_expression") {
+        const field = fn.childForFieldName("field");
+        if (field) return [{ toName: field.text, callType: "call" }];
+        const seg = fn.text.split("->").filter(Boolean).pop();
+        if (seg) return [{ toName: leafSegment(seg.split(".")[0] ?? seg), callType: "call" }];
+        return null;
+      }
+      if (fn.type === "qualified_identifier") {
+        const name = fn.childForFieldName("name");
+        if (name) return [{ toName: name.text, callType: "call" }];
+        const seg = fn.text.split("::").filter(Boolean).pop();
+        if (seg) return [{ toName: seg.split(/[<(]/)[0].trim(), callType: "call" }];
+        return null;
+      }
+      return [{ toName: fn.text.split(/[<(]/)[0].trim(), callType: "call" }];
+    };
+    rubyCallExtractor = (node) => {
+      const emissions = [];
+      const method = node.childForFieldName("method");
+      if (method) {
+        const name = method.text;
+        if (name && !name.includes(" ")) emissions.push({ toName: name, callType: "call" });
+        if (name === "require" || name === "require_relative") {
+          const args = node.childForFieldName("arguments");
+          const first = args?.namedChild(0);
+          if (first) {
+            const raw = first.text.replace(/^['"]|['"]$/g, "");
+            const toName = raw.split("/").filter(Boolean).pop();
+            if (toName) emissions.push({ toName, callType: "import", module: raw });
+          }
+        }
+      }
+      return emissions;
+    };
+    firstIdentifierCallExtractor = (node) => {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && (child.type === "simple_identifier" || child.type === "identifier")) {
+          return [{ toName: child.text, callType: "call" }];
+        }
+      }
+      const first = node.namedChild(0);
+      if (!first) return null;
+      const leaf = leafSegment(first.text.split(/[<(]/)[0] ?? first.text);
+      if (!leaf) return null;
+      return [{ toName: leaf, callType: "call" }];
+    };
+    cIncludeExtractor = (node) => {
+      const raw = node.text.replace(/^#\s*include\s*/i, "").trim();
+      const module = raw.replace(/^["'<]|["'>]$/g, "");
+      if (!module) return null;
+      const toName = module.split("/").pop()?.replace(/\.h$/, "");
+      if (!toName) return null;
+      return [{ toName, callType: "import", module }];
+    };
+    phpConstructorExtractor = (node) => {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && (child.type === "qualified_name" || child.type === "name")) {
+          const leaf = child.text.split(/[\\]/).filter(Boolean).pop();
+          if (leaf) return [{ toName: leaf, callType: "call" }];
+        }
+      }
+      return null;
+    };
     DEFAULT_QUERIES = {
       declKinds: {}
     };
@@ -2211,7 +3223,13 @@ var init_queries = __esm({
           "struct_specifier",
           "union_specifier",
           "enum_specifier"
-        ])
+        ]),
+        refRules: {
+          // `obj->run()` and `Cls::stat()` carry structured function fields —
+          // cCallExtractor handles all three AST shapes.
+          call_expression: { callType: "call", nameExtractor: cCallExtractor },
+          preproc_include: { callType: "import", nameExtractor: cIncludeExtractor }
+        }
       },
       cpp: {
         declKinds: {
@@ -2242,7 +3260,13 @@ var init_queries = __esm({
           "union_specifier",
           "enum_specifier",
           "namespace_definition"
-        ])
+        ]),
+        refRules: {
+          call_expression: { callType: "call", nameExtractor: cCallExtractor },
+          preproc_include: { callType: "import", nameExtractor: cIncludeExtractor },
+          // `class Foo : public Bar, private Baz` — the base-class clause.
+          base_class_clause: { callType: "inherit", nameExtractor: heritageExtractor }
+        }
       },
       java: {
         declKinds: {
@@ -2277,7 +3301,22 @@ var init_queries = __esm({
           "interface_declaration",
           "enum_declaration",
           "record_declaration"
-        ])
+        ]),
+        refRules: {
+          method_invocation: { callType: "call", field: "name" },
+          object_creation_expression: { callType: "call", field: "type" },
+          // Verified AST: `superclass: (superclass (type_identifier))` and
+          // `interfaces: (super_interfaces (type_list ...))` — no underscores.
+          superclass: { callType: "inherit", nameExtractor: heritageExtractor },
+          super_interfaces: {
+            callType: "implement",
+            nameExtractor: heritageExtractor
+          },
+          import_declaration: {
+            callType: "import",
+            nameExtractor: importFromText(["import "])
+          }
+        }
       },
       csharp: {
         // C# 10+ `namespace Foo.Bar;` produces this node type. The legacy block
@@ -2315,7 +3354,18 @@ var init_queries = __esm({
           "struct_declaration",
           "enum_declaration",
           "record_declaration"
-        ])
+        ]),
+        refRules: {
+          // Verified AST: `invocation_expression function: (identifier)` — the
+          // callee field is `function` (C-style), not `name`.
+          invocation_expression: { callType: "call", field: "function" },
+          object_creation_expression: { callType: "call", field: "type" },
+          base_list: { callType: "inherit", nameExtractor: heritageExtractor },
+          using_directive: {
+            callType: "import",
+            nameExtractor: importFromText(["using "])
+          }
+        }
       },
       php: {
         declKinds: {
@@ -2334,7 +3384,7 @@ var init_queries = __esm({
           interface_declaration: "name",
           trait_declaration: "name",
           enum_declaration: "name",
-          namespace_declaration: "name"
+          namespace_definition: "name"
         },
         scopeNodes: /* @__PURE__ */ new Set([
           "program",
@@ -2343,7 +3393,24 @@ var init_queries = __esm({
           "interface_declaration",
           "trait_declaration",
           "enum_declaration"
-        ])
+        ]),
+        refRules: {
+          function_call_expression: { callType: "call", field: "function" },
+          // Verified AST: `new App\Model\User()` carries a BARE qualified_name
+          // child (no `name:` field), so the field default never fires.
+          object_creation_expression: { callType: "call", nameExtractor: phpConstructorExtractor },
+          base_clause: { callType: "inherit", nameExtractor: heritageExtractor },
+          class_interface_clause: {
+            callType: "implement",
+            nameExtractor: heritageExtractor
+          },
+          // Verified AST: `namespace_use_declaration (namespace_use_clause
+          // (qualified_name ...))` — not `use_declaration`.
+          namespace_use_declaration: {
+            callType: "import",
+            nameExtractor: importFromText(["use "])
+          }
+        }
       },
       // ─── Scripting / mobile ────────────────────────────────────────────────────
       ruby: {
@@ -2361,7 +3428,13 @@ var init_queries = __esm({
           module: "name",
           constant: "name"
         },
-        scopeNodes: /* @__PURE__ */ new Set(["program", "class", "module", "singleton_method", "method"])
+        scopeNodes: /* @__PURE__ */ new Set(["program", "class", "module", "singleton_method", "method"]),
+        refRules: {
+          // `call` covers both `foo(...)` and `obj.foo(...)` — the extractor
+          // records the method leaf, plus `require`/`require_relative` imports.
+          call: { callType: "call", nameExtractor: rubyCallExtractor },
+          superclass: { callType: "inherit", nameExtractor: heritageExtractor }
+        }
       },
       swift: {
         declKinds: {
@@ -2394,7 +3467,18 @@ var init_queries = __esm({
           "protocol_declaration",
           "actor_declaration",
           "extension_declaration"
-        ])
+        ]),
+        refRules: {
+          // Verified AST: `call_expression (simple_identifier) (call_suffix …)` —
+          // the callee is a bare first child, no field name.
+          call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
+          // Verified AST: `inheritance_specifier inherits_from: (user_type …)`.
+          inheritance_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
+          import_declaration: {
+            callType: "import",
+            nameExtractor: importFromText(["import ", "import type ", "@testable import "])
+          }
+        }
       },
       kotlin: {
         declKinds: {
@@ -2419,7 +3503,17 @@ var init_queries = __esm({
           "object_declaration",
           "interface_declaration",
           "function_declaration"
-        ])
+        ]),
+        refRules: {
+          call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
+          // Verified AST: `delegation_specifier (user_type (type_identifier))` —
+          // the `: Handler` / `: Base()` clause.
+          delegation_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
+          import_header: {
+            callType: "import",
+            nameExtractor: importFromText(["import "])
+          }
+        }
       },
       elixir: {
         declKinds: {
@@ -2491,7 +3585,38 @@ function visitTree(tree, content, file, lang, queries) {
   const boundedContent = content.length > TREE_SITTER_MAX_FILE_CHARS ? content.slice(0, TREE_SITTER_MAX_FILE_CHARS) : content;
   const nlOffsets = newlineOffsets3(boundedContent);
   const symbols = [];
+  const refs = [];
+  const seenRefs = /* @__PURE__ */ new Set();
   const scopeStack = [];
+  function emitRefsForNode(node, rule) {
+    const emissions = rule.nameExtractor?.(node) ?? defaultRefTarget(node, rule);
+    if (!emissions) return;
+    const { line } = lineColAt2(nlOffsets, node.startIndex);
+    for (const emission of emissions) {
+      if (!emission.toName) continue;
+      const callType = emission.callType ?? rule.callType;
+      const key = `${emission.toName}:${callType}:${line}:${emission.module ?? ""}:${node.startIndex}`;
+      if (seenRefs.has(key)) continue;
+      seenRefs.add(key);
+      refs.push({
+        fromId: 0,
+        // assignRefsToSymbols attaches owners after insertion
+        toName: emission.toName.slice(0, 200),
+        callType,
+        line,
+        lang,
+        module: emission.module
+      });
+    }
+  }
+  function defaultRefTarget(node, rule) {
+    if (!rule.field) return null;
+    const field = node.childForFieldName(rule.field);
+    if (!field) return null;
+    const leaf = field.text.split(/[.:\\]/).filter(Boolean).pop()?.split(/[<(]/)[0];
+    if (!leaf) return null;
+    return [{ toName: leaf.trim() }];
+  }
   function visit(node, depth) {
     if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) return;
     if (node.isMissing || node.isError) {
@@ -2510,6 +3635,8 @@ function visitTree(tree, content, file, lang, queries) {
         );
         if (emitted) symbols.push(emitted);
       }
+      const refRule = queries.refRules?.[node.type];
+      if (refRule) emitRefsForNode(node, refRule);
     }
     const pushesScope = queries.scopeNodes?.has(node.type) ?? false;
     const pushIdx = pushesScope ? pushScope(scopeStack, node, queries) : -1;
@@ -2527,7 +3654,7 @@ function visitTree(tree, content, file, lang, queries) {
     if (pushIdx !== -1) scopeStack.pop();
   }
   visit(tree.rootNode, 0);
-  return { symbols };
+  return { symbols, refs };
 }
 function pushScope(scopeStack, node, queries) {
   const name = extractName(node, queries);
@@ -2614,7 +3741,7 @@ __export(tree_sitter_parser_exports, {
   parseSymbols: () => parseSymbols8,
   parseTreeSitterAst: () => parseTreeSitterAst
 });
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { fileURLToPath } from "node:url";
 function optInEnabled(env) {
   return process.env[env] === "1" || process.env[env] === "true";
@@ -2637,7 +3764,7 @@ async function loadLanguage(lang) {
     if (!grammarName) {
       throw new Error(`tree-sitter: no grammar registered for lang "${lang}"`);
     }
-    const wasmPath = path11.join(WASM_DIR, grammarName, `tree-sitter-${grammarName}.wasm`);
+    const wasmPath = path12.join(WASM_DIR, grammarName, `tree-sitter-${grammarName}.wasm`);
     const { Language, init } = await getRuntime();
     await init();
     const languageObj = await Language.load(wasmPath);
@@ -2658,7 +3785,7 @@ function isTreeSitterSupported(lang) {
 function getGrammarWasmPath(lang) {
   const name = resolveGrammarName(lang);
   if (!name) return void 0;
-  return path11.join(WASM_DIR, name, `tree-sitter-${name}.wasm`);
+  return path12.join(WASM_DIR, name, `tree-sitter-${name}.wasm`);
 }
 async function parseSymbols8(opts) {
   const { file, content, lang } = opts;
@@ -2674,89 +3801,229 @@ async function parseSymbols8(opts) {
     if (!tree) {
       return { file, lang, symbols: [], mtimeMs: Date.now() };
     }
-    const { symbols } = visitTree(tree, content, file, lang, getQueries(lang));
-    parser.delete();
-    tree.delete();
-    return { file, lang, symbols, refs: [], mtimeMs: Date.now() };
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-async function loadTreeSitterLanguage(lang) {
-  const cached = await loadLanguage(lang);
-  return cached.Language;
-}
-async function __smokeRootType(opts) {
-  if (!isTreeSitterSupported(opts.lang)) {
-    throw new Error(`tree-sitter: no grammar registered for lang "${opts.lang}"`);
-  }
-  const { Parser } = await getRuntime();
-  const cached = await loadLanguage(opts.lang);
-  const parser = new Parser();
-  parser.setLanguage(cached.Language);
-  let tree = null;
-  try {
-    tree = parser.parse(opts.content);
-    if (!tree) throw new Error("tree-sitter: parser.parse returned null");
-    return tree.rootNode.type;
-  } finally {
-    tree?.delete();
-    parser.delete();
+    const { symbols, refs } = visitTree(tree, content, file, lang, getQueries(lang));
+    parser.delete();
+    tree.delete();
+    return { file, lang, symbols, refs, mtimeMs: Date.now() };
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+async function loadTreeSitterLanguage(lang) {
+  const cached = await loadLanguage(lang);
+  return cached.Language;
+}
+async function __smokeRootType(opts) {
+  if (!isTreeSitterSupported(opts.lang)) {
+    throw new Error(`tree-sitter: no grammar registered for lang "${opts.lang}"`);
+  }
+  const { Parser } = await getRuntime();
+  const cached = await loadLanguage(opts.lang);
+  const parser = new Parser();
+  parser.setLanguage(cached.Language);
+  let tree = null;
+  try {
+    tree = parser.parse(opts.content);
+    if (!tree) throw new Error("tree-sitter: parser.parse returned null");
+    return tree.rootNode.type;
+  } finally {
+    tree?.delete();
+    parser.delete();
+  }
+}
+async function parseTreeSitterAst(opts) {
+  const grammar = resolveGrammarName(opts.lang) ?? (opts.lang === "go" ? "go" : opts.lang === "py" ? "python" : opts.lang === "rs" ? "rust" : void 0);
+  if (!grammar) return null;
+  try {
+    const { Parser, Language, init } = await getRuntime();
+    await init();
+    const wasmPath = path12.join(WASM_DIR, grammar, `tree-sitter-${grammar}.wasm`);
+    const languageObj = await Language.load(wasmPath);
+    const parser = new Parser();
+    parser.setLanguage(languageObj);
+    const tree = parser.parse(opts.content);
+    if (!tree) {
+      parser.delete();
+      return null;
+    }
+    return { tree, parser };
+  } catch {
+    return null;
+  }
+}
+var WASM_DIR, RUNTIME_WASM, LANG_TO_GRAMMAR, GO_OPT_IN, PY_OPT_IN, RS_OPT_IN, runtimePromise, languageCache;
+var init_tree_sitter_parser = __esm({
+  "src/codebase-index/tree-sitter-parser.ts"() {
+    "use strict";
+    init_queries();
+    init_visitor();
+    WASM_DIR = fileURLToPath(new URL("./wasm/", import.meta.url));
+    RUNTIME_WASM = path12.join(WASM_DIR, "tree-sitter-runtime.wasm");
+    LANG_TO_GRAMMAR = {
+      c: "c",
+      cpp: "cpp",
+      java: "java",
+      csharp: "c_sharp",
+      // tree-sitter directory uses underscore
+      php: "php",
+      ruby: "ruby",
+      swift: "swift",
+      kotlin: "kotlin",
+      shell: "bash",
+      // we treat `.sh` / `.bash` / `.zsh` via the bash grammar
+      // Go/Python/Rust are opt-in only (see goOptIn / pyOptIn / rsOptIn below)
+      elixir: "elixir"
+    };
+    GO_OPT_IN = "WRONGSTACK_USE_TS_GO";
+    PY_OPT_IN = "WRONGSTACK_USE_TS_PY";
+    RS_OPT_IN = "WRONGSTACK_USE_TS_RS";
+    runtimePromise = null;
+    languageCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/codebase-index/parser-dispatch.ts
+var parser_dispatch_exports = {};
+__export(parser_dispatch_exports, {
+  parseFileContent: () => parseFileContent,
+  parseFilesContent: () => parseFilesContent
+});
+async function parseFileContent(file, content, lang) {
+  const parsed = await dispatch(file, content, lang);
+  return withRelations(parsed, content, lang);
+}
+async function parseFilesContent(files) {
+  if (files.length === 0) return [];
+  const slots = files.map(() => ({ result: null }));
+  const batchingEnabled = process.env["WRONGSTACK_TOOLCHAIN_BATCH"] !== "0";
+  if (batchingEnabled) {
+    const goFiles = [];
+    const pyFiles = [];
+    files.forEach((f, index) => {
+      if (f.lang === "go") goFiles.push({ ...f, index });
+      else if (f.lang === "py") pyFiles.push({ ...f, index });
+    });
+    if (goFiles.length > 0) {
+      await applyBatchResults(slots, goFiles, (chunks) => runGoBatch(chunks), "go");
+    }
+    if (pyFiles.length > 0) {
+      const pyBinary = await resolvePythonBinary();
+      if (pyBinary) {
+        await applyBatchResults(slots, pyFiles, (chunks) => runPyBatch(chunks, pyBinary), "py");
+      }
+    }
+  }
+  const jobs = [];
+  for (let i = 0; i < files.length; i++) {
+    if (slots[i].result !== null) continue;
+    const { file, content, lang } = files[i];
+    const slot = slots[i];
+    jobs.push(
+      (async () => {
+        try {
+          slot.result = await parseFileContent(file, content, lang);
+        } catch (err) {
+          slot.error = err instanceof Error ? err.message : String(err);
+        }
+      })()
+    );
+  }
+  await Promise.all(jobs);
+  return slots;
+}
+async function applyBatchResults(slots, batchFiles, runBatch, lang) {
+  for (const chunk of chunkBatchFiles(batchFiles)) {
+    let byFile = null;
+    try {
+      byFile = await runBatch(chunk);
+    } catch {
+      byFile = null;
+    }
+    if (!byFile) continue;
+    for (const item of chunk) {
+      const parsed = byFile.get(item.file);
+      if (!parsed) continue;
+      slots[item.index] = { result: withRelations(parsed, item.content, lang) };
+    }
+  }
+}
+async function dispatch(file, content, lang) {
+  switch (lang) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_ts_parser(), ts_parser_exports));
+      return parseSymbols9({ file, content, lang });
+    }
+    case "go": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_go_parser(), go_parser_exports));
+      return parseSymbols9({ file, content, lang: "go" });
+    }
+    case "py": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_py_parser(), py_parser_exports));
+      return parseSymbols9({ file, content, lang: "py" });
+    }
+    case "rs": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_rs_parser(), rs_parser_exports));
+      return parseSymbols9({ file, content, lang: "rs" });
+    }
+    case "json": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_json_parser(), json_parser_exports));
+      return parseSymbols9({ file, content, lang: "json" });
+    }
+    case "yaml": {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_yaml_parser(), yaml_parser_exports));
+      return parseSymbols9({ file, content, lang: "yaml" });
+    }
+    // Phase 1: ten languages now route through the Tree-Sitter WASM
+    // universal parser (`tree-sitter-parser.ts`). The dispatch falls back to
+    // the regex extractor in `generic-parser.ts` whenever WASM loading fails
+    // or the parser returns zero symbols — preserving the indexable-file
+    // contract that "missing a parser must never mean skipping the file".
+    case "c":
+    case "cpp":
+    case "java":
+    case "csharp":
+    case "php":
+    case "ruby":
+    case "swift":
+    case "kotlin":
+    case "shell":
+    case "elixir": {
+      try {
+        const { parseSymbols: parseSymbols10 } = await Promise.resolve().then(() => (init_tree_sitter_parser(), tree_sitter_parser_exports));
+        const parsed = await parseSymbols10({ file, content, lang });
+        if (parsed.symbols.length > 0) return parsed;
+      } catch {
+      }
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
+      return parseSymbols9({ file, content, lang });
+    }
+    default: {
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
+      return parseSymbols9({ file, content, lang });
+    }
   }
 }
-async function parseTreeSitterAst(opts) {
-  const grammar = resolveGrammarName(opts.lang) ?? (opts.lang === "go" ? "go" : opts.lang === "py" ? "python" : opts.lang === "rs" ? "rust" : void 0);
-  if (!grammar) return null;
-  try {
-    const { Parser, Language, init } = await getRuntime();
-    await init();
-    const wasmPath = path11.join(WASM_DIR, grammar, `tree-sitter-${grammar}.wasm`);
-    const languageObj = await Language.load(wasmPath);
-    const parser = new Parser();
-    parser.setLanguage(languageObj);
-    const tree = parser.parse(opts.content);
-    if (!tree) {
-      parser.delete();
-      return null;
-    }
-    return { tree, parser };
-  } catch {
-    return null;
+function withRelations(parsed, content, lang) {
+  let refs = parsed.refs ?? [];
+  if (refs.length === 0 && hasImportPatterns(lang)) {
+    refs = extractImports({ content, lang });
   }
+  return { ...parsed, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
 }
-var WASM_DIR, RUNTIME_WASM, LANG_TO_GRAMMAR, GO_OPT_IN, PY_OPT_IN, RS_OPT_IN, runtimePromise, languageCache;
-var init_tree_sitter_parser = __esm({
-  "src/codebase-index/tree-sitter-parser.ts"() {
+var init_parser_dispatch = __esm({
+  "src/codebase-index/parser-dispatch.ts"() {
     "use strict";
-    init_queries();
-    init_visitor();
-    WASM_DIR = fileURLToPath(new URL("./wasm/", import.meta.url));
-    RUNTIME_WASM = path11.join(WASM_DIR, "tree-sitter-runtime.wasm");
-    LANG_TO_GRAMMAR = {
-      c: "c",
-      cpp: "cpp",
-      java: "java",
-      csharp: "c_sharp",
-      // tree-sitter directory uses underscore
-      php: "php",
-      ruby: "ruby",
-      swift: "swift",
-      kotlin: "kotlin",
-      shell: "bash",
-      // we treat `.sh` / `.bash` / `.zsh` via the bash grammar
-      // Go/Python/Rust are opt-in only (see goOptIn / pyOptIn / rsOptIn below)
-      elixir: "elixir"
-    };
-    GO_OPT_IN = "WRONGSTACK_USE_TS_GO";
-    PY_OPT_IN = "WRONGSTACK_USE_TS_PY";
-    RS_OPT_IN = "WRONGSTACK_USE_TS_RS";
-    runtimePromise = null;
-    languageCache = /* @__PURE__ */ new Map();
+    init_import_extractor();
+    init_parser_batch();
+    init_py_parser();
   }
 });
 
 // src/write.ts
-import * as fs14 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 import { ToolValidationError } from "@wrongstack/core/types";
 import {
   atomicWrite,
@@ -2942,7 +4209,7 @@ function takeHeadBytes(s, maxBytes) {
 }
 
 // src/codebase-index/background-indexer.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { Worker as Worker2 } from "node:worker_threads";
 
@@ -3030,9 +4297,9 @@ var indexCircuitBreaker = new IndexCircuitBreaker();
 import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
 import { execFile } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import { availableParallelism } from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import {
   DEFAULT_WALK_IGNORE_DIRS,
   indexParallelBatchSize,
@@ -3700,283 +4967,96 @@ var ModuleResolver = class {
     const segments = spec.split("::").filter(Boolean);
     if (segments.length === 0) return void 0;
     const head = segments[0];
-    if (head === "self" || head === "super") {
-      let base = path6.posix.dirname(fromFile);
-      for (const segment of segments) {
-        if (segment === "super") base = path6.posix.dirname(base);
-        else if (segment !== "self") break;
-      }
-      const rest2 = segments.filter((segment) => segment !== "self" && segment !== "super");
-      return this.lookupWithExtensions(path6.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(
-        path6.posix.join(path6.posix.dirname(fromFile), ...segments),
-        "rs"
-      );
-    }
-    const rest = segments.slice(1);
-    for (const base of crate.sourceRoots) {
-      const parent = rest.length > 1 ? this.lookupWithExtensions(path6.posix.join(base, ...rest.slice(0, -1)), "rs") : void 0;
-      const exact = this.lookupWithExtensions(path6.posix.join(base, ...rest), "rs");
-      const hit = exact ?? parent ?? this.lookupWithExtensions(path6.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 = path6.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(
-      path6.posix.join(path6.posix.dirname(fromFile), spec),
-      "c"
-    );
-    if (relative3) return relative3;
-    for (const base of [
-      path6.posix.join(this.structure.projectRoot, "include"),
-      this.structure.projectRoot
-    ]) {
-      const hit = this.lookupWithExtensions(path6.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(
-      path6.posix.join(path6.posix.dirname(fromFile), spec),
-      "ruby"
-    );
-    if (relative3) return relative3;
-    for (const base of [
-      path6.posix.join(this.structure.projectRoot, "lib"),
-      this.structure.projectRoot
-    ]) {
-      const hit = this.lookupWithExtensions(path6.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 parsed = await dispatch(file, content, lang);
-  return withRelations(parsed, content, lang);
-}
-async function dispatch(file, content, lang) {
-  switch (lang) {
-    case "ts":
-    case "tsx":
-    case "js":
-    case "jsx": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_ts_parser(), ts_parser_exports));
-      return parseSymbols9({ file, content, lang });
-    }
-    case "go": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_go_parser(), go_parser_exports));
-      return parseSymbols9({ file, content, lang: "go" });
-    }
-    case "py": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_py_parser(), py_parser_exports));
-      return parseSymbols9({ file, content, lang: "py" });
-    }
-    case "rs": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_rs_parser(), rs_parser_exports));
-      return parseSymbols9({ file, content, lang: "rs" });
+    if (head === "self" || head === "super") {
+      let base = path6.posix.dirname(fromFile);
+      for (const segment of segments) {
+        if (segment === "super") base = path6.posix.dirname(base);
+        else if (segment !== "self") break;
+      }
+      const rest2 = segments.filter((segment) => segment !== "self" && segment !== "super");
+      return this.lookupWithExtensions(path6.posix.join(base, ...rest2), "rs");
     }
-    case "json": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_json_parser(), json_parser_exports));
-      return parseSymbols9({ file, content, lang: "json" });
+    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(
+        path6.posix.join(path6.posix.dirname(fromFile), ...segments),
+        "rs"
+      );
     }
-    case "yaml": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_yaml_parser(), yaml_parser_exports));
-      return parseSymbols9({ file, content, lang: "yaml" });
+    const rest = segments.slice(1);
+    for (const base of crate.sourceRoots) {
+      const parent = rest.length > 1 ? this.lookupWithExtensions(path6.posix.join(base, ...rest.slice(0, -1)), "rs") : void 0;
+      const exact = this.lookupWithExtensions(path6.posix.join(base, ...rest), "rs");
+      const hit = exact ?? parent ?? this.lookupWithExtensions(path6.posix.join(base, "lib"), "rs");
+      if (hit) return hit;
     }
-    // Phase 1: ten languages now route through the Tree-Sitter WASM
-    // universal parser (`tree-sitter-parser.ts`). The dispatch falls back to
-    // the regex extractor in `generic-parser.ts` whenever WASM loading fails
-    // or the parser returns zero symbols — preserving the indexable-file
-    // contract that "missing a parser must never mean skipping the file".
-    case "c":
-    case "cpp":
-    case "java":
-    case "csharp":
-    case "php":
-    case "ruby":
-    case "swift":
-    case "kotlin":
-    case "shell":
-    case "elixir": {
-      try {
-        const { parseSymbols: parseSymbols10 } = await Promise.resolve().then(() => (init_tree_sitter_parser(), tree_sitter_parser_exports));
-        const parsed = await parseSymbols10({ file, content, lang });
-        if (parsed.symbols.length > 0) return parsed;
-      } catch {
-      }
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
-      return parseSymbols9({ file, content, lang });
+    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 = path6.posix.join(base, ...parts);
+      const hit = wildcard ? this.representativeIn(target, "jvm") : this.lookupWithExtensions(target, "jvm");
+      if (hit) return hit;
     }
-    default: {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
-      return parseSymbols9({ file, content, lang });
+    return void 0;
+  }
+  /** `#include "foo/bar.h"` — quoted form only; `<…>` is a system header. */
+  resolveInclude(fromFile, spec) {
+    const relative3 = this.lookupWithExtensions(
+      path6.posix.join(path6.posix.dirname(fromFile), spec),
+      "c"
+    );
+    if (relative3) return relative3;
+    for (const base of [
+      path6.posix.join(this.structure.projectRoot, "include"),
+      this.structure.projectRoot
+    ]) {
+      const hit = this.lookupWithExtensions(path6.posix.join(base, spec), "c");
+      if (hit) return hit;
     }
+    return void 0;
   }
-}
-function withRelations(parsed, content, lang) {
-  let refs = parsed.refs ?? [];
-  if (refs.length === 0 && hasImportPatterns(lang)) {
-    refs = extractImports({ content, lang });
+  /** `require_relative 'x'` is relative; `require 'x'` is looked up under lib/. */
+  resolveRuby(fromFile, spec) {
+    const relative3 = this.lookupWithExtensions(
+      path6.posix.join(path6.posix.dirname(fromFile), spec),
+      "ruby"
+    );
+    if (relative3) return relative3;
+    for (const base of [
+      path6.posix.join(this.structure.projectRoot, "lib"),
+      this.structure.projectRoot
+    ]) {
+      const hit = this.lookupWithExtensions(path6.posix.join(base, spec), "ruby");
+      if (hit) return hit;
+    }
+    return void 0;
   }
-  return { ...parsed, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
-}
+};
+
+// src/codebase-index/indexer.ts
+init_parser_dispatch();
 
 // src/codebase-index/parser-worker-pool.ts
+import * as fs7 from "node:fs";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import * as fs6 from "node:fs";
 var WORKER_POOL_THRESHOLD = 500;
+function resolveWorkerPoolThreshold() {
+  const raw = process.env["WRONGSTACK_INDEX_WORKER_THRESHOLD"];
+  if (raw === void 0) return WORKER_POOL_THRESHOLD;
+  if (!/^\d+$/.test(raw)) return WORKER_POOL_THRESHOLD;
+  return Number.parseInt(raw, 10);
+}
 var ParserWorkerPool = class {
   constructor(maxWorkers = defaultWorkerCount()) {
     this.maxWorkers = maxWorkers;
@@ -4020,7 +5100,8 @@ var ParserWorkerPool = class {
           w.unref();
           w.on("message", (msg) => this.handleMessage(msg));
           w.on("error", (err) => this.handleError(err, w));
-          this.workers.push({ worker: w, busy: false });
+          w.on("exit", () => this.retireByReference(w));
+          this.workers.push({ worker: w, workerId: w.threadId, busy: false });
         } catch {
           if (this.workers.length === 0) {
             this.unavailable = true;
@@ -4036,7 +5117,7 @@ var ParserWorkerPool = class {
   }
   /**
    * Parse files in parallel across the worker pool. Returns a flat
-   * `FileSymbols[]` in completion order (caller sorts if needed).
+   * `FileSymbols[]` in completion order (caller matches by file path).
    *
    * Content is pre-read by the main thread (for the content-hash check)
    * and passed to workers to avoid a second disk read. Files are
@@ -4057,21 +5138,19 @@ var ParserWorkerPool = class {
       chunks[i % workerCount].push(files[i]);
     }
     return new Promise((resolve4, reject) => {
+      const pendingChunks = /* @__PURE__ */ new Map();
       this.pending.set(batchId, {
         resolve: resolve4,
         reject,
         accumulated: [],
-        expectedWorkers: workerCount,
-        completedWorkers: 0
+        pendingChunks,
+        settled: false
       });
       for (let i = 0; i < workerCount; i++) {
         const pw = this.workers[i];
         pw.busy = true;
-        pw.worker.postMessage({
-          type: "parse",
-          id: batchId,
-          files: chunks[i]
-        });
+        pendingChunks.set(pw.workerId, chunks[i]);
+        pw.worker.postMessage({ type: "parse", id: batchId, files: chunks[i] });
       }
     });
   }
@@ -4080,6 +5159,12 @@ var ParserWorkerPool = class {
     const workers = this.workers.map((w) => w.worker);
     this.workers = [];
     this.unavailable = false;
+    for (const [, p] of this.pending) {
+      if (p.settled) continue;
+      p.settled = true;
+      p.reject(new Error("ParserWorkerPool shut down"));
+    }
+    this.pending.clear();
     for (const w of workers) {
       try {
         w.postMessage({ type: "shutdown" });
@@ -4100,39 +5185,117 @@ var ParserWorkerPool = class {
         })
       )
     );
-    for (const [, p] of this.pending) p.reject(new Error("ParserWorkerPool shut down"));
-    this.pending.clear();
   }
   handleMessage(msg) {
     const batch = this.pending.get(msg.id);
     if (!batch) return;
+    const worker2 = this.workers.find((w) => w.workerId === msg.workerId);
+    if (worker2) worker2.busy = false;
+    batch.pendingChunks.delete(msg.workerId);
     batch.accumulated.push(...msg.results);
-    batch.completedWorkers++;
-    const freeWorker = this.workers.find((w) => w.busy);
-    if (freeWorker) freeWorker.busy = false;
-    if (batch.completedWorkers >= batch.expectedWorkers) {
+    if (batch.pendingChunks.size === 0) {
+      if (batch.settled) return;
+      batch.settled = true;
       this.pending.delete(msg.id);
       batch.resolve(batch.accumulated);
     }
   }
-  handleError(err, source) {
-    this.workers = this.workers.filter((w) => w.worker !== source);
-    if (this.workers.length === 0) {
-      for (const [, p] of this.pending) p.reject(err);
-      this.pending.clear();
-      this.unavailable = true;
+  /**
+   * Remove a worker from the pool and salvage any chunk it still owed.
+   *
+   * Idempotent by workerId — `error` and `exit` can both fire for one
+   * death, and a worker may die while no batch references it. When the
+   * dead worker owed files to an in-flight batch and other workers remain,
+   * those files are re-parsed inline on this thread (one fewer worker
+   * should cost latency, not correctness). When it was the last worker,
+   * every remaining batch rejects so the indexer's existing inline
+   * fallback takes over the whole batch.
+   */
+  retireWorker(workerId) {
+    const entry = this.workers.find((w) => w.workerId === workerId);
+    if (!entry) return;
+    this.workers = this.workers.filter((w) => w.workerId !== workerId);
+    for (const [batchId, batch] of [...this.pending]) {
+      const orphaned = batch.pendingChunks.get(workerId);
+      if (!orphaned) continue;
+      if (this.workers.length === 0) {
+        this.pending.delete(batchId);
+        this.unavailable = true;
+        if (!batch.settled) {
+          batch.settled = true;
+          batch.reject(new Error("ParserWorkerPool: all workers died mid-batch"));
+        }
+        continue;
+      }
+      void this.reparseInline(batch, orphaned, workerId);
+    }
+  }
+  /**
+   * Salvage path: re-parse an orphaned chunk on this thread. Files that
+   * fail here stay absent from the results — same contract as a per-file
+   * error inside a live worker (see handleMessage).
+   */
+  async reparseInline(batch, orphaned, workerId) {
+    try {
+      const { parseFileContent: parseFileContent2 } = await Promise.resolve().then(() => (init_parser_dispatch(), parser_dispatch_exports));
+      for (const item of orphaned) {
+        if (batch.settled) return;
+        try {
+          const parsed = await parseFileContent2(item.file, item.content, item.lang);
+          batch.accumulated.push(parsed);
+        } catch {
+        }
+        await new Promise((resolve4) => setImmediate(resolve4));
+      }
+    } finally {
+      this.finishSalvage(batch, workerId);
+    }
+  }
+  /**
+   * Terminal tail of a salvage — runs on every exit path. Kept free of
+   * control flow inside a `finally` (noUnsafeFinally): releases the
+   * pending-marker and resolves the batch if this was its last chunk.
+   */
+  finishSalvage(batch, workerId) {
+    batch.pendingChunks.delete(workerId);
+    if (batch.pendingChunks.size === 0) {
+      for (const [batchId, tracked] of this.pending) {
+        if (tracked === batch) {
+          if (batch.settled) return;
+          batch.settled = true;
+          this.pending.delete(batchId);
+          batch.resolve(batch.accumulated);
+          return;
+        }
+      }
     }
   }
+  /**
+   * Retire by worker object rather than threadId. `threadId` is -1 before
+   * the worker emits `online`, so a death during script load would make a
+   * threadId-keyed lookup silently no-op and leak the entry (with its
+   * pending chunk) — reference identity is correct in every case.
+   */
+  retireByReference(source) {
+    const entry = this.workers.find((w) => w.worker === source);
+    if (entry) this.retireWorker(entry.workerId);
+  }
+  handleError(err, source) {
+    void err;
+    this.retireByReference(source);
+  }
 };
 function defaultWorkerCount() {
   const cores = globalThis.navigator?.hardwareConcurrency ?? 4;
   return Math.max(1, Math.min(4, cores - 1));
 }
 function resolveWorkerScriptUrl() {
+  const override = process.env["WRONGSTACK_PARSER_WORKER_SCRIPT"];
+  if (override) return pathToFileURL(override);
   for (const rel of ["./parser-worker-script.js", "./codebase-index/parser-worker-script.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs6.existsSync(fileURLToPath2(url))) return url;
+      if (url.protocol === "file:" && fs7.existsSync(fileURLToPath2(url))) return url;
     } catch {
     }
   }
@@ -4145,8 +5308,8 @@ function getParserPool() {
 }
 
 // src/codebase-index/writer.ts
-import * as fs8 from "node:fs";
-import * as path13 from "node:path";
+import * as fs9 from "node:fs";
+import * as path14 from "node:path";
 
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
@@ -4241,11 +5404,11 @@ var Bm25Index = class {
 init_languages();
 
 // src/codebase-index/schema.ts
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 
 // src/codebase-index/sqlite-runtime.ts
-import { createRequire } from "node:module";
 import { toErrorMessage } from "@wrongstack/core/utils";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
 var warningSilenced = false;
 function silenceSqliteExperimentalWarning() {
   if (warningSilenced) return;
@@ -4263,11 +5426,10 @@ function loadDatabaseSync() {
   if (DatabaseSyncCtor) return DatabaseSyncCtor;
   silenceSqliteExperimentalWarning();
   try {
-    const req = createRequire(import.meta.url);
-    DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
+    DatabaseSyncCtor = loadRuntimeDatabaseSync();
   } catch (err) {
     throw new Error(
-      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage(err)}`
+      `The codebase index needs node:sqlite (Node >= 22.5) or bun:sqlite. This runtime doesn't provide it: ${toErrorMessage(err)}`
     );
   }
   return DatabaseSyncCtor;
@@ -4310,9 +5472,87 @@ function runSqliteWithRetry(fn) {
   throw lastError;
 }
 
+// src/codebase-index/vector-search.ts
+var RRF_K = 60;
+function vectorEmbeddingEnabled() {
+  return process.env["WRONGSTACK_INDEX_VECTORS"] === "1";
+}
+var VECTOR_DIMENSIONS = 384;
+var NGRAM_SIZE = 3;
+function embedText(text) {
+  const vec = new Float32Array(VECTOR_DIMENSIONS);
+  const normalized = text.toLowerCase().trim();
+  if (normalized.length < NGRAM_SIZE) {
+    const padded = ` ${normalized} `.slice(0, Math.max(NGRAM_SIZE, normalized.length + 2));
+    for (let i = 0; i <= padded.length - NGRAM_SIZE; i++) {
+      const ngram = padded.slice(i, i + NGRAM_SIZE);
+      const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
+      vec[bucket] += 1;
+    }
+  } else {
+    for (let i = 0; i <= normalized.length - NGRAM_SIZE; i++) {
+      const ngram = normalized.slice(i, i + NGRAM_SIZE);
+      const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
+      vec[bucket] += 1;
+    }
+  }
+  let norm = 0;
+  for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
+    norm += vec[i] * vec[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
+      vec[i] /= norm;
+    }
+  }
+  return vec;
+}
+function hashNgram(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function encodeVector(vec) {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+function decodeVector(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const copy = new Float32Array(buf.byteLength / 4);
+  for (let i = 0; i < copy.length; i++) {
+    copy[i] = view.getFloat32(i * 4, true);
+  }
+  return copy;
+}
+function reciprocalRankFusion(bm25Ranks, vectorRanks, k = RRF_K) {
+  const allIds = /* @__PURE__ */ new Set([...bm25Ranks.keys(), ...vectorRanks.keys()]);
+  const scored = [];
+  for (const id of allIds) {
+    const bm25Rank = bm25Ranks.get(id);
+    const vecRank = vectorRanks.get(id);
+    let score = 0;
+    if (bm25Rank !== void 0) score += 1 / (k + bm25Rank);
+    if (vecRank !== void 0) score += 1 / (k + vecRank);
+    scored.push([id, score]);
+  }
+  scored.sort((a, b) => b[1] - a[1]);
+  return scored;
+}
+
 // src/codebase-index/writer-admin.ts
-import * as fs7 from "node:fs";
-import * as path12 from "node:path";
+import * as fs8 from "node:fs";
+import * as path13 from "node:path";
 var DB_FILE = "index.db";
 function getAllIndexableWithStatement(stmt) {
   return stmt("SELECT id, text FROM symbols").all().map(
@@ -4348,6 +5588,14 @@ function getMetadataWithStatement(stmt, key) {
   const rows = stmt("SELECT value FROM metadata WHERE key = ?").all(key);
   return rows[0]?.value;
 }
+function getIndexSummaryWithStatement(stmt) {
+  const fileRows = stmt("SELECT COUNT(*) AS n FROM files").all();
+  const lastRows = stmt("SELECT value FROM metadata WHERE key = 'last_indexed'").all();
+  return {
+    totalFiles: fileRows[0] ? Number(fileRows[0].n) : 0,
+    lastIndexed: lastRows.length ? Number(lastRows[0]?.value) : null
+  };
+}
 function getFileMetaWithStatement(stmt, file) {
   const rows = stmt(
     "SELECT file, lang, mtime_ms, symbol_count, last_indexed, content_hash FROM files WHERE file = ?"
@@ -4377,22 +5625,102 @@ function getAllFileMetasWithStatement(stmt) {
 }
 function getIndexDbSizeBytes(indexDir) {
   try {
-    return fs7.statSync(path12.join(indexDir, DB_FILE)).size;
+    return fs8.statSync(path13.join(indexDir, DB_FILE)).size;
   } catch {
     return 0;
   }
 }
 
+// src/codebase-index/writer-helpers.ts
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function ladderChunkSizes(total, max) {
+  if (total <= 0) return [];
+  const sizes = [];
+  let remaining = total;
+  while (remaining > 0) {
+    const cap = Math.min(remaining, max);
+    const pow = cap >= 1 ? 2 ** Math.floor(Math.log2(cap)) : 1;
+    const take = Math.max(1, Math.min(pow, remaining));
+    sizes.push(take);
+    remaining -= take;
+  }
+  return sizes;
+}
+function nextPow2(count) {
+  return count <= 1 ? 1 : 2 ** Math.ceil(Math.log2(count));
+}
+function padToInBucket(values) {
+  if (values.length <= 1) return values.slice();
+  const target = nextPow2(values.length);
+  const padded = values.slice();
+  while (padded.length < target) padded.push(padded[0]);
+  return padded;
+}
+function placeholders(count) {
+  return Array.from({ length: count }, () => "?").join(",");
+}
+function inListChunks(total, max) {
+  if (total <= 0) return [];
+  if (nextPow2(total) <= max) return [total];
+  const powMax = Math.max(1, 2 ** Math.floor(Math.log2(max)));
+  return ladderChunkSizes(total, powMax);
+}
+function posixIndexPath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function indexedFileMatchSql(column = "file") {
+  return `(${column} = ? OR replace(${column}, '\\', '/') = ? OR replace(${column}, '\\', '/') LIKE ? ESCAPE '\\')`;
+}
+function indexedFileMatchArgs(file) {
+  const posix4 = posixIndexPath(file.trim());
+  return [file, posix4, `%/${escapeLike(posix4)}`];
+}
+function matchesIndexedPackageFilter(storedFile, packageLabel, filter) {
+  if (packageLabel === filter) return true;
+  const posixFile = posixIndexPath(storedFile);
+  const posixFilter = posixIndexPath(filter.trim());
+  if (!posixFilter) return false;
+  return posixFile === posixFilter || posixFile.endsWith(`/${posixFilter}`) || posixFile.includes(`/${posixFilter}/`);
+}
+function assignRefsToSymbols(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner = symbol;
+    }
+    if (!owner && ref.callType === "import") owner = ordered[0];
+    if (!owner || owner.id <= 0) continue;
+    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;
+}
+function resolveIndexDir(projectRoot, override) {
+  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+}
+
 // src/codebase-index/writer-bulk-insert.ts
 function bulkInsertSymbolsWithStatement(stmt, maxSqlVars, rows) {
   if (rows.length === 0) return;
-  const chunkSize = Math.max(1, Math.floor(maxSqlVars / 12));
-  for (let i = 0; i < rows.length; i += chunkSize) {
-    const chunk = rows.slice(i, i + chunkSize);
-    const placeholders = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 12)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
     const insert = stmt(
-      `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-       VALUES ${placeholders}`
+      `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text)
+       VALUES ${placeholders2}`
     );
     const binds = [];
     for (const r of chunk) {
@@ -4407,8 +5735,7 @@ function bulkInsertSymbolsWithStatement(stmt, maxSqlVars, rows) {
         r.signature,
         r.docComment,
         r.scope,
-        r.text,
-        r.file
+        r.text
       );
     }
     insert.run(...binds);
@@ -4416,11 +5743,13 @@ function bulkInsertSymbolsWithStatement(stmt, maxSqlVars, rows) {
 }
 function bulkInsertFtsWithStatement(stmt, maxSqlVars, ftsAvailable, rows) {
   if (!ftsAvailable || rows.length === 0) return;
-  const chunkSize = Math.max(1, Math.floor(maxSqlVars / 2));
-  for (let i = 0; i < rows.length; i += chunkSize) {
-    const chunk = rows.slice(i, i + chunkSize);
-    const placeholders = chunk.map(() => "(?, ?)").join(", ");
-    const insert = stmt(`INSERT INTO symbols_fts(rowid, text) VALUES ${placeholders}`);
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 2)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?)").join(", ");
+    const insert = stmt(`INSERT INTO symbols_fts(rowid, text) VALUES ${placeholders2}`);
     const binds = [];
     for (const r of chunk) binds.push(r.id, r.text);
     insert.run(...binds);
@@ -4428,11 +5757,13 @@ function bulkInsertFtsWithStatement(stmt, maxSqlVars, ftsAvailable, rows) {
 }
 function bulkInsertVectorsWithStatement(stmt, maxSqlVars, rows) {
   if (rows.length === 0) return;
-  const chunkSize = Math.max(1, Math.floor(maxSqlVars / 2));
-  for (let i = 0; i < rows.length; i += chunkSize) {
-    const chunk = rows.slice(i, i + chunkSize);
-    const placeholders = chunk.map(() => "(?, ?)").join(", ");
-    const insert = stmt(`INSERT INTO symbol_vectors(symbol_id, vector) VALUES ${placeholders}`);
+  const ladder = ladderChunkSizes(rows.length, Math.max(1, Math.floor(maxSqlVars / 2)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = rows.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?)").join(", ");
+    const insert = stmt(`INSERT INTO symbol_vectors(symbol_id, vector) VALUES ${placeholders2}`);
     const binds = [];
     for (const r of chunk) binds.push(r.id, r.vector);
     insert.run(...binds);
@@ -4440,13 +5771,15 @@ function bulkInsertVectorsWithStatement(stmt, maxSqlVars, rows) {
 }
 function bulkInsertRefsWithStatement(stmt, maxSqlVars, refs) {
   if (refs.length === 0) return;
-  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 ladder = ladderChunkSizes(refs.length, Math.max(1, Math.floor(maxSqlVars / 8)));
+  let cursor = 0;
+  for (const take of ladder) {
+    const chunk = refs.slice(cursor, cursor + take);
+    cursor += take;
+    const placeholders2 = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
     const insert = stmt(
       `INSERT INTO refs(from_id, to_name, to_id, call_type, line, lang, module, to_file)
-       VALUES ${placeholders}`
+       VALUES ${placeholders2}`
     );
     const binds = [];
     for (const ref of chunk) {
@@ -4600,52 +5933,6 @@ function materializeWeightedEdges(edgeMap, idPrefix) {
   return edges;
 }
 
-// src/codebase-index/writer-helpers.ts
-import { resolveWstackPaths } from "@wrongstack/core/utils";
-function escapeLike(value) {
-  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
-}
-function posixIndexPath(file) {
-  return file.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-function indexedFileMatchSql(column = "file") {
-  return `(${column} = ? OR replace(${column}, '\\', '/') = ? OR replace(${column}, '\\', '/') LIKE ? ESCAPE '\\')`;
-}
-function indexedFileMatchArgs(file) {
-  const posix4 = posixIndexPath(file.trim());
-  return [file, posix4, `%/${escapeLike(posix4)}`];
-}
-function matchesIndexedPackageFilter(storedFile, packageLabel, filter) {
-  if (packageLabel === filter) return true;
-  const posixFile = posixIndexPath(storedFile);
-  const posixFilter = posixIndexPath(filter.trim());
-  if (!posixFilter) return false;
-  return posixFile === posixFilter || posixFile.endsWith(`/${posixFilter}`) || posixFile.includes(`/${posixFilter}/`);
-}
-function assignRefsToSymbols(refs, symbols) {
-  if (refs.length === 0 || symbols.length === 0) return [];
-  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
-  const seen = /* @__PURE__ */ new Set();
-  const assigned = [];
-  for (const ref of refs) {
-    let owner;
-    for (const symbol of ordered) {
-      if (symbol.line > ref.line) break;
-      owner = symbol;
-    }
-    if (!owner && ref.callType === "import") owner = ordered[0];
-    if (!owner || owner.id <= 0) continue;
-    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;
-}
-function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
-}
-
 // src/codebase-index/writer-ref-mapper.ts
 function mapWriterRefRow(row) {
   return {
@@ -4667,20 +5954,20 @@ function mapWriterRefRow(row) {
 var MAX_SQL_VARS = 900;
 function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
   const results = [];
-  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
-    const chunk = ids.slice(start, start + MAX_SQL_VARS);
-    const placeholders = chunk.map(() => "?").join(",");
-    const sql = buildSql(placeholders);
+  for (const take of inListChunks(ids.length, MAX_SQL_VARS)) {
+    const chunk = padToInBucket(ids.slice(0, take));
+    ids = ids.slice(take);
+    const sql = buildSql(placeholders(chunk.length));
     results.push(...stmt(sql).all(...chunk, ...extraArgs));
   }
   return results;
 }
 function chunkedIdScalar(stmt, ids, buildSql, extraArgs = []) {
   let total = 0;
-  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
-    const chunk = ids.slice(start, start + MAX_SQL_VARS);
-    const placeholders = chunk.map(() => "?").join(",");
-    const sql = buildSql(placeholders);
+  for (const take of inListChunks(ids.length, MAX_SQL_VARS)) {
+    const chunk = padToInBucket(ids.slice(0, take));
+    ids = ids.slice(take);
+    const sql = buildSql(placeholders(chunk.length));
     const rows = stmt(sql).all(...chunk, ...extraArgs);
     total += rows[0]?.n ?? 0;
   }
@@ -4709,16 +5996,24 @@ function resolveIndexedFiles(stmt, file) {
 }
 function resolveSymbolIds(stmt, symbolName, file) {
   if (!file) {
-    const rows2 = stmt("SELECT id FROM symbols WHERE name = ? ORDER BY id").all(symbolName);
-    return rows2.map((r) => r.id);
+    const rows = stmt("SELECT id FROM symbols WHERE name = ? ORDER BY id").all(
+      symbolName
+    );
+    return rows.map((r) => r.id);
   }
   const indexedFiles = resolveIndexedFiles(stmt, file);
   if (indexedFiles.length === 0) return [];
-  const placeholders = indexedFiles.map(() => "?").join(",");
-  const rows = stmt(
-    `SELECT id FROM symbols WHERE name = ? AND file IN (${placeholders}) ORDER BY id`
-  ).all(symbolName, ...indexedFiles);
-  return rows.map((r) => r.id);
+  const ids = [];
+  let cursor = 0;
+  for (const take of inListChunks(indexedFiles.length, MAX_SQL_VARS)) {
+    const files = padToInBucket(indexedFiles.slice(cursor, cursor + take));
+    cursor += take;
+    const rows = stmt(
+      `SELECT id FROM symbols WHERE name = ? AND file IN (${placeholders(files.length)}) ORDER BY id`
+    ).all(symbolName, ...files);
+    ids.push(...rows.map((r) => r.id));
+  }
+  return ids;
 }
 function findIncomingCallsByName(stmt, symbolName, file, limit) {
   const targetIds = resolveSymbolIds(stmt, symbolName, file);
@@ -5152,9 +6447,9 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   const loadedIds = new Set(syms.map((s) => s.id));
   const missingIds = [...relatedIds].filter((id) => !loadedIds.has(id));
   if (missingIds.length > 0) {
-    const placeholders = missingIds.map(() => "?").join(",");
+    const placeholders2 = missingIds.map(() => "?").join(",");
     const extras = stmt(
-      `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${placeholders})`
+      `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${placeholders2})`
     ).all(...missingIds);
     for (const s of extras) symById.set(s.id, s);
   }
@@ -5167,81 +6462,6 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   return { nodes, edges };
 }
 
-// src/codebase-index/vector-search.ts
-var RRF_K = 60;
-var VECTOR_DIMENSIONS = 384;
-var NGRAM_SIZE = 3;
-function embedText(text) {
-  const vec = new Float32Array(VECTOR_DIMENSIONS);
-  const normalized = text.toLowerCase().trim();
-  if (normalized.length < NGRAM_SIZE) {
-    const padded = ` ${normalized} `.slice(0, Math.max(NGRAM_SIZE, normalized.length + 2));
-    for (let i = 0; i <= padded.length - NGRAM_SIZE; i++) {
-      const ngram = padded.slice(i, i + NGRAM_SIZE);
-      const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
-      vec[bucket] += 1;
-    }
-  } else {
-    for (let i = 0; i <= normalized.length - NGRAM_SIZE; i++) {
-      const ngram = normalized.slice(i, i + NGRAM_SIZE);
-      const bucket = hashNgram(ngram) % VECTOR_DIMENSIONS;
-      vec[bucket] += 1;
-    }
-  }
-  let norm = 0;
-  for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
-    norm += vec[i] * vec[i];
-  }
-  norm = Math.sqrt(norm);
-  if (norm > 0) {
-    for (let i = 0; i < VECTOR_DIMENSIONS; i++) {
-      vec[i] /= norm;
-    }
-  }
-  return vec;
-}
-function hashNgram(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  const len = Math.min(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    dot += a[i] * b[i];
-  }
-  return dot;
-}
-function encodeVector(vec) {
-  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
-}
-function decodeVector(buf) {
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  const copy = new Float32Array(buf.byteLength / 4);
-  for (let i = 0; i < copy.length; i++) {
-    copy[i] = view.getFloat32(i * 4, true);
-  }
-  return copy;
-}
-function reciprocalRankFusion(bm25Ranks, vectorRanks, k = RRF_K) {
-  const allIds = /* @__PURE__ */ new Set([...bm25Ranks.keys(), ...vectorRanks.keys()]);
-  const scored = [];
-  for (const id of allIds) {
-    const bm25Rank = bm25Ranks.get(id);
-    const vecRank = vectorRanks.get(id);
-    let score = 0;
-    if (bm25Rank !== void 0) score += 1 / (k + bm25Rank);
-    if (vecRank !== void 0) score += 1 / (k + vecRank);
-    scored.push([id, score]);
-  }
-  scored.sort((a, b) => b[1] - a[1]);
-  return scored;
-}
-
 // src/codebase-index/writer-mutations.ts
 function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvailable, allocateSymbolIds, invalidateIncomingRefsForFiles, resolveRefsForNamesUnsafe2, entries, options = {}) {
   if (entries.length === 0 && (options.deleteForFiles?.length ?? 0) === 0) {
@@ -5253,24 +6473,29 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
     for (const ref of entry.refs) affectedNames.add(ref.toName);
   }
   if (options.deleteForFiles && options.deleteForFiles.length > 0) {
-    const placeholders = options.deleteForFiles.map(() => "?").join(",");
     for (const name of invalidateIncomingRefsForFiles(options.deleteForFiles)) {
       affectedNames.add(name);
     }
-    if (ftsAvailable) {
-      stmtFn(
-        `DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
-      ).run(...options.deleteForFiles);
-    }
-    if (vectorsAvailable) {
+    let cursor = 0;
+    for (const take of inListChunks(options.deleteForFiles.length, Math.floor(maxSqlVars / 4))) {
+      const bucket = padToInBucket(options.deleteForFiles.slice(cursor, cursor + take));
+      cursor += take;
+      const ph = placeholders(bucket.length);
+      if (ftsAvailable) {
+        stmtFn(
+          `DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file IN (${ph}))`
+        ).run(...bucket);
+      }
+      if (vectorsAvailable) {
+        stmtFn(
+          `DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file IN (${ph}))`
+        ).run(...bucket);
+      }
       stmtFn(
-        `DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
-      ).run(...options.deleteForFiles);
+        `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${ph}))`
+      ).run(...bucket);
+      stmtFn(`DELETE FROM symbols WHERE file IN (${ph})`).run(...bucket);
     }
-    stmtFn(
-      `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
-    ).run(...options.deleteForFiles);
-    stmtFn(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
   }
   const totalSymbols = entries.reduce((n, e) => n + e.symbols.length, 0);
   let nextId = allocateSymbolIds(totalSymbols);
@@ -5302,12 +6527,14 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
           text: buildIndexableText(s.name, s.signature, s.docComment)
         });
       }
-      vectorRows.push({
-        id,
-        vector: encodeVector(
-          embedText(s.text || buildIndexableText(s.name, s.signature, s.docComment))
-        )
-      });
+      if (vectorsAvailable) {
+        vectorRows.push({
+          id,
+          vector: encodeVector(
+            embedText(s.text || buildIndexableText(s.name, s.signature, s.docComment))
+          )
+        });
+      }
       const inserted = { ...s, id };
       allInserted.push(inserted);
       insertedForEntry.push(inserted);
@@ -5399,9 +6626,8 @@ var CORE_TABLES_SQL = `
     signature TEXT NOT NULL DEFAULT '',
     doc_comment TEXT NOT NULL DEFAULT '',
     scope TEXT NOT NULL DEFAULT '',
-    text TEXT NOT NULL DEFAULT '',
-    file_fk TEXT NOT NULL
-  );
+    text TEXT NOT NULL DEFAULT ''
+    );
 `;
 var FILE_INDEX_SQL = [
   "CREATE INDEX IF NOT EXISTS idx_f_package ON files(package)"
@@ -5412,7 +6638,6 @@ var SYMBOL_INDEX_SQL = [
   "CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)",
   "CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)",
   "CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)",
-  "CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)",
   "CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)"
 ];
 var REFS_TABLE_SQL = `
@@ -5487,11 +6712,12 @@ function getUnresolvedImportsWithStatement(stmtFn, maxSqlVars, onlyFiles) {
     return stmtFn(base).all();
   }
   const out = [];
-  for (let i = 0; i < onlyFiles.length; i += maxSqlVars) {
-    const chunk = onlyFiles.slice(i, i + maxSqlVars);
-    const placeholders = chunk.map(() => "?").join(",");
+  let cursor = 0;
+  for (const take of inListChunks(onlyFiles.length, maxSqlVars)) {
+    const chunk = padToInBucket(onlyFiles.slice(cursor, cursor + take));
+    cursor += take;
     out.push(
-      ...stmtFn(`${base} AND s.file IN (${placeholders})`).all(...chunk)
+      ...stmtFn(`${base} AND s.file IN (${placeholders(chunk.length)})`).all(...chunk)
     );
   }
   return out;
@@ -5562,16 +6788,18 @@ function applyImportResolutionsWithStatement(db, stmtFn, runWithRetry, maxSqlVar
        )`
     );
     const chunkSize = Math.max(1, Math.floor(maxSqlVars / 4));
-    for (let i = 0; i < resolutions.length; i += chunkSize) {
-      const chunk = resolutions.slice(i, i + chunkSize);
-      const placeholders = chunk.map(() => "(?, ?, ?, ?)").join(", ");
+    let cursor = 0;
+    for (const take of ladderChunkSizes(resolutions.length, chunkSize)) {
+      const chunk = resolutions.slice(cursor, cursor + take);
+      cursor += take;
+      const valuesPh = chunk.map(() => "(?, ?, ?, ?)").join(", ");
       const binds = [];
       for (const entry of chunk) {
         binds.push(entry.fromFile, entry.lang, entry.module, entry.toFile);
       }
       stmtFn(
         `INSERT INTO temp.import_resolution(from_file, lang, module, to_file)
-         VALUES ${placeholders}`
+         VALUES ${valuesPh}`
       ).run(...binds);
     }
     db.exec(
@@ -5608,9 +6836,11 @@ function resolveRefsForNamesUnsafe(stmtFn, maxSqlVars, names) {
   const list = [...names].filter((name) => name.length > 0);
   if (list.length === 0) return 0;
   let total = 0;
-  for (let i = 0; i < list.length; i += maxSqlVars) {
-    const chunk = list.slice(i, i + maxSqlVars);
-    const placeholders = chunk.map(() => "?").join(",");
+  let cursor = 0;
+  for (const take of inListChunks(list.length, maxSqlVars)) {
+    const chunk = padToInBucket(list.slice(cursor, cursor + take));
+    cursor += take;
+    const ph = placeholders(chunk.length);
     try {
       const result = stmtFn(
         `UPDATE refs
@@ -5619,16 +6849,16 @@ function resolveRefsForNamesUnsafe(stmtFn, maxSqlVars, names) {
                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
-                WHERE sym.name IN (${placeholders})
+                WHERE sym.name IN (${ph})
                 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
-                WHERE sym.name IN (${placeholders})
+                WHERE sym.name IN (${ph})
                 GROUP BY sym.name
              ) AS s,
              lang_family AS rf
-         WHERE refs.to_name IN (${placeholders})
+         WHERE refs.to_name IN (${ph})
            AND rf.lang = refs.lang
            AND s.name = refs.to_name
            AND s.family = rf.family`
@@ -5640,7 +6870,7 @@ function resolveRefsForNamesUnsafe(stmtFn, maxSqlVars, names) {
            SELECT sym.id FROM symbols sym
             WHERE sym.name = refs.to_name AND ${FAMILY_MATCH_SQL}
             ORDER BY sym.id LIMIT 1
-         ) WHERE refs.to_name IN (${placeholders})
+         ) WHERE refs.to_name IN (${ph})
            AND EXISTS (
              SELECT 1 FROM symbols sym
               WHERE sym.name = refs.to_name AND ${FAMILY_MATCH_SQL}
@@ -5697,7 +6927,7 @@ function buildWriterSearchWhere(query, filter) {
   const conditions = [];
   const values = [];
   let effectiveKind = filter?.kind;
-  if (filter?.lspKind !== void 0) {
+  if (filter?.lspKind != null) {
     const mapped = lspKindToInternalKind(filter.lspKind);
     if (mapped !== null) {
       effectiveKind = mapped;
@@ -5776,7 +7006,7 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
     );
   }
   let effectiveKind = filter?.kind;
-  if (filter?.lspKind !== void 0) {
+  if (filter?.lspKind != null) {
     const mapped = lspKindToInternalKind(filter.lspKind);
     if (mapped === null) return { results: [], total: 0 };
     effectiveKind = mapped;
@@ -5813,15 +7043,14 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
     values.push(`%${escapeLike(filter.file.replace(/\\/g, "/"))}%`);
   }
   const where = conditions.join(" AND ");
-  const countRows = stmtFn(
-    `SELECT COUNT(*) AS n FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE ${where}`
-  ).all(...values);
-  const total = countRows[0] ? Number(countRows[0].n) : 0;
-  if (total === 0) return { results: [], total: 0 };
   const bm25Rows = stmtFn(
     `SELECT s.id, s.lang, s.kind, s.name, s.file, s.line, s.col, s.signature, s.doc_comment,
             -bm25(symbols_fts) AS score,
-            snippet(symbols_fts, 0, '', '', '\u2026', 12) AS snippet
+            snippet(symbols_fts, 0, '', '', '\u2026', 12) AS snippet,
+            -- Keep this uncorrelated: referencing outer columns turns it into
+            -- a per-row subquery and defeats the one-count-per-statement win.
+            (SELECT COUNT(*) FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid
+              WHERE ${where}) AS total_count
      FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid
      WHERE ${where}
      ORDER BY
@@ -5830,13 +7059,15 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
             ELSE 2 END,
        bm25(symbols_fts), lower(s.name), s.file, s.line, s.col, s.id
      LIMIT ?`
-  ).all(...values, query.trim(), `${escapeLike(query.trim())}%`, safeLimit);
-  if (vectorsAvailable && bm25Rows.length > 0) {
+  ).all(...values, ...values, query.trim(), `${escapeLike(query.trim())}%`, safeLimit);
+  if (bm25Rows.length === 0) return { results: [], total: 0 };
+  const total = Number(bm25Rows[0]?.total_count ?? 0);
+  if (vectorsAvailable) {
     const queryVec = embedText(query);
     const candidateIds = bm25Rows.map((r) => r.id);
-    const placeholders = candidateIds.map(() => "?").join(",");
+    const placeholders2 = candidateIds.map(() => "?").join(",");
     const vecRows = stmtFn(
-      `SELECT sv.symbol_id, sv.vector FROM symbol_vectors sv WHERE sv.symbol_id IN (${placeholders})`
+      `SELECT sv.symbol_id, sv.vector FROM symbol_vectors sv WHERE sv.symbol_id IN (${placeholders2})`
     ).all(...candidateIds);
     const vecScores = vecRows.map((r) => ({
       id: r.symbol_id,
@@ -6024,9 +7255,9 @@ var IndexStore = class _IndexStore {
   }
   constructor(projectRoot, opts = {}) {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
-    fs8.mkdirSync(this.indexDir, { recursive: true });
+    fs9.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
-    this.db = new Database(path13.join(this.indexDir, DB_FILE2));
+    this.db = new Database(path14.join(this.indexDir, DB_FILE2));
     applyIndexStorePragmas(this.db);
     this.initSchema();
   }
@@ -6155,7 +7386,11 @@ var IndexStore = class _IndexStore {
       );
       if (symbolCount !== ftsCount) {
         this.db.exec("DELETE FROM symbols_fts");
-        if (this.vectorsAvailable) this.db.exec("DELETE FROM symbol_vectors");
+        if (vectorEmbeddingEnabled() && this.stmt(
+          "SELECT 1 FROM sqlite_master WHERE type='table' AND name='symbol_vectors'"
+        ).get() !== void 0) {
+          this.db.exec("DELETE FROM symbol_vectors");
+        }
         const rows = this.stmt(
           "SELECT id, name, signature, doc_comment FROM symbols ORDER BY id"
         ).all();
@@ -6174,8 +7409,13 @@ var IndexStore = class _IndexStore {
       this.ftsAvailable = false;
     }
     try {
-      this.db.exec(SYMBOL_VECTORS_TABLE_SQL);
-      this.vectorsAvailable = true;
+      if (vectorEmbeddingEnabled()) {
+        this.db.exec(SYMBOL_VECTORS_TABLE_SQL);
+        this.vectorsAvailable = true;
+      } else {
+        this.db.exec("DROP TABLE IF EXISTS symbol_vectors");
+        this.vectorsAvailable = false;
+      }
     } catch {
       this.vectorsAvailable = false;
     }
@@ -6210,14 +7450,22 @@ var IndexStore = class _IndexStore {
   }
   invalidateIncomingRefsForFiles(files) {
     if (files.length === 0) return /* @__PURE__ */ new Set();
-    const placeholders = files.map(() => "?").join(",");
-    const names = this.stmt(`SELECT DISTINCT name FROM symbols WHERE file IN (${placeholders})`).all(
-      ...files
-    ).map((row) => row.name);
-    this.stmt(
-      `UPDATE refs SET to_id = NULL
-       WHERE to_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
-    ).run(...files);
+    const names = [];
+    let cursor = 0;
+    for (const take of inListChunks(files.length, _IndexStore.MAX_SQL_VARS)) {
+      const bucket = padToInBucket(files.slice(cursor, cursor + take));
+      cursor += take;
+      const ph = placeholders(bucket.length);
+      for (const row of this.stmt(`SELECT DISTINCT name FROM symbols WHERE file IN (${ph})`).all(
+        ...bucket
+      )) {
+        names.push(row.name);
+      }
+      this.stmt(
+        `UPDATE refs SET to_id = NULL
+         WHERE to_id IN (SELECT id FROM symbols WHERE file IN (${ph}))`
+      ).run(...bucket);
+    }
     return new Set(names);
   }
   resolveRefsForNamesUnsafe(names) {
@@ -6251,6 +7499,14 @@ var IndexStore = class _IndexStore {
           if (this.ftsAvailable) {
             ftsRows.push({ id, text: buildIndexableText(s.name, s.signature, s.docComment) });
           }
+          if (this.vectorsAvailable) {
+            vectorRows.push({
+              id,
+              vector: encodeVector(
+                embedText(s.text || buildIndexableText(s.name, s.signature, s.docComment))
+              )
+            });
+          }
           result.push({ ...s, id });
         }
         bulkInsertSymbolsWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, bulk);
@@ -6283,15 +7539,15 @@ var IndexStore = class _IndexStore {
         const affectedNames = this.invalidateIncomingRefsForFiles([file]);
         if (this.ftsAvailable) {
           this.stmt(
-            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(file);
         }
         if (this.vectorsAvailable) {
           this.stmt(
-            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(file);
         }
-        this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(file);
+        this.stmt("DELETE FROM symbols WHERE file = ?").run(file);
         this.resolveRefsForNamesUnsafe(affectedNames);
         this.commitWriteTransaction(ownsTransaction);
       } catch (error) {
@@ -6308,18 +7564,18 @@ var IndexStore = class _IndexStore {
         const affectedNames = this.invalidateIncomingRefsForFiles([file]);
         if (this.ftsAvailable) {
           this.stmt(
-            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(file);
         }
         if (this.vectorsAvailable) {
           this.stmt(
-            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(file);
         }
-        this.stmt(
-          "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
-        ).run(file);
-        this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(file);
+        this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
+          file
+        );
+        this.stmt("DELETE FROM symbols WHERE file = ?").run(file);
         this.stmt("DELETE FROM files WHERE file = ?").run(file);
         this.resolveRefsForNamesUnsafe(affectedNames);
         this.commitWriteTransaction(ownsTransaction);
@@ -6423,6 +7679,10 @@ var IndexStore = class _IndexStore {
   getStats() {
     return getStatsWithStatement((sql) => this.stmt(sql), this.indexDir);
   }
+  /** P2.5: minimal summary for search-response piggyback (see writer-admin). */
+  getIndexSummary() {
+    return getIndexSummaryWithStatement((sql) => this.stmt(sql));
+  }
   setLastIndexed(ts2) {
     this.runWithRetry(() => {
       this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(
@@ -6524,18 +7784,18 @@ var IndexStore = class _IndexStore {
         const affectedNames = this.invalidateIncomingRefsForFiles([meta.file]);
         if (this.ftsAvailable) {
           this.stmt(
-            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(meta.file);
         }
         if (this.vectorsAvailable) {
           this.stmt(
-            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(meta.file);
         }
-        this.stmt(
-          "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
-        ).run(meta.file);
-        this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(meta.file);
+        this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
+          meta.file
+        );
+        this.stmt("DELETE FROM symbols WHERE file = ?").run(meta.file);
         this.stmt(
           `INSERT INTO files(file, lang, mtime_ms, content_hash, symbol_count, last_indexed)
            VALUES (?, ?, ?, ?, ?, ?)
@@ -6567,6 +7827,27 @@ var IndexStore = class _IndexStore {
     } catch {
     }
   }
+  /**
+   * P4.14: best-effort WAL checkpoint for idle-time maintenance.
+   *
+   * `wal_autocheckpoint` is PASSIVE and only attempts work after a COMMIT —
+   * once writes stop, nothing fires again, so the WAL keeps whatever frames
+   * the last burst left. This probes with PASSIVE first (never blocks; busy=1
+   * means readers still hold WAL snapshots) and only issues the TRUNCATE —
+   * which resets index.db-wal to zero bytes — when the checkpointer can
+   * proceed immediately. Callers run this on the daemon's single thread, so
+   * never wait on readers here: busy means "retry at the next idle window".
+   */
+  checkpointWal() {
+    try {
+      const probe = this.db.prepare("PRAGMA wal_checkpoint(PASSIVE)").get();
+      if (Number(probe?.busy ?? 1) !== 0) return false;
+      const done = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return Number(done?.busy ?? 1) === 0;
+    } catch {
+      return false;
+    }
+  }
   compactIfNeeded(options = {}) {
     const minBytes = options.minBytes ?? 256 * 1024 * 1024;
     const minFreeRatio = options.minFreeRatio ?? 0.35;
@@ -6652,7 +7933,9 @@ function resolveParallelBatch() {
   return indexParallelBatchSize(availableParallelism());
 }
 function shouldUseParserWorkerPool(candidateFileCount, parseBatchCount) {
-  return !isFrugalPerf() && candidateFileCount >= WORKER_POOL_THRESHOLD && parseBatchCount > 1;
+  const threshold = resolveWorkerPoolThreshold();
+  if (threshold === 0) return false;
+  return !isFrugalPerf() && candidateFileCount >= threshold && parseBatchCount > 1;
 }
 function yieldEventLoop() {
   return new Promise((resolve4) => setImmediate(resolve4));
@@ -6675,15 +7958,15 @@ var IndexSourceChangedError = class extends Error {
   name = "IndexSourceChangedError";
 };
 function isWithinProject(projectRoot, file) {
-  const rel = path14.relative(projectRoot, file);
-  return rel !== "" && !rel.startsWith(`..${path14.sep}`) && rel !== ".." && !path14.isAbsolute(rel);
+  const rel = path15.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path15.sep}`) && rel !== ".." && !path15.isAbsolute(rel);
 }
 function isMissingPathError(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
 function normalizeComparablePath(value) {
-  const resolved = path14.resolve(value);
+  const resolved = path15.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
@@ -6729,24 +8012,24 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
       const record = statusRecords[i];
       if (!record) continue;
       const status = record.slice(0, 2);
-      const changedPath = path14.resolve(projectRoot, record.slice(3));
+      const changedPath = path15.resolve(projectRoot, record.slice(3));
       dirty.add(changedPath);
       if (status.includes("D")) deleted.add(changedPath);
       if (status.includes("R") || status.includes("C")) {
         const source = statusRecords[++i];
-        if (source) dirty.add(path14.resolve(projectRoot, source));
+        if (source) dirty.add(path15.resolve(projectRoot, source));
       }
     }
     const files = [];
     for (const relative3 of output.toString("utf8").split("\0")) {
       if (!relative3) continue;
       const portable = relative3.replace(/\\/g, "/");
-      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path14.posix.basename(portable))) {
+      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path15.posix.basename(portable))) {
         continue;
       }
-      const full = path14.resolve(projectRoot, relative3);
+      const full = path15.resolve(projectRoot, relative3);
       if (deleted.has(full)) continue;
-      const ext = path14.extname(relative3).toLowerCase();
+      const ext = path15.extname(relative3).toLowerCase();
       if (INDEXABLE_EXTENSION_SET.has(ext) || detectLang(full) !== null) files.push(full);
     }
     const snapshot = createHash2("sha256").update(stagedOutput).update("\0").update(statusOutput);
@@ -6754,7 +8037,7 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
     for (const dirtyFile of [...dirty].sort()) {
       if (!indexedFiles.has(dirtyFile) || deleted.has(dirtyFile)) continue;
       snapshot.update("\0").update(dirtyFile).update("\0");
-      snapshot.update(xxhash64String(await fs9.readFile(dirtyFile, "utf8")));
+      snapshot.update(xxhash64String(await fs10.readFile(dirtyFile, "utf8")));
     }
     return {
       files,
@@ -6790,7 +8073,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs9.readdir(dir, { withFileTypes: true });
+      entries = await fs10.readdir(dir, { withFileTypes: true });
     } catch (err) {
       complete = false;
       errors.push(`scan error: ${dir}: ${err instanceof Error ? err.message : String(err)}`);
@@ -6799,14 +8082,14 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path14.join(dir, e.name);
-      const rel = path14.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path15.join(dir, e.name);
+      const rel = path15.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
         if (DEFAULT_IGNORE_FILES.has(e.name) || isGitIgnored(rel, false)) continue;
-        const ext = path14.extname(e.name).toLowerCase();
+        const ext = path15.extname(e.name).toLowerCase();
         if (indexableExts.has(ext) || detectLang(full) !== null) {
           results.push(full);
         }
@@ -6892,10 +8175,10 @@ async function runIndexerAtomic(store, opts) {
   let trustedUnchanged;
   let discoverySnapshotKey;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path14.resolve(projectRoot, f)).filter((f) => {
+    files = opts.files.map((f) => path15.resolve(projectRoot, f)).filter((f) => {
       if (!isWithinProject(projectRoot, f)) return false;
-      const rel = path14.relative(projectRoot, f).replace(/\\/g, "/");
-      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path14.basename(f)) && !isGitIgnored(rel, false);
+      const rel = path15.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path15.basename(f)) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -6928,7 +8211,6 @@ async function runIndexerAtomic(store, opts) {
       if (!meta || !trustedUnchanged.has(file)) return true;
       langStats[meta.lang] = (langStats[meta.lang] ?? 0) + meta.symbolCount;
       symbolsIndexed += meta.symbolCount;
-      filesIndexed++;
       filesSkipped++;
       filesPreSkipped++;
       return false;
@@ -6957,7 +8239,7 @@ async function runIndexerAtomic(store, opts) {
         async (file) => {
           let stat3;
           try {
-            stat3 = await fs9.stat(file, statOpts);
+            stat3 = await fs10.stat(file, statOpts);
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -6984,7 +8266,7 @@ async function runIndexerAtomic(store, opts) {
           const meta = existingMeta.get(file);
           let content;
           try {
-            content = await fs9.readFile(file, { encoding: "utf8", signal });
+            content = await fs10.readFile(file, { encoding: "utf8", signal });
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -7049,22 +8331,19 @@ async function runIndexerAtomic(store, opts) {
         }
       }
       if (!pool) {
-        await Promise.all(
-          toParse.map(async (item) => {
-            try {
-              const parsed = await parseFileContent(item.file, item.content, item.lang);
-              const settled = statReadParse[item.index];
-              if (settled.status === "fulfilled") {
-                settled.value.parsed = parsed;
-              }
-            } catch (e) {
-              const settled = statReadParse[item.index];
-              if (settled.status === "fulfilled") {
-                settled.value.error = `parse error: ${e instanceof Error ? e.message : String(e)}`;
-              }
-            }
-          })
+        const parsedAll = await parseFilesContent(
+          toParse.map((p) => ({ file: p.file, content: p.content, lang: p.lang }))
         );
+        for (let pi2 = 0; pi2 < parsedAll.length && pi2 < toParse.length; pi2++) {
+          const settled = statReadParse[toParse[pi2].index];
+          if (settled.status !== "fulfilled") continue;
+          const slot = parsedAll[pi2];
+          if (slot.result) {
+            settled.value.parsed = slot.result;
+          } else {
+            settled.value.error = `parse error: ${slot.error ?? `no result for ${toParse[pi2].file}`}`;
+          }
+        }
       }
     }
     const batchEntries = [];
@@ -7090,7 +8369,6 @@ async function runIndexerAtomic(store, opts) {
       if (result.skippedMeta) {
         langStats[lang] = (langStats[lang] ?? 0) + result.skippedMeta.symbolCount;
         symbolsIndexed += result.skippedMeta.symbolCount;
-        filesIndexed++;
         filesSkipped++;
         const stored = existingMeta.get(file);
         if (stored && stored.mtimeMs !== result.skippedMeta.mtimeMs) {
@@ -7115,7 +8393,6 @@ async function runIndexerAtomic(store, opts) {
             lastIndexed: Date.now(),
             contentHash: result.contentHash ?? ""
           });
-          filesIndexed++;
           filesEmpty++;
         }
         continue;
@@ -7129,7 +8406,6 @@ async function runIndexerAtomic(store, opts) {
           lastIndexed: Date.now(),
           contentHash: result.contentHash ?? ""
         });
-        filesIndexed++;
         filesEmpty++;
         continue;
       }
@@ -7259,7 +8535,7 @@ async function indexService(args, hooks = {}) {
 function searchService(args) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
-    return store.searchRanked(
+    const result = store.searchRanked(
       args.query,
       {
         kind: args.kind,
@@ -7269,6 +8545,10 @@ function searchService(args) {
       },
       args.limit
     );
+    if (result.total === 0) {
+      return { ...result, indexSummary: store.getIndexSummary() };
+    }
+    return result;
   } finally {
     indexStorePool.release(store);
   }
@@ -7332,34 +8612,71 @@ function outgoingCallsService(args) {
 init_languages();
 
 // src/codebase-index/project-server-client.ts
-import { spawn as spawn3 } from "node:child_process";
-import * as fs12 from "node:fs";
+import { spawn as spawn4 } from "node:child_process";
+import * as fs13 from "node:fs";
 import * as net from "node:net";
-import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/codebase-index/binary-frame.ts
 import { decode, encode } from "@msgpack/msgpack";
 var BINARY_FRAME_MAGIC = 87;
+var MAX_BINARY_FRAME_BYTES = 256 * 1024 * 1024;
+var MAX_INBOUND_BINARY_FRAME_BYTES = 64 * 1024 * 1024;
 function isBinaryFrame(firstByte) {
   return firstByte === BINARY_FRAME_MAGIC;
 }
 function encodeBinaryFrame(message) {
-  const payload = encode(message);
+  const payload = encode(normalizeUndefined(message));
   const header = Buffer.allocUnsafe(5);
   header[0] = BINARY_FRAME_MAGIC;
   header.writeUInt32BE(payload.length, 1);
   return Buffer.concat([header, payload], 5 + payload.length);
 }
+function normalizeUndefined(value) {
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? null : value.toISOString();
+  }
+  if (value instanceof Map) return normalizeUndefined(Object.fromEntries(value));
+  if (value instanceof Set) return normalizeUndefined([...value]);
+  if (value instanceof Error) {
+    return normalizeUndefined({ name: value.name, message: value.message, stack: value.stack });
+  }
+  if (value instanceof RegExp) return String(value);
+  if (value instanceof URL) return value.toJSON();
+  if (Buffer.isBuffer(value)) return { type: "Buffer", data: [...value] };
+  if (Array.isArray(value)) return value.map((entry) => normalizeUndefined(entry));
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === void 0) continue;
+    out[key] = normalizeUndefined(entry);
+  }
+  return out;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
 function decodeBinaryFrame(payload) {
   return decode(payload);
 }
+function encodeJsonFrame(message) {
+  return `${JSON.stringify(normalizeUndefined(message))}
+`;
+}
+
+// src/codebase-index/project-server-client-state.ts
+import * as fs12 from "node:fs";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { checkUnixSocketPath } from "@wrongstack/core/utils";
 
 // src/codebase-index/project-server-endpoint.ts
 import { createHash as createHash3 } from "node:crypto";
-import * as fs10 from "node:fs";
-import * as os3 from "node:os";
-import * as path15 from "node:path";
+import * as fs11 from "node:fs";
+import * as os4 from "node:os";
+import * as path16 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PROJECT_INDEX_SERVER_PROTOCOL_VERSION = 1;
 var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
@@ -7368,21 +8685,21 @@ var buildIdCache;
 function projectIndexServerBuildId(entrypoint) {
   const href = entrypoint instanceof URL ? entrypoint.href : entrypoint;
   const cleanHref = href.split(/[?#]/, 1)[0] ?? href;
-  const file = cleanHref.startsWith("file:") ? fileURLToPath3(cleanHref) : path15.resolve(cleanHref);
+  const file = cleanHref.startsWith("file:") ? fileURLToPath3(cleanHref) : path16.resolve(cleanHref);
   try {
-    const stat3 = fs10.statSync(file);
+    const stat3 = fs11.statSync(file);
     if (buildIdCache?.file === file && buildIdCache.mtimeMs === stat3.mtimeMs && buildIdCache.size === stat3.size) {
       return buildIdCache.buildId;
     }
-    const buildId = createHash3("sha256").update(fs10.readFileSync(file)).digest("hex").slice(0, 24);
+    const buildId = createHash3("sha256").update(fs11.readFileSync(file)).digest("hex").slice(0, 24);
     buildIdCache = { file, mtimeMs: stat3.mtimeMs, size: stat3.size, buildId };
     return buildId;
   } catch {
-    return `unreadable:${path15.basename(file)}`;
+    return `unreadable:${path16.basename(file)}`;
   }
 }
 function normalizeLocalPath(value) {
-  const resolved = path15.resolve(value);
+  const resolved = path16.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function projectIndexServerKey(projectRoot, indexDir) {
@@ -7394,26 +8711,16 @@ function projectIndexServerEndpoint(projectRoot, indexDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-codebase-index-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path15.join(os3.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
+  return path16.join(os4.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
 }
 function projectIndexServerMetadataPath(projectRoot, indexDir) {
-  return path15.join(
-    path15.resolve(resolveIndexDir(projectRoot, indexDir)),
+  return path16.join(
+    path16.resolve(resolveIndexDir(projectRoot, indexDir)),
     PROJECT_INDEX_SERVER_METADATA_FILE
   );
 }
 
-// src/codebase-index/project-server-protocol.ts
-var PROJECT_INDEX_SERVER_MAX_FRAME_CHARS = 64 * 1024 * 1024;
-function encodeProjectServerMessage(message) {
-  return `${JSON.stringify(message)}
-`;
-}
-
 // src/codebase-index/project-server-client-state.ts
-import * as fs11 from "node:fs";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { checkUnixSocketPath } from "@wrongstack/core/utils";
 var CONNECT_ATTEMPT_TIMEOUT_MS = 750;
 var SERVER_START_TIMEOUT_MS = 1e4;
 var SERVER_CONTROL_TIMEOUT_MS = 5e3;
@@ -7444,7 +8751,7 @@ function resolveProjectIndexDaemonAvailability(projectRoot, indexDir) {
   for (const rel of ["./project-server.js", "./codebase-index/project-server.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs11.existsSync(fileURLToPath4(url))) {
+      if (url.protocol === "file:" && fs12.existsSync(fileURLToPath4(url))) {
         builtUrl = url;
         break;
       }
@@ -7532,6 +8839,12 @@ function cancellationError(signal) {
   return signal.reason instanceof Error ? signal.reason : new Error("Indexing cancelled");
 }
 
+// src/codebase-index/project-server-protocol.ts
+var PROJECT_INDEX_SERVER_MAX_FRAME_CHARS = 64 * 1024 * 1024;
+function encodeProjectServerMessage(message) {
+  return encodeJsonFrame(message);
+}
+
 // src/codebase-index/project-server-client.ts
 var ProjectServerConnection = class {
   constructor(projectRoot, indexDir, endpoint) {
@@ -7544,11 +8857,13 @@ var ProjectServerConnection = class {
   indexDir;
   endpoint;
   socket = null;
-  buffer = "";
-  /** P6: binary frame buffer — accumulates raw bytes when in binary mode. */
-  binaryBuffer = [];
-  /** P6: StringDecoder for safe UTF-8 multibyte handling in JSON mode. */
-  textDecoder = null;
+  /**
+   * Raw inbound bytes for the unified per-frame reader. Frames are sniffed
+   * individually — JSON text (newline-terminated) or binary (magic 0x57) —
+   * instead of latching a read mode, so a JSON broadcast between binary
+   * frames cannot desynchronize the reader.
+   */
+  readBuffer = Buffer.alloc(0);
   /** P6: true once the server advertises binary support and client accepts. */
   useBinary = false;
   info = null;
@@ -7690,7 +9005,7 @@ var ProjectServerConnection = class {
     this.activity = null;
     this.health = null;
     this.useBinary = false;
-    this.binaryBuffer = [];
+    this.readBuffer = Buffer.alloc(0);
     this.connectReject?.(new Error("codebase-index client disconnected"));
     this.connectResolve = null;
     this.connectReject = null;
@@ -7711,7 +9026,7 @@ var ProjectServerConnection = class {
   currentAuthToken() {
     if (this.authToken === void 0) {
       try {
-        const raw = fs12.readFileSync(
+        const raw = fs13.readFileSync(
           projectIndexServerMetadataPath(this.projectRoot, this.indexDir),
           "utf8"
         );
@@ -7818,10 +9133,8 @@ var ProjectServerConnection = class {
     this.info = null;
     this.activity = null;
     this.health = null;
-    this.buffer = "";
-    this.binaryBuffer = [];
+    this.readBuffer = Buffer.alloc(0);
     this.useBinary = false;
-    this.textDecoder = null;
     return new Promise((resolve4, reject) => {
       const socket = net.createConnection(this.endpoint);
       this.socket = socket;
@@ -7851,18 +9164,47 @@ var ProjectServerConnection = class {
       socket.on("close", () => this.onClose(socket));
     });
   }
+  /**
+   * Unified per-frame reader. Each frame is sniffed by its first byte:
+   * `0x57` ('W') → length-prefixed MessagePack binary, anything else →
+   * newline-delimited JSON text. Sniffing per frame (instead of latching a
+   * mode) is what makes mixed streams work: the server may interleave a JSON
+   * `index-state` broadcast between binary responses, and an old JSON-only
+   * server stays readable while `useBinary` is armed.
+   *
+   * Multibyte UTF-8 in JSON frames is safe: raw `0x0a` only occurs as the
+   * JSON delimiter (inside JSON strings `\n` is escaped), so a complete line
+   * is always complete UTF-8.
+   */
   onData(socket, chunk) {
     if (socket !== this.socket) return;
-    if (this.useBinary) {
-      this.onBinaryData(socket, chunk);
-      return;
-    }
-    if (!this.textDecoder) this.textDecoder = new StringDecoder("utf8");
-    this.buffer += this.textDecoder.write(chunk);
+    this.readBuffer = this.readBuffer.length === 0 ? chunk : Buffer.concat([this.readBuffer, chunk]);
     while (true) {
-      const newline = this.buffer.indexOf("\n");
+      if (this.readBuffer.length === 0) return;
+      if (this.useBinary && isBinaryFrame(this.readBuffer[0])) {
+        if (this.readBuffer.length < 5) return;
+        const frameLen = this.readBuffer.readUInt32BE(1);
+        if (frameLen > MAX_BINARY_FRAME_BYTES) {
+          socket.destroy();
+          this.transition("offline", { error: "binary frame length exceeds the IPC limit" });
+          return;
+        }
+        if (this.readBuffer.length < 5 + frameLen) return;
+        const payload = this.readBuffer.subarray(5, 5 + frameLen);
+        this.readBuffer = this.readBuffer.subarray(5 + frameLen);
+        let message2;
+        try {
+          message2 = decodeBinaryFrame(payload);
+        } catch {
+          socket.destroy(new Error("invalid binary codebase-index server response"));
+          return;
+        }
+        this.onMessage(message2);
+        continue;
+      }
+      const newline = this.readBuffer.indexOf(10);
       if (newline < 0) {
-        if (this.buffer.length > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
+        if (this.readBuffer.length > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
           socket.destroy(new Error("codebase-index server response exceeds the IPC limit"));
         }
         return;
@@ -7871,8 +9213,8 @@ var ProjectServerConnection = class {
         socket.destroy(new Error("codebase-index server response exceeds the IPC limit"));
         return;
       }
-      const line = this.buffer.slice(0, newline);
-      this.buffer = this.buffer.slice(newline + 1);
+      const line = this.readBuffer.subarray(0, newline).toString("utf8");
+      this.readBuffer = this.readBuffer.subarray(newline + 1);
       if (!line) continue;
       let message;
       try {
@@ -7884,44 +9226,6 @@ var ProjectServerConnection = class {
       this.onMessage(message);
     }
   }
-  /**
-   * P6: Parse binary frames from the raw buffer.
-   *
-   * Each frame is: [1 byte magic 0x57] [4 bytes uint32 BE length] [payload].
-   * The magic byte distinguishes binary from JSON — a JSON frame's first byte
-   * is `{` (0x7B), so there is no ambiguity even in a mixed-mode buffer.
-   */
-  onBinaryData(socket, chunk) {
-    this.binaryBuffer.push(chunk);
-    const all = Buffer.concat(this.binaryBuffer);
-    let offset = 0;
-    while (offset + 5 <= all.length) {
-      if (!isBinaryFrame(all[offset])) {
-        this.useBinary = false;
-        this.buffer += all.subarray(offset).toString("utf8");
-        this.binaryBuffer = [];
-        return;
-      }
-      const frameLen = all.readUInt32BE(offset + 1);
-      if (frameLen > 256 * 1024 * 1024) {
-        socket.destroy();
-        this.transition("offline", { error: "binary frame length exceeds 256MB limit" });
-        return;
-      }
-      const totalLen = 5 + frameLen;
-      if (offset + totalLen > all.length) break;
-      const payload = all.subarray(offset + 5, offset + 5 + frameLen);
-      try {
-        const message = decodeBinaryFrame(payload);
-        this.onMessage(message);
-      } catch {
-        socket.destroy(new Error("invalid binary codebase-index server response"));
-        return;
-      }
-      offset += totalLen;
-    }
-    this.binaryBuffer = offset < all.length ? [all.subarray(offset)] : [];
-  }
   onMessage(message) {
     if (message.type === "hello") {
       if (message.protocolVersion !== PROJECT_INDEX_SERVER_PROTOCOL_VERSION) {
@@ -7941,7 +9245,7 @@ var ProjectServerConnection = class {
       }
       this.info = message;
       this.markResponsive();
-      if (message.binarySupported) this.useBinary = true;
+      if (message.binarySupported && binaryFramingEnabled()) this.useBinary = true;
       this.transition("connected", { pid: message.pid });
       ensureHeartbeatLoop();
       this.connectResolve?.();
@@ -8027,13 +9331,13 @@ var ProjectServerConnection = class {
     if (!url) throw new Error("built codebase-index project server is unavailable");
     if (process.platform !== "win32") {
       try {
-        fs12.rmSync(this.endpoint, { force: true });
+        fs13.rmSync(this.endpoint, { force: true });
       } catch {
       }
     }
     const args = [fileURLToPath5(url), "--project-root", this.projectRoot];
     if (this.indexDir) args.push("--index-dir", this.indexDir);
-    const child = spawn3(process.execPath, args, {
+    const child = spawn4(process.execPath, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -8051,8 +9355,8 @@ var ProjectServerConnection = class {
       process.kill(pid);
       const metadataPath = projectIndexServerMetadataPath(this.projectRoot, this.indexDir);
       try {
-        const metadata = JSON.parse(fs12.readFileSync(metadataPath, "utf8"));
-        if (metadata.pid === pid) fs12.rmSync(metadataPath, { force: true });
+        const metadata = JSON.parse(fs13.readFileSync(metadataPath, "utf8"));
+        if (metadata.pid === pid) fs13.rmSync(metadataPath, { force: true });
       } catch {
       }
       return true;
@@ -8064,6 +9368,10 @@ var ProjectServerConnection = class {
 var connections = /* @__PURE__ */ new Map();
 var MAX_CACHED_CONNECTIONS = 8;
 var heartbeatTimer;
+function binaryFramingEnabled() {
+  const flag = process.env["WRONGSTACK_INDEX_BINARY"];
+  return flag === "1" || flag === "true";
+}
 function forgetConnection(endpoint, connection) {
   if (connections.get(endpoint) === connection) connections.delete(endpoint);
   connection.close();
@@ -8153,7 +9461,7 @@ function resolveWorkerUrl() {
   for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs13.existsSync(fileURLToPath6(url))) return url;
+      if (url.protocol === "file:" && fs14.existsSync(fileURLToPath6(url))) return url;
     } catch {
     }
   }
@@ -8480,7 +9788,7 @@ var writeTool = {
     required: ["path", "content"]
   },
   async execute(input, ctx, opts) {
-    return writeFile3(input, ctx, opts?.signal);
+    return writeFile4(input, ctx, opts?.signal);
   },
   async *executeStream(input, ctx, opts) {
     const prepared = await prepareWrite(input, ctx);
@@ -8493,7 +9801,7 @@ var writeTool = {
     yield { type: "final", output: await finishWrite(input, ctx, prepared, opts?.signal) };
   }
 };
-async function writeFile3(input, ctx, signal) {
+async function writeFile4(input, ctx, signal) {
   return finishWrite(input, ctx, await prepareWrite(input, ctx), signal);
 }
 async function prepareWrite(input, ctx) {
@@ -8513,14 +9821,14 @@ async function prepareWrite(input, ctx) {
   let existed = false;
   let prev = "";
   try {
-    const stat3 = await fs14.stat(absPath);
+    const stat3 = await fs15.stat(absPath);
     existed = stat3.isFile();
     if (existed) {
       if (!ctx.hasRead(absPath)) {
-        prev = await fs14.readFile(absPath, "utf8");
+        prev = await fs15.readFile(absPath, "utf8");
         ctx.recordRead(absPath, stat3.mtimeMs, "write", sha256hex(prev));
       } else {
-        prev = await fs14.readFile(absPath, "utf8");
+        prev = await fs15.readFile(absPath, "utf8");
       }
     }
   } catch (err) {
@@ -8541,9 +9849,9 @@ async function finishWrite(input, ctx, prepared, signal) {
   const rawDiff = prepared.existed ? unifiedDiff(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${content.split("\n").length} lines)`;
   const { text: diff, truncated: diffTruncated } = truncateDiffPayload(rawDiff, MAX_DIFF_BYTES);
-  const stat3 = await fs14.stat(prepared.absPath);
+  const stat3 = await fs15.stat(prepared.absPath);
   ctx.recordRead(prepared.absPath, stat3.mtimeMs, "write", sha256hex(content));
-  ctx.session.recordFileChange({
+  ctx.session?.recordFileChange?.({
     path: prepared.absPath,
     action: prepared.existed ? "modified" : "created",
     before: prepared.existed ? prepared.prev : null,