@optave/codegraph 3.10.0 → 3.11.1

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -33,15 +33,23 @@ function buildReexportMap(ctx: PipelineContext): void {
 }
 
 /**
- * Find barrel files related to changed files for scoped re-parsing.
- * For small incremental builds (<=smallFilesThreshold files), only barrels that re-export from
- * or are imported by the changed files. For larger changes, all barrels.
+ * Find barrel files related to `fromRelPaths` for scoped re-parsing.
+ * For small frontiers (<=smallFilesThreshold files), only barrels that re-export from
+ * or are imported by `fromRelPaths`. For larger frontiers, all barrels.
+ *
+ * `firstPass` gates the reexport-from DB scan: re-parsed barrels haven't
+ * changed content, so subsequent passes can't surface new reexport-from
+ * candidates and only need to follow imports of newly-merged barrels
+ * (mirrors the Rust orchestrator's seed-only `collect_reexport_from_barrels`).
  */
-function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
+function findBarrelCandidates(
+  ctx: PipelineContext,
+  fromRelPaths: readonly string[],
+  firstPass: boolean,
+): Array<{ file: string }> {
   const { db, fileSymbols, rootDir, aliases } = ctx;
-  const changedRelPaths = new Set<string>(fileSymbols.keys());
 
-  if (changedRelPaths.size <= ctx.config.build.smallFilesThreshold) {
+  if (fromRelPaths.length <= ctx.config.build.smallFilesThreshold) {
     const allBarrelFiles = new Set(
       (
         db
@@ -56,9 +64,9 @@ function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
 
     const barrels = new Set<string>();
 
-    // Find barrels imported by changed files using parsed import data
+    // Find barrels imported by `fromRelPaths` using parsed import data
     // (can't query DB edges -- they were purged for the changed files).
-    for (const relPath of changedRelPaths) {
+    for (const relPath of fromRelPaths) {
       const symbols = fileSymbols.get(relPath);
       if (!symbols) continue;
       for (const imp of symbols.imports) {
@@ -71,16 +79,17 @@ function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
       }
     }
 
-    // Also find barrels that re-export from the changed files
-    const reexportSourceStmt = db.prepare(
-      `SELECT DISTINCT n1.file FROM edges e
-       JOIN nodes n1 ON e.source_id = n1.id
-       JOIN nodes n2 ON e.target_id = n2.id
-       WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
-    );
-    for (const relPath of changedRelPaths) {
-      for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
-        barrels.add(row.file);
+    if (firstPass) {
+      const reexportSourceStmt = db.prepare(
+        `SELECT DISTINCT n1.file FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
+      );
+      for (const relPath of fromRelPaths) {
+        for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
+          barrels.add(row.file);
+        }
       }
     }
     return [...barrels].map((file) => ({ file }));
@@ -95,11 +104,22 @@ function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
     .all() as Array<{ file: string }>;
 }
 
-/** Re-parse barrel files and update fileSymbols/reexportMap with fresh data. */
+/**
+ * Re-parse barrel files and update fileSymbols/reexportMap with fresh data.
+ * Returns the relative paths of newly-merged files so the caller can scan
+ * them for the next level of barrel candidates.
+ *
+ * A re-parsed file is marked `barrel-only` only when it really is one (the
+ * `isBarrelFile` check — reexports >= ownDefs). The previous unconditional
+ * `.add(relPath)` caused hybrid barrels with many local defs (e.g. a file
+ * with one `export type ... from` and dozens of internal functions) to drop
+ * all their non-reexport imports in build-edges, since the barrel-only branch
+ * skips them (#1174).
+ */
 async function reparseBarrelFiles(
   ctx: PipelineContext,
   barrelCandidates: Array<{ file: string }>,
-): Promise<void> {
+): Promise<string[]> {
   const { db, fileSymbols, rootDir, engineOpts } = ctx;
 
   const barrelPaths: string[] = [];
@@ -109,18 +129,27 @@ async function reparseBarrelFiles(
     }
   }
 
-  if (barrelPaths.length === 0) return;
+  if (barrelPaths.length === 0) return [];
 
+  // Preserve `contains` and `parameter_of` — those are emitted by insertNodes,
+  // which only runs on the original (changed + reverse-dep) fileSymbols. Barrel
+  // candidates are merged here *after* insertNodes, so wiping those kinds
+  // would permanently drop them (mirrors the Rust orchestrator's Stage 6b
+  // delete in build_pipeline.rs).
   const deleteOutgoingEdges = db.prepare(
-    'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+    `DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)
+     AND kind NOT IN ('contains', 'parameter_of')`,
   );
 
+  const added: string[] = [];
   try {
     const barrelSymbols = await parseFilesAuto(barrelPaths, rootDir, engineOpts);
     for (const [relPath, fileSym] of barrelSymbols) {
       deleteOutgoingEdges.run(relPath);
       fileSymbols.set(relPath, fileSym);
-      ctx.barrelOnlyFiles.add(relPath);
+      if (isBarrelFile(ctx, relPath)) {
+        ctx.barrelOnlyFiles.add(relPath);
+      }
       const reexports = fileSym.imports.filter((imp: Import) => imp.reexport);
       if (reexports.length > 0) {
         ctx.reexportMap.set(
@@ -132,10 +161,12 @@ async function reparseBarrelFiles(
           })),
         );
       }
+      added.push(relPath);
     }
   } catch (e: unknown) {
     debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
   }
+  return added;
 }
 
 export async function resolveImports(ctx: PipelineContext): Promise<void> {
@@ -156,8 +187,31 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
 
   ctx.barrelOnlyFiles = new Set<string>();
   if (!isFullBuild) {
-    const barrelCandidates = findBarrelCandidates(ctx);
-    await reparseBarrelFiles(ctx, barrelCandidates);
+    // Iteratively discover and re-parse barrel chains. A barrel that imports
+    // another barrel (e.g. `parser.ts → extractors/index.ts → extractors/<lang>.ts`)
+    // needs both loaded so build-edges can emit the barrel-through edges from
+    // the first barrel to the leaf targets. Without iteration, only the first
+    // level of barrels gets merged into fileSymbols; the deeper chain has no
+    // entry in reexportMap and the resolver silently drops the affected edges
+    // on every incremental rebuild (#1174).
+    //
+    // Convergence is guaranteed because fileSymbols grows monotonically and
+    // is bounded by the set of barrel files in the project — each iteration
+    // either adds a previously-unseen barrel or terminates.
+    //
+    // Subsequent passes only walk newly-merged barrels' imports (`frontier`
+    // = paths returned by reparseBarrelFiles), matching the Rust
+    // orchestrator's `&newly_added` slice. Without this, every pass would
+    // re-query the DB for every key in `fileSymbols`.
+    let frontier: readonly string[] = [...fileSymbols.keys()];
+    let firstPass = true;
+    while (frontier.length > 0) {
+      const barrelCandidates = findBarrelCandidates(ctx, frontier, firstPass);
+      const added = await reparseBarrelFiles(ctx, barrelCandidates);
+      if (added.length === 0) break;
+      frontier = added;
+      firstPass = false;
+    }
   }
 }
 

package/src/domain/graph/cycles.ts

@@ -3,6 +3,45 @@ import { loadNative } from '../../infrastructure/native.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import type { BetterSqlite3Database } from '../../types.js';
 
+type Edge = { source: string; target: string };
+type DbEdge = { source_id: number; target_id: number };
+
+/**
+ * Build a label-based edge list from DB rows, filtering to known nodes and
+ * deduplicating. Self-loops are skipped (Tarjan treats them as trivial SCCs).
+ */
+function buildLabelEdges(dbEdges: DbEdge[], idToLabel: Map<number, string>): Edge[] {
+  const edges: Edge[] = [];
+  const seen = new Set<string>();
+  for (const e of dbEdges) {
+    if (e.source_id === e.target_id) continue;
+    const src = idToLabel.get(e.source_id);
+    const tgt = idToLabel.get(e.target_id);
+    if (src === undefined || tgt === undefined) continue;
+    const key = `${src}\0${tgt}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({ source: src, target: tgt });
+  }
+  return edges;
+}
+
+function buildFileLevelEdges(db: BetterSqlite3Database, noTests: boolean): Edge[] {
+  let nodes = getFileNodesAll(db);
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+  const idToLabel = new Map<number, string>();
+  for (const n of nodes) idToLabel.set(n.id, n.file);
+  return buildLabelEdges(getImportEdges(db), idToLabel);
+}
+
+function buildCallableEdges(db: BetterSqlite3Database, noTests: boolean): Edge[] {
+  let nodes = getCallableNodes(db);
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+  const idToLabel = new Map<number, string>();
+  for (const n of nodes) idToLabel.set(n.id, `${n.name}|${n.file}`);
+  return buildLabelEdges(getCallEdges(db), idToLabel);
+}
+
 /**
  * Find cycles using Tarjan's SCC algorithm.
  *
@@ -16,66 +55,20 @@ export function findCycles(
   const fileLevel = opts.fileLevel !== false;
   const noTests = opts.noTests || false;
 
-  const edges: Array<{ source: string; target: string }> = [];
-  const seen = new Set<string>();
-
-  if (fileLevel) {
-    let nodes = getFileNodesAll(db);
-    if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
-    const nodeIds = new Set<number>();
-    const idToFile = new Map<number, string>();
-    for (const n of nodes) {
-      nodeIds.add(n.id);
-      idToFile.set(n.id, n.file);
-    }
-    for (const e of getImportEdges(db)) {
-      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
-      if (e.source_id === e.target_id) continue;
-      const src = idToFile.get(e.source_id)!;
-      const tgt = idToFile.get(e.target_id)!;
-      const key = `${src}\0${tgt}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      edges.push({ source: src, target: tgt });
-    }
-  } else {
-    let nodes = getCallableNodes(db);
-    if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
-    const nodeIds = new Set<number>();
-    const idToLabel = new Map<number, string>();
-    for (const n of nodes) {
-      nodeIds.add(n.id);
-      idToLabel.set(n.id, `${n.name}|${n.file}`);
-    }
-    for (const e of getCallEdges(db)) {
-      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
-      if (e.source_id === e.target_id) continue;
-      const src = idToLabel.get(e.source_id)!;
-      const tgt = idToLabel.get(e.target_id)!;
-      const key = `${src}\0${tgt}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      edges.push({ source: src, target: tgt });
-    }
-  }
+  const edges = fileLevel ? buildFileLevelEdges(db, noTests) : buildCallableEdges(db, noTests);
 
   const native = loadNative();
   if (native) {
     return native.detectCycles(edges) as string[][];
   }
-
   return tarjanFromEdges(edges);
 }
 
-export function findCyclesJS(edges: Array<{ source: string; target: string }>): string[][] {
+export function findCyclesJS(edges: Edge[]): string[][] {
   return tarjanFromEdges(edges);
 }
 
-/**
- * Run Tarjan's SCC on a flat edge list. Returns SCCs with length > 1 (cycles).
- * Uses a simple adjacency-list Map instead of a full CodeGraph.
- */
-function tarjanFromEdges(edges: Array<{ source: string; target: string }>): string[][] {
+function buildAdjacency(edges: Edge[]): { adj: Map<string, string[]>; allNodes: Set<string> } {
   const adj = new Map<string, string[]>();
   const allNodes = new Set<string>();
   for (const { source, target } of edges) {
@@ -88,6 +81,15 @@ function tarjanFromEdges(edges: Array<{ source: string; target: string }>): stri
     }
     list.push(target);
   }
+  return { adj, allNodes };
+}
+
+/**
+ * Run Tarjan's SCC on a flat edge list. Returns SCCs with length > 1 (cycles).
+ * Uses a simple adjacency-list Map instead of a full CodeGraph.
+ */
+function tarjanFromEdges(edges: Edge[]): string[][] {
+  const { adj, allNodes } = buildAdjacency(edges);
 
   let index = 0;
   const stack: string[] = [];

package/src/domain/graph/journal.ts

@@ -91,62 +91,69 @@ function trySteal(lockPath: string): AcquiredLock | null {
   return { fd, nonce };
 }
 
-function acquireJournalLock(lockPath: string): AcquiredLock {
-  const start = Date.now();
-  for (;;) {
-    const nonce = `${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+/**
+ * Try to create the lockfile fresh via `wx`. Returns the acquired lock on
+ * success, `null` if another holder exists, or throws on unexpected errors.
+ *
+ * If the stamp write fails (ENOSPC, I/O error) we release the empty file —
+ * leaving it would look stale to concurrent waiters and admit double-acquire.
+ */
+function tryFreshAcquire(lockPath: string): AcquiredLock | null {
+  const nonce = `${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  let fd: number;
+  try {
+    fd = fs.openSync(lockPath, 'wx');
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === 'EEXIST') return null;
+    throw e;
+  }
+  try {
+    fs.writeSync(fd, `${process.pid}\n${nonce}\n`);
+  } catch {
     try {
-      const fd = fs.openSync(lockPath, 'wx');
-      try {
-        fs.writeSync(fd, `${process.pid}\n${nonce}\n`);
-      } catch {
-        // Stamp write failed (ENOSPC, I/O error). An empty lockfile would
-        // look stale to concurrent waiters (Number('') === 0, isPidAlive(0)
-        // returns false), so they'd steal our live lock. Release and retry.
-        try {
-          fs.closeSync(fd);
-        } catch {
-          /* ignore */
-        }
-        try {
-          fs.unlinkSync(lockPath);
-        } catch {
-          /* ignore */
-        }
-        if (Date.now() - start > LOCK_TIMEOUT_MS) {
-          throw new Error(
-            `Failed to acquire journal lock at ${lockPath} within ${LOCK_TIMEOUT_MS}ms`,
-          );
-        }
-        sleepSync(LOCK_RETRY_MS);
-        continue;
-      }
-      return { fd, nonce };
-    } catch (e) {
-      if ((e as NodeJS.ErrnoException).code !== 'EEXIST') throw e;
+      fs.closeSync(fd);
+    } catch {
+      /* ignore */
     }
-
-    let holderAlive = true;
     try {
-      const pidContent = fs.readFileSync(lockPath, 'utf-8').split('\n')[0]!.trim();
-      holderAlive = isPidAlive(Number(pidContent));
+      fs.unlinkSync(lockPath);
     } catch {
-      /* unreadable — fall through to age check */
+      /* ignore */
     }
+    return null;
+  }
+  return { fd, nonce };
+}
 
-    let shouldSteal = !holderAlive;
-    if (holderAlive) {
-      try {
-        const stat = fs.statSync(lockPath);
-        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-          shouldSteal = true;
-        }
-      } catch {
-        /* stat failed — keep retrying */
-      }
-    }
+/**
+ * Decide whether the current lock holder is stale and should be stolen.
+ * Returns true if the PID is dead, or if the lockfile mtime exceeds the
+ * staleness threshold.
+ */
+function isLockStale(lockPath: string): boolean {
+  let holderAlive = true;
+  try {
+    const pidContent = fs.readFileSync(lockPath, 'utf-8').split('\n')[0]!.trim();
+    holderAlive = isPidAlive(Number(pidContent));
+  } catch {
+    /* unreadable — fall through to age check */
+  }
+  if (!holderAlive) return true;
+  try {
+    const stat = fs.statSync(lockPath);
+    return Date.now() - stat.mtimeMs > LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
 
-    if (shouldSteal) {
+function acquireJournalLock(lockPath: string): AcquiredLock {
+  const start = Date.now();
+  for (;;) {
+    const fresh = tryFreshAcquire(lockPath);
+    if (fresh) return fresh;
+
+    if (isLockStale(lockPath)) {
       const stolen = trySteal(lockPath);
       if (stolen) return stolen;
       // Steal failed or lost the race — fall through to timeout check & retry.
@@ -227,27 +234,20 @@ interface JournalResult {
   removed?: string[];
 }
 
-export function readJournal(rootDir: string): JournalResult {
-  const journalPath = path.join(rootDir, '.codegraph', JOURNAL_FILENAME);
-  let content: string;
-  try {
-    content = fs.readFileSync(journalPath, 'utf-8');
-  } catch {
-    return { valid: false };
-  }
-
-  const lines = content.split('\n');
-  if (lines.length === 0 || !lines[0]!.startsWith(HEADER_PREFIX)) {
+function parseJournalHeader(firstLine: string | undefined): number | null {
+  if (!firstLine || !firstLine.startsWith(HEADER_PREFIX)) {
     debug('Journal has malformed or missing header');
-    return { valid: false };
+    return null;
   }
-
-  const timestamp = Number(lines[0]!.slice(HEADER_PREFIX.length).trim());
+  const timestamp = Number(firstLine.slice(HEADER_PREFIX.length).trim());
   if (!Number.isFinite(timestamp) || timestamp <= 0) {
     debug('Journal has invalid timestamp');
-    return { valid: false };
+    return null;
   }
+  return timestamp;
+}
 
+function parseJournalBody(lines: string[]): { changed: string[]; removed: string[] } {
   const changed: string[] = [];
   const removed: string[] = [];
   const seenChanged = new Set<string>();
@@ -263,14 +263,29 @@ export function readJournal(rootDir: string): JournalResult {
         seenRemoved.add(filePath);
         removed.push(filePath);
       }
-    } else {
-      if (!seenChanged.has(line)) {
-        seenChanged.add(line);
-        changed.push(line);
-      }
+    } else if (!seenChanged.has(line)) {
+      seenChanged.add(line);
+      changed.push(line);
     }
   }
 
+  return { changed, removed };
+}
+
+export function readJournal(rootDir: string): JournalResult {
+  const journalPath = path.join(rootDir, '.codegraph', JOURNAL_FILENAME);
+  let content: string;
+  try {
+    content = fs.readFileSync(journalPath, 'utf-8');
+  } catch {
+    return { valid: false };
+  }
+
+  const lines = content.split('\n');
+  const timestamp = parseJournalHeader(lines[0]);
+  if (timestamp === null) return { valid: false };
+
+  const { changed, removed } = parseJournalBody(lines);
   return { valid: true, timestamp, changed, removed };
 }
 

package/src/domain/graph/watcher.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
-import { debug, info } from '../../infrastructure/logger.js';
+import { debug, info, warn } from '../../infrastructure/logger.js';
 import { isSupportedFile, normalizePath, shouldIgnore } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
@@ -16,12 +16,13 @@ function shouldIgnorePath(filePath: string): boolean {
 
 /** Prepare all SQL statements needed by the watcher's incremental rebuild. */
 function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStmts {
-  const stmts = {
+  return {
     insertNode: db.prepare(
       'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
     ),
     getNodeId: {
-      get: (name: string, kind: string, file: string, line: number) => {
+      get: (...params: unknown[]) => {
+        const [name, kind, file, line] = params as [string, string, string, number];
         const id = getNodeIdQuery(db, name, kind, file, line);
         return id != null ? { id } : undefined;
       },
@@ -29,10 +30,10 @@ function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStm
     insertEdge: db.prepare(
       'INSERT INTO edges (source_id, target_id, kind, confidence, dynamic) VALUES (?, ?, ?, ?, ?)',
     ),
-    deleteNodes: db.prepare('DELETE FROM nodes WHERE file = ?'),
-    deleteEdgesForFile: null as { run: (f: string) => void } | null,
     countNodes: db.prepare('SELECT COUNT(*) as c FROM nodes WHERE file = ?'),
-    countEdgesForFile: null as { get: (f: string) => { c: number } | undefined } | null,
+    countEdges: db.prepare(
+      'SELECT COUNT(*) as c FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+    ),
     findNodeInFile: db.prepare(
       "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant') AND file = ?",
     ),
@@ -41,19 +42,6 @@ function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStm
     ),
     listSymbols: db.prepare("SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file'"),
   };
-
-  const origDeleteEdges = db.prepare(
-    `DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f) OR target_id IN (SELECT id FROM nodes WHERE file = @f)`,
-  );
-  const origCountEdges = db.prepare(
-    `SELECT COUNT(*) as c FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f) OR target_id IN (SELECT id FROM nodes WHERE file = @f)`,
-  );
-  stmts.deleteEdgesForFile = { run: (f: string) => origDeleteEdges.run({ f }) };
-  stmts.countEdgesForFile = {
-    get: (f: string) => origCountEdges.get({ f }) as { c: number } | undefined,
-  };
-
-  return stmts as IncrementalStmts;
 }
 
 /** Rebuild result shape from rebuildFile. */
@@ -67,6 +55,7 @@ interface RebuildResult {
   nodesAdded: number;
   nodesRemoved: number;
   edgesAdded: number;
+  edgesBefore: number;
 }
 
 /** Process a batch of pending file changes: rebuild, journal, and log. */
@@ -80,10 +69,23 @@ async function processPendingFiles(
 ): Promise<void> {
   const results: RebuildResult[] = [];
   for (const filePath of files) {
-    const result = (await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
-      diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
-    })) as RebuildResult | null;
-    if (result) results.push(result);
+    // Per-file try/catch so one bad rebuild doesn't crash the watcher loop.
+    // The watcher is a long-running session — any SQLite error, parse failure,
+    // or filesystem race must be reported and skipped, not propagated. Issue #1176.
+    try {
+      const result = (await rebuildFile(db, rootDir, filePath, stmts, engineOpts, cache, {
+        diffSymbols: diffSymbols as (old: unknown[], new_: unknown[]) => unknown,
+      })) as RebuildResult | null;
+      if (result) results.push(result);
+    } catch (err: unknown) {
+      const relPath = normalizePath(path.relative(rootDir, filePath));
+      // Narrow with `instanceof` instead of casting: a non-Error throw (a plain
+      // string, `null`, or any value a third-party dependency throws) would log
+      // `(err as Error).message` as `undefined`. See Greptile review on #1182.
+      const message = err instanceof Error ? err.message : String(err);
+      warn(`Failed to rebuild ${relPath}: ${message} — skipping`);
+      debug(err instanceof Error ? (err.stack ?? message) : String(err));
+    }
   }
 
   if (results.length > 0) {
@@ -109,7 +111,7 @@ function writeJournalAndChangeEvents(rootDir: string, updates: RebuildResult[]):
     buildChangeEvent(r.file, r.event, r.symbolDiff, {
       nodesBefore: r.nodesBefore,
       nodesAfter: r.nodesAfter,
-      edgesAdded: r.edgesAdded,
+      edgesAdded: r.edgesAdded - r.edgesBefore,
     }),
   );
   try {
@@ -127,7 +129,9 @@ function logRebuildResults(updates: RebuildResult[]): void {
     if (r.deleted) {
       info(`Removed: ${r.file} (-${r.nodesRemoved} nodes)`);
     } else {
-      info(`Updated: ${r.file} (${nodeStr} nodes, +${r.edgesAdded} edges)`);
+      const edgeDelta = r.edgesAdded - r.edgesBefore;
+      const edgeStr = edgeDelta >= 0 ? `+${edgeDelta}` : `${edgeDelta}`;
+      info(`Updated: ${r.file} (${nodeStr} nodes, ${edgeStr} edges)`);
     }
   }
 }