@monoes/monograph 1.4.0 → 1.5.0

package/src/analysis/feature-flags.ts

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync, statSync } from 'fs';
+import { readFileSync, readdirSync, lstatSync } from 'fs';
 import { join, extname } from 'path';
 
 export type FlagKind = 'EnvironmentVariable' | 'SdkCall' | 'ConfigObject';
@@ -170,13 +170,18 @@ export function crossReferenceWithDeadCode(
 }
 
 function walkDir(dir: string, fn: (filePath: string) => void): void {
-  let entries: string[];
-  try { entries = readdirSync(dir); } catch { return; }
-  for (const entry of entries) {
+  let dirents: import('fs').Dirent[];
+  try { dirents = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const dirent of dirents) {
+    const entry = dirent.name;
     if (entry === 'node_modules' || entry === '.git' || entry === 'dist' || entry === 'build') continue;
+    // Never follow symlinks — avoids infinite recursion on a symlink pointing to
+    // an ancestor directory, and avoids indexing a symlinked external tree as if
+    // it were part of the repo. Matches scan.ts's walk().
+    if (dirent.isSymbolicLink()) continue;
     const full = join(dir, entry);
     let st;
-    try { st = statSync(full); } catch { continue; }
+    try { st = lstatSync(full); } catch { continue; }
     if (st.isDirectory()) walkDir(full, fn);
     else if (st.isFile()) fn(full);
   }

package/src/cache/extraction-cache.ts

@@ -1,14 +1,25 @@
 import { createHash } from 'crypto';
-import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync, existsSync, statSync } from 'fs';
 import { join } from 'path';
 import type { MonographNode, MonographEdge } from '../types.js';
 
+/**
+ * Bump this whenever the parser/extractor output format changes in a way that
+ * would make previously-cached nodes/edges stale or wrong (e.g. a parser bugfix,
+ * a change to what symbols get extracted, a change to node/edge shape). Any
+ * cached entry written under an older version is treated as a miss on read, so
+ * bumping this effectively invalidates the entire on-disk extraction cache.
+ */
+export const EXTRACTION_CACHE_VERSION = 1;
+
 export interface CacheEntry {
   fileHash: string;
   mtimeMs?: number;
   size?: number;
   nodes: MonographNode[];
   edges: MonographEdge[];
+  /** Extraction format version this entry was written under — see EXTRACTION_CACHE_VERSION. */
+  cacheVersion?: number;
 }
 
 export class ExtractionCache {
@@ -32,6 +43,46 @@ export class ExtractionCache {
     return join(this.dir, `${key}.json`);
   }
 
+  /** tmp+rename write — cache corruption is low-stakes but a torn write from a
+   * killed process still shouldn't poison the next read. */
+  private writeAtomic(p: string, data: string): void {
+    const tmp = `${p}.${process.pid}.tmp`;
+    try {
+      writeFileSync(tmp, data);
+      renameSync(tmp, p);
+    } catch {
+      try { unlinkSync(tmp); } catch { /* ignore */ }
+    }
+  }
+
+  /**
+   * Delete cache entries whose mtime exceeds maxAgeMs (default 30 days).
+   * Covers files that were deleted/renamed (their cache entry is now orphaned
+   * and would otherwise sit on disk forever) as well as entries simply not
+   * touched in a long time. Single readdir + stat pass over the cache dir.
+   * Returns the number of entries removed.
+   */
+  prune(maxAgeMs = 30 * 24 * 60 * 60 * 1000): number {
+    let removed = 0;
+    let entries: string[];
+    try {
+      entries = readdirSync(this.dir).filter((f) => f.endsWith('.json') && !f.startsWith('._'));
+    } catch {
+      return 0;
+    }
+    const cutoff = Date.now() - maxAgeMs;
+    for (const f of entries) {
+      const p = join(this.dir, f);
+      try {
+        if (statSync(p).mtimeMs < cutoff) {
+          unlinkSync(p);
+          removed++;
+        }
+      } catch { /* ignore */ }
+    }
+    return removed;
+  }
+
   /**
    * Fast-path: check mtime+size before falling back to content hash.
    * Returns cached entry if file hasn't changed, null on miss.
@@ -41,6 +92,7 @@ export class ExtractionCache {
     if (!existsSync(p)) return null;
     try {
       const entry: CacheEntry = JSON.parse(readFileSync(p, 'utf-8'));
+      if (entry.cacheVersion !== EXTRACTION_CACHE_VERSION) return null;
       const st = statSync(filePath);
       if (entry.mtimeMs === st.mtimeMs && entry.size === st.size) return entry;
       // mtime/size differ or missing — recheck content hash
@@ -49,7 +101,7 @@ export class ExtractionCache {
       // Hash matches — update entry with current mtime+size for next run
       entry.mtimeMs = st.mtimeMs;
       entry.size = st.size;
-      try { writeFileSync(p, JSON.stringify(entry)); } catch { /* non-fatal */ }
+      try { this.writeAtomic(p, JSON.stringify(entry)); } catch { /* non-fatal */ }
       return entry;
     } catch { return null; }
   }
