gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -2,9 +2,12 @@
  * Parse implementation — chunked parse + resolve loop.
  *
  * This is the core parsing engine of the ingestion pipeline. It reads
- * source files in byte-budget chunks (~20MB each), parses via worker
- * pool (or sequential fallback), resolves imports/calls/heritage per
- * chunk, and synthesizes wildcard import bindings.
+ * source files in byte-budget chunks (~20MB each), parses via the worker
+ * pool (the sole parse path — there is no sequential fallback), and emits
+ * route CALLS edges. Import,
+ * call, and inheritance resolution are owned by the scope-resolution
+ * phase, not here (RING4-1 #942 removed the legacy call DAG; RING4-2 #943
+ * removed the legacy per-file import resolution + wildcard synthesis).
  *
  * Consumed by the parse phase (`parse.ts`) — the phase file handles
  * dependency wiring while the heavy implementation lives here.
@@ -12,29 +15,22 @@
  * @module
  */
 import { BindingAccumulator, enrichExportedTypeMap, } from '../binding-accumulator.js';
-import { processParsing, mergeChunkResults } from '../parsing-processor.js';
-import { fileContentHash, computeChunkHash } from '../../../storage/parse-cache.js';
-import { processImports, processImportsFromExtracted, buildImportResolutionContext, } from '../import-processor.js';
-import { EMPTY_INDEX } from '../import-resolvers/utils.js';
-import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted, seedCrossFileReceiverTypes, buildExportedTypeMapFromGraph, } from '../call-processor.js';
-import { buildHeritageMap } from '../model/heritage-map.js';
-import { processHeritage, processHeritageFromExtracted, extractExtractedHeritageFromFiles, getHeritageStrategyForLanguage, } from '../heritage-processor.js';
-import { createResolutionContext } from '../model/resolution-context.js';
-import { createASTCache } from '../ast-cache.js';
+import { mergeChunkResults, dispatchChunkParse } from '../parsing-processor.js';
+import { fileContentHash, computeChunkHash, loadParseCacheChunk, persistParseCacheChunk, PARSE_CACHE_VERSION, } from '../../../storage/parse-cache.js';
+import { clearParsedFileStore, persistParsedFileChunk, getDurableParsedFileDir, loadDurableParsedFileIndex, restoreDurableParsedFileShard, } from '../../../storage/parsedfile-store.js';
+import { processRoutesFromExtracted, buildExportedTypeMapFromGraph, } from '../call-processor.js';
+import { createSemanticModel } from '../model/index.js';
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { isRegistryPrimary } from '../registry-primary-flag.js';
 import { readFileContents } from '../filesystem-walker.js';
 import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
-import { createWorkerPool, WorkerPoolInitializationError } from '../workers/worker-pool.js';
-import { extractFetchCallsFromFiles } from '../call-processor.js';
+import { createWorkerPool, workerPoolDisabledByEnv, resolveAutoPoolSize, WorkerPoolInitializationError, WorkerPoolDisabledError, } from '../workers/worker-pool.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { isDev } from '../utils/env.js';
 import { isVerboseIngestionEnabled } from '../utils/verbose.js';
 import { endTimer, isDeferredResolutionProfileEnabled, logDeferredProfile, startTimer, } from '../utils/deferred-resolution-profile.js';
-import { synthesizeWildcardImportBindings, needsSynthesis } from './wildcard-synthesis.js';
-import { extractORMQueriesInline } from './orm-extraction.js';
+import { isDebugHeapEnabled, logHeapProbe } from '../utils/heap-probe.js';
 import { logger } from '../../logger.js';
 // ── Constants ──────────────────────────────────────────────────────────────
 /** Max bytes of source content to load per parse chunk.
@@ -57,29 +53,107 @@ import { logger } from '../../logger.js';
  * import time and meant per-call option threading silently no-op'd.
  */
 const DEFAULT_CHUNK_BYTE_BUDGET = 2 * 1024 * 1024;
