@wrongstack/tools 0.302.2 → 0.305.0

package/dist/codebase-index/worker.js

@@ -2127,21 +2127,672 @@ var init_yaml_parser = __esm({
   }
 });
 
+// src/codebase-index/tree-sitter/queries.ts
+function getQueries(lang) {
+  return LANG_QUERIES[lang] ?? DEFAULT_QUERIES;
+}
+function readFirstString(node) {
+  if (!node) return null;
+  if (node.type === "string_literal" || node.type === "alias") {
+    return node.text.replace(/^"|"$/g, "");
+  }
+  const child = node.namedChild(0);
+  return child ? readFirstString(child) : null;
+}
+var DEFAULT_QUERIES, LANG_QUERIES;
+var init_queries = __esm({
+  "src/codebase-index/tree-sitter/queries.ts"() {
+    "use strict";
+    DEFAULT_QUERIES = {
+      declKinds: {}
+    };
+    LANG_QUERIES = {
+      // ─── C family ──────────────────────────────────────────────────────────────
+      c: {
+        declKinds: {
+          function_definition: "function",
+          declaration: "function",
+          // K&R-style `int foo(...)` ambiguous w/ local var; the visitor prefers the function branch when the declarator field is present
+          struct_specifier: "struct",
+          union_specifier: "struct",
+          enum_specifier: "enum",
+          type_definition: "type",
+          // `typedef … X;`
+          preproc_def: "const"
+          // `#define NAME …`
+        },
+        nameField: {
+          function_definition: "declarator",
+          declaration: "declarator",
+          struct_specifier: "name",
+          enum_specifier: "name",
+          type_definition: "declarator",
+          preproc_def: "name"
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "translation_unit",
+          "function_definition",
+          "struct_specifier",
+          "union_specifier",
+          "enum_specifier"
+        ])
+      },
+      cpp: {
+        declKinds: {
+          function_definition: "function",
+          template_declaration: "function",
+          // `template<typename T> …`
+          class_specifier: "class",
+          struct_specifier: "struct",
+          union_specifier: "struct",
+          enum_specifier: "enum",
+          namespace_definition: "namespace",
+          type_definition: "type"
+        },
+        nameField: {
+          function_definition: "declarator",
+          template_declaration: "name",
+          class_specifier: "name",
+          struct_specifier: "name",
+          enum_specifier: "name",
+          namespace_definition: "name",
+          type_definition: "declarator"
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "translation_unit",
+          "function_definition",
+          "class_specifier",
+          "struct_specifier",
+          "union_specifier",
+          "enum_specifier",
+          "namespace_definition"
+        ])
+      },
+      java: {
+        declKinds: {
+          class_declaration: "class",
+          interface_declaration: "interface",
+          enum_declaration: "enum",
+          record_declaration: "class",
+          annotation_type_declaration: "interface",
+          method_declaration: "method",
+          constructor_declaration: "method",
+          field_declaration: "property"
+        },
+        nameField: {
+          class_declaration: "name",
+          interface_declaration: "name",
+          enum_declaration: "name",
+          record_declaration: "name",
+          annotation_type_declaration: "name",
+          method_declaration: "name",
+          constructor_declaration: "name"
+        },
+        // `field_declaration` has no single `name` field — it carries a list of
+        // variable declarators. We emit one Symbol per node using the first
+        // identifier-shaped named child (see `extractName` fallback in
+        // `visitor.ts`). `int a, b, c;` therefore indexes only `a` — splitting
+        // multi-declarator fields into separate Symbols is a separate refactor
+        // that needs the visitor to know it has multiple names per node, and no
+        // current test relies on it.
+        scopeNodes: /* @__PURE__ */ new Set([
+          "program",
+          "class_declaration",
+          "interface_declaration",
+          "enum_declaration",
+          "record_declaration"
+        ])
+      },
+      csharp: {
+        // C# 10+ `namespace Foo.Bar;` produces this node type. The legacy block
+        // form `namespace Foo.Bar { ... }` produces `namespace_declaration`. Both
+        // carry a `qualified_name` child whose text already includes the dots.
+        // `using_directive` is intentionally not a declaration. Imports are
+        // extracted separately; indexing a using directive as a namespace makes
+        // the resolver bind it to its own source file before the real declaration.
+        declKinds: {
+          file_scoped_namespace_declaration: "namespace",
+          class_declaration: "class",
+          interface_declaration: "interface",
+          struct_declaration: "struct",
+          enum_declaration: "enum",
+          record_declaration: "class",
+          method_declaration: "method",
+          constructor_declaration: "method",
+          property_declaration: "property",
+          field_declaration: "property",
+          namespace_declaration: "namespace"
+        },
+        // Custom name extractor: take the full dotted name verbatim.
+        nameExtractor: (node) => {
+          const inner = node.namedChild(0);
+          if (inner && (inner.type === "qualified_name" || inner.type === "name")) {
+            return inner.text;
+          }
+          return null;
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "compilation_unit",
+          "namespace_declaration",
+          "class_declaration",
+          "interface_declaration",
+          "struct_declaration",
+          "enum_declaration",
+          "record_declaration"
+        ])
+      },
+      php: {
+        declKinds: {
+          function_definition: "function",
+          method_declaration: "method",
+          class_declaration: "class",
+          interface_declaration: "interface",
+          trait_declaration: "class",
+          enum_declaration: "enum",
+          namespace_definition: "namespace"
+        },
+        nameField: {
+          function_definition: "name",
+          method_declaration: "name",
+          class_declaration: "name",
+          interface_declaration: "name",
+          trait_declaration: "name",
+          enum_declaration: "name",
+          namespace_declaration: "name"
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "program",
+          "namespace_definition",
+          "class_declaration",
+          "interface_declaration",
+          "trait_declaration",
+          "enum_declaration"
+        ])
+      },
+      // ─── Scripting / mobile ────────────────────────────────────────────────────
+      ruby: {
+        declKinds: {
+          method: "function",
+          singleton_method: "method",
+          class: "class",
+          module: "namespace",
+          constant: "const"
+        },
+        nameField: {
+          method: "name",
+          singleton_method: "name",
+          class: "name",
+          module: "name",
+          constant: "name"
+        },
+        scopeNodes: /* @__PURE__ */ new Set(["program", "class", "module", "singleton_method", "method"])
+      },
+      swift: {
+        declKinds: {
+          function_declaration: "function",
+          class_declaration: "class",
+          struct_declaration: "struct",
+          enum_declaration: "enum",
+          protocol_declaration: "interface",
+          actor_declaration: "class",
+          extension_declaration: "class",
+          initializer: "method",
+          property_declaration: "property"
+        },
+        nameField: {
+          function_declaration: "name",
+          class_declaration: "name",
+          struct_declaration: "name",
+          enum_declaration: "name",
+          protocol_declaration: "name",
+          actor_declaration: "name",
+          extension_declaration: "name",
+          initializer: "name",
+          property_declaration: "name"
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "source_file",
+          "class_declaration",
+          "struct_declaration",
+          "enum_declaration",
+          "protocol_declaration",
+          "actor_declaration",
+          "extension_declaration"
+        ])
+      },
+      kotlin: {
+        declKinds: {
+          class_declaration: "class",
+          object_declaration: "class",
+          interface_declaration: "interface",
+          function_declaration: "function",
+          property_declaration: "property",
+          type_alias: "type"
+        },
+        nameField: {
+          class_declaration: "name",
+          object_declaration: "name",
+          interface_declaration: "name",
+          function_declaration: "name",
+          property_declaration: "name",
+          type_alias: "name"
+        },
+        scopeNodes: /* @__PURE__ */ new Set([
+          "source_file",
+          "class_declaration",
+          "object_declaration",
+          "interface_declaration",
+          "function_declaration"
+        ])
+      },
+      elixir: {
+        declKinds: {
+          // `def foo`, `defp foo`, `defmacro foo`, `macrop foo` all surface as
+          // `call` nodes in the tree-sitter grammar — there is no
+          // `function_definition`. The `nameExtractor` walks the call's
+          // children to pick the right sibling identifier.
+          call: "function",
+          module: "namespace"
+        },
+        nameExtractor: (node) => {
+          if (node.type === "module") {
+            const aliasNode = node.childForFieldName("alias");
+            return readFirstString(aliasNode) ?? null;
+          }
+          if (node.type !== "call") return null;
+          const first = node.namedChild(0);
+          if (!first) return null;
+          const target = first.text;
+          if (target !== "def" && target !== "defp" && target !== "defmacro" && target !== "defp_macro" && target !== "macrop" && target !== "defprotocol" && target !== "defguard" && target !== "defguardp") {
+            return null;
+          }
+          const nameNode = node.namedChild(1);
+          return nameNode?.text ?? null;
+        },
+        scopeNodes: /* @__PURE__ */ new Set(["source", "module"])
+      },
+      shell: {
+        declKinds: {
+          function_definition: "function"
+        },
+        nameField: { function_definition: "name" },
+        scopeNodes: /* @__PURE__ */ new Set(["program", "function_definition"])
+      }
+    };
+  }
+});
+
+// src/codebase-index/tree-sitter/util.ts
+function lineColAt2(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;
+  }
+  const lastNl = low > 0 ? offsets[low - 1] ?? -1 : -1;
+  return { line: low + 1, col: index - lastNl };
+}
+function newlineOffsets3(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
+  }
+  return offsets;
+}
+var TREE_SITTER_MAX_FILE_CHARS, TREE_SITTER_MAX_SYMBOLS;
+var init_util = __esm({
+  "src/codebase-index/tree-sitter/util.ts"() {
+    "use strict";
+    TREE_SITTER_MAX_FILE_CHARS = 512 * 1024;
+    TREE_SITTER_MAX_SYMBOLS = 500;
+  }
+});
+
+// src/codebase-index/tree-sitter/visitor.ts
+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 scopeStack = [];
+  function visit(node, depth) {
+    if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) return;
+    if (node.isMissing || node.isError) {
+    } else {
+      const kind = queries.declKinds[node.type];
+      if (kind) {
+        const emitted = emitSymbol(
+          node,
+          kind,
+          file,
+          lang,
+          scopeStack,
+          boundedContent,
+          nlOffsets,
+          queries
+        );
+        if (emitted) symbols.push(emitted);
+      }
+    }
+    const pushesScope = queries.scopeNodes?.has(node.type) ?? false;
+    const pushIdx = pushesScope ? pushScope(scopeStack, node, queries) : -1;
+    if (queries.skipNamedChildren) {
+      if (pushIdx !== -1) scopeStack.pop();
+      return;
+    }
+    for (const child of node.namedChildren) {
+      visit(child, depth + 1);
+      if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) {
+        if (pushIdx !== -1) scopeStack.pop();
+        return;
+      }
+    }
+    if (pushIdx !== -1) scopeStack.pop();
+  }
+  visit(tree.rootNode, 0);
+  return { symbols };
+}
+function pushScope(scopeStack, node, queries) {
+  const name = extractName(node, queries);
+  if (!name) return -1;
+  scopeStack.push(name);
+  return scopeStack.length - 1;
+}
+function extractName(node, queries) {
+  if (queries.nameExtractor) {
+    const extracted = queries.nameExtractor(node);
+    if (extracted) return extracted;
+  }
+  const fieldName = queries.nameField?.[node.type] ?? "name";
+  const field = node.childForFieldName(fieldName);
+  if (field) {
+    if (IDENTIFIER_NODE_TYPES.has(field.type)) {
+      return field.text;
+    }
+    const inner = field.childForFieldName("name") ?? field.namedChild(0);
+    if (inner && IDENTIFIER_NODE_TYPES.has(inner.type)) {
+      return inner.text;
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && IDENTIFIER_NODE_TYPES.has(child.type)) {
+      return child.text;
+    }
+  }
+  return null;
+}
+function emitSymbol(node, kind, file, lang, scopeStack, content, nlOffsets, queries) {
+  const name = extractName(node, queries);
+  if (!name) return null;
+  const pos = node.startIndex;
+  const { line, col } = lineColAt2(nlOffsets, pos);
+  const end = Math.min(node.endIndex, content.length);
+  const signature = content.slice(pos, end).replace(/\s+/g, " ").trim().slice(0, 500);
+  const scope = scopeStack.join(".");
+  const text = [name, signature].filter(Boolean).join(" | ").trim().slice(0, 1e3);
+  return {
+    id: 0,
+    // caller assigns during bulk insertion
+    lang,
+    kind,
+    name: name.slice(0, 200),
+    file,
+    line,
+    col,
+    signature,
+    docComment: "",
+    // doc-comment extraction lands with ref emission on Day 4
+    scope,
+    text
+  };
+}
+var IDENTIFIER_NODE_TYPES;
+var init_visitor = __esm({
+  "src/codebase-index/tree-sitter/visitor.ts"() {
+    "use strict";
+    init_util();
+    IDENTIFIER_NODE_TYPES = /* @__PURE__ */ new Set([
+      "identifier",
+      "simple_identifier",
+      "type_identifier",
+      "field_identifier",
+      "property_identifier",
+      "name",
+      "word",
+      "variable_name",
+      "constant",
+      "sym"
+    ]);
+  }
+});
+
+// src/codebase-index/tree-sitter-parser.ts
+var tree_sitter_parser_exports = {};
+__export(tree_sitter_parser_exports, {
+  __smokeRootType: () => __smokeRootType,
+  getGrammarWasmPath: () => getGrammarWasmPath,
+  isTreeSitterSupported: () => isTreeSitterSupported,
+  loadTreeSitterLanguage: () => loadTreeSitterLanguage,
+  parseSymbols: () => parseSymbols8
+});
+import * as path9 from "node:path";
+import { fileURLToPath } from "node:url";
+function optInEnabled(env) {
+  return process.env[env] === "1" || process.env[env] === "true";
+}
+function getRuntime() {
+  if (!runtimePromise) {
+    runtimePromise = (async () => {
+      const mod = await import("web-tree-sitter");
+      const init = () => mod.Parser.init({ locateFile: () => RUNTIME_WASM });
+      return { Parser: mod.Parser, Language: mod.Language, init };
+    })();
+  }
+  return runtimePromise;
+}
+async function loadLanguage(lang) {
+  const existing = languageCache.get(lang);
+  if (existing) return existing;
+  const promise = (async () => {
+    const grammarName = resolveGrammarName(lang);
+    if (!grammarName) {
+      throw new Error(`tree-sitter: no grammar registered for lang "${lang}"`);
+    }
+    const wasmPath = path9.join(WASM_DIR, grammarName, `tree-sitter-${grammarName}.wasm`);
+    const { Language, init } = await getRuntime();
+    await init();
+    const languageObj = await Language.load(wasmPath);
+    return { lang, Language: languageObj };
+  })();
+  languageCache.set(lang, promise);
+  return promise;
+}
+function resolveGrammarName(lang) {
+  if (lang === "go" && optInEnabled(GO_OPT_IN)) return "go";
+  if (lang === "py" && optInEnabled(PY_OPT_IN)) return "python";
+  if (lang === "rs" && optInEnabled(RS_OPT_IN)) return "rust";
+  return LANG_TO_GRAMMAR[lang];
+}
+function isTreeSitterSupported(lang) {
+  return resolveGrammarName(lang) !== void 0;
+}
+function getGrammarWasmPath(lang) {
+  const name = resolveGrammarName(lang);
+  if (!name) return void 0;
+  return path9.join(WASM_DIR, name, `tree-sitter-${name}.wasm`);
+}
+async function parseSymbols8(opts) {
+  const { file, content, lang } = opts;
+  if (!isTreeSitterSupported(lang)) {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  try {
+    const { Parser } = await getRuntime();
+    const cached = await loadLanguage(lang);
+    const parser = new Parser();
+    parser.setLanguage(cached.Language);
+    const tree = parser.parse(content);
+    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();
+  }
+}
+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 = path9.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/worker.ts
 import { parentPort } from "node:worker_threads";
 
 // src/codebase-index/indexer.ts
 import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
 import { execFile } from "node:child_process";
-import * as fs8 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import { availableParallelism } from "node:os";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import {
   DEFAULT_WALK_IGNORE_DIRS,
   indexParallelBatchSize,
   isFrugalPerf
 } from "@wrongstack/core/utils";
 
+// src/codebase-index/content-hash.ts
+var PRIME64_1 = 0x9e3779b185ebca87n;
+var PRIME64_2 = 0xc2b2ae3d27d4eb4fn;
+var PRIME64_3 = 0x165667b19e3779f9n;
+var PRIME64_4 = 0x85ebca77c2b2ae63n;
+var PRIME64_5 = 0x27d4eb2f165667c5n;
+var MASK64 = 0xffffffffffffffffn;
+function mul64(a, b) {
+  return (a & MASK64) * (b & MASK64) & MASK64;
+}
+function rotl64(x, n) {
+  const v = x & MASK64;
+  return (v << BigInt(n) | v >> BigInt(64 - n)) & MASK64;
+}
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 7; i >= 0; i--) {
+    v = v << 8n | BigInt(buf[off + i] ?? 0);
+  }
+  return v & MASK64;
+}
+function readU32LE(buf, off) {
+  return (BigInt(buf[off] ?? 0) | BigInt(buf[off + 1] ?? 0) << 8n | BigInt(buf[off + 2] ?? 0) << 16n | BigInt(buf[off + 3] ?? 0) << 24n) & MASK64;
+}
+function xxh64Round(acc, lane) {
+  return mul64(rotl64(acc + mul64(lane, PRIME64_2) & MASK64, 31), PRIME64_1);
+}
+function xxh64MergeRound(acc, val) {
+  return mul64(acc ^ xxh64Round(0n, val), PRIME64_1) + PRIME64_4 & MASK64;
+}
+function xxhash64Hex(buf, explicitLen) {
+  const length = explicitLen ?? buf.length;
+  let h;
+  let off = 0;
+  if (length >= 32) {
+    let v1 = PRIME64_1 + PRIME64_2 & MASK64;
+    let v2 = PRIME64_2;
+    let v3 = 0n;
+    let v4 = 0n - PRIME64_1 & MASK64;
+    const end32 = length - 32;
+    while (off <= end32) {
+      v1 = xxh64Round(v1, readU64LE(buf, off));
+      v2 = xxh64Round(v2, readU64LE(buf, off + 8));
+      v3 = xxh64Round(v3, readU64LE(buf, off + 16));
+      v4 = xxh64Round(v4, readU64LE(buf, off + 24));
+      off += 32;
+    }
+    h = rotl64(v1, 1) + rotl64(v2, 7) + rotl64(v3, 12) + rotl64(v4, 18) & MASK64;
+    h = xxh64MergeRound(h, v1);
+    h = xxh64MergeRound(h, v2);
+    h = xxh64MergeRound(h, v3);
+    h = xxh64MergeRound(h, v4);
+  } else {
+    h = PRIME64_5;
+  }
+  h = h + BigInt(length) & MASK64;
+  while (off + 8 <= length) {
+    const k1 = xxh64Round(0n, readU64LE(buf, off));
+    h = mul64(rotl64(h ^ k1, 27), PRIME64_1) + PRIME64_4 & MASK64;
+    off += 8;
+  }
+  if (off + 4 <= length) {
+    h = mul64(rotl64(h ^ mul64(readU32LE(buf, off), PRIME64_1), 23), PRIME64_2) + PRIME64_3 & MASK64;
+    off += 4;
+  }
+  while (off < length) {
+    h = mul64(rotl64(h ^ mul64(BigInt(buf[off] ?? 0), PRIME64_5), 11), PRIME64_1) & MASK64;
+    off += 1;
+  }
+  h = (h ^ h >> 33n) & MASK64;
+  h = mul64(h, PRIME64_2);
+  h = (h ^ h >> 29n) & MASK64;
+  h = mul64(h, PRIME64_3);
+  h = (h ^ h >> 32n) & MASK64;
+  return h.toString(16).padStart(16, "0");
+}
+function xxhash64String(content) {
+  return xxhash64Hex(new TextEncoder().encode(content));
+}
+
 // src/codebase-index/gitignore.ts
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -2937,32 +3588,56 @@ async function dispatch(file, content, lang) {
     case "tsx":
     case "js":
     case "jsx": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_ts_parser(), ts_parser_exports));
