@monoes/monograph 1.3.0 → 1.4.1

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/index.ts

@@ -16,6 +16,9 @@ export * from './export/html.js';
 export * from './export/cypher.js';
 export * from './export/graphml.js';
 export * from './export/svg.js';
+export * from './export/obsidian.js';
+export * from './export/canvas.js';
+export * from './export/mermaid.js';
 export * from './mcp-tools/index.js';
 export * from './staleness/git-staleness.js';
 export * from './search/rrf.js';

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,10 +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 {
@@ -73,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) {
@@ -112,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 {
@@ -127,47 +145,90 @@ 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);
     }
 
+    // Populate churnScore on File nodes from git history (6-month window)
+    try {
+      const churnResult = await analyzeChurn(ctx.repoPath, '6m');
+      if (churnResult.files.length > 0) {
+        // Only consider files that exist as graph nodes for normalization —
+        // build artifacts and config files inflate the denominator otherwise
+        const graphFiles = new Set(
+          (db.prepare("SELECT file_path FROM nodes WHERE label = 'File' AND file_path IS NOT NULL").all() as { file_path: string }[])
+            .map(r => r.file_path),
+        );
+        const graphChurn = churnResult.files.filter(f => graphFiles.has(f.path));
+        const maxWeighted = graphChurn.reduce((m, f) => f.weightedCommits > m ? f.weightedCommits : m, 0);
+        if (maxWeighted > 0) {
+          const updateProps = db.prepare(`
+            UPDATE nodes SET properties = json_set(COALESCE(properties, '{}'), '$.churnScore', ?)
+            WHERE file_path = ? AND label = 'File'
+          `);
+          db.transaction(() => {
+            for (const f of graphChurn) {
+              updateProps.run(f.weightedCommits / maxWeighted, f.path);
+            }
+          })();
+        }
+      }
+    } catch {
+      // churn analysis is non-fatal (e.g. no git history)
+    }
+
     const hash = getCurrentCommitHash(resolve(repoPath));
     if (hash) {
       db.prepare("INSERT OR REPLACE INTO index_meta VALUES ('last_commit_hash', ?)").run(hash);
+    } else {
+      const msg = 'Could not determine git HEAD — staleness tracking will be unavailable';
+      if (options.onProgress) {
+        options.onProgress({ phase: 'warning', message: msg } as PipelineProgress);
+      } else {
+        process.stderr.write(`[monograph] ${msg}\n`);
+      }
     }
+    db.prepare("INSERT OR REPLACE INTO index_meta VALUES ('indexed_at', ?)").run(new Date().toISOString());
   } finally {
     closeDb(db);
   }

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,
+];

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