-function resolveChunkByteBudget(options) {
+/**
+ * Per-worker share of a chunk's byte budget when auto-scaling (#worker-idle).
+ *
+ * A chunk is a single `WorkerPool.dispatch` unit; the pool fans a chunk's files
+ * into sub-batch jobs and assigns them to idle workers (`wakeIdleSlots`). When
+ * the chunk budget (2 MB) was far below the 8 MB sub-batch cap, every chunk
+ * produced exactly ONE job → ONE busy worker while the other N-1 sat idle. To
+ * keep all workers fed, the auto chunk budget now scales as
+ * `poolSize × CHUNK_BYTES_PER_WORKER`, so each dispatch carries enough work to
+ * fan across the whole pool. Sequential / explicit-budget runs are unaffected.
+ */
+const CHUNK_BYTES_PER_WORKER = 2 * 1024 * 1024;
+/**
+ * Target jobs-per-worker per dispatch. More jobs than workers gives the pool's
+ * idle-slot assignment room to load-balance (a slow job doesn't strand a worker
+ * while the rest finish early). Drives the derived `subBatchMaxBytes`.
+ */
+const TARGET_JOBS_PER_WORKER = 3;
+/** Floor for a derived sub-batch so jobs don't shrink to per-file IPC churn. */
+const MIN_SUB_BATCH_BYTES = 256 * 1024;
+function resolveChunkByteBudget(options, effectivePoolSize = 1) {
     const opt = options?.chunkByteBudget;
     if (typeof opt === 'number' && Number.isFinite(opt) && opt > 0)
         return opt;
     const env = Number(process.env.GITNEXUS_CHUNK_BYTE_BUDGET);
     if (Number.isFinite(env) && env > 0)
         return env;
-    return DEFAULT_CHUNK_BYTE_BUDGET;
+    // Auto: size each chunk so a dispatch can fan across the whole pool. A
+    // single-worker (tiny-repo) run keeps the original 2 MB invalidation floor.
+    return Math.max(DEFAULT_CHUNK_BYTE_BUDGET, effectivePoolSize * CHUNK_BYTES_PER_WORKER);
+}
+/**
+ * Handle a worker-pool startup failure by FAILING FAST with the captured cause
+ * (#1741). The pool self-heals *transient* worker crashes on its own — a
+ * bounded, jittered startup restart loop (see worker-pool.ts) — so this is
+ * reached only when that self-heal is EXHAUSTED, or a deterministic crash-loop
+ * was detected, or the pool could not even be constructed. In every such case
+ * the workers genuinely cannot start.
+ *
+ * There is no sequential parser to silently degrade to — that fallback was
+ * removed (and it had masked a worker-startup regression as a 2-hour "stuck"
+ * run in #1741, rc99: a dropped `logger.warn` plus an unbounded sequential
+ * grind). GitNexus surfaces the real crash and aborts so the operator fixes the
+ * worker startup (commonly a missing build). The pool's own crash
+ * classification (`crashClass` on WorkerPoolInitializationError) sharpens the
+ * message.
+ *
+ * @throws always — an actionable Error carrying the captured worker crash.
+ * @internal Exported for unit tests; production callers are the parse loop's
+ *           two worker-startup catch sites below.
+ */
+export function handleWorkerStartupFailure(err) {
+    const isInit = err instanceof WorkerPoolInitializationError;
+    const readinessFailures = isInit ? err.readinessFailures : [];
+    const crashClass = isInit ? err.crashClass : undefined;
+    // Surface the real cause verbatim: readiness failures for an init crash, or
+    // the construction error message (e.g. "Worker script not found: …") when the
+    // pool never got to spawn workers.
+    const failureDetail = readinessFailures.length > 0
+        ? ` Underlying worker failure(s): ${readinessFailures.join(' | ')}`
+        : isInit
+            ? ''
+            : ` Underlying error: ${err.message}`;
+    // Always surface the real crash — never let a startup failure pass silently.
+    logger.error({ err: err.message, readinessFailures, crashClass }, 'Worker pool failed to start — workers could not start (bounded self-heal exhausted).');
+    const cause = crashClass === 'deterministic-startup'
+        ? `every worker crashed identically during startup (a deterministic ` +
+            `crash-loop — retrying cannot help), so the pool has no usable workers.`
+        : isInit
+            ? `workers exhausted the bounded startup retry budget without reporting ` +
+                `ready, so the pool has no usable workers.`
+            : `the worker pool could not be constructed.`;
+    // Class-aware fix hint: a missing/broken native binding is the likely cause
+    // when workers crashed during init, but it is the WRONG guess for a pool that
+    // never constructed (commonly a missing build / unresolvable worker path).
+    const fixHint = isInit
+        ? `Fix the worker startup failure shown above (often a missing/broken native ` +
+            `binding or a top-of-script import error in parse-worker).`
+        : `Fix the worker pool construction error shown above (commonly a missing ` +
+            `build, so dist/ has no parse-worker, or an unresolvable worker path).`;
+    throw new Error(`Worker pool failed to start: ${cause}${failureDetail}\n\n` +
+        `The worker pool is GitNexus's only parse path — there is no sequential ` +
+        `fallback to hide this crash behind (silently degrading masked a ` +
+        `worker-startup regression as a 2-hour "stuck" run in #1741). Fix:\n` +
+        `  • ${fixHint}`);
 }
 /**
  * Chunked parse + resolve loop.
  *
- * Reads source in byte-budget chunks (~20MB each). For each chunk:
- * 1. Parse via worker pool (or sequential fallback)
- * 2. Resolve imports from extracted data
- * 3. Synthesize wildcard import bindings (Go/Ruby/C++/Swift/Python)
- * 4. Resolve heritage + routes per chunk; defer worker CALLS until all chunks
- *    have contributed heritage so interface-dispatch implementor map is complete
- * 5. Collect TypeEnv bindings for cross-file propagation
+ * Reads source in byte-budget chunks (~20MB each):
+ * 1. Parse each chunk via the worker pool (the sole parse path)
+ * 2. After all chunks parse, emit route CALLS edges (deferred so resolution
+ *    sees the full repo graph) and collect the exported-type map
+ * 3. Collect TypeEnv bindings for cross-file propagation
+ *
+ * Import, call, and inheritance edges are emitted by the scope-resolution
+ * phase, not here (RING4-1 #942 / RING4-2 #943 removed the legacy passes).
  */
 export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress, options) {
-    const ctx = createResolutionContext();
-    const symbolTable = ctx.model.symbols;
+    const model = createSemanticModel();
+    const symbolTable = model.symbols;
     const parseableScanned = scannedFiles.filter((f) => {
         const lang = getLanguageFromFilename(f.path);
         return lang && isLanguageAvailable(lang);
@@ -104,6 +178,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // Linux-built cache misses on macOS for the same repo.
     parseableScanned.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
     const totalParseable = parseableScanned.length;
+    const totalBytes = parseableScanned.reduce((sum, f) => sum + f.size, 0);
     if (totalParseable === 0) {
         onProgress({
             phase: 'parsing',
@@ -115,6 +190,27 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount },
         });
     }
+    // Sequential parsing has been removed: the worker pool (quarantine +
+    // respawn/recycle + circuit breaker) is the sole parse path. The three
+    // channels that used to select an in-process parser are now hard errors, so
+    // an operator who set one gets an actionable message instead of a silently
+    // slower (now nonexistent) fallback. Validated before any chunk work; a
+    // zero-parseable-file repo is exempt (nothing to parse).
+    if (totalParseable > 0) {
+        const requestedPoolSize = options?.workerPoolSize;
+        const disabledByEnv = requestedPoolSize === undefined && workerPoolDisabledByEnv();
+        if (options?.skipWorkers || requestedPoolSize === 0 || disabledByEnv) {
+            const reason = options?.skipWorkers
+                ? '`skipWorkers: true` was passed'
+                : requestedPoolSize === 0
+                    ? '`--workers 0` (workerPoolSize=0) was requested'
+                    : '`GITNEXUS_WORKER_POOL_SIZE=0` is set';
+            throw new WorkerPoolDisabledError(`Worker-pool parsing cannot be disabled (${reason}). GitNexus no longer ` +
+                `has a sequential parser — the worker pool self-heals via quarantine + ` +
+                `respawn, so there is no slower path to fall back to. Pass ` +
+                `\`--workers <N>\` with N>=1, or omit it for an auto-sized pool.`);
+        }
+    }
     // Build byte-budget chunks. The budget is resolved per-call (U14): options
     // first, then env, then the built-in default. Pre-U14 this was a
     // module-load IIFE constant, which froze the env value at import time
@@ -122,7 +218,28 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // runs. Resolving in the function body restores per-call configurability
     // and matches the pattern used by resolveAutoPoolSize and the U1
     // parseChunkConcurrency resolver.
-    const chunkByteBudget = resolveChunkByteBudget(options);
+    // Effective worker count, computed up-front so the chunk budget can scale to
+    // keep the whole pool busy (#worker-idle). The pool is ALWAYS used (sequential
+    // parsing was removed; the disabled channels threw above). Size it to the
+    // work: an explicit `--workers <N>` pins the size; otherwise the cores-based
+    // auto size is capped by the repo's worth of work (~one worker per
+    // CHUNK_BYTES_PER_WORKER of source) so a tiny repo spawns ~1 worker instead of
+    // a full pool, replacing the job the deleted small-repo threshold used to do.
+    // KTD-3 of the remove-sequential plan; the cap formula is intentionally coarse
+    // (tuning deferred).
+    const explicitPoolSize = options?.workerPoolSize;
+    const workProportionalCap = Math.max(1, Math.ceil(totalBytes / CHUNK_BYTES_PER_WORKER));
+    const effectivePoolSize = explicitPoolSize && explicitPoolSize > 0
+        ? explicitPoolSize
+        : Math.min(resolveAutoPoolSize(), workProportionalCap);
+    const chunkByteBudget = resolveChunkByteBudget(options, effectivePoolSize);
+    // Sub-batch size so each chunk fans into ~`TARGET_JOBS_PER_WORKER` jobs per
+    // worker, giving the pool's idle-slot assignment room to load-balance. An
+    // explicit `GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES` operator override wins.
+    const subBatchEnv = Number(process.env.GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES);
+    const dispatchSubBatchMaxBytes = Number.isFinite(subBatchEnv) && subBatchEnv > 0
+        ? subBatchEnv
+        : Math.max(MIN_SUB_BATCH_BYTES, Math.ceil(chunkByteBudget / (effectivePoolSize * TARGET_JOBS_PER_WORKER)));
     const chunks = [];
     let currentChunk = [];
     let currentBytes = 0;
@@ -154,37 +271,25 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             stats: { filesProcessed: 0, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
         });
     }
-    // Don't spawn workers for tiny repos — overhead exceeds benefit.
-    // Test suites may lower the thresholds via `options.workerThresholdsForTest`
-    // to exercise the worker-pool path with small fixtures; see PipelineOptions.
-    const MIN_FILES_FOR_WORKERS = options?.workerThresholdsForTest?.minFiles ?? 15;
-    const MIN_BYTES_FOR_WORKERS = options?.workerThresholdsForTest?.minBytes ?? 512 * 1024;
-    const totalBytes = parseableScanned.reduce((s, f) => s + f.size, 0);
-    // Create worker pool lazily, reuse across cache-miss chunks.
+    // Create the worker pool lazily, reusing it across cache-miss chunks.
     //
-    // `workerPoolSize === 0` is a programmatic equivalent of `skipWorkers:
-    // true` per the `PipelineOptions.workerPoolSize` contract. Short-
-    // circuiting here avoids constructing a useless pool. The pool is
-    // intentionally NOT created before parse-cache lookup: a warm-cache
-    // all-hit run should replay cached worker output without loading
-    // parse-worker.js or any tree-sitter/N-API native bindings.
-    const shouldUseWorkers = !options?.skipWorkers &&
-        options?.workerPoolSize !== 0 &&
-        (totalParseable >= MIN_FILES_FOR_WORKERS || totalBytes >= MIN_BYTES_FOR_WORKERS);
+    // KTD-8 — the pool is intentionally NOT created before the parse-cache
+    // lookup: a warm-cache all-hit run must replay cached worker output without
+    // loading parse-worker.js or any tree-sitter/N-API native bindings. So
+    // `getOrCreateWorkerPool` is called only from inside the chunk loop, on the
+    // first cache MISS. There is no longer a "should we use workers?" gate:
+    // sequential parsing was removed and the disabled channels (`--workers 0` /
+    // env=0 / `skipWorkers`) threw above, so for any repo with parseable files
+    // the pool is always the parse path.
     let workerPool;
