@monoes/monograph 1.2.0 → 1.2.2

package/src/pipeline/phases/contextual-proximity.ts

@@ -22,19 +22,26 @@ export const contextualProximityPhase: PipelinePhase<ContextualProximityOutput>
 
     if (rows.length === 0) return { coOccursEdges: 0, conceptsScored: 0 };
 
-    // Group concepts by section
+    // Group concepts by section using ??= to avoid has+get pattern
     const sectionConcepts = new Map<string, string[]>();
     for (const { source_id, target_id } of rows) {
-      if (!sectionConcepts.has(source_id)) sectionConcepts.set(source_id, []);
-      sectionConcepts.get(source_id)!.push(target_id);
+      let list = sectionConcepts.get(source_id);
+      if (!list) { list = []; sectionConcepts.set(source_id, list); }
+      list.push(target_id);
     }
 
-    // Count concept co-occurrences across all sections
+    // Count concept co-occurrences across all sections.
+    // Accumulate conceptDegree in the same pass to avoid a second loop over sectionConcepts.
+    // Use a ternary comparison instead of [a,b].sort() to avoid per-pair array allocation.
     const coOccur = new Map<string, number>();
+    const conceptDegree = new Map<string, number>();
     for (const concepts of sectionConcepts.values()) {
       for (let i = 0; i < concepts.length; i++) {
+        conceptDegree.set(concepts[i], (conceptDegree.get(concepts[i]) ?? 0) + 1);
         for (let j = i + 1; j < concepts.length; j++) {
-          const [a, b] = [concepts[i], concepts[j]].sort();
+          // Avoid allocating a 2-element sort array — ternary comparison is equivalent
+          const a = concepts[i] <= concepts[j] ? concepts[i] : concepts[j];
+          const b = concepts[i] <= concepts[j] ? concepts[j] : concepts[i];
           const key = `${a}::${b}`;
           coOccur.set(key, (coOccur.get(key) ?? 0) + 1);
         }
@@ -58,16 +65,10 @@ export const contextualProximityPhase: PipelinePhase<ContextualProximityOutput>
       });
     }
 