@@ -59,6 +111,7 @@ export class ExtractionCache {
     if (!existsSync(p)) return null;
     try {
       const entry: CacheEntry = JSON.parse(readFileSync(p, 'utf-8'));
+      if (entry.cacheVersion !== EXTRACTION_CACHE_VERSION) return null;
       return entry.fileHash === fileHash ? entry : null;
     } catch { return null; }
   }
@@ -67,21 +120,21 @@ export class ExtractionCache {
     let mtimeMs: number | undefined;
     let size: number | undefined;
     try { const st = statSync(filePath); mtimeMs = st.mtimeMs; size = st.size; } catch { /* ignore */ }
-    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges };
-    writeFileSync(this.entryPath(filePath), JSON.stringify(entry));
+    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges, cacheVersion: EXTRACTION_CACHE_VERSION };
+    this.writeAtomic(this.entryPath(filePath), JSON.stringify(entry));
   }
 
   setDeferred(filePath: string, fileHash: string, nodes: MonographNode[], edges: MonographEdge[]): void {
     let mtimeMs: number | undefined;
     let size: number | undefined;
     try { const st = statSync(filePath); mtimeMs = st.mtimeMs; size = st.size; } catch { /* ignore */ }
-    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges };
+    const entry: CacheEntry = { fileHash, mtimeMs, size, nodes, edges, cacheVersion: EXTRACTION_CACHE_VERSION };
     this.pending.push({ path: this.entryPath(filePath), data: JSON.stringify(entry) });
   }
 
   flush(): void {
     for (const { path, data } of this.pending) {
-      try { writeFileSync(path, data); } catch { /* non-fatal */ }
+      try { this.writeAtomic(path, data); } catch { /* non-fatal */ }
     }
     this.pending = [];
   }

package/src/cli/doctor.ts

@@ -51,12 +51,9 @@ function checkDbExists(dbPath: string): DoctorCheck {
   };
 }
 
