@optave/codegraph 3.9.4 → 3.9.6

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -5,9 +5,42 @@ import type {
   Visitor,
   VisitorContext,
 } from '../../types.js';
+import type { AstStringConfig } from '../rules/index.js';
 
 const TEXT_MAX = 200;
 
+// ── Cross-language node-type constants (mirror Rust `helpers.rs`) ────────
+const IDENT_TYPES = new Set<string>([
+  'identifier',
+  'type_identifier',
+  'name',
+  'qualified_name',
+  'scoped_identifier',
+  'qualified_identifier',
+  'member_expression',
+  'member_access_expression',
+  'field_expression',
+  'attribute',
+  'scoped_type_identifier',
+]);
+
+const CALL_TYPES = new Set<string>([
+  'call_expression',
+  'call',
+  'invocation_expression',
+  'method_invocation',
+  'function_call_expression',
+  'member_call_expression',
+  'scoped_call_expression',
+]);
+
+const DEFAULT_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+
+// Keyword tokens skipped when extracting the inner expression text of a
+// throw/raise/await/new node. Module-level constant avoids reallocating on
+// every call (can be hot in large files).
+const CHILD_EXPR_SKIP_KEYWORDS = new Set<string>(['throw', 'raise', 'await', 'new']);
+
 interface AstStoreRow {
   file: string;
   line: number;
@@ -20,69 +53,122 @@ interface AstStoreRow {
 
 function truncate(s: string | null | undefined, max: number = TEXT_MAX): string | null {
   if (!s) return null;
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+  return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}
+
+function trimLeadingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = 0;
+  while (i < s.length && chars.includes(s[i]!)) i++;
+  return i === 0 ? s : s.slice(i);
 }
 
-function extractNewName(node: TreeSitterNode): string {
+function trimTrailingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = s.length;
+  while (i > 0 && chars.includes(s[i - 1]!)) i--;
+  return i === s.length ? s : s.slice(0, i);
+}
+
+/** Extract constructor name from a `new_expression` / `object_creation_expression`. */
+function extractConstructorName(node: TreeSitterNode): string {
+  for (const field of ['type', 'class', 'constructor']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'identifier') return child.text;
-    if (child.type === 'member_expression') return child.text;
+    if (IDENT_TYPES.has(child.type)) return child.text;
+  }
+  const raw = node.text || '';
+  const beforeParen = raw.split('(')[0] || raw;
+  return beforeParen.replace(/^new\s+/, '').trim() || '?';
+}
+
+/** Extract function name from a call node. */
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
   }
-  return node.text?.split('(')[0]?.replace('new ', '').trim() || '?';
+  const text = node.text || '';
+  return text.split('(')[0] || '?';
 }
 
-function extractExpressionText(node: TreeSitterNode): string | null {
+/** Extract name from a throw/raise statement — matches native `extract_throw_target`. */
+function extractThrowName(node: TreeSitterNode, newTypes: Set<string>): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type !== 'throw' && child.type !== 'await') {
-      return truncate(child.text);
-    }
+    const ck = child.type;
+    if (newTypes.has(ck)) return extractConstructorName(child);
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from a throw statement's child nodes. */
-function extractThrowName(node: TreeSitterNode): string | null {
+/** Extract name from an await expression — matches native `extract_awaited_name`. */
+function extractAwaitName(node: TreeSitterNode): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'new_expression') return extractNewName(child);
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier') return child.text;
+    const ck = child.type;
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from an await expression's child nodes. */
-function extractAwaitName(node: TreeSitterNode): string | null {
+/** Extract text of the expression inside a throw/await, skipping the keyword. */
+function extractChildExpressionText(node: TreeSitterNode): string | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier' || child.type === 'member_expression') {
-      return child.text;
-    }
+    if (!CHILD_EXPR_SKIP_KEYWORDS.has(child.type)) return truncate(child.text);
   }
   return truncate(node.text);
 }
 