-      return parseSymbols8({ file, content, lang });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_ts_parser(), ts_parser_exports));
+      return parseSymbols9({ file, content, lang });
     }
     case "go": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_go_parser(), go_parser_exports));
-      return parseSymbols8({ file, content, lang: "go" });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_go_parser(), go_parser_exports));
+      return parseSymbols9({ file, content, lang: "go" });
     }
     case "py": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_py_parser(), py_parser_exports));
-      return parseSymbols8({ file, content, lang: "py" });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_py_parser(), py_parser_exports));
+      return parseSymbols9({ file, content, lang: "py" });
     }
     case "rs": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_rs_parser(), rs_parser_exports));
-      return parseSymbols8({ file, content, lang: "rs" });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_rs_parser(), rs_parser_exports));
+      return parseSymbols9({ file, content, lang: "rs" });
     }
     case "json": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_json_parser(), json_parser_exports));
-      return parseSymbols8({ file, content, lang: "json" });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_json_parser(), json_parser_exports));
+      return parseSymbols9({ file, content, lang: "json" });
     }
     case "yaml": {
-      const { parseSymbols: parseSymbols8 } = await Promise.resolve().then(() => (init_yaml_parser(), yaml_parser_exports));
-      return parseSymbols8({ file, content, lang: "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: parseSymbols8 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
-      return parseSymbols8({ file, content, lang });
+      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
+      return parseSymbols9({ file, content, lang });
     }
   }
 }