-function checkDbReadable(dbPath: string): DoctorCheck {
+async function checkDbReadable(dbPath: string): Promise<DoctorCheck> {
   try {
-    // Dynamic require keeps this check lazy so missing better-sqlite3 doesn't
-    // crash the entire doctor invocation.
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const Database = require('better-sqlite3') as typeof import('better-sqlite3');
+    const Database = (await import('better-sqlite3')).default;
     const db = new Database(dbPath, { readonly: true });
     db.prepare('SELECT 1').get();
     db.close();
@@ -67,10 +64,9 @@ function checkDbReadable(dbPath: string): DoctorCheck {
   }
 }
 
-function checkNodeCount(dbPath: string): DoctorCheck {
+async function checkNodeCount(dbPath: string): Promise<DoctorCheck> {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const Database = require('better-sqlite3') as typeof import('better-sqlite3');
+    const Database = (await import('better-sqlite3')).default;
     const db = new Database(dbPath, { readonly: true });
     const row = db.prepare('SELECT COUNT(*) AS n FROM nodes').get() as { n: number } | undefined;
     db.close();
@@ -159,8 +155,8 @@ export async function runDoctor(repoPath: string): Promise<DoctorResult> {
 
   // 3. DB readable (only if DB exists)
   if (dbExistsCheck.status !== 'error') {
-    checks.push(checkDbReadable(dbPath));
-    checks.push(checkNodeCount(dbPath));
+    checks.push(await checkDbReadable(dbPath));
+    checks.push(await checkNodeCount(dbPath));
   } else {
     checks.push({
       name: 'SQLite DB readable',

package/src/graph/dead-code.ts

@@ -11,8 +11,13 @@ import type { MonographDb } from '../storage/db.js';
  * - Only exported — private locals are internal by design
  * - Skips entry-point, test, dist, and node_modules paths
  * - Requires zero inbound CALLS, IMPORTS, REFERENCES, and RE_EXPORTS edges
- * - No same-name node in another file (catches import bindings)
- * - Not re-exported through any index.ts barrel file
+ * - Not re-exported through any index.ts barrel file, via an actual RE_EXPORTS
+ *   edge from that barrel's File node (not merely sharing a name with something
+ *   an index.ts happens to also define)
+ *
+ * Known gap: files consumed only via a dynamic `import()` call won't have a static
+ * edge in the graph, so they can still surface as false positives here — this
+ * detector only tracks statically-resolved edges.
  */
 export function detectDeadCode(db: MonographDb): string[] {
   return detectDeadCodeNodes(db).map(n => n.id);
@@ -58,21 +63,19 @@ export function detectDeadCodeNodes(db: MonographDb): DeadCodeNode[] {
            WHERE e.target_id = n.id
              AND e.relation IN ('CALLS', 'IMPORTS', 'REFERENCES', 'RE_EXPORTS')
          )
-         -- no same-name node in another file (import bindings, .cjs callers, etc.)
-         AND NOT EXISTS (
-           SELECT 1 FROM nodes o
-           WHERE o.name = n.name AND o.file_path != n.file_path
-             AND o.file_path IS NOT NULL
-             AND o.file_path NOT LIKE '%/dist/%'
-             AND o.file_path NOT LIKE '%node_modules%'
-         )
-         -- not re-exported through a barrel (index.ts/index.js)
+         -- not re-exported through a barrel (index.ts/index.js) — checked via an
+         -- ACTUAL RE_EXPORTS edge from the barrel's File node to this candidate's
+         -- File node, not a same-NAME coincidence with an unrelated symbol that
+         -- happens to also live in some index.ts elsewhere in the repo.
          AND NOT EXISTS (
-           SELECT 1 FROM nodes b
-           WHERE b.name = n.name
-             AND b.file_path LIKE '%/index.%'
-             AND b.file_path NOT LIKE '%/dist/%'
-             AND b.file_path NOT LIKE '%node_modules%'
+           SELECT 1 FROM edges e
+           JOIN nodes fn ON fn.id = e.target_id AND fn.label = 'File'
+           JOIN nodes bn ON bn.id = e.source_id AND bn.label = 'File'
+           WHERE e.relation = 'RE_EXPORTS'
+             AND fn.file_path = n.file_path
+             AND bn.file_path LIKE '%/index.%'
+             AND bn.file_path NOT LIKE '%/dist/%'
+             AND bn.file_path NOT LIKE '%node_modules%'
          )
        ORDER BY n.file_path, n.start_line`,
     )

package/src/graph/pagerank.ts

@@ -24,6 +24,10 @@ function getStmts(db: MonographDb): StmtCache {
   const key = (db as unknown as { name: string }).name ?? '__default__';
   let cache = _stmtCache.get(key);
   if (!cache) {
+    if (_stmtCache.size >= MAX_STMT_CACHE) {
+      const oldest = _stmtCache.keys().next().value!;
+      _stmtCache.delete(oldest);
+    }
     cache = {
       selectNodes: db.prepare('SELECT id FROM nodes'),
       selectEdges: db.prepare('SELECT source_id, target_id FROM edges'),
@@ -38,6 +42,8 @@ function getStmts(db: MonographDb): StmtCache {
 // changed. Keyed by (dbName, nodeCount, edgeCount) with a 5-second TTL.
 // ---------------------------------------------------------------------------
 const PAGERANK_CACHE_TTL_MS = 5_000;
+const MAX_RESULT_CACHE = 50;
+const MAX_STMT_CACHE = 20;
 
 interface PageRankCacheEntry {
   result: Map<string, number>;
@@ -149,7 +155,10 @@ export function pageRank(db: MonographDb, options: PageRankOptions = {}): Map<st
     result.set(nodes[i], scores[i]);
   }
 
-  // Store in result cache
+  if (_resultCache.size >= MAX_RESULT_CACHE) {
+    const oldest = _resultCache.keys().next().value!;
+    _resultCache.delete(oldest);
+  }
   _resultCache.set(cacheKey, { result, expiresAt: now + PAGERANK_CACHE_TTL_MS });
 
   return result;

package/src/groups/group-search.ts

@@ -8,6 +8,7 @@ import { join } from 'path';
 import { existsSync } from 'fs';
 import Database from 'better-sqlite3';
 import { type RankedResult } from '../search/rrf.js';
+import { ftsSearch } from '../storage/fts-store.js';
 import type { GroupConfig } from './group-config.js';
 
 export interface GroupResult {
@@ -19,13 +20,6 @@ export interface GroupResult {
   score: number;
 }
 
-interface RawFtsRow {
-  id: string;
-  name: string;
-  label: string;
-  file_path: string | null;
-}
-
 /**
  * Determine the monograph DB path for a given repo root.
  * Mirrors the convention used in monograph-tools.ts: <repoPath>/.monomind/monograph.db
@@ -53,31 +47,19 @@ function searchRepo(
   try {
     db = new Database(dbPath, { readonly: true });
 
-    // Sanitize and build prefix query
-    const safeQuery = query.replace(/['"*]/g, ' ').trim();
-    if (!safeQuery) return [];
-
-    const ftsPrefixQuery = safeQuery
-      .split(/\s+/)
-      .map((t) => t + '*')
-      .join(' ');
-
-    const sql = `
-      SELECT n.id, n.name, n.label, n.file_path
-      FROM nodes_fts
-      JOIN nodes n ON n.rowid = nodes_fts.rowid
-      WHERE nodes_fts MATCH ?
-      ORDER BY nodes_fts.rank
-      LIMIT ?
-    `;
-
-    const rows = db.prepare(sql).all(ftsPrefixQuery, perRepoLimit) as RawFtsRow[];
+    // Reuse the SAME ftsSearch() the single-repo `monograph_query` tool uses —
+    // its trigram-aware sanitization and MATCH/LIKE fallback (P2-15) — instead of
+    // a divergent inline query that appended `*` as if this were a prefix-match
+    // tokenizer. The trigram index needs no prefix wildcard and errors on terms
+    // shorter than 3 chars when one is appended, which silently produced empty
+    // results here before.
+    const rows = ftsSearch(db, query, perRepoLimit);
 
     return rows.map((r, idx) => ({
       id: `${repoName}::${r.id}`,
       name: r.name,
       label: r.label,
-      filePath: r.file_path ?? null,
+      filePath: r.filePath,
       repo: repoName,
       // Use rank position as initial score so RRF can compute correctly
       score: 1 / (60 + idx + 1),

package/src/mcp-tools/impact.ts

@@ -60,7 +60,13 @@ function reverseBfs(
   const visited = new Map<string, number>([[startNodeId, 0]]);
   const queue: Array<{ id: string; depth: number }> = [{ id: startNodeId, depth: 0 }];
 
-  const relations = options.relationTypes ?? ['CALLS'];
+  // Default to a broad set of relation types, not just CALLS — a class extended
+  // in 20 files, or a function only ever referenced via import/re-export (never
+  // directly called), should still show up in the blast radius. A narrow default
+  // reports "0 symbols affected, risk LOW" for changes that are anything but low
+  // risk. Callers that need the old narrow/fast behavior can still pass
+  // relationTypes: ['CALLS'] explicitly.
+  const relations = options.relationTypes ?? ['CALLS', 'IMPORTS', 'REFERENCES', 'EXTENDS', 'RE_EXPORTS'];
   const placeholders = relations.map(() => '?').join(',');
   const baseQuery = `SELECT source_id FROM edges WHERE target_id = ? AND relation IN (${placeholders})`;
   const query = options.minConfidenceScore !== undefined

package/src/pipeline/orchestrator.ts

@@ -11,7 +11,7 @@ import { routesPhase } from './phases/routes.js';
 import { toolsPhase } from './phases/tools.js';
 import { ormPhase } from './phases/orm.js';
 import { crossFilePhase } from './phases/cross-file.js';
-import { scopeResolutionPhase } from './phases/scope-resolution.js';
+import { scopeResolutionPhase, clearWorkspacePackageMapCache } from './phases/scope-resolution.js';
 import { mroPhase } from './phases/mro.js';
 import { communitiesPhase } from './phases/communities.js';
 import { processesPhase } from './phases/processes.js';
@@ -22,11 +22,13 @@ import { variablesPhase } from './phases/variables-phase.js';
 import { wildcardSynthesisPhase } from './phases/wildcard-phase.js';
 import { frameworkDetectPhase } from './phases/framework-detect.js';
 import { importResolverPhase } from './phases/import-resolver.js';
+import { bridgeResolverPhase } from './phases/bridge-resolver.js';
 import type { PipelineOptions, PipelineContext } from './types.js';
 import { DEFAULT_OPTIONS } from './types.js';
 import type { PipelineProgress, SuggestedQuestion } from '../types.js';
 import { generateGraphReport } from '../reporting/graph-report.js';
 import { analyzeChurn } from '../analysis/churn.js';
+import { ExtractionCache } from '../cache/extraction-cache.js';
 
 function getCurrentCommitHash(repoPath: string): string | null {
   try {
@@ -74,6 +76,7 @@ async function acquireBuildLock(dbPath: string): Promise<(() => void) | null> {
 export async function buildAsync(repoPath: string, options: BuildOptions = {}): Promise<void> {
   const dbPath = resolve(join(repoPath, '.monomind', 'monograph.db'));
   const fullOptions: PipelineOptions = { ...DEFAULT_OPTIONS, ...options };
+  clearWorkspacePackageMapCache(repoPath);
 
   const releaseLock = await acquireBuildLock(dbPath);
   if (!releaseLock) {
@@ -113,6 +116,20 @@ async function buildAsyncLocked(
     }
   }
 
+  // Parse-cache eviction — runs once at the start of a full (non-incremental)
+  // build. The cache only ever grows via writes (parse.ts's ExtractionCache);
+  // nothing else prunes entries for files that were deleted/renamed or
+  // haven't been touched in a long time, so it accumulates forever otherwise.
+  if (!options.incremental) {
+    try {
+      const parseCache = new ExtractionCache(resolve(join(repoPath, '.monomind', 'parse-cache')));
+      const removed = parseCache.prune();
+      if (removed > 0) {
+        options.onProgress?.({ phase: 'prune', message: `Parse cache: pruned ${removed} stale entries` });
+      }
+    } catch { /* non-fatal — cache pruning must never block a build */ }
+  }
+
   const db = openDb(dbPath);
 
   try {
@@ -128,38 +145,45 @@ async function buildAsyncLocked(
       scanPhase, frameworkDetectPhase, structurePhase, parsePhase, variablesPhase,
       markdownPhase, routesPhase, toolsPhase, ormPhase,
       crossFilePhase, wildcardSynthesisPhase, importResolverPhase, scopeResolutionPhase,
+      bridgeResolverPhase,
       mroPhase, communitiesPhase, processesPhase, godNodesPhase, surprisesPhase, suggestPhase,
     ]);
 
     const outputs = await runner.run(ctx);
 
-    // Skip post-pipeline work when all files were cached (nothing changed)
-    if (!ctx.allFilesCached) {
-      // Sweep orphaned rows for files that were renamed/deleted since the last build.
-      const scanOut = outputs.get('scan') as { filePaths: string[] } | undefined;
-      if (scanOut) {
-        const liveFiles = new Set(scanOut.filePaths.map((f) => resolve(f)));
-        const staleFiles = (
-          db.prepare('SELECT DISTINCT file_path FROM nodes WHERE file_path IS NOT NULL').all() as { file_path: string }[]
-        )
-          .map((r) => r.file_path)
-          .filter((f) => !liveFiles.has(resolve(ctx.repoPath, f)));
-        if (staleFiles.length > 0) {
-          const deleteStale = db.transaction((files: string[]) => {
-            const deleteEdges = db.prepare(`
-              DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file_path = ?)
-                 OR target_id IN (SELECT id FROM nodes WHERE file_path = ?)
-            `);
-            const deleteNodesStmt = db.prepare('DELETE FROM nodes WHERE file_path = ?');
-            for (const f of files) {
-              deleteEdges.run(f, f);
-              deleteNodesStmt.run(f);
-            }
-          });
-          deleteStale(staleFiles);
-        }
+    // Sweep orphaned rows for files that were renamed/deleted since the last build.
+    // This MUST run unconditionally — even when every remaining file cache-hit
+    // (ctx.allFilesCached === true), a file may have been deleted from disk between
+    // builds, which produces zero cache misses but still leaves ghost rows in the DB
+    // unless we compare the DB's known file set against the current on-disk set.
+    const scanOut = outputs.get('scan') as { filePaths: string[] } | undefined;
+    if (scanOut) {
+      const liveFiles = new Set(scanOut.filePaths.map((f) => resolve(f)));
+      const staleFiles = (
+        db.prepare('SELECT DISTINCT file_path FROM nodes WHERE file_path IS NOT NULL').all() as { file_path: string }[]
+      )
+        .map((r) => r.file_path)
+        .filter((f) => !liveFiles.has(resolve(ctx.repoPath, f)));
+      if (staleFiles.length > 0) {
+        const deleteStale = db.transaction((files: string[]) => {
+          const deleteEdges = db.prepare(`
+            DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file_path = ?)
+               OR target_id IN (SELECT id FROM nodes WHERE file_path = ?)
+          `);
+          const deleteNodesStmt = db.prepare('DELETE FROM nodes WHERE file_path = ?');
+          for (const f of files) {
+            deleteEdges.run(f, f);
+            deleteNodesStmt.run(f);
+          }
+        });
+        deleteStale(staleFiles);
       }
+    }
 
+    // Skip expensive report regeneration when all files were cached (nothing changed) —
+    // this is purely a performance optimization, not correctness-critical, so it stays
+    // gated behind allFilesCached.
+    if (!ctx.allFilesCached) {
       const suggestOut = outputs.get('suggest') as { questions: SuggestedQuestion[] } | undefined;
       const questions = suggestOut?.questions ?? [];
       await generateGraphReport(resolve(repoPath), undefined, dbPath, questions);

package/src/pipeline/phases/bridge-adapters/electron-ipc.ts

@@ -0,0 +1,91 @@
+import { statSync, readFileSync } from 'fs';
+import { join, extname } from 'path';
+import type { PipelineContext } from '../../types.js';
+import type { BridgeAdapter, BridgeEndpoint } from './types.js';
+
+const JS_TS_EXT = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+
+const IPC_MAIN_RE = /\bipcMain\.(?:handle|on)\(\s*['"]([^'"]+)['"]/g;
+const IPC_RENDERER_RE = /\bipcRenderer\.(?:invoke|send)\(\s*['"]([^'"]+)['"]/g;
+
+function safeReadSource(absPath: string, maxBytes: number): string | undefined {
+  try {
+    const stat = statSync(absPath);
+    if (stat.size > maxBytes) return undefined;
+    return readFileSync(absPath, 'utf-8');
+  } catch {
+    return undefined;
+  }
+}
+
+function extractChannels(re: RegExp, source: string): string[] {
+  re.lastIndex = 0;
+  const names: string[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(source)) !== null) names.push(m[1]!);
+  return names;
+}
+
+/**
+ * Electron IPC (main process JS <-> renderer/preload JS): both sides are the
+ * same language, so nothing in the existing same-file import resolution
+ * connects them — the only link is the shared channel-name string literal
+ * passed to `ipcMain.handle/on` (definition) and `ipcRenderer.invoke/send`
+ * (call site). Neither side has call-expression-level node granularity from
+ * a plain regex scan, so both attach to their containing File node.
+ */
+export const electronIpcAdapter: BridgeAdapter = {
+  name: 'electron-ipc',
+
+  detect(ctx, filePaths) {
+    let hasMain = false;
+    let hasRenderer = false;
+    for (const relPath of filePaths) {
+      if (!JS_TS_EXT.has(extname(relPath))) continue;
+      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+      if (!hasMain && /\bipcMain\.(?:handle|on)\(/.test(source)) hasMain = true;
+      if (!hasRenderer && /\bipcRenderer\.(?:invoke|send)\(/.test(source)) hasRenderer = true;
+      if (hasMain && hasRenderer) return true;
+    }
+    return false;
+  },
+
+  findDefinitions(ctx, filePaths) {
+    const endpoints: BridgeEndpoint[] = [];
+    for (const relPath of filePaths) {
+      if (!JS_TS_EXT.has(extname(relPath))) continue;
+      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+      const channels = extractChannels(IPC_MAIN_RE, source);
+      if (channels.length === 0) continue;
+
+      const fileRow = ctx.db
+        .prepare(`SELECT id FROM nodes WHERE label = 'File' AND file_path = ?`)
+        .get(relPath) as { id: string } | undefined;
+      if (!fileRow) continue;
+
+      for (const channel of channels) endpoints.push({ key: channel, nodeId: fileRow.id, language: 'javascript' });
+    }
+    return endpoints;
+  },
+
+  findCallSites(ctx, filePaths) {
+    const endpoints: BridgeEndpoint[] = [];
+    for (const relPath of filePaths) {
+      if (!JS_TS_EXT.has(extname(relPath))) continue;
+      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+      const channels = extractChannels(IPC_RENDERER_RE, source);
+      if (channels.length === 0) continue;
+
+      const fileRow = ctx.db
+        .prepare(`SELECT id FROM nodes WHERE label = 'File' AND file_path = ?`)
+        .get(relPath) as { id: string } | undefined;
+      if (!fileRow) continue;
+
+      for (const channel of channels) endpoints.push({ key: channel, nodeId: fileRow.id, language: 'javascript' });
+    }
+    return endpoints;
+  },
+};

package/src/pipeline/phases/bridge-adapters/registry.ts

@@ -0,0 +1,14 @@
+import type { BridgeAdapter } from './types.js';
+import { wailsAdapter } from './wails.js';
+import { tauriAdapter } from './tauri.js';
+import { electronIpcAdapter } from './electron-ipc.js';
+
+// Every adapter here has an unambiguous detect() signal (a generated binding
+// path, or a framework-specific call shape that only appears when its
+// framework is actually in use) — so all run unconditionally; detect() is
+// what keeps the no-op cost near zero for repos that don't use any of them.
+export const BUILTIN_BRIDGE_ADAPTERS: BridgeAdapter[] = [
+  wailsAdapter,
+  tauriAdapter,
+  electronIpcAdapter,
+];