-    // Score concept importance 1-5 based on normalized degree (sections it appears in)
-    const conceptDegree = new Map<string, number>();
-    for (const concepts of sectionConcepts.values()) {
-      for (const cid of concepts) {
-        conceptDegree.set(cid, (conceptDegree.get(cid) ?? 0) + 1);
-      }
-    }
-
     if (conceptDegree.size > 0) {
-      const maxDeg = [...conceptDegree.values()].reduce((a, b) => Math.max(a, b), 0);
+      // Compute maxDeg with a loop to avoid spread array allocation from [...values()]
+      let maxDeg = 0;
+      for (const deg of conceptDegree.values()) { if (deg > maxDeg) maxDeg = deg; }
       const update = ctx.db.prepare(
         `UPDATE nodes SET properties = json_set(COALESCE(properties, '{}'), '$.importance', ?) WHERE id = ?`,
       );

package/src/pipeline/phases/cross-file.ts

@@ -16,27 +16,49 @@ export const crossFilePhase: PipelinePhase<CrossFileOutput> = {
     const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
     const { fileNodes } = deps.get('structure') as StructureOutput;
 
-    // Symbol name → symbol node ID
+    /** Extract the last path segment of a '/'-separated string (faster than split+pop). */
+    function lastSegment(s: string): string {
+      const idx = s.lastIndexOf('/');
+      return idx === -1 ? s : s.slice(idx + 1);
+    }
+
+    /** Strip leading `import_` prefix, then return the last path segment. */
+    function targetBasename(rawId: string): string {
+      const stripped = rawId.startsWith('import_') ? rawId.slice(7) : rawId;
+      return lastSegment(stripped);
+    }
+
+    // Symbol name → symbol node ID.
+    // Pre-key lowercase variants so IMPORTS resolution is a single Map.get() instead of two.
     const nameIndex = new Map<string, string>();
     for (const node of symbolNodes) {
       nameIndex.set(node.name, node.id);
-      if (node.normLabel) nameIndex.set(node.normLabel, node.id);
+      const lower = node.name.toLowerCase();
+      if (lower !== node.name) nameIndex.set(lower, node.id);
+      if (node.normLabel) {
+        nameIndex.set(node.normLabel, node.id);
+        const normLower = node.normLabel.toLowerCase();
+        if (normLower !== node.normLabel) nameIndex.set(normLower, node.id);
+      }
     }
 
-    // Basename (without extension) → File node ID, for resolving RE_EXPORTS
+    // Basename (without extension) → File node ID, for resolving RE_EXPORTS.
+    // Use lastIndexOf to avoid allocating a full split array per file path.
     const fileBasenameIndex = new Map<string, string>();
     for (const fileNode of fileNodes) {
-      const basename = (fileNode.filePath ?? '').split('/').pop() ?? '';
-      const noExt = basename.replace(/\.[^.]+$/, '');
-      fileBasenameIndex.set(noExt.toLowerCase(), fileNode.id);
-      fileBasenameIndex.set(basename.toLowerCase(), fileNode.id);
+      const basename = lastSegment(fileNode.filePath ?? '').toLowerCase();
+      const dotIdx = basename.lastIndexOf('.');
+      const noExt = dotIdx === -1 ? basename : basename.slice(0, dotIdx);
+      fileBasenameIndex.set(basename, fileNode.id);
+      if (noExt !== basename) fileBasenameIndex.set(noExt, fileNode.id);
     }
 
     const resolvedEdges: MonographEdge[] = [];
 
     for (const edge of allEdges) {
       if (edge.relation === 'IMPORTS') {
-        const targetName = edge.targetId.replace(/^import_/, '').split('/').pop() ?? '';
+        const targetName = targetBasename(edge.targetId);
+        // Single lookup — lowercase variants are pre-keyed in nameIndex
         const resolvedId = nameIndex.get(targetName) ?? nameIndex.get(targetName.toLowerCase());
 
         if (resolvedId && resolvedId !== edge.targetId) {
@@ -49,12 +71,11 @@ export const crossFilePhase: PipelinePhase<CrossFileOutput> = {
           });
         }
       } else if (edge.relation === 'RE_EXPORTS') {
-        // Resolve to a File node ID
-        const rawTarget = edge.targetId.replace(/^import_/, '');
-        const basename = rawTarget.split('/').pop() ?? '';
-        const noExt = basename.replace(/\.[^.]+$/, '');
-        const resolvedId = fileBasenameIndex.get(basename.toLowerCase())
-          ?? fileBasenameIndex.get(noExt.toLowerCase());
+        // Resolve to a File node ID using the pre-built basename index
+        const basename = targetBasename(edge.targetId).toLowerCase();
+        const dotIdx = basename.lastIndexOf('.');
+        const noExt = dotIdx === -1 ? basename : basename.slice(0, dotIdx);
+        const resolvedId = fileBasenameIndex.get(basename) ?? fileBasenameIndex.get(noExt);
 
         if (resolvedId && resolvedId !== edge.targetId) {
           resolvedEdges.push({

package/src/pipeline/phases/field-access.ts

@@ -16,12 +16,19 @@ export function extractFieldAccesses(source: string, varName: string, filePath:
   const lines = source.split('\n');
   const escapedName = escapeRegexChars(varName);
 
+  // Hoist regex construction outside the loop — both patterns are fixed for the
+  // entire call, so creating them once avoids O(lines) RegExp allocations.
+  // Write: varName.field = or varName.field +=/-=/*=
+  const writeRe = new RegExp(`\\b${escapedName}\\.(\\w+)\\s*(?:\\+|-|\\*|\\/|%)?=(?!=)`, 'g');
+  // Read: varName.field NOT followed by assignment operator
+  const readRe = new RegExp(`\\b${escapedName}\\.(\\w+)`, 'g');
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    // Write: varName.field = or varName.field +=/-=/*=
-    const writeRe = new RegExp(`\\b${escapedName}\\.(\\w+)\\s*(?:\\+|-|\\*|\\/|%)?=(?!=)`, 'g');
-    // Read: varName.field NOT followed by assignment operator
-    const readRe = new RegExp(`\\b${escapedName}\\.(\\w+)`, 'g');
+
+    // Reset stateful lastIndex before each line (required for reused /g regexes).
+    writeRe.lastIndex = 0;
+    readRe.lastIndex = 0;
 
     const writeFields = new Set<string>();
     let m: RegExpExecArray | null;

package/src/pipeline/phases/god-nodes.ts

@@ -53,16 +53,17 @@ export const godNodesPhase: PipelinePhase<GodNodesOutput> = {
       inDeg.set(e.targetId, (inDeg.get(e.targetId) ?? 0) + 1);
     }
 
-    // Compute degree distributions from all symbol nodes
-    const allFanIn = symbolNodes
-      .filter(n => !EXCLUDED_LABELS.has(n.label))
-      .map(n => inDeg.get(n.id) ?? 0)
-      .sort((a, b) => a - b);
-
-    const allFanOut = symbolNodes
-      .filter(n => !EXCLUDED_LABELS.has(n.label))
-      .map(n => outDeg.get(n.id) ?? 0)
-      .sort((a, b) => a - b);
+    // Compute degree distributions from all symbol nodes in a single pass
+    // (avoids two separate filter + map passes over potentially large arrays)
+    const allFanIn: number[] = [];
+    const allFanOut: number[] = [];
+    for (const n of symbolNodes) {
+      if (EXCLUDED_LABELS.has(n.label)) continue;
+      allFanIn.push(inDeg.get(n.id) ?? 0);
+      allFanOut.push(outDeg.get(n.id) ?? 0);
+    }
+    allFanIn.sort((a, b) => a - b);
+    allFanOut.sort((a, b) => a - b);
 
     const thresholds: GodNodesThresholds = {
       p75FanIn: percentile(allFanIn, 75),
@@ -116,3 +117,39 @@ export const godNodesPhase: PipelinePhase<GodNodesOutput> = {
     return { godNodes, thresholds };
   },
 };
+
+/**
+ * Format god-node results as structured text with file:line hints for LLM navigation.
+ */
+export function formatGodNodes(output: GodNodesOutput): string {
+  const { godNodes, thresholds } = output;
+  if (godNodes.length === 0) {
+    return 'god-nodes: none\nstatus: no high-centrality nodes detected\n';
+  }
+
+  const lines: string[] = [
+    `god-nodes: ${godNodes.length} high-centrality node(s) detected`,
+    `thresholds: fanIn p75=${thresholds.p75FanIn} p90=${thresholds.p90FanIn} p95=${thresholds.p95FanIn}; fanOut p75=${thresholds.p75FanOut} p90=${thresholds.p90FanOut}`,
+    '',
+  ];
+
+  for (let i = 0; i < godNodes.length; i++) {
+    const n = godNodes[i];
+    const loc = n.filePath
+      ? `${n.filePath}${n.startLine !== undefined ? `:${n.startLine}` : ''}`
+      : n.id;
+    lines.push(`[${i + 1}] ${n.name} (${n.label}) — ${n.category}`);
+    lines.push(`  file: ${loc}`);
+    lines.push(`  degree: ${n.degree} (fanIn=${n.inDegree}, fanOut=${n.outDegree})`);
+    for (const f of n.contributingFactors) {
+      lines.push(`  factor: ${f.metric}=${f.value} (threshold=${f.threshold})`);
+    }
+    lines.push('');
+  }
+
+  const bridgeCount = godNodes.filter(n => n.category === 'BRIDGE_NODE').length;
+  const highCentralityCount = godNodes.length - bridgeCount;
+  lines.push(`summary: ${highCentralityCount} HIGH_CENTRALITY, ${bridgeCount} BRIDGE_NODE`);
+
+  return lines.join('\n');
+}

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

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
+import { readFileSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
 import type { PipelinePhase, PipelineContext } from '../types.js';
 
@@ -18,7 +18,7 @@ function globWorkspacePattern(repoPath: string, pattern: string): string[] {
   }
   const [base] = pattern.split('/*');
   const baseDir = join(repoPath, base ?? '');
-  if (!existsSync(baseDir)) return [];
+  // Skip existsSync — readdirSync will throw ENOENT which the catch already handles.
   try {
     return readdirSync(baseDir, { withFileTypes: true })
       .filter(d => d.isDirectory())
@@ -30,8 +30,6 @@ function globWorkspacePattern(repoPath: string, pattern: string): string[] {
 
 export function detectWorkspacePackages(repoPath: string): WorkspacePackage[] {
   const pkgPath = join(repoPath, 'package.json');
-  if (!existsSync(pkgPath)) return [];
-
   let workspaceGlobs: string[] = [];
   try {
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
@@ -47,8 +45,8 @@ export function detectWorkspacePackages(repoPath: string): WorkspacePackage[] {
     const dirs = globWorkspacePattern(repoPath, glob);
     for (const dir of dirs) {
       const subPkgPath = join(dir, 'package.json');
-      if (!existsSync(subPkgPath)) continue;
       try {
+        // existsSync guard removed — readFileSync throws ENOENT which the catch handles.
         const subPkg = JSON.parse(readFileSync(subPkgPath, 'utf8'));
         if (subPkg.name) {
           result.push({ name: subPkg.name, path: resolve(dir) });
@@ -72,6 +70,40 @@ export function resolveWorkspaceImport(
   return null;
 }
 
+/**
+ * Build a Map<packageName, packagePath> index from a WorkspacePackage array.
+ * Use this when resolveWorkspaceImport will be called many times (e.g. per import
+ * statement across a whole repo) to reduce resolution cost from O(N*I) to O(N+I).
+ */
+export function buildPackageIndex(packages: WorkspacePackage[]): Map<string, string> {
+  const index = new Map<string, string>();
+  for (const pkg of packages) {
+    index.set(pkg.name, pkg.path);
+  }
+  return index;
+}
+
+/**
+ * O(1) workspace import resolution using a pre-built package index.
+ * Falls back to prefix scan only for sub-path imports (e.g. `pkg/subpath`).
+ */
+export function resolveWorkspaceImportFromIndex(
+  importSpecifier: string,
+  index: Map<string, string>,
+): string | null {
+  // Exact match: O(1)
+  const exact = index.get(importSpecifier);
+  if (exact !== undefined) return exact;
+  // Sub-path import: find the matching package name prefix
+  const slash = importSpecifier.indexOf('/', importSpecifier.startsWith('@') ? importSpecifier.indexOf('/') + 1 : 0);
+  if (slash !== -1) {
+    const pkgName = importSpecifier.slice(0, slash);
+    const path = index.get(pkgName);
+    if (path !== undefined) return path;
+  }
+  return null;
+}
+
 export const importResolverPhase: PipelinePhase<ImportResolverOutput> = {
   name: 'import-resolver',
   deps: ['cross-file'],

package/src/pipeline/phases/leiden.ts

@@ -26,11 +26,18 @@ export function leiden(graph: Graph, _options: { seed?: number } = {}): Record<s
   // Phase 1: Louvain with deterministic settings
   const communities: Record<string, number> = louvain(graph, { randomWalk: false });
 
-  // Phase 2: Refinement — merge singletons into their largest neighbor's community
+  // Phase 2: Refinement — merge singletons into their largest neighbor's community.
+  // Single pass over Object.entries to build both communitySizes and the singletonNodes Set,
+  // avoiding a separate Object.values scan. The singletonNodes Set enables O(1) skip in the
+  // refinement loop below instead of a map.get(commId) <= 1 test per node.
   const communitySizes = new Map<number, number>();
   for (const comm of Object.values(communities)) {
     communitySizes.set(comm, (communitySizes.get(comm) ?? 0) + 1);
   }
+  const singletonNodes = new Set<string>();
+  for (const [nodeId, commId] of Object.entries(communities)) {
+    if ((communitySizes.get(commId) ?? 0) <= 1) singletonNodes.add(nodeId);
+  }
 
   // Refinement: merge singletons into their largest neighbor's community.
   // Pass 1: update communitySizes eagerly (so adjacent singletons see each other's moves
@@ -38,26 +45,26 @@ export function leiden(graph: Graph, _options: { seed?: number } = {}): Record<s
   // Pass 2: apply community writes — keeps the community map consistent at all times.
   const pending = new Map<string, number>();
   for (const [nodeId, commId] of Object.entries(communities)) {
-    if ((communitySizes.get(commId) ?? 0) <= 1) {
-      let bestComm = commId;
-      let bestSize = 0;
+    if (!singletonNodes.has(nodeId)) continue; // O(1) skip for non-singletons
 
-      graph.forEachNeighbor(nodeId, (neighbor: string) => {
-        const neighborComm = communities[neighbor];
-        if (neighborComm === undefined) return;
-        const size = communitySizes.get(neighborComm) ?? 0;
-        if (size > bestSize) {
-          bestSize = size;
-          bestComm = neighborComm;
-        }
-      });
+    let bestComm = commId;
+    let bestSize = 0;
 
-      if (bestComm !== commId) {
-        // Update sizes eagerly so subsequent singletons see the correct community sizes
-        communitySizes.set(commId, (communitySizes.get(commId) ?? 1) - 1);
-        communitySizes.set(bestComm, (communitySizes.get(bestComm) ?? 0) + 1);
-        pending.set(nodeId, bestComm);
+    graph.forEachNeighbor(nodeId, (neighbor: string) => {
+      const neighborComm = communities[neighbor];
+      if (neighborComm === undefined) return;
+      const size = communitySizes.get(neighborComm) ?? 0;
+      if (size > bestSize) {
+        bestSize = size;
+        bestComm = neighborComm;
       }
+    });
+
+    if (bestComm !== commId) {
+      // Update sizes eagerly so subsequent singletons see the correct community sizes
+      communitySizes.set(commId, (communitySizes.get(commId) ?? 1) - 1);
+      communitySizes.set(bestComm, (communitySizes.get(bestComm) ?? 0) + 1);
+      pending.set(nodeId, bestComm);
     }
   }
 

package/src/pipeline/phases/markdown.ts

@@ -10,6 +10,8 @@ import type { StructureOutput } from './structure.js';
 const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
 // Inline code span: `identifier`
 const INLINE_CODE_RE = /`([^`]+)`/g;
+// Module-level constant: compiled once per process, not per isIdentifier() call.
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$.-]*$/;
 
 export interface MarkdownOutput {
   documentNodes: MonographNode[];
@@ -23,6 +25,7 @@ export const markdownPhase: PipelinePhase<MarkdownOutput> = {
   // Runs before communities so REFERENCES edges are visible to graph analyses.
   deps: ['parse', 'structure'],
   async execute(ctx, deps) {
+    if (ctx.options.codeOnly) return { documentNodes: [], referencesEdges: [] };
     const { fileNodes } = deps.get('structure') as StructureOutput;
     const documentNodes: MonographNode[] = [];
     const referencesEdges: MonographEdge[] = [];
@@ -62,17 +65,19 @@ export const markdownPhase: PipelinePhase<MarkdownOutput> = {
       // Extract inline code spans and match against symbol names in the DB
       if (ctx.db) {
         const spans = extractCodeSpans(source);
+        // Hoist prepared statement outside the span loop — avoids re-compiling the
+        // SQL query for every identifier in every markdown file (N+1 preparation).
+        const symbolLookup = ctx.db.prepare(
+          `SELECT id FROM nodes WHERE name = ?
+           AND label NOT IN ('File', 'Folder', 'Document')`,
+        );
+
         for (const span of spans) {
           // Only match single-word identifiers (not shell commands, paths, etc.)
           if (!isIdentifier(span)) continue;
 
           // Exact name match, excluding structural nodes to avoid matching file names
-          const rows = ctx.db
-            .prepare(
-              `SELECT id FROM nodes WHERE name = ?
-               AND label NOT IN ('File', 'Folder', 'Document')`,
-            )
-            .all(span) as { id: string }[];
+          const rows = symbolLookup.all(span) as { id: string }[];
 
           if (rows.length === 1) {
             const edgeId = makeId(docId, rows[0].id, 'references');
@@ -112,5 +117,5 @@ function extractCodeSpans(source: string): string[] {
 
 /** Accept only simple identifiers — letters, digits, underscores, hyphens, dots (for namespaced names). */
 function isIdentifier(span: string): boolean {
-  return /^[A-Za-z_$][A-Za-z0-9_$.-]*$/.test(span);
+  return IDENTIFIER_RE.test(span);
 }

package/src/pipeline/phases/pdf-parse.ts

@@ -107,8 +107,25 @@ export const pdfParsePhase: PipelinePhase<PdfParseOutput> = {
       }
     }
 
-    if (sectionNodes.length > 0) insertNodes(ctx.db, sectionNodes);
-    if (allEdges.length > 0) insertEdges(ctx.db, allEdges);
+    if (sectionNodes.length > 0) {
+      // File nodes are not persisted by structure/parse phases for non-code files —
+      // insert them here before edges to satisfy the FK constraint.
+      const seenFileIds = new Set<string>();
+      const fileNodes: MonographNode[] = [];
+      for (const edge of allEdges) {
+        if (!seenFileIds.has(edge.sourceId)) {
+          seenFileIds.add(edge.sourceId);
+          const relPath = sectionNodes.find(n => n.id === edge.targetId)?.filePath ?? '';
+          fileNodes.push({
+            id: edge.sourceId, label: 'File',
+            name: basename(relPath), normLabel: toNormLabel(basename(relPath)),
+            filePath: relPath, isExported: false,
+          });
+        }
+      }
+      insertNodes(ctx.db, [...fileNodes, ...sectionNodes]);
+      insertEdges(ctx.db, allEdges);
+    }
 
     ctx.onProgress?.({ phase: 'pdf-parse', message: `Parsed ${pdfPaths.length} PDF files → ${sectionNodes.length} chunks` });
     return { sectionNodes, pdfFiles: pdfPaths.length };

package/src/pipeline/phases/processes.ts

@@ -79,31 +79,43 @@ function scoreEntryPoints(db: Database.Database): ScoredNode[] {
       language: string | null;
     }>;
 
-  const incomingCallsStmt = db.prepare(
-    `SELECT COUNT(*) as cnt FROM edges WHERE target_id = ? AND relation = 'CALLS'`,
-  );
-  const isRouteHandlerStmt = db.prepare(
-    `SELECT COUNT(*) as cnt FROM edges WHERE target_id = ? AND relation = 'HANDLES_ROUTE'`,
-  );
-  const isToolHandlerStmt = db.prepare(
-    `SELECT COUNT(*) as cnt FROM edges WHERE target_id = ? AND relation = 'HANDLES_TOOL'`,
-  );
+  // Preload all three edge-count signals in a single pass instead of 3 per-row queries.
+  // LEFT JOIN with FILTER avoids N*3 prepared-stmt round-trips.
+  const edgeCounts = db
+    .prepare(
+      `SELECT
+         n.id,
+         COUNT(CASE WHEN e.relation = 'CALLS'         THEN 1 END) AS incoming_calls,
+         COUNT(CASE WHEN e.relation = 'HANDLES_ROUTE' THEN 1 END) AS route_count,
+         COUNT(CASE WHEN e.relation = 'HANDLES_TOOL'  THEN 1 END) AS tool_count
+       FROM nodes n
+       LEFT JOIN edges e ON e.target_id = n.id AND e.relation IN ('CALLS','HANDLES_ROUTE','HANDLES_TOOL')
+       WHERE n.label IN ('Function','Method','Class')
+       GROUP BY n.id`,
+    )
+    .all() as Array<{ id: string; incoming_calls: number; route_count: number; tool_count: number }>;
+
+  const callsMap    = new Map<string, number>();
+  const routeSet    = new Set<string>();
+  const toolSet     = new Set<string>();
+  for (const r of edgeCounts) {
+    callsMap.set(r.id, r.incoming_calls);
+    if (r.route_count > 0) routeSet.add(r.id);
+    if (r.tool_count  > 0) toolSet.add(r.id);
+  }
 
   const scored: ScoredNode[] = [];
 
   for (const row of symbolRows) {
     let score = 0;
 
-    const incomingCalls = (incomingCallsStmt.get(row.id) as { cnt: number }).cnt;
-    if (incomingCalls === 0) score += 3;
+    if ((callsMap.get(row.id) ?? 0) === 0) score += 3;
 
     if (row.is_exported === 1) score += 2;
 
-    const isRouteHandler = (isRouteHandlerStmt.get(row.id) as { cnt: number }).cnt > 0;
-    if (isRouteHandler) score += 4;
+    if (routeSet.has(row.id)) score += 4;
 
-    const isToolHandler = (isToolHandlerStmt.get(row.id) as { cnt: number }).cnt > 0;
-    if (isToolHandler) score += 4;
+    if (toolSet.has(row.id)) score += 4;
 
     const filePath = row.file_path ?? '';
     const filename = basename(filePath, extname(filePath)).toLowerCase();

package/src/pipeline/phases/re-export-propagation.ts

@@ -74,6 +74,36 @@ export function propagateReExports(db: Database.Database): ReExportPropagationOu
     },
   );
 
+  // ── Preload: avoid per-iteration DB queries inside the BFS while-loop ─────────
+
+  // nodeId → file_path for all nodes (used to resolve importer file paths)
+  const nodeIdToFilePath = new Map<string, string>(
+    (db.prepare(`SELECT id, file_path FROM nodes WHERE file_path IS NOT NULL`)
+      .all() as { id: string; file_path: string }[]).map(r => [r.id, r.file_path]),
+  );
+
+  // barrelFilePath → Set<importerNodeId>: who IMPORTS any node from each barrel file
+  // Load all IMPORTS edges once and group by target file_path
+  const allImportEdges = db.prepare(`
+    SELECT e.source_id, n.file_path AS target_file_path
+    FROM edges e
+    JOIN nodes n ON n.id = e.target_id
+    WHERE e.relation = 'IMPORTS'
+      AND n.file_path IS NOT NULL
+  `).all() as { source_id: string; target_file_path: string }[];
+
+  const barrelImporters = new Map<string, Set<string>>();
+  for (const row of allImportEdges) {
+    let s = barrelImporters.get(row.target_file_path);
+    if (!s) {
+      s = new Set();
+      barrelImporters.set(row.target_file_path, s);
+    }
+    s.add(row.source_id);
+  }
+
+  // ── BFS fixed-point (all lookups now O(1) from preloaded maps) ────────────────
+
   let totalPropagated = 0;
   let changed = true;
 
@@ -85,24 +115,16 @@ export function propagateReExports(db: Database.Database): ReExportPropagationOu
       const barrelFilePath = fileIdToPath.get(barrelFileId);
       if (!barrelFilePath || !reachedFilePaths.has(barrelFilePath)) continue;
 
-      // Find who imports this barrel (via its File node or via its symbols)
-      const importers = db.prepare(`
-        SELECT DISTINCT e.source_id
-        FROM edges e
-        WHERE e.relation = 'IMPORTS'
-          AND e.target_id IN (
-            SELECT id FROM nodes
-            WHERE file_path = ?
-          )
-      `).all(barrelFilePath) as { source_id: string }[];
-
-      for (const { source_id: importerNodeId } of importers) {
-        // Walk up to the importing File node
-        const importerFilePath = (db.prepare(
-          `SELECT file_path FROM nodes WHERE id = ? AND file_path IS NOT NULL LIMIT 1`,
-        ).get(importerNodeId) as { file_path: string } | null)?.file_path;
-
-        const importerFileId = importerFilePath ? filePathToId.get(importerFilePath) : undefined;
+      // O(1) lookup instead of per-barrel DB query
+      const importerNodeIds = barrelImporters.get(barrelFilePath);
+      if (!importerNodeIds) continue;
+
+      for (const importerNodeId of importerNodeIds) {
+        // O(1) lookup instead of per-importer DB query
+        const importerFilePath = nodeIdToFilePath.get(importerNodeId);
+        if (!importerFilePath) continue;
+
+        const importerFileId = filePathToId.get(importerFilePath);
         if (!importerFileId) continue;
 
         for (const targetFileId of exportedFileIds) {