gitnexus 1.4.0 → 1.4.5

package/dist/core/ingestion/parsing-processor.js

@@ -1,10 +1,11 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
 import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
+import { typeConfigs } from './type-extractors/index.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
 // isNodeExported imported from ./export-detection.js (shared module)
 // Re-export for backward compatibility with any external consumers
@@ -21,7 +22,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             parseableFiles.push({ path: file.path, content: file.content });
     }
     if (parseableFiles.length === 0)
-        return { imports: [], calls: [], heritage: [], routes: [] };
+        return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -32,6 +33,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allCalls = [];
     const allHeritage = [];
     const allRoutes = [];
+    const allConstructorBindings = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -46,6 +48,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         for (const sym of result.symbols) {
             symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
                 parameterCount: sym.parameterCount,
+                returnType: sym.returnType,
                 ownerId: sym.ownerId,
             });
         }
@@ -53,10 +56,24 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         allCalls.push(...result.calls);
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
+        allConstructorBindings.push(...result.constructorBindings);
+    }
+    // Merge and log skipped languages from workers
+    const skippedLanguages = new Map();
+    for (const result of chunkResults) {
+        for (const [lang, count] of Object.entries(result.skippedLanguages)) {
+            skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count);
+        }
+    }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes };
+    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
@@ -64,6 +81,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
+    const skippedLanguages = new Map();
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onFileProgress?.(i + 1, total, file.path);
@@ -72,6 +90,11 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
+        // Skip unsupported languages (e.g. Swift when tree-sitter-swift not installed)
+        if (!isLanguageAvailable(language)) {
+            skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
+            continue;
+        }
         // Skip files larger than the max tree-sitter buffer (32 MB)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
@@ -79,7 +102,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             await loadLanguage(language, file.path);
         }
         catch {
-            continue; // parser unavailable — already warned in pipeline
+            continue; // parser unavailable — safety net
         }
         let tree;
         try {
@@ -177,6 +200,13 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             const methodSig = (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor')
                 ? extractMethodSignature(definitionNode)
                 : undefined;
+            // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
+            if (methodSig && !methodSig.returnType && definitionNode) {
+                const tc = typeConfigs[language];
+                if (tc?.extractReturnType) {
+                    methodSig.returnType = tc.extractReturnType(definitionNode);
+                }
+            }
             const node = {
                 id: nodeId,
                 label: nodeLabel,
@@ -204,6 +234,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
                 parameterCount: methodSig?.parameterCount,
+                returnType: methodSig?.returnType,
                 ownerId: enclosingClassId ?? undefined,
             });
             const fileId = generateId('File', file.path);
@@ -230,6 +261,12 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             }
         });
     }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
+    }
 };
 // ============================================================================
 // Public API

package/dist/core/ingestion/pipeline.d.ts

@@ -1,2 +1,6 @@
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void) => Promise<PipelineResult>;
+export interface PipelineOptions {
+    /** Skip MRO, community detection, and process extraction for faster test runs. */
+    skipGraphPhases?: boolean;
+}
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions) => Promise<PipelineResult>;

package/dist/core/ingestion/pipeline.js

@@ -1,13 +1,13 @@
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
 import { processParsing } from './parsing-processor.js';
-import { processImports, processImportsFromExtracted, createImportMap, createPackageMap, createNamedImportMap, buildImportResolutionContext } from './import-processor.js';
+import { processImports, processImportsFromExtracted, buildImportResolutionContext } from './import-processor.js';
 import { processCalls, processCallsFromExtracted, processRoutesFromExtracted } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
 import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
-import { createSymbolTable } from './symbol-table.js';
+import { createResolutionContext } from './resolution-context.js';
 import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
@@ -24,16 +24,14 @@ const isDev = process.env.NODE_ENV === 'development';
 const CHUNK_BYTE_BUDGET = 20 * 1024 * 1024; // 20MB
 /** Max AST trees to keep in LRU cache */
 const AST_CACHE_CAP = 50;