-    let workerPoolDisabled = false;
     const getOrCreateWorkerPool = () => {
-        if (!shouldUseWorkers || workerPoolDisabled)
-            return undefined;
         if (workerPool)
             return workerPool;
         try {
-            // U20.U3 test-only injection: integration tests pass a custom
-            // worker script URL via `workerUrlForTest` (mirrors the
-            // `workerThresholdsForTest` precedent) so they can drive the
-            // chunk-loop with deterministically-misbehaving workers without
-            // mocking the module import graph. When unset, the normal src/
-            // → dist/ resolution runs.
+            // Test-only injection: integration tests pass a custom worker script URL
+            // via `workerUrlForTest` so they can drive the chunk-loop with
+            // deterministically-misbehaving workers without mocking the module import
+            // graph. When unset, the normal src/ → dist/ resolution runs.
             let workerUrl = options?.workerUrlForTest ?? 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.
@@ -195,44 +300,35 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     workerUrl = pathToFileURL(distWorker);
                 }
             }
-            workerPool = createWorkerPool(workerUrl, options?.workerPoolSize);
+            // Thread the ParsedFile store path into the pool so workers write their
+            // own shards (#1983 parallel serialization). `parsedFileStorePath` is
+            // declared below but this closure only runs from inside the chunk loop,
+            // after it is initialized; `undefined` drives the worker no-store
+            // fallback (return ParsedFiles in the result).
+            workerPool = createWorkerPool(workerUrl, effectivePoolSize, {
+                parsedFileStoreStoragePath: parsedFileStorePath,
+                // Durable, content-addressed shard dir for warm-cache reuse (#2038).
+                // Initialized below before the chunk loop (same deferred-init pattern
+                // as `parsedFileStorePath`); this closure only runs from the loop.
+                durableParsedFileStoragePath: durableParsedFileDir,
+                // Fan each chunk across the whole pool (#worker-idle): without this a
+                // chunk smaller than the 8 MB sub-batch cap became a single job on a
+                // single worker. Honors an explicit `subBatchMaxBytes` / env override.
+                subBatchMaxBytes: dispatchSubBatchMaxBytes,
+            });
             return workerPool;
         }
         catch (err) {
-            workerPoolDisabled = true;
-            logger.warn({ err: err.message }, 'Worker pool creation failed, using sequential fallback:');
-            return undefined;
+            // Pool *construction* failed (e.g. the worker script is missing — a
+            // broken install). Fail fast with the cause (#1741). There is no
+            // sequential parser to fall back to; the operator must fix the worker
+            // startup (commonly a missing build so dist/ has no parse-worker).
+            handleWorkerStartupFailure(err);
         }
     };
     let filesParsedSoFar = 0;
-    // Two caches with different lifetimes:
-    //   - `astCache` (chunk-local, cleared between chunks) — call /
-    //     heritage / import processors read it during parse to avoid
-    //     re-parsing within the same chunk.
-    //   - `scopeTreeCache` (total-parseable-sized, never cleared by
-    //     parse-impl) — exposed via ParseOutput so scope-resolution can
-    //     skip a second tree-sitter parse. Worker-mode parses don't
-    //     populate either; consumers fall back to a fresh parse.
-    // See plan docs/plans/2026-04-20-002-perf-parse-heritage-mro-plan.md (Unit 4).
-    const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0);
-    let astCache = createASTCache(maxChunkFiles);
-    const scopeTreeCache = createASTCache(Math.max(parseableScanned.length, 1));
-    // Build import resolution context once — suffix index, file lists, resolve cache.
-    const importCtx = buildImportResolutionContext(allPaths);
-    const allPathObjects = allPaths.map((p) => ({ path: p }));
-    const sequentialChunkPaths = [];
-    const chunkNeedsSynthesis = chunks.map((paths) => paths.some((p) => {
-        const lang = getLanguageFromFilename(p);
-        return lang != null && needsSynthesis(lang);
-    }));
     const exportedTypeMap = new Map();
     const bindingAccumulator = new BindingAccumulator();
-    // Tracks whether per-chunk or fallback wildcard-binding synthesis already
-    // ran, so the unconditional final call below can be skipped when redundant.
-    // synthesizeWildcardImportBindings is graph-global; once any chunk runs it
-    // after parsing wildcard files, later non-wildcard chunks add no work for
-    // it, and later wildcard chunks re-run it themselves.
-    let hasSynthesized = false;
     const allFetchCalls = [];
     const allFetchWrapperDefs = [];
     const allExtractedRoutes = [];
@@ -242,20 +338,6 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     const allRouterModuleAliases = [];
     const allToolDefs = [];
     const allORMQueries = [];
-    const deferredWorkerCalls = [];
-    const deferredWorkerHeritage = [];
-    const deferredConstructorBindings = [];
-    const deferredAssignments = [];
-    // Imports accumulated across chunks. Previously processed per-chunk
-    // via `processImportsFromExtracted` inside the chunk loop, which
-    // forced workers to sit idle on the main thread's extraction pass
-    // between chunk dispatches (4-5% CPU utilization symptom). Deferring
-    // to a single end-of-loop pass lets the worker pool start chunk N+1
-    // immediately after chunk N's worker dispatch returns. Resolution is
-    // strictly-more-information at end-of-loop because graph now has
-    // every chunk's symbols — improves cross-chunk import targets.
-    const deferredWorkerImports = [];
-    let anyChunkNeedsWildcardSynth = false;
     // Aggregated per-file ParsedFile artifacts produced by workers' calls
     // to `extractParsedFile`. Threaded through to the scope-resolution
     // phase so it can SKIP its own re-extraction on cache hits — this is
@@ -267,6 +349,29 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // run's, replay the cached ParseWorkerResult[] instead of dispatching
     // to workers. See gitnexus/src/storage/parse-cache.ts.
     const parseCache = options?.parseCache;