@@ -0,0 +1,103 @@
+import { statSync, readFileSync } from 'fs';
+import { join, extname } from 'path';
+import type { PipelineContext } from '../../types.js';
+import type { BridgeAdapter, BridgeEndpoint } from './types.js';
+
+const RUST_EXT = new Set(['.rs']);
+const JS_TS_EXT = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+
+/** `#[tauri::command]` (with or without args) directly above an fn declaration. */
+const TAURI_COMMAND_RE = /#\[tauri::command(?:\([^)]*\))?\]\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)/g;
+
+/**
+ * Tauri's `invoke(...)` call from the JS/TS side, e.g.
+ * `import { invoke } from '@tauri-apps/api/core'; invoke('my_command', {...})`.
+ * We don't verify the import — matching the call shape is enough signal here,
+ * same tradeoff extractor.ts already makes for plain call-site regexes.
+ */
+const TAURI_INVOKE_RE = /\binvoke\(\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;
+  }
+}
+
+/**
+ * Tauri (Rust <-> JS/TS): a `#[tauri::command]`-annotated Rust fn is invoked
+ * from the frontend by name via `invoke("name", ...)` — a string-literal
+ * match, not a generated file. The Rust side already has a real Function
+ * node (from the Rust extractor); the JS/TS call site does not, so it's
+ * attached to its containing File node.
+ */
+export const tauriAdapter: BridgeAdapter = {
+  name: 'tauri',
+
+  // A bare .rs file isn't a Tauri signal by itself (a repo can have unrelated
+  // Rust code alongside a JS/TS frontend) — require an actual
+  // #[tauri::command] annotation before this adapter runs at all.
+  detect(ctx, filePaths) {
+    for (const relPath of filePaths) {
+      if (!RUST_EXT.has(extname(relPath))) continue;
+      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+      TAURI_COMMAND_RE.lastIndex = 0;
+      if (TAURI_COMMAND_RE.test(source)) return true;
+    }
+    return false;
+  },
+
+  findDefinitions(ctx, filePaths) {
+    const endpoints: BridgeEndpoint[] = [];
+    for (const relPath of filePaths) {
+      if (!RUST_EXT.has(extname(relPath))) continue;
+      const source = safeReadSource(join(ctx.repoPath, relPath), ctx.options.maxFileSizeBytes);
+      if (!source) continue;
+
+      TAURI_COMMAND_RE.lastIndex = 0;
+      let m: RegExpExecArray | null;
+      const names: string[] = [];
+      while ((m = TAURI_COMMAND_RE.exec(source)) !== null) names.push(m[1]!);
+      if (names.length === 0) continue;
+
+      const rows = ctx.db
+        .prepare(`SELECT id, name FROM nodes WHERE label = 'Function' AND language = 'rust' AND file_path = ?`)
+        .all(relPath) as { id: string; name: string }[];
+      const byName = new Map(rows.map((r) => [r.name, r.id]));
+      for (const name of names) {
+        const nodeId = byName.get(name);
+        if (nodeId) endpoints.push({ key: name, nodeId, language: 'rust' });
+      }
+    }
+    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;
+
+      TAURI_INVOKE_RE.lastIndex = 0;
+      let m: RegExpExecArray | null;
+      const commandNames: string[] = [];
+      while ((m = TAURI_INVOKE_RE.exec(source)) !== null) commandNames.push(m[1]!);
+      if (commandNames.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 name of commandNames) {
+        endpoints.push({ key: name, nodeId: fileRow.id, language: 'javascript' });
+      }
+    }
+    return endpoints;
+  },
+};

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

@@ -0,0 +1,31 @@
+import type { PipelineContext } from '../../types.js';
+
+/**
+ * One side of a cross-language bridge boundary — a definition (the thing being
+ * exposed across the boundary) or a call site (the thing invoking across it).
+ * `key` is the string both sides are matched on: an exact symbol name for
+ * codegen-based bridges (Wails, wasm-bindgen), or a string-literal channel/
+ * command name for registration-based bridges (Tauri, Electron IPC).
+ */
+export interface BridgeEndpoint {
+  key: string;
+  nodeId: string;
+  language: string;
+}
+
+/**
+ * A cross-language bridge adapter. Each adapter independently extracts
+ * (key, nodeId) pairs from both sides of one specific FFI/IPC/RPC boundary;
+ * the bridge-resolver phase matches them by key and emits CALLS edges.
+ *
+ * `detect` must be cheap — it runs for every adapter on every build, so an
+ * adapter whose framework isn't present in the repo should bail out fast
+ * (e.g. checking file paths already collected by the scan phase) rather than
+ * re-reading the filesystem.
+ */
+export interface BridgeAdapter {
+  name: string;
+  detect(ctx: PipelineContext, filePaths: string[]): boolean;
+  findDefinitions(ctx: PipelineContext, filePaths: string[]): BridgeEndpoint[];
+  findCallSites(ctx: PipelineContext, filePaths: string[]): BridgeEndpoint[];
+}

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

@@ -0,0 +1,33 @@
+import type { PipelineContext } from '../../types.js';
+import type { BridgeAdapter, BridgeEndpoint } from './types.js';
+
+const WAILS_BINDING_RE = /wailsjs\/go\//i;
+
+/**
+ * Wails (Go <-> JS/TS): `wails` generates a JS/TS binding file per bound Go
+ * struct at `frontend/**\/wailsjs/go/<package>/<Struct>.js`, exporting one
+ * function per Go method with the exact same name. Both sides are already
+ * parsed into real Function/Method nodes by the Go and TS/JS extractors —
+ * this adapter just links them by name across the language boundary.
+ */
+export const wailsAdapter: BridgeAdapter = {
+  name: 'wails',
+
+  detect(_ctx, filePaths) {
+    return filePaths.some((p) => WAILS_BINDING_RE.test(p));
+  },
+
+  findDefinitions(ctx) {
+    const rows = ctx.db
+      .prepare(`SELECT id, name, language FROM nodes WHERE label = 'Method' AND language = 'go' AND file_path IS NOT NULL`)
+      .all() as { id: string; name: string; language: string }[];
+    return rows.map((r): BridgeEndpoint => ({ key: r.name, nodeId: r.id, language: r.language }));
+  },
+
+  findCallSites(ctx) {
+    const rows = ctx.db
+      .prepare(`SELECT id, name, language, file_path FROM nodes WHERE label = 'Function' AND file_path LIKE '%wailsjs/go/%'`)
+      .all() as { id: string; name: string; language: string; file_path: string }[];
+    return rows.map((r): BridgeEndpoint => ({ key: r.name, nodeId: r.id, language: r.language ?? 'javascript' }));
+  },
+};