-export const runPipelineFromRepo = async (repoPath, onProgress) => {
+export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const graph = createKnowledgeGraph();
-    const symbolTable = createSymbolTable();
+    const ctx = createResolutionContext();
+    const symbolTable = ctx.symbols;
     let astCache = createASTCache(AST_CACHE_CAP);
-    const importMap = createImportMap();
-    const packageMap = createPackageMap();
-    const namedImportMap = createNamedImportMap();
     const cleanup = () => {
         astCache.clear();
-        symbolTable.clear();
+        ctx.clear();
     };
     try {
         // ── Phase 1: Scan paths only (no content read) ─────────────────────
@@ -127,24 +125,30 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
             message: `Parsing ${totalParseable} files in ${numChunks} chunk${numChunks !== 1 ? 's' : ''}...`,
             stats: { filesProcessed: 0, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
         });
+        // Don't spawn workers for tiny repos — overhead exceeds benefit
+        const MIN_FILES_FOR_WORKERS = 15;
+        const MIN_BYTES_FOR_WORKERS = 512 * 1024;
+        const totalBytes = parseableScanned.reduce((s, f) => s + f.size, 0);
         // Create worker pool once, reuse across chunks
         let workerPool;
-        try {
-            let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
-            // When running under vitest, import.meta.url points to src/ where no .js exists.
-            // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
-            const thisDir = fileURLToPath(new URL('.', import.meta.url));
-            if (!fs.existsSync(fileURLToPath(workerUrl))) {
-                const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
-                if (fs.existsSync(distWorker)) {
-                    workerUrl = pathToFileURL(distWorker);
+        if (totalParseable >= MIN_FILES_FOR_WORKERS || totalBytes >= MIN_BYTES_FOR_WORKERS) {
+            try {
+                let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
+                // When running under vitest, import.meta.url points to src/ where no .js exists.
+                // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
+                const thisDir = fileURLToPath(new URL('.', import.meta.url));
+                if (!fs.existsSync(fileURLToPath(workerUrl))) {
+                    const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
+                    if (fs.existsSync(distWorker)) {
+                        workerUrl = pathToFileURL(distWorker);
+                    }
                 }
+                workerPool = createWorkerPool(workerUrl);
+            }
+            catch (err) {
+                if (isDev)
+                    console.warn('Worker pool creation failed, using sequential fallback:', err.message);
             }
-            workerPool = createWorkerPool(workerUrl);
-        }
-        catch (err) {
-            if (isDev)
-                console.warn('Worker pool creation failed, using sequential fallback:', err.message);
         }
         let filesParsedSoFar = 0;
         // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)
@@ -179,20 +183,53 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                         stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
                     });
                 }, workerPool);
+                const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
                 if (chunkWorkerData) {
                     // Imports
-                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx, packageMap, namedImportMap);
+                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {
+                        onProgress({
+                            phase: 'parsing',
+                            percent: Math.round(chunkBasePercent),
+                            message: `Resolving imports (chunk ${chunkIdx + 1}/${numChunks})...`,
+                            detail: `${current}/${total} files`,
+                            stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                        });
+                    }, repoPath, importCtx);
                     // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them)
                     // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps,
                     // and the single-threaded event loop prevents races between synchronous addRelationship calls.
                     await Promise.all([
-                        processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap, packageMap, undefined, namedImportMap),
-                        processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable, importMap, packageMap),
-                        processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], symbolTable, importMap, packageMap),
+                        processCallsFromExtracted(graph, chunkWorkerData.calls, ctx, (current, total) => {
+                            onProgress({
+                                phase: 'parsing',
+                                percent: Math.round(chunkBasePercent),
+                                message: `Resolving calls (chunk ${chunkIdx + 1}/${numChunks})...`,
+                                detail: `${current}/${total} files`,
+                                stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                            });
+                        }, chunkWorkerData.constructorBindings),
+                        processHeritageFromExtracted(graph, chunkWorkerData.heritage, ctx, (current, total) => {
+                            onProgress({
+                                phase: 'parsing',
+                                percent: Math.round(chunkBasePercent),
+                                message: `Resolving heritage (chunk ${chunkIdx + 1}/${numChunks})...`,
+                                detail: `${current}/${total} records`,
+                                stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                            });
+                        }),
+                        processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], ctx, (current, total) => {
+                            onProgress({
+                                phase: 'parsing',
+                                percent: Math.round(chunkBasePercent),
+                                message: `Resolving routes (chunk ${chunkIdx + 1}/${numChunks})...`,
+                                detail: `${current}/${total} routes`,
+                                stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                            });
+                        }),
                     ]);
                 }
                 else {
-                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths, packageMap, namedImportMap);
+                    await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
                     sequentialChunkPaths.push(chunkPaths);
                 }
                 filesParsedSoFar += chunkFiles.length;
@@ -211,123 +248,139 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 .filter(p => chunkContents.has(p))
                 .map(p => ({ path: p, content: chunkContents.get(p) }));
             astCache = createASTCache(chunkFiles.length);
-            await processCalls(graph, chunkFiles, astCache, symbolTable, importMap, packageMap, undefined, namedImportMap);
-            await processHeritage(graph, chunkFiles, astCache, symbolTable, importMap, packageMap);
+            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx);
+            await processHeritage(graph, chunkFiles, astCache, ctx);
+            if (rubyHeritage.length > 0) {
+                await processHeritageFromExtracted(graph, rubyHeritage, ctx);
+            }
             astCache.clear();
         }