+    // Disk-backed ParsedFile store (#1983): when a storage path is available we
+    // flush worker-produced ParsedFiles to disk per chunk (instead of retaining
+    // them in `allParsedFiles`) and scope-resolution streams them back per
+    // language — avoiding both the ~1× semantic-model RAM cost of holding them
+    // and, critically, the unbounded native tree-sitter re-parse leak that
+    // scope-resolution's main-thread re-extraction otherwise accumulates. When
+    // there is no storage path (tests / direct pipeline calls), we fall back to
+    // retaining them in `allParsedFiles` (small-repo path, preserves prior
+    // behavior). Cleared up-front so a prior run's shards never leak in.
+    const parsedFileStorePath = parseCache?.storagePath;
+    if (parsedFileStorePath)
+        await clearParsedFileStore(parsedFileStorePath);
+    // Durable, content-addressed ParsedFile store (#2038 warm-cache coverage) —
+    // a sibling of the run-scoped store, NOT cleared per run. Workers write a
+    // shard per chunk hash; on a warm parse-cache hit we restore the chunk's
+    // shards into the run-scoped store so scope-resolution streams them without
+    // re-parsing. `durableHitKeys` is the prior run's index, version-gated by
+    // PARSE_CACHE_VERSION (a mismatch ⇒ empty ⇒ every chunk re-dispatches, which
+    // repopulates the durable store — never the main-thread extract fallback).
+    const durableParsedFileDir = parsedFileStorePath !== undefined ? getDurableParsedFileDir(parsedFileStorePath) : undefined;
+    const durableHitKeys = durableParsedFileDir !== undefined
+        ? await loadDurableParsedFileIndex(durableParsedFileDir, PARSE_CACHE_VERSION)
+        : new Set();
     let chunkCacheHits = 0;
     let chunkCacheMisses = 0;
     try {
@@ -305,7 +410,125 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         // body, which re-read process.env on every iteration even though
         // the env can't change mid-run.
         const verboseThroughputLog = isDev || isVerboseIngestionEnabled();
+        const heapProbeEveryN = isDebugHeapEnabled() ? 25 : 0;
+        let pendingWorkerChunk = null;
+        // Apply one chunk's merged worker data: per-chunk aggregation into the
+        // run-level accumulators + the throughput log. Shared by the cache-hit
+        // (inline) and worker (deferred) paths. The `| null` guard is defensive —
+        // every live caller passes real worker data now that sequential parsing
+        // (which was the only path that passed null) is gone.
+        const applyChunkResults = async (chunkWorkerData, chunkIdx, chunkFiles, chunkStartMs) => {
+            if (chunkWorkerData) {
+                if (chunkWorkerData.parsedFiles?.length) {
+                    if (parsedFileStorePath) {
+                        await persistParsedFileChunk(parsedFileStorePath, `chunk-${chunkIdx}`, chunkWorkerData.parsedFiles);
+                    }
+                    else {
+                        for (const item of chunkWorkerData.parsedFiles)
+                            allParsedFiles.push(item);
+                    }
+                }
+                if (chunkWorkerData.fileScopeBindings?.length) {
+                    for (const { filePath, bindings } of chunkWorkerData.fileScopeBindings) {
+                        if (typeof filePath !== 'string' || filePath.length === 0)
+                            continue;
+                        if (!Array.isArray(bindings))
+                            continue;
+                        const entries = [];
+                        for (const tuple of bindings) {
+                            if (!Array.isArray(tuple) || tuple.length !== 2)
+                                continue;
+                            const [varName, typeName] = tuple;
+                            if (typeof varName !== 'string' || typeof typeName !== 'string')
+                                continue;
+                            entries.push({ scope: '', varName, typeName });
+                        }
+                        if (entries.length > 0) {
+                            bindingAccumulator.appendFile(filePath, entries);
+                        }
+                    }
+                }
+                if (chunkWorkerData.fetchCalls?.length) {
+                    for (const item of chunkWorkerData.fetchCalls)
+                        allFetchCalls.push(item);
+                }
+                if (chunkWorkerData.fetchWrapperDefs?.length) {
+                    for (const item of chunkWorkerData.fetchWrapperDefs)
+                        allFetchWrapperDefs.push(item);
+                }
+                if (chunkWorkerData.routes?.length) {
+                    for (const item of chunkWorkerData.routes)
+                        allExtractedRoutes.push(item);
+                }
+                if (chunkWorkerData.decoratorRoutes?.length) {
+                    for (const item of chunkWorkerData.decoratorRoutes)
+                        allDecoratorRoutes.push(item);
+                }
+                if (chunkWorkerData.routerIncludes?.length) {
+                    for (const item of chunkWorkerData.routerIncludes)
+                        allRouterIncludes.push(item);
+                }
+                if (chunkWorkerData.routerImports?.length) {
+                    for (const item of chunkWorkerData.routerImports)
+                        allRouterImports.push(item);
+                }
+                if (chunkWorkerData.routerModuleAliases?.length) {
+                    for (const item of chunkWorkerData.routerModuleAliases)
+                        allRouterModuleAliases.push(item);
+                }
+                if (chunkWorkerData.toolDefs?.length) {
+                    for (const item of chunkWorkerData.toolDefs)
+                        allToolDefs.push(item);
+                }
+                if (chunkWorkerData.ormQueries?.length) {
+                    for (const item of chunkWorkerData.ormQueries)
+                        allORMQueries.push(item);
+                }
+            }
+            filesParsedSoFar += chunkFiles.length;
+            if (verboseThroughputLog && chunkStartMs !== null) {
+                const elapsedMs = Date.now() - chunkStartMs;
+                const filesPerSec = elapsedMs > 0 ? (chunkFiles.length * 1000) / elapsedMs : 0;
+                const stats = workerPool?.getStats?.();
+                const poolFrag = stats
+                    ? ` pool: ${stats.activeSlots}/${stats.size} active, ` +
+                        `${stats.quarantined} quarantined${stats.poolBroken ? ', BROKEN' : ''}`
+                    : ' (cache replay)';
+                logger.info(`📊 chunk ${chunkIdx + 1}/${numChunks}: ${chunkFiles.length} files in ${elapsedMs}ms ` +
+                    `(${filesPerSec.toFixed(1)} files/s)${poolFrag}`);
+            }
+        };
+        // Merge + finalize a parked worker chunk: graph merge (the overlapped
+        // main-thread step) → parse-cache write-guard → run-level aggregation.
+        const finalizeWorkerChunk = async (p) => {
+            const chunkWorkerData = mergeChunkResults(graph, symbolTable, p.rawResults, exportedTypeMap);
+            // Persist raw results for this chunk hash (skipping when any chunk file
+            // was worker-quarantined, so the narrower rawResults isn't cached under
+            // the full-chunk key — see the original inline note / U20.U2).
+            if (parseCache && p.chunkHash && p.rawResults.length > 0) {
+                const quarantineSet = new Set(workerPool?.getQuarantinedPaths?.() ?? []);
+                const chunkHadQuarantine = p.chunkFiles.some((f) => quarantineSet.has(f.path));
+                if (chunkHadQuarantine) {
+                    if (isDev) {
+                        const quarantinedInChunk = p.chunkFiles.filter((f) => quarantineSet.has(f.path)).length;
+                        logger.info(`📦 parse-cache SKIP: chunk ${p.chunkIdx + 1}/${numChunks} ` +
+                            `had ${quarantinedInChunk} worker-quarantined file(s); ` +
+                            `next run will rediscover (${p.chunkHash.slice(0, 8)})`);
+                    }
+                }
+                else {
+                    await persistParseCacheChunk(parseCache, p.chunkHash, p.rawResults);
+                    if (isDev) {
+                        logger.info(`📦 parse-cache MISS+store: chunk ${p.chunkIdx + 1}/${numChunks} (${p.chunkFiles.length} files, ${p.chunkHash.slice(0, 8)})`);
+                    }
+                }
+            }
+            await applyChunkResults(chunkWorkerData, p.chunkIdx, p.chunkFiles, p.chunkStartMs);
+        };
         for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+            if (heapProbeEveryN > 0 && chunkIdx > 0 && chunkIdx % heapProbeEveryN === 0) {
+                logHeapProbe(`parse-chunk-${chunkIdx}`, `nodes=${graph.nodeCount} parsedFiles=${allParsedFiles.length}`);
+            }
             const chunkPaths = chunks[chunkIdx];
             // Start wall-clock for the per-chunk throughput log emitted at end
             // of this iteration. The gate is computed once above; here we just
@@ -337,18 +560,30 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 }));
                 chunkHash = computeChunkHash(entries);
             }
-            let chunkWorkerData;
-            const cachedRaw = chunkHash && parseCache ? parseCache.entries.get(chunkHash) : undefined;
+            const cachedRaw = chunkHash && parseCache ? await loadParseCacheChunk(parseCache, chunkHash) : undefined;
             // Track every chunk hash we touched so the orchestrator can
             // prune stale entries (chunks whose composition no longer
             // corresponds to a live chunk in the current scan) before saving.
             if (parseCache && chunkHash)
                 parseCache.usedKeys.add(chunkHash);
-            if (cachedRaw && cachedRaw.length > 0) {
-                // Cache hit: replay the cached worker output through the same
-                // merge logic the live worker path uses.
+            // A parse-cache hit may skip the workers ONLY if the chunk's ParsedFiles
+            // are recoverable without a main-thread re-parse: restored from a durable
+            // shard (store path) or carried in the cached result (no-store path). If a
+            // cached chunk's durable shards are missing — first run after the durable
+            // store was introduced, or a pruned/version-stale shard — fall through to
+            // a worker re-dispatch to repopulate them. NEVER let scope-resolution
+            // re-extract on the main thread (the #1983 OOM the durable store closes).
+            const durableHit = chunkHash !== null && durableParsedFileDir !== undefined && durableHitKeys.has(chunkHash);
+            if (cachedRaw && cachedRaw.length > 0 && (durableHit || parsedFileStorePath === undefined)) {
+                // Cache hit: replay cached worker output. Finalize any parked worker
+                // chunk FIRST so deferred aggregation stays in chunk order, then merge
+                // + apply this hit inline (no worker dispatch to overlap).
+                if (pendingWorkerChunk) {
+                    await finalizeWorkerChunk(pendingWorkerChunk);
+                    pendingWorkerChunk = null;
+                }
                 chunkCacheHits++;
-                chunkWorkerData = mergeChunkResults(graph, symbolTable, cachedRaw);
+                const chunkWorkerData = mergeChunkResults(graph, symbolTable, cachedRaw, exportedTypeMap);
                 if (isDev) {
                     logger.info(`📦 parse-cache HIT: chunk ${chunkIdx + 1}/${numChunks} (${chunkFiles.length} files, ${chunkHash?.slice(0, 8) ?? 'unknown'})`);
                 }
@@ -368,12 +603,22 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                         nodesCreated: graph.nodeCount,
                     },
                 });
