@wrongstack/tools 0.302.0 → 0.303.0

package/dist/read.js

@@ -2127,8 +2127,579 @@ 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 path10 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 = path10.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 path10.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 = path10.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/read.ts
-import * as fs12 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 import { FsError, ToolValidationError } from "@wrongstack/core/types";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 
@@ -2203,9 +2774,9 @@ function isBinaryBuffer(buf) {
 }
 
 // src/codebase-index/background-indexer.ts
-import * as fs11 from "node:fs";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { Worker } from "node:worker_threads";
+import * as fs12 from "node:fs";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { Worker as Worker2 } from "node:worker_threads";
 
 // src/codebase-index/circuit-breaker.ts
 var IndexTimeoutError = class extends Error {
@@ -2287,9 +2858,9 @@ var indexCircuitBreaker = new IndexCircuitBreaker();
 // 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 path12 from "node:path";
+import * as path13 from "node:path";
 import {
   DEFAULT_WALK_IGNORE_DIRS,
   indexParallelBatchSize,
@@ -3091,32 +3662,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 });
     }
   }
 }
@@ -3128,10 +3723,265 @@ 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((resolve4, reject) => {
+      this.pending.set(batchId, {
+        resolve: resolve4,
+        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((resolve4) => {
+            w.once("exit", () => resolve4());
+          }),
+          new Promise((resolve4) => setTimeout(() => resolve4(), 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/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/writer.ts
 import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
-import * as fs7 from "node:fs";
-import * as path11 from "node:path";
+import * as fs8 from "node:fs";
+import * as path12 from "node:path";
 
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
@@ -3329,8 +4179,8 @@ function runSqliteWithRetry(fn) {
 }
 
 // src/codebase-index/writer-admin.ts
-import * as fs6 from "node:fs";
-import * as path10 from "node:path";
+import * as fs7 from "node:fs";
+import * as path11 from "node:path";
 var DB_FILE = "index.db";
 function getAllIndexableWithStatement(stmt) {
   return stmt("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
@@ -3366,7 +4216,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;
@@ -3375,21 +4225,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(path10.join(indexDir, DB_FILE)).size;
+    return fs7.statSync(path11.join(indexDir, DB_FILE)).size;
   } catch {
     return 0;
   }
@@ -3438,6 +4292,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));
@@ -3742,6 +4608,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 = ?)"
@@ -3985,6 +5016,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
@@ -4052,7 +5089,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;
@@ -4193,6 +5237,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;
@@ -4205,6 +5328,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
@@ -4263,9 +5392,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(path11.join(this.indexDir, DB_FILE2));
+    this.db = new Database(path12.join(this.indexDir, DB_FILE2));
     applyIndexStorePragmas(this.db);
     this.initSchema();
   }
@@ -4303,7 +5432,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: [
@@ -4335,6 +5470,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(
@@ -4356,6 +5492,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 && 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(
@@ -4366,6 +5508,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();
@@ -4383,6 +5526,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 ────────────────────────────────────────────
@@ -4492,6 +5641,7 @@ var IndexStore = class _IndexStore {
         const result = [];
         const bulk = [];
         const ftsRows = [];
+        const vectorRows = [];
         for (const s of symbols) {
           const id = nextId++;
           bulk.push({
@@ -4510,6 +5660,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);
@@ -4519,6 +5673,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) {
@@ -4538,6 +5699,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");
@@ -4563,6 +5729,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);
@@ -4580,14 +5751,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) {
@@ -4754,9 +5933,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);
@@ -4775,7 +5963,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
@@ -4788,8 +5976,35 @@ 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
@@ -4917,6 +6132,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();
@@ -5004,6 +6220,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);
@@ -5017,6 +6238,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) {
@@ -5040,6 +6262,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);
@@ -5053,19 +6279,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");
@@ -5156,19 +6397,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) {
@@ -5231,6 +6485,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?).
    */
@@ -5338,15 +6617,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 = path12.relative(projectRoot, file);
-  return rel !== "" && !rel.startsWith(`..${path12.sep}`) && rel !== ".." && !path12.isAbsolute(rel);
+  const rel = path13.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path13.sep}`) && rel !== ".." && !path13.isAbsolute(rel);
 }
 function isMissingPathError(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
 function normalizeComparablePath(value) {
-  const resolved = path12.resolve(value);
+  const resolved = path13.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
@@ -5391,24 +6670,24 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
       const record = statusRecords[i];
       if (!record) continue;
       const status = record.slice(0, 2);
-      const changedPath = path12.resolve(projectRoot, record.slice(3));
+      const changedPath = path13.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(path12.resolve(projectRoot, source));
+        if (source) dirty.add(path13.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(path12.posix.basename(portable))) {
+      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path13.posix.basename(portable))) {
         continue;
       }
-      const full = path12.resolve(projectRoot, relative3);
+      const full = path13.resolve(projectRoot, relative3);
       if (deleted.has(full)) continue;
-      const ext = path12.extname(relative3).toLowerCase();
+      const ext = path13.extname(relative3).toLowerCase();
       if (INDEXABLE_EXTENSION_SET.has(ext) || detectLang(full) !== null) files.push(full);
     }
     return {
@@ -5443,7 +6722,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)}`);
@@ -5452,14 +6731,14 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path12.join(dir, e.name);
-      const rel = path12.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path13.join(dir, e.name);
+      const rel = path13.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 = path12.extname(e.name).toLowerCase();
+        const ext = path13.extname(e.name).toLowerCase();
         if (indexableExts.has(ext) || detectLang(full) !== null) {
           results.push(full);
         }
@@ -5533,10 +6812,10 @@ async function runIndexerWithStore(store, opts) {
   let discoveryComplete = true;
   let trustedUnchanged;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path12.resolve(projectRoot, f)).filter((f) => {
+    files = opts.files.map((f) => path13.resolve(projectRoot, f)).filter((f) => {
       if (!isWithinProject(projectRoot, f)) return 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);
+      const rel = path13.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path13.basename(f)) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -5593,7 +6872,7 @@ async function runIndexerWithStore(store, opts) {
         async (file) => {
           let stat3;
           try {
-            stat3 = await fs8.stat(file, statOpts);
+            stat3 = await fs9.stat(file, statOpts);
           } catch (e) {
             if (isAbortError(e)) throw e;
             return {
@@ -5623,7 +6902,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 {
@@ -5634,22 +6913,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: stat3,
               lang,
               parsed: null,
-              error: `parse error: ${e instanceof Error ? e.message : String(e)}`
+              content,
+              contentHash,
+              skippedMeta: { ...meta, mtimeMs: Math.floor(stat3.mtimeMs) }
             };
           }
-          return { file, stat: stat3, lang, parsed, content };
+          return { file, stat: stat3, 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 = toParse.length >= WORKER_POOL_THRESHOLD ? 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++) {
@@ -5672,6 +7007,17 @@ async function runIndexerWithStore(store, opts) {
         langStats[lang] = (langStats[lang] ?? 0) + result.skippedMeta.symbolCount;
         symbolsIndexed += result.skippedMeta.symbolCount;
         filesIndexed++;
+        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) {
@@ -5681,7 +7027,8 @@ async function runIndexerWithStore(store, opts) {
             lang,
             mtimeMs: Math.floor(stat3.mtimeMs),
             symbolCount: 0,
-            lastIndexed: Date.now()
+            lastIndexed: Date.now(),
+            contentHash: result.contentHash ?? ""
           });
           filesIndexed++;
         }
@@ -5693,7 +7040,8 @@ async function runIndexerWithStore(store, opts) {
           lang,
           mtimeMs: Math.floor(stat3.mtimeMs),
           symbolCount: 0,
-          lastIndexed: Date.now()
+          lastIndexed: Date.now(),
+          contentHash: result.contentHash ?? ""
         });
         filesIndexed++;
         continue;
@@ -5704,7 +7052,8 @@ async function runIndexerWithStore(store, opts) {
         symbols: parsed.symbols,
         refs: parsed.refs ?? [],
         mtimeMs: Math.floor(stat3.mtimeMs),
-        symbolCount: parsed.symbols.length
+        symbolCount: parsed.symbols.length,
+        contentHash: result.contentHash ?? ""
       });
       deleteForFiles.push(file);
     }
@@ -5741,7 +7090,8 @@ 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) {
             errors.push(
@@ -5853,6 +7203,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);
@@ -5861,6 +7214,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);
@@ -5869,17 +7225,35 @@ function outgoingCallsService(args) {
 
 // src/codebase-index/project-server-client.ts
 import { spawn as spawn3 } from "node:child_process";
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as net from "node:net";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { StringDecoder } from "node:string_decoder";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { checkUnixSocketPath } from "@wrongstack/core/utils";
 
+// src/codebase-index/binary-frame.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BINARY_FRAME_MAGIC = 87;
+function isBinaryFrame(firstByte) {
+  return firstByte === BINARY_FRAME_MAGIC;
+}
+function encodeBinaryFrame(message) {
+  const payload = encode(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 decodeBinaryFrame(payload) {
+  return decode(payload);
+}
+
 // src/codebase-index/project-server-endpoint.ts
 import { createHash as createHash2 } from "node:crypto";
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os3 from "node:os";
-import * as path13 from "node:path";
-import { fileURLToPath } from "node:url";
+import * as path14 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { assertUnixSocketPathWithinLimit } from "@wrongstack/core/utils";
 var PROJECT_INDEX_SERVER_PROTOCOL_VERSION = 1;
 var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
@@ -5888,21 +7262,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:") ? fileURLToPath(cleanHref) : path13.resolve(cleanHref);
+  const file = cleanHref.startsWith("file:") ? fileURLToPath3(cleanHref) : path14.resolve(cleanHref);
   try {
-    const stat3 = fs9.statSync(file);
+    const stat3 = fs10.statSync(file);
     if (buildIdCache?.file === file && buildIdCache.mtimeMs === stat3.mtimeMs && buildIdCache.size === stat3.size) {
       return buildIdCache.buildId;
     }
-    const buildId = createHash2("sha256").update(fs9.readFileSync(file)).digest("hex").slice(0, 24);
+    const buildId = createHash2("sha256").update(fs10.readFileSync(file)).digest("hex").slice(0, 24);
     buildIdCache = { file, mtimeMs: stat3.mtimeMs, size: stat3.size, buildId };
     return buildId;
   } catch {
-    return `unreadable:${path13.basename(file)}`;
+    return `unreadable:${path14.basename(file)}`;
   }
 }
 function normalizeLocalPath(value) {
-  const resolved = path13.resolve(value);
+  const resolved = path14.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function projectIndexServerKey(projectRoot, indexDir) {
@@ -5914,11 +7288,11 @@ function projectIndexServerEndpoint(projectRoot, indexDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-codebase-index-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path13.join(os3.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
+  return path14.join(os3.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
 }
 function projectIndexServerMetadataPath(projectRoot, indexDir) {
-  return path13.join(
-    path13.resolve(resolveIndexDir(projectRoot, indexDir)),
+  return path14.join(
+    path14.resolve(resolveIndexDir(projectRoot, indexDir)),
     PROJECT_INDEX_SERVER_METADATA_FILE
   );
 }
@@ -5958,7 +7332,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:" && fs10.existsSync(fileURLToPath2(url))) {
+      if (url.protocol === "file:" && fs11.existsSync(fileURLToPath4(url))) {
         builtUrl = url;
         break;
       }
@@ -6057,6 +7431,12 @@ var ProjectServerConnection = class {
   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;
+  /** P6: true once the server advertises binary support and client accepts. */
+  useBinary = false;
   info = null;
   activity = null;
   health = null;
@@ -6195,6 +7575,8 @@ var ProjectServerConnection = class {
     this.info = null;
     this.activity = null;
     this.health = null;
+    this.useBinary = false;
+    this.binaryBuffer = [];
     this.connectReject?.(new Error("codebase-index client disconnected"));
     this.connectResolve = null;
     this.connectReject = null;
@@ -6215,7 +7597,7 @@ var ProjectServerConnection = class {
   currentAuthToken() {
     if (this.authToken === void 0) {
       try {
-        const raw = fs10.readFileSync(
+        const raw = fs11.readFileSync(
           projectIndexServerMetadataPath(this.projectRoot, this.indexDir),
           "utf8"
         );
@@ -6323,10 +7705,12 @@ var ProjectServerConnection = class {
     this.activity = null;
     this.health = null;
     this.buffer = "";
+    this.binaryBuffer = [];
+    this.useBinary = false;
+    this.textDecoder = null;
     return new Promise((resolve4, reject) => {
       const socket = net.createConnection(this.endpoint);
       this.socket = socket;
-      socket.setEncoding("utf8");
       const timer = setTimeout(() => {
         reject(new Error("codebase-index server handshake timed out"));
         socket.destroy();
@@ -6355,7 +7739,12 @@ var ProjectServerConnection = class {
   }
   onData(socket, chunk) {
     if (socket !== this.socket) return;
-    this.buffer += chunk;
+    if (this.useBinary) {
+      this.onBinaryData(socket, chunk);
+      return;
+    }
+    if (!this.textDecoder) this.textDecoder = new StringDecoder("utf8");
+    this.buffer += this.textDecoder.write(chunk);
     while (true) {
       const newline = this.buffer.indexOf("\n");
       if (newline < 0) {
@@ -6381,6 +7770,44 @@ 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) {
@@ -6400,6 +7827,7 @@ var ProjectServerConnection = class {
       }
       this.info = message;
       this.markResponsive();
+      if (message.binarySupported) this.useBinary = true;
       this.transition("connected", { pid: message.pid });
       ensureHeartbeatLoop();
       this.connectResolve?.();
@@ -6458,7 +7886,12 @@ var ProjectServerConnection = class {
   }
   write(message) {
     const socket = this.socket;
-    if (socket && !socket.destroyed) socket.write(encodeProjectServerMessage(message));
+    if (!socket || socket.destroyed) return;
+    if (this.useBinary) {
+      socket.write(encodeBinaryFrame(message));
+    } else {
+      socket.write(encodeProjectServerMessage(message));
+    }
   }
   rejectStaleServer(message, reason) {
     const socket = this.socket;
@@ -6480,11 +7913,11 @@ var ProjectServerConnection = class {
     if (!url) throw new Error("built codebase-index project server is unavailable");
     if (process.platform !== "win32") {
       try {
-        fs10.rmSync(this.endpoint, { force: true });
+        fs11.rmSync(this.endpoint, { force: true });
       } catch {
       }
     }
-    const args = [fileURLToPath2(url), "--project-root", this.projectRoot];
+    const args = [fileURLToPath4(url), "--project-root", this.projectRoot];
     if (this.indexDir) args.push("--index-dir", this.indexDir);
     const child = spawn3(process.execPath, args, {
       detached: true,
@@ -6504,8 +7937,8 @@ var ProjectServerConnection = class {
       process.kill(pid);
       const metadataPath = projectIndexServerMetadataPath(this.projectRoot, this.indexDir);
       try {
-        const metadata = JSON.parse(fs10.readFileSync(metadataPath, "utf8"));
-        if (metadata.pid === pid) fs10.rmSync(metadataPath, { force: true });
+        const metadata = JSON.parse(fs11.readFileSync(metadataPath, "utf8"));
+        if (metadata.pid === pid) fs11.rmSync(metadataPath, { force: true });
       } catch {
       }
       return true;
@@ -6604,7 +8037,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:" && fs11.existsSync(fileURLToPath3(url))) return url;
+      if (url.protocol === "file:" && fs12.existsSync(fileURLToPath5(url))) return url;
     } catch {
     }
   }
@@ -6624,7 +8057,7 @@ function ensureWorker() {
     return null;
   }
   try {
-    const w = new Worker(url, { name: "wstack-codebase-index" });
+    const w = new Worker2(url, { name: "wstack-codebase-index" });
     w.unref();
     w.on("message", (msg) => {
       if (msg.type === "progress") {
@@ -6848,7 +8281,7 @@ var readTool = {
     const shouldIncludeSymbols = input.includeSymbols === true || input.includeSymbols !== false && ctx.meta[ADVANCED_MODE_META_KEY] === true;
     let stat3;
     try {
-      stat3 = await fs12.stat(absPath);
+      stat3 = await fs13.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -6900,7 +8333,7 @@ var readTool = {
         ...symResult2?.symbols ? { symbols: symResult2.symbols } : {}
       };
     }
-    const buf = await fs12.readFile(absPath);
+    const buf = await fs13.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new Error(`read: "${input.path}" appears to be binary`);
     }