package/src/pipeline/phases/bridge-resolver.ts

@@ -0,0 +1,77 @@
+import type { PipelinePhase } from '../types.js';
+import type { MonographEdge } from '../../types.js';
+import { makeId, CONFIDENCE_SCORE } from '../../types.js';
+import { insertEdges } from '../../storage/edge-store.js';
+import type { ScanOutput } from './scan.js';
+import { BUILTIN_BRIDGE_ADAPTERS } from './bridge-adapters/registry.js';
+import type { BridgeEndpoint } from './bridge-adapters/types.js';
+
+export interface BridgeResolverOutput {
+  edgesCreated: number;
+}
+
+/**
+ * Cross-language bridge resolution — links calls across an FFI/IPC boundary
+ * that no single language's own import/call resolution can see (Wails'
+ * generated Go<->JS bindings, Tauri's invoke() commands, Electron's IPC
+ * channels, ...). Each adapter in bridge-adapters/ extracts (key, nodeId)
+ * pairs from both sides; here they're matched by key and turned into CALLS
+ * edges — reusing the existing relation so every existing consumer
+ * (monograph_impact, monograph_neighbors, community detection) picks them up
+ * with no changes on their end.
+ *
+ * Confidence is always INFERRED: a bridge edge is a name/key match, not an
+ * AST-verified call. A key with more than one matching definition is
+ * dropped rather than guessed at — the call site can't know which one was
+ * meant, and a wrong edge is worse than a missing one. Multiple call sites
+ * sharing one definition (the common case: several UI files calling the
+ * same bound method) is normal and always kept.
+ */
+export const bridgeResolverPhase: PipelinePhase<BridgeResolverOutput> = {
+  name: 'bridge-resolver',
+  deps: ['scan', 'structure', 'parse'],
+  async execute(ctx, deps) {
+    if (ctx.allFilesCached) return { edgesCreated: 0 };
+
+    const { filePaths } = deps.get('scan') as ScanOutput;
+    const edges: MonographEdge[] = [];
+
+    for (const adapter of BUILTIN_BRIDGE_ADAPTERS) {
+      if (!adapter.detect(ctx, filePaths)) continue;
+
+      const definitions = adapter.findDefinitions(ctx, filePaths);
+      const callSites = adapter.findCallSites(ctx, filePaths);
+      if (definitions.length === 0 || callSites.length === 0) continue;
+
+      const definitionsByKey = new Map<string, BridgeEndpoint[]>();
+      for (const def of definitions) {
+        const arr = definitionsByKey.get(def.key);
+        if (arr) arr.push(def);
+        else definitionsByKey.set(def.key, [def]);
+      }
+
+      for (const callSite of callSites) {
+        const matches = definitionsByKey.get(callSite.key);
+        if (!matches || matches.length !== 1) continue; // 0 or ambiguous — drop, don't guess
+        const target = matches[0]!;
+        if (target.nodeId === callSite.nodeId) continue; // same node on both sides — nothing to link
+
+        const id = makeId('bridge', adapter.name, callSite.nodeId, target.nodeId);
+        const languagePair = `${callSite.language} -> ${target.language}`;
+        edges.push({
+          id,
+          sourceId: callSite.nodeId,
+          targetId: target.nodeId,
+          relation: 'CALLS',
+          confidence: 'INFERRED',
+          confidenceScore: CONFIDENCE_SCORE.INFERRED,
+          reason: `${adapter.name} bridge (${languagePair}): "${callSite.key}"`,
+          evidence: [{ kind: 'bridge', weight: CONFIDENCE_SCORE.INFERRED, note: `${adapter.name}: ${languagePair}` }],
+        });
+      }
+    }
+
+    if (edges.length > 0) insertEdges(ctx.db, edges);
+    return { edgesCreated: edges.length };
+  },
+};