+                // Restore the chunk's durable ParsedFile shards into the run-scoped
+                // store so scope-resolution finds full coverage with ZERO main-thread
+                // re-parse. A verbatim byte copy — byte-identical to a cold run.
+                if (durableHit && durableParsedFileDir && parsedFileStorePath && chunkHash) {
+                    const restored = await restoreDurableParsedFileShard(durableParsedFileDir, parsedFileStorePath, chunkHash);
+                    if (restored === 0) {
+                        logger.warn(`parsedfile-cache: durable shards missing for cached chunk ` +
+                            `${chunkHash.slice(0, 8)} — scope-resolution will re-extract these files`);
+                    }
+                }
+                await applyChunkResults(chunkWorkerData, chunkIdx, chunkFiles, chunkStartMs);
             }
             else {
                 // Cache miss: dispatch to workers, capture the raw results, store
                 // them under the chunk hash for the next run.
                 chunkCacheMisses++;
-                const rawResults = [];
                 const progressForChunk = (current, _total, filePath) => {
                     const globalCurrent = filesParsedSoFar + current;
                     // Parse phase covers 20-70 (M2). Deferred extraction handles 70-95.
@@ -391,315 +636,82 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     });
                 };
                 const activeWorkerPool = getOrCreateWorkerPool();
+                // Worker path — PIPELINE: kick off this chunk's dispatch, merge the
+                // PREVIOUS chunk while these workers parse, then park this chunk for
+                // the next iteration to merge (overlapping its parse). The deferred
+                // merge + parse-cache write-guard + aggregation all run in
+                // `finalizeWorkerChunk`, in chunk order. The pool is the sole parse
+                // path — `getOrCreateWorkerPool` returns a pool or throws.
+                const dispatchPromise = dispatchChunkParse(chunkFiles, activeWorkerPool, progressForChunk, undefined, chunkHash ?? undefined);
+                // Mark handled so a rejection during the overlap drain below isn't
+                // flagged as unhandled; the `await` re-throws it for real handling.
+                dispatchPromise.catch(() => { });
+                if (pendingWorkerChunk) {
+                    await finalizeWorkerChunk(pendingWorkerChunk);
+                    pendingWorkerChunk = null;
+                }
+                let chunkResults;
                 try {
-                    chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, scopeTreeCache, progressForChunk, activeWorkerPool, 
-                    // Capture raw results only when we have a cache to write to —
-                    // otherwise we'd retain extra arrays for nothing.
-                    parseCache && chunkHash && activeWorkerPool ? rawResults : undefined);
+                    chunkResults = await dispatchPromise;
                 }
                 catch (err) {
                     if (!(err instanceof WorkerPoolInitializationError))
                         throw err;
-                    logger.warn({
-                        err: err.message,
-                        readinessFailures: err.readinessFailures,
-                    }, 'Worker pool initialization failed, using sequential fallback:');
-                    rawResults.length = 0;
-                    workerPoolDisabled = true;
-                    const failedPool = workerPool;
-                    workerPool = undefined;
-                    await failedPool?.terminate().catch(() => undefined);
-                    chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, scopeTreeCache, progressForChunk, undefined, undefined);
-                }
-                // Persist the raw results for this chunk hash. Sequential path
-                // doesn't populate rawResults (it writes directly to graph), so
-                // small repos without worker pool simply don't cache. That's fine.
-                //
-                // U20.U2: refuse the write when any chunk file is in the
-                // worker pool's cumulative quarantine snapshot. The chunkHash
-                // is computed from EVERY file in the chunk, but the pool's
-                // Layer 3 quarantine filters quarantined files out of dispatch
-                // — so `rawResults` is narrower than the chunkHash key implies.
-                // Caching it would silently replay incomplete results on the
-                // next run with unchanged content (the corruption class Codex's
-                // adversarial review of PR #1693 flagged).
-                //
-                // Skipping the write means the next analyze gets a cache miss
-                // for this chunk and re-dispatches against a fresh worker pool
-                // (quarantine is session-scoped — `createQuarantine` is called
-                // per-pool at worker-pool.ts), giving the quarantined file
-                // another chance. If quarantine fires again, U20.U1's
-                // sequential gap-fill still produces a complete graph for this
-                // run; the cache just stays empty for this chunk until a fully-
-                // clean dispatch lands.
-                if (parseCache && chunkHash && rawResults.length > 0) {
-                    const quarantineSnapshot = workerPool?.getQuarantinedPaths?.() ?? [];
-                    const quarantineSet = new Set(quarantineSnapshot);
-                    const chunkHadQuarantine = chunkFiles.some((f) => quarantineSet.has(f.path));
-                    if (chunkHadQuarantine) {
-                        if (isDev) {
-                            const quarantinedInChunk = chunkFiles.filter((f) => quarantineSet.has(f.path)).length;
-                            logger.info(`📦 parse-cache SKIP: chunk ${chunkIdx + 1}/${numChunks} ` +
-                                `had ${quarantinedInChunk} worker-quarantined file(s); ` +
-                                `next run will rediscover (${chunkHash.slice(0, 8)})`);
-                        }
-                    }
-                    else {
-                        parseCache.entries.set(chunkHash, rawResults);
-                        if (isDev) {
-                            logger.info(`📦 parse-cache MISS+store: chunk ${chunkIdx + 1}/${numChunks} (${chunkFiles.length} files, ${chunkHash.slice(0, 8)})`);
-                        }
-                    }
+                    // Every worker crashed during startup and the pool's bounded
+                    // self-heal was exhausted. Fail fast (#1741) — there is no sequential
+                    // parser to degrade to. `handleWorkerStartupFailure` always throws, so
+                    // `chunkResults` stays definitely assigned for the parked chunk below.
+                    handleWorkerStartupFailure(err);
                 }