+        // Log resolution cache stats
+        if (isDev) {
+            const rcStats = ctx.getStats();
+            const total = rcStats.cacheHits + rcStats.cacheMisses;
+            const hitRate = total > 0 ? ((rcStats.cacheHits / total) * 100).toFixed(1) : '0';
+            console.log(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`);
+        }
         // Free import resolution context — suffix index + resolve cache no longer needed
         // (allPathObjects and importCtx hold ~94MB+ for large repos)
         allPathObjects.length = 0;
         importCtx.resolveCache.clear();
         importCtx.suffixIndex = null;
         importCtx.normalizedFileList = null;
-        // ── Phase 4.5: Method Resolution Order ──────────────────────────────
-        onProgress({
-            phase: 'parsing',
-            percent: 81,
-            message: 'Computing method resolution order...',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-        });
-        const mroResult = computeMRO(graph);
-        if (isDev && mroResult.entries.length > 0) {
-            console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`);
-        }
-        // ── Phase 5: Communities ───────────────────────────────────────────
-        onProgress({
-            phase: 'communities',
-            percent: 82,
-            message: 'Detecting code communities...',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-        });
-        const communityResult = await processCommunities(graph, (message, progress) => {
-            const communityProgress = 82 + (progress * 0.10);
+        let communityResult;
+        let processResult;
+        if (!options?.skipGraphPhases) {
+            // ── Phase 4.5: Method Resolution Order ──────────────────────────────
+            onProgress({
+                phase: 'parsing',
+                percent: 81,
+                message: 'Computing method resolution order...',
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+            });
+            const mroResult = computeMRO(graph);
+            if (isDev && mroResult.entries.length > 0) {
+                console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`);
+            }
+            // ── Phase 5: Communities ───────────────────────────────────────────
             onProgress({
                 phase: 'communities',
-                percent: Math.round(communityProgress),
-                message,
+                percent: 82,
+                message: 'Detecting code communities...',
                 stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
             });
-        });
-        if (isDev) {
-            console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
-        }
-        communityResult.communities.forEach(comm => {
-            graph.addNode({
-                id: comm.id,
-                label: 'Community',
-                properties: {
-                    name: comm.label,
-                    filePath: '',
-                    heuristicLabel: comm.heuristicLabel,
-                    cohesion: comm.cohesion,
-                    symbolCount: comm.symbolCount,
-                }
+            communityResult = await processCommunities(graph, (message, progress) => {
+                const communityProgress = 82 + (progress * 0.10);
+                onProgress({
+                    phase: 'communities',
+                    percent: Math.round(communityProgress),
+                    message,
+                    stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+                });
             });
-        });
-        communityResult.memberships.forEach(membership => {
-            graph.addRelationship({
-                id: `${membership.nodeId}_member_of_${membership.communityId}`,
-                type: 'MEMBER_OF',
-                sourceId: membership.nodeId,
-                targetId: membership.communityId,
-                confidence: 1.0,
-                reason: 'leiden-algorithm',
+            if (isDev) {
+                console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
+            }
+            communityResult.communities.forEach(comm => {
+                graph.addNode({
+                    id: comm.id,
+                    label: 'Community',
+                    properties: {
+                        name: comm.label,
+                        filePath: '',
+                        heuristicLabel: comm.heuristicLabel,
+                        cohesion: comm.cohesion,
+                        symbolCount: comm.symbolCount,
+                    }
+                });
             });
-        });
-        // ── Phase 6: Processes ─────────────────────────────────────────────
-        onProgress({
-            phase: 'processes',
-            percent: 94,
-            message: 'Detecting execution flows...',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-        });
-        let symbolCount = 0;
-        graph.forEachNode(n => { if (n.label !== 'File')
-            symbolCount++; });
-        const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
-        const processResult = await processProcesses(graph, communityResult.memberships, (message, progress) => {
-            const processProgress = 94 + (progress * 0.05);
+            communityResult.memberships.forEach(membership => {
+                graph.addRelationship({
+                    id: `${membership.nodeId}_member_of_${membership.communityId}`,
+                    type: 'MEMBER_OF',
+                    sourceId: membership.nodeId,
+                    targetId: membership.communityId,
+                    confidence: 1.0,
+                    reason: 'leiden-algorithm',
+                });
+            });
+            // ── Phase 6: Processes ─────────────────────────────────────────────
             onProgress({
                 phase: 'processes',
-                percent: Math.round(processProgress),
-                message,
+                percent: 94,
+                message: 'Detecting execution flows...',
                 stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
             });
-        }, { maxProcesses: dynamicMaxProcesses, minSteps: 3 });
-        if (isDev) {
-            console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
-        }
-        processResult.processes.forEach(proc => {
-            graph.addNode({
-                id: proc.id,
-                label: 'Process',
-                properties: {
-                    name: proc.label,
-                    filePath: '',
-                    heuristicLabel: proc.heuristicLabel,
-                    processType: proc.processType,
-                    stepCount: proc.stepCount,
-                    communities: proc.communities,
-                    entryPointId: proc.entryPointId,
-                    terminalId: proc.terminalId,
-                }
+            let symbolCount = 0;
+            graph.forEachNode(n => { if (n.label !== 'File')
+                symbolCount++; });
+            const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
+            processResult = await processProcesses(graph, communityResult.memberships, (message, progress) => {
+                const processProgress = 94 + (progress * 0.05);
+                onProgress({
+                    phase: 'processes',
+                    percent: Math.round(processProgress),
+                    message,
+                    stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+                });
+            }, { maxProcesses: dynamicMaxProcesses, minSteps: 3 });
+            if (isDev) {
+                console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
+            }
+            processResult.processes.forEach(proc => {
+                graph.addNode({
+                    id: proc.id,
+                    label: 'Process',
+                    properties: {
+                        name: proc.label,
+                        filePath: '',
+                        heuristicLabel: proc.heuristicLabel,
+                        processType: proc.processType,
+                        stepCount: proc.stepCount,
+                        communities: proc.communities,
+                        entryPointId: proc.entryPointId,
+                        terminalId: proc.terminalId,
+                    }
+                });
             });
-        });
-        processResult.steps.forEach(step => {
-            graph.addRelationship({
-                id: `${step.nodeId}_step_${step.step}_${step.processId}`,
-                type: 'STEP_IN_PROCESS',
-                sourceId: step.nodeId,
-                targetId: step.processId,
-                confidence: 1.0,
-                reason: 'trace-detection',
-                step: step.step,
+            processResult.steps.forEach(step => {
+                graph.addRelationship({
+                    id: `${step.nodeId}_step_${step.step}_${step.processId}`,
+                    type: 'STEP_IN_PROCESS',
+                    sourceId: step.nodeId,
+                    targetId: step.processId,
+                    confidence: 1.0,
+                    reason: 'trace-detection',
+                    step: step.step,
+                });
             });
-        });
+        }
         onProgress({
             phase: 'complete',
             percent: 100,
-            message: `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`,
+            message: communityResult && processResult
+                ? `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`
+                : 'Graph complete! (graph phases skipped)',
             stats: {
                 filesProcessed: totalFiles,
                 totalFiles,

package/dist/core/ingestion/resolution-context.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Resolution Context
+ *
+ * Single implementation of tiered name resolution. Replaces the duplicated
+ * tier-selection logic previously split between symbol-resolver.ts and
+ * call-processor.ts.
+ *
+ * Resolution tiers (highest confidence first):
+ * 1. Same file (lookupExactFull — authoritative)
+ * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
+ * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
+ * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
+ * 3. Global (all candidates — consumers must check candidate count)
+ */
+import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
+import type { NamedImportBinding } from './import-processor.js';
+/** Resolution tier for tracking, logging, and test assertions. */
+export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
+/** Tier-selected candidates with metadata. */
+export interface TieredCandidates {
+    readonly candidates: readonly SymbolDefinition[];
+    readonly tier: ResolutionTier;
+}
+/** Confidence scores per resolution tier. */
+export declare const TIER_CONFIDENCE: Record<ResolutionTier, number>;
+export type ImportMap = Map<string, Set<string>>;
+export type PackageMap = Map<string, Set<string>>;
+export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
+export interface ResolutionContext {
+    /**
+     * The only resolution API. Returns all candidates at the winning tier.
+     *
+     * Tier 3 ('global') returns ALL candidates regardless of count —
+     * consumers must check candidates.length and refuse ambiguous matches.
+     */
+    resolve(name: string, fromFile: string): TieredCandidates | null;
+    /** Symbol table — used by parsing-processor to populate symbols. */
+    readonly symbols: SymbolTable;
+    /** Raw maps — used by import-processor to populate import data. */
+    readonly importMap: ImportMap;
+    readonly packageMap: PackageMap;
+    readonly namedImportMap: NamedImportMap;
+    enableCache(filePath: string): void;
+    clearCache(): void;
+    getStats(): {
+        fileCount: number;
+        globalSymbolCount: number;
+        cacheHits: number;
+        cacheMisses: number;
+    };
+    clear(): void;
+}
+export declare const createResolutionContext: () => ResolutionContext;