@@ -2974,10 +3649,185 @@ function withRelations(parsed, content, lang) {
   return { ...parsed, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
 }
 
+// src/codebase-index/parser-worker-pool.ts
+import { Worker } from "node:worker_threads";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import * as fs6 from "node:fs";
+var WORKER_POOL_THRESHOLD = 500;
+var ParserWorkerPool = class {
+  constructor(maxWorkers = defaultWorkerCount()) {
+    this.maxWorkers = maxWorkers;
+  }
+  maxWorkers;
+  workers = [];
+  nextBatchId = 1;
+  pending = /* @__PURE__ */ new Map();
+  creating = false;
+  unavailable = false;
+  /**
+   * True if the pool is available for use. Returns false when:
+   * - Worker threads aren't supported (sandbox, exotic runtime)
+   * - The built worker script can't be found
+   * - Pool creation was attempted and failed
+   */
+  isAvailable() {
+    return !this.unavailable && this.workers.length > 0;
+  }
+  /**
+   * Lazily create the worker pool. Returns true if the pool is ready, false
+   * if it's unavailable (caller should fall back to inline parsing).
+   */
+  async ensureReady() {
+    if (this.isAvailable()) return true;
+    if (this.unavailable) return false;
+    if (this.creating) {
+      await new Promise((r) => setTimeout(r, 50));
+      return this.isAvailable();
+    }
+    this.creating = true;
+    try {
+      const url = resolveWorkerScriptUrl();
+      if (!url) {
+        this.unavailable = true;
+        return false;
+      }
+      for (let i = 0; i < this.maxWorkers; i++) {
+        try {
+          const w = new Worker(url, { name: `wstack-parser-${i}` });
+          w.unref();
+          w.on("message", (msg) => this.handleMessage(msg));
+          w.on("error", (err) => this.handleError(err, w));
+          this.workers.push({ worker: w, busy: false });
+        } catch {
+          if (this.workers.length === 0) {
+            this.unavailable = true;
+            return false;
+          }
+          break;
+        }
+      }
+      return this.workers.length > 0;
+    } finally {
+      this.creating = false;
+    }
+  }
+  /**
+   * Parse files in parallel across the worker pool. Returns a flat
+   * `FileSymbols[]` in completion order (caller sorts if needed).
+   *
+   * 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
+   * distributed round-robin across workers.
+   */
+  async parseFiles(files) {
+    if (!this.isAvailable()) {
+      throw new Error("ParserWorkerPool.parseFiles called before ensureReady() succeeded");
+    }
+    if (files.length === 0) return [];
+    const batchId = this.nextBatchId++;
+    const workerCount = Math.min(this.workers.length, files.length);
+    const chunks = Array.from(
+      { length: workerCount },
+      () => []
+    );
+    for (let i = 0; i < files.length; i++) {
+      chunks[i % workerCount].push(files[i]);
+    }
+    return new Promise((resolve2, reject) => {
+      this.pending.set(batchId, {
+        resolve: resolve2,
+        reject,
+        accumulated: [],
+        expectedWorkers: workerCount,
+        completedWorkers: 0
+      });
+      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]
+        });
+      }
+    });
+  }
+  /** Shut down all workers. Safe to call multiple times. */
+  async shutdown() {
+    const workers = this.workers.map((w) => w.worker);
+    this.workers = [];
+    this.unavailable = false;
+    for (const w of workers) {
+      try {
+        w.postMessage({ type: "shutdown" });
+      } catch {
+      }
+    }
+    await Promise.allSettled(
+      workers.map(
+        (w) => Promise.race([
+          new Promise((resolve2) => {
+            w.once("exit", () => resolve2());
+          }),
+          new Promise((resolve2) => setTimeout(() => resolve2(), 2e3))
+        ]).then(() => {
+          if (!w.threadId) return;
+          return w.terminate().catch(() => {
+          });
+        })
+      )
+    );
+    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;
+    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) {
+      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;
+    }
+  }
+};
+function defaultWorkerCount() {
+  const cores = globalThis.navigator?.hardwareConcurrency ?? 4;
+  return Math.max(1, Math.min(4, cores - 1));
+}
+function resolveWorkerScriptUrl() {
+  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;
+    } catch {
+    }
+  }
+  return null;
+}
+var _pool = null;
+function getParserPool() {
+  _pool ??= new ParserWorkerPool();
+  return _pool;
+}
+
 // src/codebase-index/writer.ts
 import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