-            }
-            // Per-chunk extraction passes (processImportsFromExtracted,
-            // processHeritageFromExtracted, processRoutesFromExtracted,
-            // synthesizeWildcardImportBindings, seedCrossFileReceiverTypes)
-            // moved out of the chunk loop into a single end-of-loop pass below.
-            // Reason: per-chunk extraction blocked the chunk loop on
-            // main-thread work between worker dispatches — workers sat idle
-            // and total CPU utilization plateaued at 4-5% on multi-core boxes.
-            // Deferring keeps workers busy chunk-after-chunk; resolution sees
-            // strictly-more-information (full repo graph) so cross-chunk import
-            // and heritage targets resolve at least as well as before.
-            if (chunkWorkerData) {
-                if (chunkNeedsSynthesis[chunkIdx]) {
-                    anyChunkNeedsWildcardSynth = true;
-                }
-                const skipFile = new Set();
-                const checkFile = new Set();
-                const shouldAccumulate = (filePath) => {
-                    if (checkFile.has(filePath))
-                        return true;
-                    if (skipFile.has(filePath))
-                        return false;
-                    const lang = getLanguageFromFilename(filePath);
-                    if (lang !== null && isRegistryPrimary(lang)) {
-                        skipFile.add(filePath);
-                        return false;
-                    }
-                    checkFile.add(filePath);
-                    return true;
+                pendingWorkerChunk = {
+                    rawResults: chunkResults,
+                    chunkIdx,
+                    chunkHash,
+                    chunkFiles,
+                    chunkStartMs,
                 };
-                for (const item of chunkWorkerData.imports) {
-                    if (shouldAccumulate(item.filePath))
-                        deferredWorkerImports.push(item);
-                }
-                for (const item of chunkWorkerData.calls) {
-                    if (shouldAccumulate(item.filePath))
-                        deferredWorkerCalls.push(item);
-                }
-                for (const item of chunkWorkerData.heritage) {
-                    if (shouldAccumulate(item.filePath))
-                        deferredWorkerHeritage.push(item);
-                }
-                for (const item of chunkWorkerData.constructorBindings) {
-                    if (shouldAccumulate(item.filePath))
-                        deferredConstructorBindings.push(item);
-                }
-                // Aggregate worker-produced ParsedFile artifacts so scope-
-                // resolution can use them as a re-extraction cache (skips its
-                // own tree-sitter re-parse on warm runs).
-                if (chunkWorkerData.parsedFiles?.length) {
-                    for (const item of chunkWorkerData.parsedFiles)
-                        allParsedFiles.push(item);
-                }
-                if (chunkWorkerData.assignments?.length) {
-                    for (const item of chunkWorkerData.assignments) {
-                        if (shouldAccumulate(item.filePath))
-                            deferredAssignments.push(item);
-                    }
-                }
-                if (chunkWorkerData.fileScopeBindings?.length) {
-                    for (const { filePath, bindings } of chunkWorkerData.fileScopeBindings) {
-                        if (typeof filePath !== 'string' || filePath.length === 0)
-                            continue;
-                        if (!Array.isArray(bindings))
-                            continue;
-                        const entries = [];
-                        for (const tuple of bindings) {
-                            if (!Array.isArray(tuple) || tuple.length !== 2)
-                                continue;
-                            const [varName, typeName] = tuple;
-                            if (typeof varName !== 'string' || typeof typeName !== 'string')
-                                continue;
-                            entries.push({ scope: '', varName, typeName });
-                        }
-                        if (entries.length > 0) {
-                            bindingAccumulator.appendFile(filePath, entries);
-                        }
-                    }
-                }
-                if (chunkWorkerData.fetchCalls?.length) {
-                    for (const item of chunkWorkerData.fetchCalls)
-                        allFetchCalls.push(item);
-                }
-                if (chunkWorkerData.fetchWrapperDefs?.length) {
-                    for (const item of chunkWorkerData.fetchWrapperDefs)
-                        allFetchWrapperDefs.push(item);
-                }
-                if (chunkWorkerData.routes?.length) {
-                    for (const item of chunkWorkerData.routes)
-                        allExtractedRoutes.push(item);
-                }
-                if (chunkWorkerData.decoratorRoutes?.length) {
-                    for (const item of chunkWorkerData.decoratorRoutes)
-                        allDecoratorRoutes.push(item);
-                }
-                if (chunkWorkerData.routerIncludes?.length) {
-                    for (const item of chunkWorkerData.routerIncludes)
-                        allRouterIncludes.push(item);
-                }
-                if (chunkWorkerData.routerImports?.length) {
-                    for (const item of chunkWorkerData.routerImports)
-                        allRouterImports.push(item);
-                }
-                if (chunkWorkerData.routerModuleAliases?.length) {
-                    for (const item of chunkWorkerData.routerModuleAliases)
-                        allRouterModuleAliases.push(item);
-                }
-                if (chunkWorkerData.toolDefs?.length) {
-                    for (const item of chunkWorkerData.toolDefs)
-                        allToolDefs.push(item);
-                }
-                if (chunkWorkerData.ormQueries?.length) {
-                    for (const item of chunkWorkerData.ormQueries)
-                        allORMQueries.push(item);
-                }
-            }
-            else {
-                await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
-                sequentialChunkPaths.push(chunkPaths);
-            }
-            filesParsedSoFar += chunkFiles.length;
-            astCache.clear();
-            // Throughput observability (U3): emit a per-chunk metrics line
-            // under verbose ingestion mode so operators can verify CPU
-            // utilization moved + tune `--workers` / batch sizes without
-            // guessing. Cheap snapshot — just reads pool closure state.
-            if (verboseThroughputLog && chunkStartMs !== null) {
-                const elapsedMs = Date.now() - chunkStartMs;
-                const filesPerSec = elapsedMs > 0 ? (chunkFiles.length * 1000) / elapsedMs : 0;
-                const stats = workerPool?.getStats?.();
-                const poolFrag = stats
-                    ? ` pool: ${stats.activeSlots}/${stats.size} active, ` +
-                        `${stats.quarantined} quarantined${stats.poolBroken ? ', BROKEN' : ''}`
-                    : ' (sequential)';
-                logger.info(`📊 chunk ${chunkIdx + 1}/${numChunks}: ${chunkFiles.length} files in ${elapsedMs}ms ` +
-                    `(${filesPerSec.toFixed(1)} files/s)${poolFrag}`);
             }
+            // (Per-chunk aggregation + parse-cache write + throughput log now run in
+            // `applyChunkResults` / `finalizeWorkerChunk` — see the merge-pipelining
+            // block above. Route/import/inheritance edges are emitted later: route
+            // resolution in the single end-of-loop pass below, the rest by the
+            // scope-resolution phase, RING4-2 #943.)
+        }
+        // Drain the final parked worker chunk — the last pipelined chunk has no
+        // successor to overlap its merge with, so merge + finalize it here.
+        if (pendingWorkerChunk) {
+            await finalizeWorkerChunk(pendingWorkerChunk);
+            pendingWorkerChunk = null;
         }
         if (isDev && parseCache && (chunkCacheHits > 0 || chunkCacheMisses > 0)) {
             logger.info(`📦 parse-cache summary: ${chunkCacheHits} chunk hit(s), ${chunkCacheMisses} miss(es) across ${numChunks} chunk(s)`);
         }
+        logHeapProbe('post-parse-chunks', `routes=${allExtractedRoutes.length} nodes=${graph.nodeCount} parsedFiles=${allParsedFiles.length}`);
         // Deferred end-of-loop extraction (moved out of the per-chunk block):
-        //   1. processImportsFromExtracted on all chunks' imports
-        //   2. synthesizeWildcardImportBindings (if any chunk had wildcards)
-        //   3. seedCrossFileReceiverTypes on deferred calls (depends on
-        //      namedImportMap populated by step 1)
-        //   4. processHeritageFromExtracted on all chunks' heritage
-        //   5. processRoutesFromExtracted on all chunks' routes
-        // Same logic as the prior per-chunk passes, just batched — resolution
-        // sees the full repo graph instead of just current-and-earlier chunks.
-        // Deferred extraction band (M2 from PR #1693 review): the 4 stages below
-        // each get their own 5-10 point slice of the 70-95 range so percent
-        // advances monotonically through the (potentially long) resolution work
-        // instead of holding flat at 82. Stages that are skipped (zero-length
-        // input) leave their band as a no-op jump — the next stage still starts
-        // at its own band, preserving monotonicity.
-        //   imports:  70 -> 75 (5)
-        //   heritage: 75 -> 80 (5)
+        //   1. route resolution on all chunks' routes
+        // Resolution sees the full repo graph instead of just current-and-earlier
+        // chunks. Import, call, and inheritance edges are emitted by the
+        // scope-resolution phase, not here (RING4-1 #942 removed the legacy call
+        // DAG; RING4-2 #943 removed the legacy import-map resolution + wildcard
+        // synthesis). Progress band: the route stage gets a slice of the 70-95
+        // range; a zero-length input leaves its band as a no-op jump.
         //   routes:   80 -> 85 (5)
-        //   calls:    85 -> 95 (10)
         const deferredProfile = isDeferredResolutionProfileEnabled();
         if (deferredProfile) {
-            logDeferredProfile(`deferred band start: imports=${deferredWorkerImports.length} heritage=${deferredWorkerHeritage.length} ` +
-                `calls=${deferredWorkerCalls.length} routes=${allExtractedRoutes.length}`);
+            logDeferredProfile(`deferred band start: routes=${allExtractedRoutes.length}`);
         }