+/**
+ * Extract string content from a string-literal node, mirroring the native
+ * engine's `build_string_node` (`helpers.rs`). Returns `null` when the
+ * content is shorter than 2 Unicode code points.
+ */
+function extractStringContent(node: TreeSitterNode, cfg: AstStringConfig): string | null {
+  const raw = node.text ?? '';
+  const isRawString = node.type.includes('raw_string');
+
+  let s = raw;
+  s = trimLeadingChars(s, '@');
+  s = trimLeadingChars(s, cfg.stringPrefixes);
+  if (isRawString) s = trimLeadingChars(s, 'r#');
+  s = trimLeadingChars(s, cfg.quoteChars);
+  if (isRawString) s = trimTrailingChars(s, '#');
+  s = trimTrailingChars(s, cfg.quoteChars);
+
+  // Count code points, not UTF-16 code units — matches Rust `chars().count()`.
+  const codePointCount = [...s].length;
+  if (codePointCount < 2) return null;
+  return s;
+}
+
 export function createAstStoreVisitor(
   astTypeMap: Record<string, string>,
   defs: Definition[],
   relPath: string,
   nodeIdMap: Map<string, number>,
+  stringConfig: AstStringConfig = DEFAULT_STRING_CONFIG,
+  stopRecurseKinds: ReadonlySet<string> = new Set(),
 ): Visitor {
   const rows: AstStoreRow[] = [];
   const matched = new Set<number>();
+  const newTypes = new Set<string>(
+    Object.entries(astTypeMap)
+      .filter(([, kind]) => kind === 'new')
+      .map(([type]) => type),
+  );
 
   function findParentDef(line: number): Definition | null {
     let best: Definition | null = null;
@@ -106,12 +192,15 @@ export function createAstStoreVisitor(
   type KindHandler = (node: TreeSitterNode) => NameTextResult;
 
   const kindHandlers: Record<string, KindHandler> = {
-    new: (node) => ({ name: extractNewName(node), text: truncate(node.text) }),
-    throw: (node) => ({ name: extractThrowName(node), text: extractExpressionText(node) }),
-    await: (node) => ({ name: extractAwaitName(node), text: extractExpressionText(node) }),
+    new: (node) => ({ name: extractConstructorName(node), text: truncate(node.text) }),
+    throw: (node) => ({
+      name: extractThrowName(node, newTypes),
+      text: extractChildExpressionText(node),
+    }),
+    await: (node) => ({ name: extractAwaitName(node), text: extractChildExpressionText(node) }),
     string: (node) => {
-      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-      if (content.length < 2) return { name: null, text: null, skip: true };
+      const content = extractStringContent(node, stringConfig);
+      if (content == null) return { name: null, text: null, skip: true };
       return { name: truncate(content, 100), text: truncate(node.text) };
     },
     regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
@@ -156,7 +245,13 @@ export function createAstStoreVisitor(
 
       collectNode(node, kind);
 
-      if (kind !== 'string' && kind !== 'regex') {
+      // Mirror the native walker's recursion policy. In JS/TS, the native
+      // javascript.rs walker returns after collecting `new` or `throw` to
+      // avoid double-counting the wrapped expression (e.g. `throw new
+      // Error('x')` emits one `throw` row, not throw+new+string). Other
+      // languages go through helpers.rs::walk_ast_nodes_with_config_depth
+      // which always recurses — so `stopRecurseKinds` is empty for them.
+      if (stopRecurseKinds.has(kind)) {
         return { skipChildren: true };
       }
     },

package/src/cli/commands/watch.ts

@@ -6,6 +6,7 @@ export const command: CommandDefinition = {
   name: 'watch [dir]',
   description: 'Watch project for file changes and incrementally update the graph',
   options: [
+    ['-d, --db <path>', 'Path to graph.db'],
     ['--poll', 'Use stat-based polling (default on Windows to avoid ReFS/Dev Drive crashes)'],
     ['--native', 'Force native OS file watchers instead of polling'],
     ['--poll-interval <ms>', 'Polling interval in milliseconds (default: 2000)'],
@@ -22,6 +23,7 @@ export const command: CommandDefinition = {
       engine,
       poll,
       pollInterval: opts.pollInterval ? Number(opts.pollInterval) : undefined,
+      dbPath: opts.db ? path.resolve(opts.db) : undefined,
     });
   },
 };

package/src/cli.ts

@@ -1,14 +1,37 @@
 #!/usr/bin/env node
 
 import { run } from './cli/index.js';
+import { disposeParsers } from './domain/parser.js';
 import { CodegraphError, toErrorMessage } from './shared/errors.js';
 
-run().catch((err: unknown) => {
-  if (err instanceof CodegraphError) {
-    console.error(`codegraph [${err.code}]: ${err.message}`);
-    if (err.file) console.error(`  file: ${err.file}`);
-  } else {
-    console.error(`codegraph: fatal error — ${toErrorMessage(err)}`);
+/**
+ * After the CLI command finishes, tear down any cached WASM parsers and the
+ * worker thread pool. The WASM parse worker (see `domain/wasm-worker-pool.ts`)
+ * keeps the event loop alive until `worker.terminate()` is called, so without
+ * this teardown short-lived commands like `codegraph build` would hang for
+ * minutes before Node gives up — surfacing in CI as `spawnSync ETIMEDOUT`
+ * even though the command's work is already complete.
+ *
+ * `disposeParsers` is safe to call when the pool was never instantiated
+ * (e.g. native engine, or commands that never parse): it no-ops cleanly.
+ */
+async function shutdown(): Promise<void> {
+  try {
+    await disposeParsers();
+  } catch {
+    /* don't mask the real exit status over a teardown failure */
   }
-  process.exit(1);
-});
+}
+
+run()
+  .then(shutdown)
+  .catch(async (err: unknown) => {
+    if (err instanceof CodegraphError) {
+      console.error(`codegraph [${err.code}]: ${err.message}`);
+      if (err.file) console.error(`  file: ${err.file}`);
+    } else {
+      console.error(`codegraph: fatal error — ${toErrorMessage(err)}`);
+    }
+    await shutdown();
+    process.exit(1);
+  });

package/src/domain/graph/builder/context.ts

@@ -87,6 +87,8 @@ export class PipelineContext {
   // ── Phase timing ───────────────────────────────────────────────────
   timing: {
     setupMs?: number;
+    collectMs?: number;
+    detectMs?: number;
     parseMs?: number;
     insertMs?: number;
     resolveMs?: number;

package/src/domain/graph/builder/helpers.ts

@@ -8,7 +8,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { purgeFilesData } from '../../../db/index.js';
 import { warn } from '../../../infrastructure/logger.js';
-import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
+import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../../shared/constants.js';
+import { compileGlobs, matchesAny } from '../../../shared/globs.js';
 import type {
   BetterSqlite3Database,
   CodegraphConfig,
@@ -58,9 +59,29 @@ function shouldSkipEntry(entry: fs.Dirent, extraIgnore: Set<string> | null): boo
   return false;
 }
 
+/**
+ * Check whether a source file passes the configured include/exclude globs.
+ *
+ * Patterns are matched against the path relative to the project root,
+ * normalized to forward slashes (e.g. `src/foo/bar.ts`). When both lists
+ * are set, a file must match at least one include and no exclude.
+ */
+export function passesIncludeExclude(
+  relPath: string,
+  includeRegexes: readonly RegExp[],
+  excludeRegexes: readonly RegExp[],
+): boolean {
+  if (includeRegexes.length > 0 && !matchesAny(includeRegexes, relPath)) return false;
+  if (excludeRegexes.length > 0 && matchesAny(excludeRegexes, relPath)) return false;
+  return true;
+}
+
 /**
  * Recursively collect all source files under `dir`.
  * When `directories` is a Set, also tracks which directories contain files.
+ *
+ * The first invocation establishes `dir` as the project root against which
+ * `config.include` / `config.exclude` globs are matched.
  */
 export function collectFiles(
   dir: string,
@@ -68,6 +89,9 @@ export function collectFiles(
   config: Partial<CodegraphConfig>,
   directories: Set<string>,
   _visited?: Set<string>,
+  _rootDir?: string,
+  _includeRegexes?: readonly RegExp[],
+  _excludeRegexes?: readonly RegExp[],
 ): { files: string[]; directories: Set<string> };
 export function collectFiles(
   dir: string,
@@ -75,6 +99,9 @@ export function collectFiles(
   config?: Partial<CodegraphConfig>,
   directories?: null,
   _visited?: Set<string>,
+  _rootDir?: string,
+  _includeRegexes?: readonly RegExp[],
+  _excludeRegexes?: readonly RegExp[],
 ): string[];
 export function collectFiles(
   dir: string,
@@ -82,10 +109,20 @@ export function collectFiles(
   config: Partial<CodegraphConfig> = {},
   directories: Set<string> | null = null,
   _visited: Set<string> = new Set(),
+  _rootDir?: string,
+  _includeRegexes?: readonly RegExp[],
+  _excludeRegexes?: readonly RegExp[],
 ): string[] | { files: string[]; directories: Set<string> } {
   const trackDirs = directories instanceof Set;
   let hasFiles = false;
 
+  // First call: compute root and compile include/exclude patterns once,
+  // then pass them down recursive calls so we don't recompile per directory.
+  const rootDir = _rootDir ?? dir;
+  const includeRegexes = _includeRegexes ?? compileGlobs(config.include);
+  const excludeRegexes = _excludeRegexes ?? compileGlobs(config.exclude);
+  const hasGlobFilters = includeRegexes.length > 0 || excludeRegexes.length > 0;
+
   // Merge config ignoreDirs with defaults
   const extraIgnore = config.ignoreDirs ? new Set(config.ignoreDirs) : null;
 
@@ -116,11 +153,24 @@ export function collectFiles(
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (trackDirs) {
-        collectFiles(full, files, config, directories as Set<string>, _visited);
+        collectFiles(
+          full,
+          files,
+          config,
+          directories as Set<string>,
+          _visited,
+          rootDir,
+          includeRegexes,
+          excludeRegexes,
+        );
       } else {
-        collectFiles(full, files, config, null, _visited);
+        collectFiles(full, files, config, null, _visited, rootDir, includeRegexes, excludeRegexes);
       }
     } else if (EXTENSIONS.has(path.extname(entry.name))) {
+      if (hasGlobFilters) {
+        const rel = normalizePath(path.relative(rootDir, full));
+        if (!passesIncludeExclude(rel, includeRegexes, excludeRegexes)) continue;
+      }
       files.push(full);
       hasFiles = true;
     }

package/src/domain/graph/builder/pipeline.ts

@@ -21,6 +21,7 @@ import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js'
 import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
 import { semverCompare } from '../../../infrastructure/update-check.js';
+import { normalizePath } from '../../../shared/constants.js';
 import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
 import type {
@@ -29,11 +30,18 @@ import type {
   BuildResult,
   Definition,
   ExtractorOutput,
+  SqliteStatement,
 } from '../../../types.js';
-import { getActiveEngine } from '../../parser.js';
+import {
+  classifyNativeDrops,
+  formatDropExtensionSummary,
+  getActiveEngine,
+  getInstalledWasmExtensions,
+  parseFilesAuto,
+} from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
-import { loadPathAliases } from './helpers.js';
+import { batchInsertNodes, collectFiles as collectFilesUtil, loadPathAliases } from './helpers.js';
 import { NativeDbProxy } from './native-db-proxy.js';
 import { buildEdges } from './stages/build-edges.js';
 import { buildStructure } from './stages/build-structure.js';
@@ -104,6 +112,21 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
   }
 }
 
+function warnOnEmbeddingsWipe(ctx: PipelineContext): void {
+  const willBeFullBuild = !ctx.incremental || ctx.forceFullRebuild;
+  if (!willBeFullBuild) return;
+  let count = 0;
+  try {
+    count = (ctx.db.prepare('SELECT COUNT(*) AS c FROM embeddings').get() as { c: number }).c;
+  } catch {
+    return; // embeddings table missing — nothing to warn about
+  }
+  if (count === 0) return;
+  warn(
+    `Full rebuild will discard ${count} embedding${count === 1 ? '' : 's'}; re-run \`codegraph embed\` after the build.`,
+  );
+}
+
 function loadAliases(ctx: PipelineContext): void {
   ctx.aliases = loadPathAliases(ctx.rootDir);
   if (ctx.config.aliases) {
@@ -149,6 +172,7 @@ function setupPipeline(ctx: PipelineContext): void {
 
   initializeEngine(ctx);
   checkEngineSchemaMismatch(ctx);
+  warnOnEmbeddingsWipe(ctx);
   loadAliases(ctx);
 
   // Workspace packages (monorepo)
@@ -166,6 +190,8 @@ function formatTimingResult(ctx: PipelineContext): BuildResult {
   return {
     phases: {
       setupMs: +(t.setupMs ?? 0).toFixed(1),
+      collectMs: +(t.collectMs ?? 0).toFixed(1),
+      detectMs: +(t.detectMs ?? 0).toFixed(1),
       parseMs: +(t.parseMs ?? 0).toFixed(1),
       insertMs: +(t.insertMs ?? 0).toFixed(1),
       resolveMs: +(t.resolveMs ?? 0).toFixed(1),
@@ -540,7 +566,9 @@ function formatNativeTimingResult(
 ): BuildResult {
   return {
     phases: {
-      setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+      setupMs: +(p.setupMs ?? 0).toFixed(1),
+      collectMs: +(p.collectMs ?? 0).toFixed(1),
+      detectMs: +(p.detectMs ?? 0).toFixed(1),
       parseMs: +(p.parseMs ?? 0).toFixed(1),
       insertMs: +(p.insertMs ?? 0).toFixed(1),
       resolveMs: +(p.resolveMs ?? 0).toFixed(1),
@@ -696,10 +724,137 @@ async function tryNativeOrchestrator(
     }
   }
 
+  // Engine parity: the native orchestrator silently drops files whose
+  // Rust extractor/grammar is missing or fails (e.g. HCL, Scala, Swift on
+  // stale native binaries). WASM handles those — backfill via WASM so both
+  // engines process the same file set (#967).
+  //
+  // Only runs on full builds: incremental builds only touch changed files,
+  // which are parsed through parseFilesAuto (which has its own per-file
+  // backfill), so a full filesystem scan here would be wasted work.
+  if (result.isFullBuild) {
+    await backfillNativeDroppedFiles(ctx);
+  }
+
   closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
   return formatNativeTimingResult(p, structurePatchMs, analysisTiming);
 }
 
+/**
+ * Backfill files that the native orchestrator silently dropped during parse.
+ * Falls back to WASM + inserts file/symbol nodes so engine counts match (#967).
+ */
+async function backfillNativeDroppedFiles(ctx: PipelineContext): Promise<void> {
+  // Needs a real better-sqlite3 connection for INSERT.
+  if (ctx.nativeFirstProxy) {
+    closeNativeDb(ctx, 'pre-parity-backfill');
+    ctx.db = openDb(ctx.dbPath);
+    ctx.nativeFirstProxy = false;
+  }
+
+  const collected = collectFilesUtil(ctx.rootDir, [], ctx.config, new Set<string>());
+  const expected = new Set(
+    collected.files.map((f) => normalizePath(path.relative(ctx.rootDir, f))),
+  );
+
+  const existingRows = ctx.db
+    .prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'")
+    .all() as Array<{ file: string }>;
+  const existing = new Set(existingRows.map((r) => r.file));
+
+  // Restrict backfill to files with an installed WASM grammar. Extensions in
+  // LANGUAGE_REGISTRY without a shipped grammar file (e.g. groovy, erlang on
+  // minimal installs) can't be parsed by either engine, so they're not a
+  // native regression — excluding them keeps the warn count meaningful.
+  const installedExts = getInstalledWasmExtensions();
+  const missingRel: string[] = [];
+  const missingAbs: string[] = [];
+  for (const rel of expected) {
+    if (existing.has(rel)) continue;
+    const ext = path.extname(rel).toLowerCase();
+    if (!installedExts.has(ext)) continue;
+    missingRel.push(rel);
+    missingAbs.push(path.join(ctx.rootDir, rel));
+  }
+  if (missingAbs.length === 0) return;
+
+  // Classify drops so users see per-extension reasons instead of just a count
+  // (#1011). `unsupported-by-native` is a legitimate parser limit (no Rust
+  // extractor); `native-extractor-failure` indicates a real native bug since
+  // the language IS supported by the addon yet the file was dropped anyway.
+  const { byReason, totals } = classifyNativeDrops(missingRel);
+  if (totals['unsupported-by-native'] > 0) {
+    info(
+      `Native orchestrator skipped ${totals['unsupported-by-native']} file(s) in languages without a Rust extractor; backfilling via WASM: ${formatDropExtensionSummary(byReason['unsupported-by-native'])}`,
+    );
+  }
+  if (totals['native-extractor-failure'] > 0) {
+    warn(
+      `Native orchestrator dropped ${totals['native-extractor-failure']} file(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM: ${formatDropExtensionSummary(byReason['native-extractor-failure'])}`,
+    );
+  }
+  const wasmResults = await parseFilesAuto(missingAbs, ctx.rootDir, { engine: 'wasm' });
+
+  const rows: unknown[][] = [];
+  const exportKeys: unknown[][] = [];
+  for (const [relPath, symbols] of wasmResults) {
+    // File row — mirrors insertDefinitionsAndExports: qualified_name is null.
+    rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
+    for (const def of symbols.definitions ?? []) {
+      // Populate qualified_name/scope the same way the JS fallback does so
+      // downstream queries (cross-file references, "go to definition") find
+      // these symbols.
+      const dotIdx = def.name.lastIndexOf('.');
+      const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
+      rows.push([
+        def.name,
+        def.kind,
+        relPath,
+        def.line,
+        def.endLine ?? null,
+        null,
+        def.name,
+        scope,
+        def.visibility ?? null,
+      ]);
+    }
+    // Exports: insert the row (INSERT OR IGNORE — a matching definition row
+    // is a no-op) and queue a key for the second-pass exported=1 update, so
+    // queries filtering on exported=1 find backfilled symbols (#970).
+    for (const exp of symbols.exports ?? []) {
+      rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
+      exportKeys.push([exp.name, exp.kind, relPath, exp.line]);
+    }
+  }
+  const db = ctx.db as unknown as BetterSqlite3Database;
+  batchInsertNodes(db, rows);
+
+  // Mark exported symbols in batches — mirrors insertDefinitionsAndExports.
+  if (exportKeys.length > 0) {
+    const EXPORT_CHUNK = 500;
+    const exportStmtCache = new Map<number, SqliteStatement>();
+    for (let i = 0; i < exportKeys.length; i += EXPORT_CHUNK) {
+      const end = Math.min(i + EXPORT_CHUNK, exportKeys.length);
+      const chunkSize = end - i;
+      let updateStmt = exportStmtCache.get(chunkSize);
+      if (!updateStmt) {
+        const conditions = Array.from(
+          { length: chunkSize },
+          () => '(name = ? AND kind = ? AND file = ? AND line = ?)',
+        ).join(' OR ');
+        updateStmt = db.prepare(`UPDATE nodes SET exported = 1 WHERE ${conditions}`);
+        exportStmtCache.set(chunkSize, updateStmt);
+      }
+      const vals: unknown[] = [];
+      for (let j = i; j < end; j++) {
+        const k = exportKeys[j] as unknown[];
+        vals.push(k[0], k[1], k[2], k[3]);
+      }
+      updateStmt.run(...vals);
+    }
+  }
+}
+
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
@@ -845,6 +1000,10 @@ export async function buildGraph(
             `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
           );
           ctx.forceFullRebuild = true;
+          // Re-check embeddings: the initial warnOnEmbeddingsWipe ran before
+          // forceFullRebuild was set here, so the silent-data-loss guard
+          // would otherwise miss this late-promotion path (#986 follow-up).
+          warnOnEmbeddingsWipe(ctx);
         }
       }
     }