-import * as fs7 from "node:fs";
-import * as path10 from "node:path";
+import * as fs8 from "node:fs";
+import * as path11 from "node:path";
 
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
@@ -3251,8 +4101,8 @@ function runSqliteWithRetry(fn) {
 }
 
 // src/codebase-index/writer-admin.ts
-import * as fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as fs7 from "node:fs";
+import * as path10 from "node:path";
 var DB_FILE = "index.db";
 function getAllIndexableWithStatement(stmt) {
   return stmt("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
@@ -3288,7 +4138,7 @@ function getMetadataWithStatement(stmt, key) {
 }
 function getFileMetaWithStatement(stmt, file) {
   const rows = stmt(
-    "SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files WHERE file = ?"
+    "SELECT file, lang, mtime_ms, symbol_count, last_indexed, content_hash FROM files WHERE file = ?"
   ).all(file);
   const r = rows[0];
   if (!r) return null;
@@ -3297,21 +4147,25 @@ function getFileMetaWithStatement(stmt, file) {
     lang: r.lang,
     mtimeMs: r.mtime_ms,
     symbolCount: r.symbol_count,
-    lastIndexed: r.last_indexed
+    lastIndexed: r.last_indexed,
+    contentHash: r.content_hash
   };
 }
 function getAllFileMetasWithStatement(stmt) {
-  return stmt("SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files").all().map((r) => ({
+  return stmt(
+    "SELECT file, lang, mtime_ms, symbol_count, last_indexed, content_hash FROM files"
+  ).all().map((r) => ({
     file: r.file,
     lang: r.lang,
     mtimeMs: r.mtime_ms,
     symbolCount: r.symbol_count,
-    lastIndexed: r.last_indexed
+    lastIndexed: r.last_indexed,
+    contentHash: r.content_hash
   }));
 }
 function getIndexDbSizeBytes(indexDir) {
   try {
-    return fs6.statSync(path9.join(indexDir, DB_FILE)).size;
+    return fs7.statSync(path10.join(indexDir, DB_FILE)).size;
   } catch {
     return 0;
   }
@@ -3360,6 +4214,18 @@ function bulkInsertFtsWithStatement(stmt, maxSqlVars, ftsAvailable, rows) {
     insert.run(...binds);
   }
 }
+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 binds = [];
+    for (const r of chunk) binds.push(r.id, r.vector);
+    insert.run(...binds);
+  }
+}
 function bulkInsertRefsWithStatement(stmt, maxSqlVars, refs) {
   if (refs.length === 0) return;
   const chunkSize = Math.max(1, Math.floor(maxSqlVars / 8));
@@ -3664,6 +4530,171 @@ function findOutgoingCallsByName(stmt, symbolName, file, limit) {
   const calls = rows.map(mapCallSiteRow).slice(0, limit);
   return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
 }
+function runCteWithSeeds(stmt, seedIds, buildSql) {
+  if (seedIds.length <= 900) {
+    const ph = seedIds.map(() => "?").join(",");
+    return stmt(buildSql(ph)).all(...seedIds);
+  }
+  stmt("DROP TABLE IF EXISTS _cte_seeds").run();
+  try {
+    stmt("CREATE TEMP TABLE _cte_seeds (id INTEGER PRIMARY KEY)").run();
+    for (let i = 0; i < seedIds.length; i += 500) {
+      const chunk = seedIds.slice(i, i + 500);
+      const ph = chunk.map(() => "(?)").join(",");
+      stmt(`INSERT OR IGNORE INTO _cte_seeds (id) VALUES ${ph}`).run(...chunk);
+    }
+    return stmt(buildSql("SELECT id FROM _cte_seeds")).all();
+  } finally {
+    stmt("DROP TABLE IF EXISTS _cte_seeds").run();
+  }
+}
+function findTransitiveIncomingCallsByName(stmt, symbolName, file, limit) {
+  const targetIds = resolveSymbolIds(stmt, symbolName, file);
+  if (targetIds.length === 0)
+    return { calls: [], symbolFound: false, ambiguous: false, totalMatches: 0 };
+  let matchIds = targetIds;
+  let ambiguous = false;
+  if (file !== void 0) {
+    const allNamedIds = resolveSymbolIds(stmt, symbolName, void 0);
+    if (allNamedIds.length > targetIds.length) {
+      matchIds = allNamedIds;
+      ambiguous = true;
+    }
+  }
+  const cteSql = (seedSource) => `WITH RECURSIVE incoming_tree(from_id) AS (
+       SELECT r.from_id
+       FROM refs r
+       WHERE r.to_id IN (${seedSource})
+
+       UNION
+
+       SELECT r.from_id
+       FROM refs r
+       JOIN incoming_tree it ON r.to_id = it.from_id
+     )
+     SELECT
+       s.id   AS sym_id,
+       s.name AS sym_name,
+       s.kind AS sym_kind,
+       s.lang AS sym_lang,
+       s.file AS sym_file,
+       s.line AS sym_line,
+       s.signature AS sym_signature,
+       '' AS call_type,
+       0 AS ref_line
+     FROM incoming_tree it
+     JOIN symbols s ON s.id = it.from_id
+     GROUP BY s.id
+     ORDER BY s.file, s.line`;
+  const rows = runCteWithSeeds(stmt, matchIds, cteSql);
+  if (!file) {
+    const fallbackRows = stmt(
+      `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.from_id
+       WHERE r.to_id IS NULL AND r.to_name = ?
+       ORDER BY r.line, r.id`
+    ).all(symbolName);
+    rows.push(...fallbackRows);
+  }
+  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  const allCalls = rows.map(mapCallSiteRow);
+  return {
+    calls: allCalls.slice(0, limit),
+    symbolFound: true,
+    ambiguous,
+    totalMatches: allCalls.length
+  };
+}
+function findTransitiveOutgoingCallsByName(stmt, symbolName, file, limit) {
+  const sourceIds = resolveSymbolIds(stmt, symbolName, file);
+  if (sourceIds.length === 0)
+    return { calls: [], symbolFound: false, unresolvedCount: 0, totalMatches: 0 };
+  const unresolvedCount = chunkedIdScalar(
+    stmt,
+    sourceIds,
+    (ph) => `SELECT COUNT(*) AS n FROM refs WHERE from_id IN (${ph}) AND to_id IS NULL`
+  );
+  const cteSql = (seedSource) => `WITH RECURSIVE outgoing_tree(to_id) AS (
+       SELECT r.to_id
+       FROM refs r
+       WHERE r.from_id IN (${seedSource}) AND r.to_id IS NOT NULL
+
+       UNION
+
+       SELECT r.to_id
+       FROM refs r
+       JOIN outgoing_tree ot ON r.from_id = ot.to_id
+       WHERE r.to_id IS NOT NULL
+     )
+     SELECT
+       s.id   AS sym_id,
+       s.name AS sym_name,
+       s.kind AS sym_kind,
+       s.lang AS sym_lang,
+       s.file AS sym_file,
+       s.line AS sym_line,
+       s.signature AS sym_signature,
+       '' AS call_type,
+       0 AS ref_line
+     FROM outgoing_tree ot
+     JOIN symbols s ON s.id = ot.to_id
+     GROUP BY s.id
+     ORDER BY s.file, s.line`;
+  const rows = runCteWithSeeds(stmt, sourceIds, cteSql);
+  const calls = rows.map(mapCallSiteRow).slice(0, limit);
+  return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
+}
+function findReachableSymbolIds(stmt, seedIds) {
+  if (seedIds.length === 0) return /* @__PURE__ */ new Set();
+  if (seedIds.length > 900) {
+    stmt("DROP TABLE IF EXISTS _seeds").run();
+    try {
+      stmt("CREATE TEMP TABLE _seeds (id INTEGER PRIMARY KEY)").run();
+      for (let i = 0; i < seedIds.length; i += 500) {
+        const chunk = seedIds.slice(i, i + 500);
+        const ph2 = chunk.map(() => "(?)").join(",");
+        stmt(`INSERT OR IGNORE INTO _seeds (id) VALUES ${ph2}`).run(...chunk);
+      }
+      const rows2 = stmt(
+        `WITH RECURSIVE reachable(id) AS (
+           SELECT id FROM _seeds
+           UNION
+           SELECT r.to_id
+           FROM refs r
+           JOIN reachable ON r.from_id = reachable.id
+           WHERE r.to_id IS NOT NULL
+         )
+         SELECT DISTINCT id FROM reachable`
+      ).all();
+      return new Set(rows2.map((r) => r.id));
+    } finally {
+      stmt("DROP TABLE IF EXISTS _seeds").run();
+    }
+  }
+  const ph = seedIds.map(() => "?").join(",");
+  const rows = stmt(
+    `WITH RECURSIVE reachable(id) AS (
+       SELECT id FROM symbols WHERE id IN (${ph})
+       UNION
+       SELECT r.to_id
+       FROM refs r
+       JOIN reachable ON r.from_id = reachable.id
+       WHERE r.to_id IS NOT NULL
+     )
+     SELECT DISTINCT id FROM reachable`
+  ).all(...seedIds);
+  return new Set(rows.map((r) => r.id));
+}
 function findRefsToWithStatement(stmt, symbolId) {
   return stmt(
     "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE to_id = ? OR to_name = (SELECT name FROM symbols WHERE id = ?)"
@@ -3903,6 +4934,12 @@ var CORE_TABLES_SQL = `
     file TEXT PRIMARY KEY,
     lang TEXT NOT NULL,
     mtime_ms INTEGER NOT NULL,
+    -- Phase 2: xxHash64 of the file's UTF-8 bytes. Empty string when the
+    -- indexer hasn't populated it yet (legacy rows, schema repaired by
+    -- repairMissingColumns). Compared on incremental re-index so that a
+    -- touch or branch-switch that leaves content byte-identical skips the
+    -- expensive parse phase entirely (refactoring proposal Phase 2).
+    content_hash TEXT NOT NULL DEFAULT '',
     symbol_count INTEGER NOT NULL DEFAULT 0,
     last_indexed INTEGER NOT NULL,
     -- Code Atlas grouping label, computed at index time from the ecosystem's
@@ -3970,7 +5007,14 @@ var LANG_FAMILY_TABLE_SQL = `
   );
 `;
 var LANG_FAMILY_WILDCARD = "*";
-var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
+var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'trigram')";
+var SYMBOL_VECTORS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS symbol_vectors (
+    symbol_id INTEGER PRIMARY KEY,
+    vector BLOB NOT NULL,
+    FOREIGN KEY (symbol_id) REFERENCES symbols(id) ON DELETE CASCADE
+  );
+`;
 
 // src/codebase-index/writer-search-helpers.ts
 var SEARCH_CANDIDATE_SCAN_CAP = 5e3;
@@ -4111,6 +5155,85 @@ var StorePool = class {
   }
 };
 
+// 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.ts
 var DB_FILE2 = "index.db";
 var MAX_STATEMENT_CACHE = 128;
@@ -4123,6 +5246,12 @@ var IndexStore = class _IndexStore {
    * When false, ranked search falls back to the LIKE + in-process BM25 path.
    */
   ftsAvailable = false;
+  /**
+   * Phase 3: true when the `symbol_vectors` table was created successfully.
+   * When false, hybrid search skips the vector pass and falls back to FTS5
+   * (or LIKE) only.
+   */
+  vectorsAvailable = false;
   /**
    * Cache of prepared statements keyed by their SQL text. `DatabaseSync`
    * compiles SQL on every `.prepare()` call; for the fixed-SQL methods
@@ -4181,9 +5310,9 @@ var IndexStore = class _IndexStore {
   }
   constructor(projectRoot, opts = {}) {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
-    fs7.mkdirSync(this.indexDir, { recursive: true });
+    fs8.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
-    this.db = new Database(path10.join(this.indexDir, DB_FILE2));
+    this.db = new Database(path11.join(this.indexDir, DB_FILE2));
     applyIndexStorePragmas(this.db);
     this.initSchema();
   }
@@ -4221,7 +5350,13 @@ var IndexStore = class _IndexStore {
    */
   repairMissingColumns() {
     const expected = [
-      { table: "files", columns: [["package", "TEXT NOT NULL DEFAULT ''"]] },
+      {
+        table: "files",
+        columns: [
+          ["package", "TEXT NOT NULL DEFAULT ''"],
+          ["content_hash", "TEXT NOT NULL DEFAULT ''"]
+        ]
+      },
       {
         table: "refs",
         columns: [
@@ -4253,6 +5388,7 @@ var IndexStore = class _IndexStore {
         DROP TABLE IF EXISTS symbols;
         DROP TABLE IF EXISTS files;
         DROP TABLE IF EXISTS refs;
+        DROP TABLE IF EXISTS symbol_vectors;
       `);
       this.db.exec("DROP TABLE IF EXISTS symbols_fts");
       this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(
@@ -4274,6 +5410,12 @@ var IndexStore = class _IndexStore {
     this.db.exec(LANG_FAMILY_TABLE_SQL);
     this.seedLangFamilies();
     try {
+      const ftsSchema = this.stmt(
+        "SELECT sql FROM sqlite_master WHERE type='table' AND name='symbols_fts'"
+      ).get();
+      if (ftsSchema?.sql?.includes("unicode61")) {
+        this.db.exec("DROP TABLE IF EXISTS symbols_fts");
+      }
       this.db.exec(SYMBOLS_FTS_SQL);
       this.ftsAvailable = true;
       const symbolCount = Number(
@@ -4284,6 +5426,7 @@ var IndexStore = class _IndexStore {
       );
       if (symbolCount !== ftsCount) {
         this.db.exec("DELETE FROM symbols_fts");
+        if (this.vectorsAvailable) this.db.exec("DELETE FROM symbol_vectors");
         const rows = this.stmt(
           "SELECT id, name, signature, doc_comment FROM symbols ORDER BY id"
         ).all();
@@ -4301,6 +5444,12 @@ var IndexStore = class _IndexStore {
     } catch {
       this.ftsAvailable = false;
     }
+    try {
+      this.db.exec(SYMBOL_VECTORS_TABLE_SQL);
+      this.vectorsAvailable = true;
+    } catch {
+      this.vectorsAvailable = false;
+    }
     this.ensureNextSymbolIdSeeded();
   }
   // ─── ID allocation & bulk helpers ────────────────────────────────────────────
@@ -4410,6 +5559,7 @@ var IndexStore = class _IndexStore {
         const result = [];
         const bulk = [];
         const ftsRows = [];
+        const vectorRows = [];
         for (const s of symbols) {
           const id = nextId++;
           bulk.push({
@@ -4428,6 +5578,10 @@ var IndexStore = class _IndexStore {
           if (this.ftsAvailable) {
             ftsRows.push({ id, text: buildIndexableText(s.name, s.signature, s.docComment) });
           }
+          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);
@@ -4437,6 +5591,13 @@ var IndexStore = class _IndexStore {
           this.ftsAvailable,
           ftsRows
         );
+        if (this.vectorsAvailable) {
+          bulkInsertVectorsWithStatement(
+            (sql) => this.stmt(sql),
+            _IndexStore.MAX_SQL_VARS,
+            vectorRows
+          );
+        }
         this.db.exec("COMMIT");
         return result;
       } catch (err) {
@@ -4456,6 +5617,11 @@ var IndexStore = class _IndexStore {
             "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
           ).run(file);
         }
+        if (this.vectorsAvailable) {
+          this.stmt(
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+          ).run(file);
+        }
         this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(file);
         this.resolveRefsForNamesUnsafe(affectedNames);
         this.db.exec("COMMIT");
@@ -4481,6 +5647,11 @@ var IndexStore = class _IndexStore {
             "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
           ).run(file);
         }
+        if (this.vectorsAvailable) {
+          this.stmt(
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+          ).run(file);
+        }
         this.stmt(
           "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
         ).run(file);
@@ -4498,14 +5669,22 @@ var IndexStore = class _IndexStore {
   upsertFile(meta) {
     this.runWithRetry(() => {
       this.stmt(
-        `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
-         VALUES (?, ?, ?, ?, ?)
+        `INSERT INTO files(file, lang, mtime_ms, content_hash, symbol_count, last_indexed)
+         VALUES (?, ?, ?, ?, ?, ?)
          ON CONFLICT(file) DO UPDATE SET
            lang = excluded.lang,
            mtime_ms = excluded.mtime_ms,
+           content_hash = excluded.content_hash,
            symbol_count = excluded.symbol_count,
            last_indexed = excluded.last_indexed`
-      ).run(meta.file, meta.lang, meta.mtimeMs, meta.symbolCount, meta.lastIndexed);
+      ).run(
+        meta.file,
+        meta.lang,
+        meta.mtimeMs,
+        meta.contentHash ?? "",
+        meta.symbolCount,
+        meta.lastIndexed
+      );
     });
   }
   getFileMeta(file) {
@@ -4672,9 +5851,18 @@ var IndexStore = class _IndexStore {
       if (mapped === null) return { results: [], total: 0 };
       effectiveKind = mapped;
     }
-    const match = tokens.map((t) => `"${t.replaceAll('"', "")}"*`).join(" OR ");
+    const longTokens = tokens.filter((t) => t.length >= 3);
+    const shortTokens = tokens.filter((t) => t.length < 3);
+    if (longTokens.length === 0) {
+      return this.searchRankedFallback(query, filter, safeLimit);
+    }
+    const match = longTokens.map((t) => `"${t.replaceAll('"', "")}"`).join(" OR ");
     const conditions = ["symbols_fts MATCH ?"];
     const values = [match];
+    for (const shortTok of shortTokens) {
+      conditions.push("s.text LIKE ? ESCAPE '\\'");
+      values.push(`%${escapeLike(shortTok)}%`);
+    }
     if (effectiveKind) {
       conditions.push("s.kind = ?");
       values.push(effectiveKind);
@@ -4693,7 +5881,7 @@ var IndexStore = class _IndexStore {
     ).all(...values);
     const total = countRows[0] ? Number(countRows[0].n) : 0;
     if (total === 0) return { results: [], total: 0 };
-    const rows = this.stmt(
+    const bm25Rows = this.stmt(
       `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
@@ -4706,8 +5894,39 @@ var IndexStore = class _IndexStore {
            bm25(symbols_fts), lower(s.name), s.file, s.line, s.col, s.id
          LIMIT ?`
     ).all(...values, query.trim(), `${escapeLike(query.trim())}%`, safeLimit);
+    if (this.vectorsAvailable && bm25Rows.length > 0) {
+      const queryVec = embedText(query);
+      const candidateIds = bm25Rows.map((r) => r.id);
+      const placeholders = candidateIds.map(() => "?").join(",");
+      const vecRows = this.stmt(
+        `SELECT sv.symbol_id, sv.vector FROM symbol_vectors sv WHERE sv.symbol_id IN (${placeholders})`
+      ).all(...candidateIds);
+      const vecScores = vecRows.map((r) => ({
+        id: r.symbol_id,
+        sim: cosineSimilarity(queryVec, decodeVector(r.vector))
+      })).sort((a, b) => b.sim - a.sim);
+      const bm25Rank = /* @__PURE__ */ new Map();
+      bm25Rows.forEach((r, i) => {
+        bm25Rank.set(r.id, i);
+      });
+      const vecRank = /* @__PURE__ */ new Map();
+      vecScores.forEach((r, i) => {
+        vecRank.set(r.id, i);
+      });
+      const fused = reciprocalRankFusion(bm25Rank, vecRank, 60);
+      const fusedScore = new Map(fused);
+      const sorted = [...bm25Rows].sort(
+        (a, b) => (fusedScore.get(b.id) ?? 0) - (fusedScore.get(a.id) ?? 0)
+      );
+      return {
+        results: sorted.map(
+          (row) => mapWriterSearchRow(row, filter?.lspKind, Math.max(1e-4, row.score), row.snippet)
+        ),
+        total
+      };
+    }
     return {
-      results: rows.map(
+      results: bm25Rows.map(
         (row) => mapWriterSearchRow(row, filter?.lspKind, Math.max(1e-4, row.score), row.snippet)
       ),
       total
@@ -4835,6 +6054,7 @@ var IndexStore = class _IndexStore {
         this.db.exec("DROP TABLE IF EXISTS files");
         this.db.exec("DROP TABLE IF EXISTS metadata");
         if (this.ftsAvailable) this.db.exec("DROP TABLE IF EXISTS symbols_fts");
+        this.db.exec("DROP TABLE IF EXISTS symbol_vectors");
         this.db.exec("COMMIT");
         this.stmtCache.clear();
         this.initSchema();
@@ -4922,6 +6142,11 @@ var IndexStore = class _IndexStore {
               `DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
             ).run(...options.deleteForFiles);
           }
+          if (this.vectorsAvailable) {
+            this.stmt(
+              `DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
+            ).run(...options.deleteForFiles);
+          }
           this.stmt(
             `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
           ).run(...options.deleteForFiles);
@@ -4935,6 +6160,7 @@ var IndexStore = class _IndexStore {
         const refsToInsert = [];
         const bulkSyms = [];
         const ftsRows = [];
+        const vectorRows = [];
         for (const entry of entries) {
           const insertedForEntry = [];
           for (const s of entry.symbols) {
@@ -4958,6 +6184,10 @@ var IndexStore = class _IndexStore {
                 text: buildIndexableText(s.name, s.signature, s.docComment)
               });
             }
+            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);
@@ -4971,19 +6201,34 @@ var IndexStore = class _IndexStore {
           this.ftsAvailable,
           ftsRows
         );
+        if (this.vectorsAvailable) {
+          bulkInsertVectorsWithStatement(
+            (sql) => this.stmt(sql),
+            _IndexStore.MAX_SQL_VARS,
+            vectorRows
+          );
+        }
         bulkInsertRefsWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, refsToInsert);
         const upsertStmt = this.stmt(
-          `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
-           VALUES (?, ?, ?, ?, ?)
+          `INSERT INTO files(file, lang, mtime_ms, content_hash, symbol_count, last_indexed)
+           VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(file) DO UPDATE SET
              lang = excluded.lang,
              mtime_ms = excluded.mtime_ms,
+             content_hash = excluded.content_hash,
              symbol_count = excluded.symbol_count,
              last_indexed = excluded.last_indexed`
         );
         const now = Date.now();
         for (const entry of entries) {
-          upsertStmt.run(entry.file, entry.lang, entry.mtimeMs, entry.symbolCount, now);
+          upsertStmt.run(
+            entry.file,
+            entry.lang,
+            entry.mtimeMs,
+            entry.contentHash ?? "",
+            entry.symbolCount,
+            now
+          );
         }
         this.resolveRefsForNamesUnsafe(affectedNames);
         this.db.exec("COMMIT");
@@ -5074,19 +6319,32 @@ var IndexStore = class _IndexStore {
             "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
           ).run(meta.file);
         }
+        if (this.vectorsAvailable) {
+          this.stmt(
+            "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+          ).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(
-          `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
-           VALUES (?, ?, ?, ?, ?)
+          `INSERT INTO files(file, lang, mtime_ms, content_hash, symbol_count, last_indexed)
+           VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(file) DO UPDATE SET
              lang = excluded.lang,
              mtime_ms = excluded.mtime_ms,
+             content_hash = excluded.content_hash,
              symbol_count = excluded.symbol_count,
              last_indexed = excluded.last_indexed`
-        ).run(meta.file, meta.lang, meta.mtimeMs, meta.symbolCount, meta.lastIndexed);
+        ).run(
+          meta.file,
+          meta.lang,
+          meta.mtimeMs,
+          meta.contentHash ?? "",
+          meta.symbolCount,
+          meta.lastIndexed
+        );
         this.resolveRefsForNamesUnsafe(affectedNames);
         this.db.exec("COMMIT");
       } catch (err) {
@@ -5149,6 +6407,31 @@ var IndexStore = class _IndexStore {
   findOutgoingCallsByName(symbolName, file, limit = 100) {
     return findOutgoingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
   }
+  /**
+   * Transitive incoming-call tree: all symbols that transitively call the
+   * target, to an unbounded depth (cycle-safe via SQL UNION deduplication).
+   * Used by `codebase-incoming-calls` when the caller wants the full call
+   * chain rather than just direct callers.
+   */
+  findTransitiveIncomingCallsByName(symbolName, file, limit = 200) {
+    return findTransitiveIncomingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
+  /**
+   * Transitive outgoing-call tree: all symbols the target transitively calls.
+   * Used by `codebase-outgoing-calls` when the caller wants the full
+   * dependency chain rather than just direct callees.
+   */
+  findTransitiveOutgoingCallsByName(symbolName, file, limit = 200) {
+    return findTransitiveOutgoingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
+  /**
+   * Compute the set of symbol IDs reachable from the given seed IDs using a
+   * native SQLite recursive CTE. Used by dead-code detection to replace the
+   * in-memory BFS.
+   */
+  findReachableSymbolIds(seedIds) {
+    return findReachableSymbolIds((sql) => this.stmt(sql), seedIds);
+  }
   /**
    * Find all references TO a given symbol (who calls / uses this symbol?).
    */
@@ -5239,6 +6522,9 @@ var YIELD_EVERY_N = 50;
 function resolveParallelBatch() {
   return indexParallelBatchSize(availableParallelism());
 }
+function shouldUseParserWorkerPool(candidateFileCount, parseBatchCount) {
+  return !isFrugalPerf() && candidateFileCount >= WORKER_POOL_THRESHOLD && parseBatchCount > 1;
+}
 function yieldEventLoop() {
   return new Promise((resolve2) => setImmediate(resolve2));
 }
@@ -5256,15 +6542,15 @@ var INDEXABLE_EXTENSION_SET = new Set(INDEXABLE_EXTENSIONS);
 var MAX_INDEX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_GIT_FILE_LIST_BYTES = 64 * 1024 * 1024;
 function isWithinProject(projectRoot, file) {
-  const rel = path11.relative(projectRoot, file);
-  return rel !== "" && !rel.startsWith(`..${path11.sep}`) && rel !== ".." && !path11.isAbsolute(rel);
+  const rel = path12.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path12.sep}`) && rel !== ".." && !path12.isAbsolute(rel);
 }
 function isMissingPathError(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
 function normalizeComparablePath(value) {
-  const resolved = path11.resolve(value);
+  const resolved = path12.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
@@ -5309,24 +6595,24 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
       const record = statusRecords[i];
       if (!record) continue;
       const status = record.slice(0, 2);
-      const changedPath = path11.resolve(projectRoot, record.slice(3));
+      const changedPath = path12.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(path11.resolve(projectRoot, source));
+        if (source) dirty.add(path12.resolve(projectRoot, source));
       }
     }
     const files = [];
     for (const relative2 of output.toString("utf8").split("\0")) {
       if (!relative2) continue;
       const portable = relative2.replace(/\\/g, "/");
-      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path11.posix.basename(portable))) {
+      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path12.posix.basename(portable))) {
         continue;
       }
-      const full = path11.resolve(projectRoot, relative2);
+      const full = path12.resolve(projectRoot, relative2);
       if (deleted.has(full)) continue;
-      const ext = path11.extname(relative2).toLowerCase();
+      const ext = path12.extname(relative2).toLowerCase();
       if (INDEXABLE_EXTENSION_SET.has(ext) || detectLang(full) !== null) files.push(full);
     }
     return {
@@ -5361,7 +6647,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs9.readdir(dir, { withFileTypes: true });
     } catch (err) {
       complete = false;
       errors.push(`scan error: ${dir}: ${err instanceof Error ? err.message : String(err)}`);
@@ -5370,14 +6656,14 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path11.join(dir, e.name);
-      const rel = path11.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path12.join(dir, e.name);
+      const rel = path12.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 = path11.extname(e.name).toLowerCase();
+        const ext = path12.extname(e.name).toLowerCase();
         if (indexableExts.has(ext) || detectLang(full) !== null) {
           results.push(full);
         }
@@ -5415,11 +6701,7 @@ async function resolveProjectRelations(store, projectRoot, opts) {
     const structure = await detectModuleRoots(projectRoot, indexedFiles);
     if (opts.signal?.aborted) return;
     store.setFilePackages(assignPackageLabels(structure, indexedFiles));
-    const resolver = new ModuleResolver(
-      structure,
-      indexedFiles,
-      store.getNamespaceDeclarations()
-    );
+    const resolver = new ModuleResolver(structure, indexedFiles, store.getNamespaceDeclarations());
     const pending = store.getUnresolvedImports(opts.onlyFiles);
     const resolutions = [];
     for (const entry of pending) {
@@ -5444,6 +6726,10 @@ async function runIndexerWithStore(store, opts) {
   const errors = [];
   const langStats = {};
   let filesIndexed = 0;
+  let filesParsed = 0;
+  let filesSkipped = 0;
+  let filesEmpty = 0;
+  let filesFailed = 0;
   let symbolsIndexed = 0;
   const isGitIgnored = await loadGitignoreMatcher(projectRoot);
   let files;
@@ -5451,10 +6737,10 @@ async function runIndexerWithStore(store, opts) {
   let discoveryComplete = true;
   let trustedUnchanged;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path11.resolve(projectRoot, f)).filter((f) => {
+    files = opts.files.map((f) => path12.resolve(projectRoot, f)).filter((f) => {
       if (!isWithinProject(projectRoot, f)) return false;
-      const rel = path11.relative(projectRoot, f).replace(/\\/g, "/");
-      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path11.basename(f)) && !isGitIgnored(rel, false);
+      const rel = path12.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path12.basename(f)) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -5485,12 +6771,14 @@ async function runIndexerWithStore(store, opts) {
       langStats[meta.lang] = (langStats[meta.lang] ?? 0) + meta.symbolCount;
       symbolsIndexed += meta.symbolCount;
       filesIndexed++;
+      filesSkipped++;
       filesPreSkipped++;
       return false;
     });
     if (filesPreSkipped > 0) opts.onProgress?.(filesPreSkipped, totalFilesForProgress);
   }
   const parallelBatch = resolveParallelBatch();
+  const parserPoolCandidateCount = files.length;
   let filesSinceLastYield = 0;
   for (let batchStart = 0; batchStart < files.length; batchStart += parallelBatch) {
     const batchEnd = Math.min(batchStart + parallelBatch, files.length);
@@ -5511,7 +6799,7 @@ async function runIndexerWithStore(store, opts) {
         async (file) => {
           let stat2;
           try {
-            stat2 = await fs8.stat(file, statOpts);
+            stat2 = await fs9.stat(file, statOpts);
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -5541,7 +6829,7 @@ async function runIndexerWithStore(store, opts) {
           }
           let content;
           try {
-            content = await fs8.readFile(file, { encoding: "utf8", signal });
+            content = await fs9.readFile(file, { encoding: "utf8", signal });
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -5552,22 +6840,78 @@ async function runIndexerWithStore(store, opts) {
               error: `read error: ${e instanceof Error ? e.message : String(e)}`
             };
           }
-          let parsed;
-          try {
-            parsed = await parseFileContent(file, content, lang);
-          } catch (e) {
+          const contentHash = xxhash64String(content);
+          if (!force && meta && meta.contentHash && contentHash === meta.contentHash) {
             return {
               file,
               stat: stat2,
               lang,
               parsed: null,
-              error: `parse error: ${e instanceof Error ? e.message : String(e)}`
+              content,
+              contentHash,
+              skippedMeta: { ...meta, mtimeMs: Math.floor(stat2.mtimeMs) }
             };
           }
-          return { file, stat: stat2, lang, parsed, content };
+          return { file, stat: stat2, lang, parsed: null, content, contentHash };
         }
       )
     );
+    const toParse = [];
+    for (let pi = 0; pi < statReadParse.length; pi++) {
+      const s = statReadParse[pi];
+      if (s.status !== "fulfilled") continue;
+      const r = s.value;
+      if (r.error || r.skippedMeta || !r.lang || r.parsed) continue;
+      if (r.content === void 0) continue;
+      toParse.push({
+        index: pi,
+        file: batchFiles[pi],
+        content: r.content,
+        lang: r.lang
+      });
+    }
+    if (toParse.length > 0) {
+      let pool = shouldUseParserWorkerPool(parserPoolCandidateCount, toParse.length) ? getParserPool() : null;
+      if (pool) {
+        try {
+          await pool.ensureReady();
+          const parsedResults = await pool.parseFiles(
+            toParse.map((p) => ({ file: p.file, content: p.content, lang: p.lang }))
+          );
+          const byFile = new Map(parsedResults.map((r) => [r.file, r]));
+          for (const item of toParse) {
+            const parsed = byFile.get(item.file);
+            const settled = statReadParse[item.index];
+            if (settled.status !== "fulfilled") continue;
+            if (parsed) {
+              settled.value.parsed = parsed;
+            } else {
+              settled.value.error = `parse error: worker returned no result for ${item.file}`;
+            }
+          }
+        } catch {
+          pool = null;
+        }
+      }
+      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 batchEntries = [];
     const deleteForFiles = [];
     for (let fi = 0; fi < statReadParse.length; fi++) {
@@ -5577,12 +6921,14 @@ async function runIndexerWithStore(store, opts) {
         const err = settled.reason;
         if (err instanceof Error && isAbortError(err)) throw err;
         errors.push(`batch error: ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        filesFailed++;
         continue;
       }
       const result = settled.value;
       if (result.error) {
         if (result.missing) store.deleteFile(file);
         errors.push(`${file}: ${result.error}`);
+        filesFailed++;
         continue;
       }
       const { stat: stat2, lang, parsed } = result;
@@ -5590,6 +6936,18 @@ async function runIndexerWithStore(store, opts) {
         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) {
+          store.upsertFile({
+            file,
+            lang,
+            mtimeMs: result.skippedMeta.mtimeMs,
+            symbolCount: result.skippedMeta.symbolCount,
+            lastIndexed: Date.now(),
+            contentHash: result.skippedMeta.contentHash
+          });
+        }
         continue;
       }
       if (!lang || !parsed) {
@@ -5599,9 +6957,11 @@ async function runIndexerWithStore(store, opts) {
             lang,
             mtimeMs: Math.floor(stat2.mtimeMs),
             symbolCount: 0,
-            lastIndexed: Date.now()
+            lastIndexed: Date.now(),
+            contentHash: result.contentHash ?? ""
           });
           filesIndexed++;
+          filesEmpty++;
         }
         continue;
       }
@@ -5611,9 +6971,11 @@ async function runIndexerWithStore(store, opts) {
           lang,
           mtimeMs: Math.floor(stat2.mtimeMs),
           symbolCount: 0,
-          lastIndexed: Date.now()
+          lastIndexed: Date.now(),
+          contentHash: result.contentHash ?? ""
         });
         filesIndexed++;
+        filesEmpty++;
         continue;
       }
       batchEntries.push({
@@ -5622,7 +6984,8 @@ async function runIndexerWithStore(store, opts) {
         symbols: parsed.symbols,
         refs: parsed.refs ?? [],
         mtimeMs: Math.floor(stat2.mtimeMs),
-        symbolCount: parsed.symbols.length
+        symbolCount: parsed.symbols.length,
+        contentHash: result.contentHash ?? ""
       });
       deleteForFiles.push(file);
     }
@@ -5634,6 +6997,7 @@ async function runIndexerWithStore(store, opts) {
           symbolsIndexed += count;
           langStats[entry.lang] = (langStats[entry.lang] ?? 0) + count;
           filesIndexed++;
+          filesParsed++;
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -5646,6 +7010,7 @@ async function runIndexerWithStore(store, opts) {
             symbolsIndexed += symbolsWithIds.length;
             langStats[entry.lang] = (langStats[entry.lang] ?? 0) + symbolsWithIds.length;
             filesIndexed++;
+            filesParsed++;
             if (entry.refs.length > 0 && symbolsWithIds.length > 0) {
               const fallbackBatch = assignRefsToSymbols2(entry.refs, symbolsWithIds);
               if (fallbackBatch.length > 0) store.insertRefsBatch(fallbackBatch);
@@ -5659,9 +7024,11 @@ async function runIndexerWithStore(store, opts) {
               lang: entry.lang,
               mtimeMs: entry.mtimeMs,
               symbolCount: entry.symbolCount,
-              lastIndexed: Date.now()
+              lastIndexed: Date.now(),
+              contentHash: entry.contentHash
             });
           } catch (innerErr) {
+            filesFailed++;
             errors.push(
               `fallback write failed: ${entry.file}: ${innerErr instanceof Error ? innerErr.message : String(innerErr)}`
             );
@@ -5694,6 +7061,12 @@ async function runIndexerWithStore(store, opts) {
   const durationMs = Date.now() - startMs;
   return {
     filesIndexed,
+    fileOutcomes: {
+      parsed: filesParsed,
+      skipped: filesSkipped,
+      empty: filesEmpty,
+      failed: filesFailed
+    },
     symbolsIndexed,
     langStats,
     durationMs,
@@ -5771,6 +7144,9 @@ function symbolGraphService(args) {
 function incomingCallsService(args) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
+    if (args.transitive) {
+      return store.findTransitiveIncomingCallsByName(args.symbol, args.file, args.limit ?? 100);
+    }
     return store.findIncomingCallsByName(args.symbol, args.file, args.limit ?? 100);
   } finally {
     indexStorePool.release(store);
@@ -5779,6 +7155,9 @@ function incomingCallsService(args) {
 function outgoingCallsService(args) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
+    if (args.transitive) {
+      return store.findTransitiveOutgoingCallsByName(args.symbol, args.file, args.limit ?? 100);
+    }
     return store.findOutgoingCallsByName(args.symbol, args.file, args.limit ?? 100);
   } finally {
     indexStorePool.release(store);