-        if (deferredWorkerImports.length > 0) {
-            const tImports = startTimer(deferredProfile);
-            await processImportsFromExtracted(graph, allPathObjects, deferredWorkerImports, ctx, (current, total) => {
-                const ratio = total > 0 ? current / total : 1;
-                onProgress({
-                    phase: 'parsing',
-                    percent: 70 + Math.round(ratio * 5),
-                    message: 'Resolving imports (all chunks)...',
-                    detail: `${current}/${total} files`,
-                    stats: {
-                        filesProcessed: filesParsedSoFar,
-                        totalFiles: totalParseable,
-                        nodesCreated: graph.nodeCount,
-                    },
-                });
-            }, repoPath, importCtx);
-            endTimer(tImports, (ms) => `processImportsFromExtracted: ${ms.toFixed(0)}ms (${deferredWorkerImports.length} import batches before drain)`);
-            // U15 (lightweight M1): processImportsFromExtracted is the sole
-            // consumer of `deferredWorkerImports`. Free the array now so the
-            // GC can reclaim the per-file ExtractedImport records before the
-            // heavier downstream stages run (heritage, routes, calls). Peak
-            // accumulator memory drops from O(repo) to O(repo - imports) for
-            // the remainder of the deferred phase. The future per-chunk
-            // streaming upgrade can rewrite this with the same correctness
-            // contract once profile data shows it's warranted.
-            deferredWorkerImports.length = 0;
-        }
-        if (anyChunkNeedsWildcardSynth) {
-            const tWildcard = startTimer(deferredProfile);
-            synthesizeWildcardImportBindings(graph, ctx);
-            hasSynthesized = true;
-            endTimer(tWildcard, (ms) => `synthesizeWildcardImportBindings: ${ms.toFixed(0)}ms`);
-        }
-        // L5 from PR #1693 review: populate `exportedTypeMap` from the in-progress
-        // graph BEFORE `seedCrossFileReceiverTypes` runs. Previously the seeding
-        // branch below was reached with `exportedTypeMap.size === 0` in the
-        // worker path (the map was only built at the post-parse block far below,
-        // AFTER the seeding branch), so the seed dead-coded itself silently and
-        // call resolution never got the cross-file receiver-type enrichment.
-        // The post-parse builder still runs as a defensive fallback on the
-        // sequential path; its `size === 0` guard means we don't pay the cost
-        // twice on the worker path.
+        // Populate `exportedTypeMap` from the in-progress graph so the post-parse
+        // enrichment pass (enrichExportedTypeMap) sees cross-file export types.
         if (exportedTypeMap.size === 0 && graph.nodeCount > 0) {
-            const graphExports = buildExportedTypeMapFromGraph(graph, ctx.model.symbols);
+            logHeapProbe('pre-buildExportedTypeMapFromGraph');
+            const graphExports = buildExportedTypeMapFromGraph(graph, model.symbols);
             for (const [fp, exports] of graphExports)
                 exportedTypeMap.set(fp, exports);
-        }
-        if (exportedTypeMap.size > 0 && ctx.namedImportMap.size > 0 && deferredWorkerCalls.length > 0) {
-            const { enrichedCount } = seedCrossFileReceiverTypes(deferredWorkerCalls, ctx.namedImportMap, exportedTypeMap);
-            if (enrichedCount > 0) {
-                // Two independent gates, not else-if: when both isDev AND
-                // deferredProfile are active, BOTH lines fire — log scrapers keyed
-                // on the original "🔗 E1" emoji marker keep matching, AND operators
-                // grepping the [deferred-profile] prefix see no gap between the
-                // wildcard-synth and heritage timings.
-                if (isDev) {
-                    logger.info(`🔗 E1: Seeded ${enrichedCount} cross-file receiver types (all chunks)`);
-                }
-                if (deferredProfile) {
-                    logDeferredProfile(`E1: seeded ${enrichedCount} cross-file receiver types (all chunks)`);
-                }
-            }
-        }
-        if (deferredWorkerHeritage.length > 0) {
-            const tHeritage = startTimer(deferredProfile);
-            await processHeritageFromExtracted(graph, deferredWorkerHeritage, ctx, (current, total) => {
-                const ratio = total > 0 ? current / total : 1;
-                onProgress({
-                    phase: 'parsing',
-                    percent: 75 + Math.round(ratio * 5),
-                    message: 'Resolving heritage (all chunks)...',
-                    detail: `${current}/${total} records`,
-                    stats: {
-                        filesProcessed: filesParsedSoFar,
-                        totalFiles: totalParseable,
-                        nodesCreated: graph.nodeCount,
-                    },
-                });
-            });
-            endTimer(tHeritage, (ms) => `processHeritageFromExtracted: ${ms.toFixed(0)}ms (${deferredWorkerHeritage.length} records)`);
+            logHeapProbe('post-buildExportedTypeMapFromGraph');
         }
         if (allExtractedRoutes.length > 0) {
             const tRoutes = startTimer(deferredProfile);
-            await processRoutesFromExtracted(graph, allExtractedRoutes, ctx, (current, total) => {
+            await processRoutesFromExtracted(graph, allExtractedRoutes, model, (current, total) => {
                 const ratio = total > 0 ? current / total : 1;
                 onProgress({
                     phase: 'parsing',
@@ -715,159 +727,27 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             });
             endTimer(tRoutes, (ms) => `processRoutesFromExtracted: ${ms.toFixed(0)}ms (${allExtractedRoutes.length} routes)`);
         }
-        let fullWorkerHeritageMap;
-        if (deferredWorkerHeritage.length > 0) {
-            const tBuildHeritage = startTimer(deferredProfile);
-            fullWorkerHeritageMap = buildHeritageMap(deferredWorkerHeritage, ctx, getHeritageStrategyForLanguage);
-            endTimer(tBuildHeritage, (ms) => `buildHeritageMap wall: ${ms.toFixed(0)}ms`);
-        }
-        else if (deferredProfile) {
-            logDeferredProfile('buildHeritageMap: skipped (no heritage records)');
-        }
-        // U15 (lightweight M1): buildHeritageMap is the LAST consumer of the
-        // raw `deferredWorkerHeritage` records — processCallsFromExtracted
-        // below reads from the derived `fullWorkerHeritageMap` instead. Free
-        // the raw heritage array now so the GC can reclaim it before the
-        // (potentially long) call-resolution stage. processHeritageFromExtracted
-        // earlier was a read-only consumer (pushed to graph, didn't drain).
-        deferredWorkerHeritage.length = 0;
-        if (deferredWorkerCalls.length > 0) {
-            if (deferredProfile) {
-                logDeferredProfile(`processCallsFromExtracted: starting (${deferredWorkerCalls.length} call sites, heritageMap=${fullWorkerHeritageMap !== undefined})`);
-            }
-            const tCalls = startTimer(deferredProfile);
-            await processCallsFromExtracted(graph, deferredWorkerCalls, ctx, (current, total) => {
-                const ratio = total > 0 ? current / total : 1;
-                onProgress({
-                    phase: 'parsing',
-                    // Calls is the longest deferred stage on real repos — give it the
-                    // 10-point tail 85-95 so the progress bar visibly advances during
-                    // call resolution instead of holding at 82 (M2).
-                    percent: 85 + Math.round(ratio * 10),
-                    message: 'Resolving calls (all chunks)...',
-                    detail: `${current}/${total} files`,
-                    stats: {
-                        filesProcessed: filesParsedSoFar,
-                        totalFiles: totalParseable,
-                        nodesCreated: graph.nodeCount,
-                    },
-                });
-            }, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, fullWorkerHeritageMap, bindingAccumulator);
-            endTimer(tCalls, (ms) => `processCallsFromExtracted: ${ms.toFixed(0)}ms total`);
-        }
-        if (deferredAssignments.length > 0) {
-            processAssignmentsFromExtracted(graph, deferredAssignments, ctx, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, bindingAccumulator);
-        }
-        // U15 (lightweight M1): all three arrays have had their last consumer
-        // by the time we reach this point — processCallsFromExtracted drained
-        // `deferredWorkerCalls` and read `deferredConstructorBindings`;
-        // processAssignmentsFromExtracted drained `deferredAssignments` and
-        // also read `deferredConstructorBindings`. Free them now so the
-        // function-scope references die before downstream graph-build /
-        // scope-resolution starts using its own working memory. Note: arrays
-        // returned in the function result object (allFetchCalls,
-        // allExtractedRoutes, allDecoratorRoutes, allToolDefs, allORMQueries,
-        // allParsedFiles) intentionally stay live — downstream consumers
-        // need them.
-        deferredWorkerCalls.length = 0;
-        deferredConstructorBindings.length = 0;
-        deferredAssignments.length = 0;
     }
     finally {
         await workerPool?.terminate();
     }
-    // Sequential fallback chunks.
-    //
-    // U6: wrap the fallback loop and the finalize/enrich steps in a try/finally
-    // so cleanup still runs on a mid-fallback throw. The `finally` guarantees:
-    //   1. `astCache.clear()` releases any tree-sitter trees held by the most
-    //      recently allocated per-chunk cache, mirroring the per-chunk
-    //      `astCache.clear()` calls on the happy path.
-    //   2. `bindingAccumulator.finalize()` runs before `crossFile` disposes the
-    //      accumulator downstream — callers that inspect partial TypeEnv state
-    //      (or consume it via `enrichExportedTypeMap` on a partial recovery)
-    //      still see a finalized accumulator.
-    //   3. `enrichExportedTypeMap` runs so any bindings already accumulated
-    //      are propagated into `exportedTypeMap` even if the fallback aborted.
-    //
-    // Disposal of the accumulator remains with `crossFile` (owned by U2). We do
-    // NOT call `bindingAccumulator.dispose()` here.
+    // Fetch calls + ORM queries were already extracted inside each worker
+    // (returned in ParseWorkerResult, aggregated per chunk in applyChunkResults).
+    // With sequential parsing removed there is no post-loop drain to run — only
+    // the TypeEnv finalize + enrichment that the drain's `finally` used to host.
+    // Finalize the accumulator and propagate any fixpoint-inferred exports before
+    // `crossFile` disposes it downstream. Wrapped in try/catch so a cleanup
+    // failure never masks a real parse error; disposal stays with `crossFile`.
     try {
-        if (sequentialChunkPaths.length > 0) {
-            synthesizeWildcardImportBindings(graph, ctx);
-            hasSynthesized = true;
-        }
-        const allSequentialHeritage = [];
-        const cachedSequentialChunkFiles = [];
-        for (const chunkPaths of sequentialChunkPaths) {
-            const chunkContents = await readFileContents(repoPath, chunkPaths);
-            const chunkFiles = [];
-            for (const p of chunkPaths) {
-                const content = chunkContents.get(p);
-                if (content !== undefined)
-                    chunkFiles.push({ path: p, content });
-            }
-            cachedSequentialChunkFiles.push(chunkFiles);
-            astCache = createASTCache(chunkFiles.length);
-            const sequentialHeritage = await extractExtractedHeritageFromFiles(chunkFiles, astCache);
-            for (const h of sequentialHeritage)
-                allSequentialHeritage.push(h);
-            astCache.clear();
-        }
-        const sequentialHeritageMap = allSequentialHeritage.length > 0
-            ? buildHeritageMap(allSequentialHeritage, ctx, getHeritageStrategyForLanguage)
-            : undefined;
-        for (let chunkIdx = 0; chunkIdx < sequentialChunkPaths.length; chunkIdx++) {
-            const chunkFiles = cachedSequentialChunkFiles[chunkIdx];
-            astCache = createASTCache(chunkFiles.length);
-            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, exportedTypeMap, undefined, undefined, undefined, sequentialHeritageMap, bindingAccumulator);
-            await processHeritage(graph, chunkFiles, astCache, ctx);
-            if (rubyHeritage.length > 0) {
-                await processHeritageFromExtracted(graph, rubyHeritage, ctx);
-            }
-            const chunkFetchCalls = await extractFetchCallsFromFiles(chunkFiles, astCache);
-            if (chunkFetchCalls.length > 0) {
-                for (const item of chunkFetchCalls)
-                    allFetchCalls.push(item);
-            }
-            for (const f of chunkFiles) {
-                extractORMQueriesInline(f.path, f.content, allORMQueries);
-            }
-            astCache.clear();
-            cachedSequentialChunkFiles[chunkIdx] = [];
-        }
-        // 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';
-            logger.info(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`);
+        bindingAccumulator.finalize();
+        const enriched = enrichExportedTypeMap(bindingAccumulator, graph, exportedTypeMap);
+        if (isDev && enriched > 0) {
+            logger.info(`🔗 Worker TypeEnv enrichment: ${enriched} fixpoint-inferred exports added to ExportedTypeMap`);
         }
     }
-    finally {
-        // Clearing an already-empty cache is a no-op, so this is idempotent-safe
-        // on the happy path where every per-chunk block already cleared astCache.
-        astCache.clear();
-        // Run finalize + enrichment inside try/catch so a cleanup failure never
-        // masks the original fallback error. finalize must precede crossFile's
-        // dispose (U2) and enrichExportedTypeMap depends on finalized bindings.
-        try {
-            bindingAccumulator.finalize();
-            const enriched = enrichExportedTypeMap(bindingAccumulator, graph, exportedTypeMap);
-            if (isDev && enriched > 0) {
-                logger.info(`🔗 Worker TypeEnv enrichment: ${enriched} fixpoint-inferred exports added to ExportedTypeMap`);
-            }
-        }
-        catch (enrichErr) {
-            if (isDev) {
-                logger.warn({ err: enrichErr.message }, 'Post-fallback finalize/enrich failed during cleanup:');
-            }
-        }
-    }
-    if (!hasSynthesized) {
-        const synthesized = synthesizeWildcardImportBindings(graph, ctx);
-        if (isDev && synthesized > 0) {
-            logger.info(`🔗 Synthesized ${synthesized} additional wildcard import bindings (Go/Ruby/C++/Swift/Python)`);
+    catch (enrichErr) {
+        if (isDev) {
+            logger.warn({ err: enrichErr.message }, 'Post-parse finalize/enrich failed during cleanup:');
         }
     }
     // Worker-path enrichment: if exportedTypeMap is empty (e.g. the worker pool
@@ -877,22 +757,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // crossFile receives a fully-populated map and never needs to mutate it for
     // initial-graph enrichment.
     if (exportedTypeMap.size === 0 && graph.nodeCount > 0) {
-        const graphExports = buildExportedTypeMapFromGraph(graph, ctx.model.symbols);
+        const graphExports = buildExportedTypeMapFromGraph(graph, model.symbols);
         for (const [fp, exports] of graphExports)
             exportedTypeMap.set(fp, exports);
     }
-    allPathObjects.length = 0;
-    // Safe to reset importCtx caches here: `importCtx` (ImportResolutionContext)
-    // is a scratch workspace used only during import path resolution. The
-    // `resolutionContext` (`ctx`) returned below is a distinct object — it owns
-    // the fully-populated, post-parse `importMap` / `namedImportMap` /
-    // `packageMap` / `moduleAliasMap` / `model`, and never references
-    // `importCtx`. Cross-file re-resolution in cross-file-impl.ts consumes only
-    // `ctx` (via `processCalls`), so clearing the suffix index / resolveCache /
-    // normalizedFileList here cannot lose import matches downstream.
-    importCtx.resolveCache.clear();
-    importCtx.index = EMPTY_INDEX;
-    importCtx.normalizedFileList = [];
     // FastAPI router-prefix resolution (cross-file).
     //
     // Workers emit two kinds of records per Python file:
@@ -1030,6 +898,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 allDecoratorRoutes.push(dr);
         }
     }
+    logHeapProbe('parse-impl-return', `exportedTypeMap=${exportedTypeMap.size} parsedFiles=${allParsedFiles.length} nodes=${graph.nodeCount}`);
     return {
         exportedTypeMap,
         allFetchCalls,
@@ -1039,23 +908,15 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         allToolDefs,
         allORMQueries,
         bindingAccumulator,
-        resolutionContext: ctx,
-        // Whether a worker pool was actually live for this run. False means the
-        // sequential fallback handled every chunk (either due to `skipWorkers`,
-        // the file-count/byte thresholds, or a pool-creation failure).
+        model,
+        // Whether a worker pool was actually constructed for this run. False means
+        // no pool was needed: a warm all-cache-hit run replays cached worker output
+        // without spawning workers, or there were no parseable files.
         usedWorkerPool: workerPool !== undefined,
-        // Surface the persistent scope cache so downstream phases
-        // (scope-resolution) can skip re-parsing files that the
-        // sequential path already parsed. Survives chunk boundaries; the
-        // chunk-local `astCache` above is intentionally NOT exposed
-        // because parse-impl clears it between chunks.
-        scopeTreeCache,
         // Per-file ParsedFile artifacts produced by workers' calls to
-        // `extractParsedFile`. Empty when only the sequential path ran
-        // (sequential doesn't go through the worker, and extracts ParsedFile
-        // inline rather than emitting it). Consumed by scope-resolution as
-        // a re-extraction cache: when the file's ParsedFile is here,
-        // scope-resolution skips its own `extractParsedFile` call.
+        // `extractParsedFile`. Consumed by scope-resolution as a re-extraction
+        // cache: when the file's ParsedFile is here, scope-resolution skips its own
+        // `extractParsedFile` call.
         parsedFiles: allParsedFiles,
     };
 }