gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/run-analyze.js

@@ -21,11 +21,11 @@ import { logUnresolvedReceiverFiles, summarizeUnresolvedReceivers, } from './ing
 import { summarizeUndecidedSatisfaction } from './ingestion/scope-resolution/undecided-satisfaction.js';
 import { summarizeScopeExtractionFailures } from './ingestion/scope-resolution/scope-extraction-failures.js';
 import { resetDegradedParseCounter } from './tree-sitter/safe-parse.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, ensureEmbeddingRowDmlSafe, ensureFtsRowDmlSafe, readIndexCatalogSnapshot, INDEX_CATALOG_UNREADABLE, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, deleteAllAdvisedBy, deleteSpringAopEvidenceNodes, deleteSpringAutoConfigurationDeclarations, deleteSpringAutoConfigurationSyntheticClasses, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
+import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, nodeTablesWithRowsForFiles, snapshotDerivedRelsForFiles, restoreDerivedRels, ensureEmbeddingRowDmlSafe, ensureFtsRowDmlSafe, readIndexCatalogSnapshot, INDEX_CATALOG_UNREADABLE, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, deleteAllAdvisedBy, deleteAllDestinations, deleteSpringAopEvidenceNodes, deleteSpringAutoConfigurationDeclarations, deleteSpringAutoConfigurationSyntheticClasses, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
 import { estimateBufferPool, setBufferPoolSizeHint, resolveNativeSafeStorageDir, } from './lbug/lbug-config.js';
 import { escapeCypherString } from './lbug/cypher-escape.js';
 import { chunk } from '../lib/utils.js';
-import { buildSearchIndexesOrDegrade, ftsFailureIsFatal, createSearchFTSIndexes, summarizeFtsIndexBuildFailures, dropSearchFTSIndexes, initialiseSearchFTSStemmer, verifySearchFTSIndexes, } from './search/fts-indexes.js';
+import { buildSearchIndexesOrDegrade, ftsFailureIsFatal, createSearchFTSIndexes, summarizeFtsIndexBuildFailures, dropSearchFTSIndexes, missingSearchFTSIndexTables, initialiseSearchFTSStemmer, verifySearchFTSIndexes, } from './search/fts-indexes.js';
 import { cjkSegmentationModeMismatch, getSearchFTSCjkSegmentation, initialiseSearchFTSCjkSegmentation, } from './search/cjk-segmentation.js';
 import { getExtensionCapability, getExtensionCapabilities, getFtsCapability, resolveAnalyzeInstallPolicy, } from './lbug/extension-loader.js';
 import { diagnoseExtensionLoad } from './lbug/extension-load-error.js';
@@ -41,10 +41,13 @@ import { taintModelVersion } from './ingestion/taint/typescript-model.js';
 import { parseTruthyEnv, parsePositiveIntEnv } from './ingestion/utils/env.js';
 import { computeFileHashes, diffFileHashes } from '../storage/file-hash.js';
 import { extractChangedSubgraph, computeEffectiveWriteSet, } from './incremental/subgraph-extract.js';
+import { collectSpringConfigConsumerDriftFiles, } from './incremental/spring-config-drift.js';
 import { shadowCandidatesFor } from './incremental/shadow-candidates.js';
 import { shouldEscalateIncrementalWrite } from './incremental/escalation-gate.js';
-import { loadParseCache, saveParseCache, pruneCache, PARSE_CACHE_VERSION, } from '../storage/parse-cache.js';
-import { getDurableParsedFileDir, pruneAndSaveDurableParsedFileStore, } from '../storage/parsedfile-store.js';
+import { ftsTablesAmong, incrementalFtsTablesFromGraph, nodeTablesForIncrementalDelete, shouldPreservePersistedDerivedGraph, } from './incremental/derived-writeback.js';
+import { NODE_TABLES } from './lbug/schema.js';
+import { loadParseCache, saveParseCache, pruneCache, PARSE_CACHE_VERSION, createColdParseRebuildDir, emptyParseCache, forgetCreatedParseCacheDir, } from '../storage/parse-cache.js';
+import { mergeStagedDurableParsedFileStore } from '../storage/parsedfile-store.js';
 import { getCurrentCommit, getCurrentBranch, getRemoteUrl, hasGitDir, getInferredRepoName, isWorkingTreeDirty, listWorkingTreeDirtyPaths, resolveRepoIdentityRoot, } from '../storage/git.js';
 import { isGitNexusManagedPath } from '../storage/gitnexus-managed-paths.js';
 import { getMaxFileSizeBytes } from './ingestion/utils/max-file-size.js';
@@ -53,9 +56,12 @@ import { sanitizeDetectedBranch } from '../cli/analyze-config.js';
 import { EMBEDDING_TABLE_NAME, EMBEDDING_DIMS, STALE_HASH_SENTINEL, SCHEMA_FINGERPRINT, schemaFingerprintMismatch, isSchemaFingerprintShaped, embeddingDimsMismatch, } from './lbug/schema.js';
 import { isSpringBeanCandidateSourceFile } from './ingestion/frameworks/spring/bean-catalog.js';
 import { isSpringBeanFactoryDeclaration } from './ingestion/frameworks/spring/bean-factories.js';
-import { SPRING_AOP_FEATURE, SPRING_BEAN_INVENTORY_FEATURE, SPRING_CONDITIONALS_FEATURE, SPRING_NON_HTTP_HANDLERS_FEATURE, } from './ingestion/frameworks/spring/analysis-features.js';
-import { JAVA_ENUM_INTERFACE_HERITAGE_FEATURE, JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE, SPRING_CONFIG_BINDINGS_FEATURE, } from './ingestion/languages/java/analysis-features.js';
-import { CLASS_FRAMEWORK_ANNOTATIONS_FEATURE, findAnalysisFeatureMismatches, resolveAnalysisFeatureVersions, } from './analysis-features.js';
+import { SPRING_CONFIG_UNRESOLVED_PREFIX } from './ingestion/frameworks/spring/config-bindings.js';
+import { classifySpringConfigFile } from './ingestion/pipeline-phases/spring-config.js';
+import { SPRING_ROUTE_BINDINGS_FEATURE } from './ingestion/frameworks/spring/analysis-features.js';
+import { springVendorPrefixesKey } from './ingestion/frameworks/spring/vendor-prefixes.js';
+import { findAnalysisFeatureMismatches, resolveAnalysisFeatureVersions, } from './analysis-features.js';
+import { ANALYSIS_FEATURES } from './analysis-feature-registry.js';
 import { analyzerRunnerIdentitiesEqual, finalizeAnalyzerRunnerIdentity, resolveAnalyzerRunnerIdentity, } from './analyzer-identity.js';
 // Static, and deliberately so: `embedding-count.ts` and `embedding-checkpoint.ts`
 // live outside `core/embeddings/` precisely because the lazy-embeddings
@@ -79,16 +85,6 @@ import { EMBEDDING_RESUME_MAX_ATTEMPTS, decideEmbeddingResume, mintInterruptedCh
  * Newline and tab are preserved — multi-line notices are intentional.
  */
 const stripControlCharacters = (msg) => msg.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, '');
-const ANALYSIS_FEATURES = [
-    CLASS_FRAMEWORK_ANNOTATIONS_FEATURE,
-    SPRING_AOP_FEATURE,
-    SPRING_BEAN_INVENTORY_FEATURE,
-    SPRING_CONDITIONALS_FEATURE,
-    SPRING_NON_HTTP_HANDLERS_FEATURE,
-    SPRING_CONFIG_BINDINGS_FEATURE,
-    JAVA_ENUM_INTERFACE_HERITAGE_FEATURE,
-    JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE,
-];
 function stringList(value) {
     return Array.isArray(value)
         ? value.filter((item) => typeof item === 'string')
@@ -557,6 +553,17 @@ async function resolveWriteTarget(repoPath, options) {
         metaDir: path.dirname(metaPath),
     };
 }
+async function removeColdParseRebuildDir(dir, ignoreErrors) {
+    if (!dir)
+        return;
+    try {
+        await fs.rm(dir, { recursive: true, force: true });
+    }
+    catch (err) {
+        if (!ignoreErrors)
+            throw err;
+    }
+}
 /**
  * Run the full analysis under an exclusive, index-directory-scoped write lock
  * (#2658). A second concurrent `analyze` on the same slot waits here for the
@@ -634,6 +641,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
     // selects a `branches/<slug>/` sub-slot only for an explicit `--branch` that
     // does not own the flat slot. See resolveWriteTarget for the full contract.
     const { storagePath, repoHasGit, currentCommit, branchLabel, placement, lbugPath, metaDir } = writeTarget;
+    let coldParseRebuildDir;
     // Start each analyze with a clean buffer-pool hint: any pre-pipeline DB open
     // (e.g. the embeddings-cache open) falls back to the default until the hint is
     // set from the built graph below, so a prior run's size can't leak in.
@@ -798,6 +806,13 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             }
             progress('fts', 90, 'Search indexes ready');
             progress('done', 100, 'Done');
+            if (options.registryName) {
+                await registerRepo(repoPath, existingMeta, {
+                    name: options.registryName,
+                    allowDuplicateName: options.allowDuplicateName,
+                    branch: placement.branch,
+                });
+            }
             return {
                 repoName: options.registryName ??
                     getInferredRepoName(repoPath) ??
@@ -1029,6 +1044,15 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         options = { ...options, force: true };
         analysisFeatureMismatchLogged = true;
     }
+    const currentSpringVendorPrefixes = springVendorPrefixesKey();
+    const persistedRouteBindings = existingMeta?.analysisFeatures?.[SPRING_ROUTE_BINDINGS_FEATURE.id];
+    if (existingMeta &&
+        persistedRouteBindings === SPRING_ROUTE_BINDINGS_FEATURE.version &&
+        existingMeta.springVendorPrefixes !== currentSpringVendorPrefixes) {
+        log('Spring vendor mapping prefixes changed; forcing a full rebuild so persisted Route ' +
+            'evidence matches the configured aliases.');
+        options = { ...options, force: true };
+    }
     // Analyzer provenance is part of freshness, not merely diagnostics. A
     // same-commit fast path must not preserve metadata produced by an older,
     // malformed, or dependency/native-different runner. Force a real rebuild so
@@ -1083,6 +1107,82 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             `new width. Tip: set GITNEXUS_EMBEDDING_DIMS (or --embedding-dims) to pin it across runs.`);
         options = { ...options, force: true };
     }
+    // Actuator snapshots are external runtime inputs and are intentionally not
+    // hashed or persisted. Rebuild on every enabled run so updated snapshots
+    // cannot hit the git freshness fast path; rebuild once when the option is
+    // removed so stale runtime-only evidence is cleared from the index.
+    const springActuatorRequested = options.springActuatorPath !== undefined;
+    const springActuatorPreviouslyEnabled = existingMeta?.springActuator?.enabled === true;
+    const previousActuatorInputs = existingMeta?.springActuator?.repoRelativeInputs;
+    const retainedActuatorInputs = Array.isArray(previousActuatorInputs)
+        ? previousActuatorInputs.filter((input) => typeof input === 'string')
+        : [];
+    if (springActuatorRequested) {
+        const resolvedRepo = path.resolve(repoPath);
+        const resolvedInput = path.resolve(repoPath, options.springActuatorPath);
+        const relativeInput = path.relative(resolvedRepo, resolvedInput);
+        const springActuatorRepoRelativeInput = relativeInput === ''
+            ? '.'
+            : relativeInput === '..' ||
+                relativeInput.startsWith(`..${path.sep}`) ||
+                path.isAbsolute(relativeInput)
+                ? null
+                : relativeInput.split(path.sep).join('/');
+        if (springActuatorRepoRelativeInput !== null &&
+            !retainedActuatorInputs.includes(springActuatorRepoRelativeInput)) {
+            retainedActuatorInputs.push(springActuatorRepoRelativeInput);
+        }
+        if (!options.force) {
+            log('Spring Actuator runtime enrichment requested; forcing a full rebuild.');
+        }
+        options = { ...options, force: true };
+    }
+    else if (springActuatorPreviouslyEnabled) {
+        if (!Array.isArray(previousActuatorInputs) ||
+            previousActuatorInputs.some((input) => typeof input !== 'string')) {
+            throw new Error('Cannot safely disable Spring Actuator runtime enrichment because the previous ' +
+                'index did not record whether its snapshot was inside the repository. Re-run once ' +
+                'with the previous --spring-actuator path, then run again without it.');
+        }
+        log('Spring Actuator runtime enrichment disabled; rebuilding to remove runtime evidence.');
+        options = { ...options, force: true };
+    }
+    const springActuatorScanExclusions = retainedActuatorInputs.length === 0 ? undefined : retainedActuatorInputs;
+    // AsyncAPI documents are the same class of input as Actuator snapshots and
+    // need the same treatment, for a reason git cannot see: the documents live
+    // outside the tree as often as in it, and NOTHING about replacing one moves
+    // the commit or dirties the working tree. Without this, the second run of an
+    // out-of-band cache — the workflow the option exists for — takes the
+    // already-up-to-date fast path below, never opens a document, and serves the
+    // previous run's addresses while reporting success. Measured, not reasoned:
+    // editing a document and re-running printed "Already up to date" and left the
+    // old address in the graph.
+    //
+    // Forcing the rebuild also settles a second defect for free. A synthetic
+    // `File` node for an out-of-tree document (`asyncapi:<label>`) carries a path
+    // that is in no write set and is not covered by `isGraphWideNode`, so on an
+    // incremental writeback the node is dropped while its edges — anchored to a
+    // graph-wide `Destination` — are kept, and the edges then COPY against a row
+    // that was never written. A full rebuild has no incremental subgraph to get
+    // that wrong, so the pair cannot come apart.
+    const asyncApiSpecRequested = options.asyncApiSpecPath !== undefined;
+    const asyncApiSpecPreviouslyEnabled = existingMeta?.asyncApiSpec?.enabled === true;
+    if (asyncApiSpecRequested) {
+        if (!options.force) {
+            log('AsyncAPI document reading requested; forcing a full rebuild.');
+        }
+        options = { ...options, force: true };
+    }
+    else if (asyncApiSpecPreviouslyEnabled) {
+        log('AsyncAPI document reading disabled; rebuilding to remove document-derived evidence.');
+        options = { ...options, force: true };
+    }
+    // Programmatic `useParseCache: false` must set force or the up-to-date
+    // guard returns before the empty-cache construction below.
+    if (options.useParseCache === false && !options.force) {
+        log('Parser cache bypass requested; forcing a full rebuild so unchanged files are re-parsed.');
+        options = { ...options, force: true };
+    }
     // ── Early-return: already up to date ──────────────────────────────
     if (existingMeta &&
         !existingMeta.embeddingCheckpoint &&
@@ -1132,6 +1232,30 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             // later read on a host where it loads — which is a legitimate, common
             // state, and the invariant `analyzer-identity-cli.test.ts` pins.
             if (!dirty && !healUnregistered) {
+                if (options.registryName) {
+                    await registerRepo(repoPath, existingMeta, {
+                        name: options.registryName,
+                        allowDuplicateName: options.allowDuplicateName,
+                        branch: placement.branch,
+                    });
+                    if (!placement.branch) {
+                        try {
+                            await generateAIContextFiles(repoPath, storagePath, options.registryName, existingMeta.stats ?? {}, undefined, {
+                                skipAgentsMd: options.skipAgentsMd,
+                                skipSkills: options.skipSkills,
+                                noStats: options.noStats,
+                                defaultBranch: options.defaultBranch,
+                                // Fast path does not re-run PDG. Using `options.pdg` would
+                                // strip PDG bullets from AGENTS.md on a rename-only analyze.
+                                hasPdg: existingMeta.pdg != null,
+                                hasSpringActuator: existingMeta.springActuator?.enabled === true,
+                            });
+                        }
+                        catch {
+                            /* best-effort — never fail the fast path over a context refresh */
+                        }
+                    }
+                }
                 // ── #2354: restamp the workspace label on a same-commit branch flip ──
                 // The flat slot follows the checked-out working tree; a branch switch
                 // at the SAME commit with a clean tree changes nothing the pipeline
@@ -1256,11 +1380,17 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         }
     }
     // ── Load incremental parse cache ──────────────────────────────────
-    // Content-addressed: safe to reuse across `--force` runs (chunks whose
-    // file contents haven't changed produce identical worker output).
-    // Loaded into a single ParseCache object that the pipeline mutates
-    // in-place (cache hits leave entries unchanged; misses add new ones).
-    const parseCache = await loadParseCache(storagePath);
+    // Content-addressed: `--force` reuses parser shards; `useParseCache: false`
+    // stages a new generation under a run-unique parse-rebuild.* dir and publishes
+    // after success. Unique because index locks are per branch slot while this
+    // cache root is shared across branches.
+    if (options.useParseCache === false) {
+        coldParseRebuildDir = await createColdParseRebuildDir(storagePath);
+        forgetCreatedParseCacheDir(coldParseRebuildDir);
+    }
+    const parseCache = options.useParseCache === false
+        ? emptyParseCache(coldParseRebuildDir)
+        : await loadParseCache(storagePath);
     // Streamed structural emit (#2680). Resolved ONCE, so the pipeline flag and
     // the CSV-dir resolution below cannot disagree — and resolved HERE, not at
     // function entry, because the POSITION is load-bearing: the gate is
@@ -1276,46 +1406,81 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
     // pipeline has already run by then; that run emits non-streamed, precisely as
     // `resolveStreamPdgEmit` — read fresh at the same point — behaves.)
     const streamGraphEmitActive = resolveStreamGraphEmit(options);
+    // #3016: hold back Leiden and flow extraction when the persisted metadata
+    // says this run is a candidate for a surgical incremental write, whose
+    // derived layer is reused rather than recomputed. Deliberately the same
+    // conditions as the `isIncremental` decision below MINUS the two that only
+    // the pipeline can answer (the analysis-feature re-check and a non-empty
+    // file list), so this is a superset: every run that turns out incremental
+    // had the phases skipped, and the runs that do not are caught by
+    // `runDeferredDerivedPhases` once the write plan is known. Excluded on the
+    // streaming path because that is a full rebuild by construction, and the
+    // deferred phases must not write into a finalized emit sink.
+    const skipDerivedGraphPhases = !streamGraphEmitActive &&
+        !options.force &&
+        !!existingMeta &&
+        !!existingMeta.fileHashes &&
+        Object.keys(existingMeta.fileHashes).length > 0 &&
+        repoHasGit &&
+        !schemaFingerprintMismatch(existingMeta.schemaFingerprint);
     // ── Phase 1: Full Pipeline (0–60%) ────────────────────────────────
-    const pipelineResult = await runPipelineFromRepo(repoPath, (p) => {
-        const phaseLabel = PHASE_LABELS[p.phase] || p.phase;
-        const scaled = Math.round(p.percent * 0.6);
-        const message = p.detail
-            ? `${p.message || phaseLabel} (${p.detail})`
-            : p.message || phaseLabel;
-        progress(p.phase, scaled, message);
-    }, {
-        parseCache,
-        workerPoolSize: options.workerPoolSize,
-        // CFG/PDG opt-in (#2081 M1). PipelineOptions.pdg fans out to the worker
-        // build gate (workerData.pdg) and the scope-resolution emit gate.
-        pdg: options.pdg === true,
-        pdgMaxFunctionLines: options.pdgMaxFunctionLines,
-        pdgMaxEdgesPerFunction: options.pdgMaxEdgesPerFunction,
-        pdgMaxReachingDefEdgesPerFunction: options.pdgMaxReachingDefEdgesPerFunction,
-        pdgMaxCdgEdgesPerFunction: options.pdgMaxCdgEdgesPerFunction,
-        pdgMaxTaintFindingsPerFunction: options.pdgMaxTaintFindingsPerFunction,
-        pdgMaxTaintHops: options.pdgMaxTaintHops,
-        pdgMaxInterprocFindings: options.pdgMaxInterprocFindings,
-        pdgMaxInterprocHops: options.pdgMaxInterprocHops,
-        pdgMaxInterprocEdges: options.pdgMaxInterprocEdges,
-        // Streaming/chunked PDG emit (#2202) — gated to full-rebuild runs
-        // (force === true) so the incremental writeback never reads back an
-        // offloaded BasicBlock layer. Memory-only; byte-identical output.
-        streamPdgEmit: resolveStreamPdgEmit(options),
-        pdgEmitChunkSize: resolvePdgEmitChunkSize(options),
-        // Streamed structural emit (#2680) — same full-rebuild gate as the PDG
-        // toggle above, for the same incremental-writeback reason.
-        streamGraphEmit: streamGraphEmitActive,
-        // Resolved ONLY when streaming is active: on a Windows non-ASCII storage
-        // path this helper mkdtempSyncs a real directory, so evaluating it
-        // unconditionally would leak one temp dir per analyze even with the flag
-        // off. The PDG sibling resolves inside its guard for the same reason.
-        graphEmitCsvDir: streamGraphEmitActive
-            ? resolveNativeSafeStorageDir(storagePath, 'graph-csv')
-            : undefined,
-        fetchWrappers: options.fetchWrappers,
-    });
+    let pipelineResult;
+    try {
+        pipelineResult = await runPipelineFromRepo(repoPath, (p) => {
+            const phaseLabel = PHASE_LABELS[p.phase] || p.phase;
+            const scaled = Math.round(p.percent * 0.6);
+            const message = p.detail
+                ? `${p.message || phaseLabel} (${p.detail})`
+                : p.message || phaseLabel;
+            progress(p.phase, scaled, message);
+        }, {
+            parseCache,
+            workerPoolSize: options.workerPoolSize,
+            // CFG/PDG opt-in (#2081 M1). PipelineOptions.pdg fans out to the worker
+            // build gate (workerData.pdg) and the scope-resolution emit gate.
+            pdg: options.pdg === true,
+            pdgMaxFunctionLines: options.pdgMaxFunctionLines,
+            pdgMaxEdgesPerFunction: options.pdgMaxEdgesPerFunction,
+            pdgMaxReachingDefEdgesPerFunction: options.pdgMaxReachingDefEdgesPerFunction,
+            pdgMaxCdgEdgesPerFunction: options.pdgMaxCdgEdgesPerFunction,
+            pdgMaxTaintFindingsPerFunction: options.pdgMaxTaintFindingsPerFunction,
+            pdgMaxTaintHops: options.pdgMaxTaintHops,
+            pdgMaxInterprocFindings: options.pdgMaxInterprocFindings,
+            pdgMaxInterprocHops: options.pdgMaxInterprocHops,
+            pdgMaxInterprocEdges: options.pdgMaxInterprocEdges,
+            // Streaming/chunked PDG emit (#2202) — gated to full-rebuild runs
+            // (force === true) so the incremental writeback never reads back an
+            // offloaded BasicBlock layer. Memory-only; byte-identical output.
+            streamPdgEmit: resolveStreamPdgEmit(options),
+            pdgEmitChunkSize: resolvePdgEmitChunkSize(options),
+            // Streamed structural emit (#2680) — same full-rebuild gate as the PDG
+            // toggle above, for the same incremental-writeback reason.
+            streamGraphEmit: streamGraphEmitActive,
+            // Resolved ONLY when streaming is active: on a Windows non-ASCII storage
+            // path this helper mkdtempSyncs a real directory, so evaluating it
+            // unconditionally would leak one temp dir per analyze even with the flag
+            // off. The PDG sibling resolves inside its guard for the same reason.
+            graphEmitCsvDir: streamGraphEmitActive
+                ? resolveNativeSafeStorageDir(storagePath, 'graph-csv')
+                : undefined,
+            fetchWrappers: options.fetchWrappers,
+            skipDerivedGraphPhases,
+            springActuatorPath: options.springActuatorPath,
+            asyncApiSpecPath: options.asyncApiSpecPath,
+            springActuatorScanExclusions,
+        });
+    }
+    catch (err) {
+        await removeColdParseRebuildDir(coldParseRebuildDir, true);
+        throw err;
+    }
+    if (options.force && (pipelineResult.parseCacheHitFileCount ?? 0) > 0) {
+        log(`Rebuilt the graph and FTS while reusing cached parser output for ` +
+            `${pipelineResult.parseCacheHitFileCount} file(s) ` +
+            `(parse cache ${PARSE_CACHE_VERSION}). ` +
+            `For same-version capture/query development changes, increment SCHEMA_BUMP in ` +
+            `src/storage/parse-cache.ts to invalidate parser output.`);
+    }
     // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────
     progress('lbug', 60, 'Loading into LadybugDB...');
     // Compute current per-file content hashes from the pipeline's File nodes.
@@ -1364,6 +1529,26 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
     const hashDiff = isIncremental
         ? diffFileHashes(newFileHashes, existingMeta.fileHashes)
         : undefined;
+    // #3016: `skipDerivedGraphPhases` was decided BEFORE the pipeline, from the
+    // persisted metadata alone, so it can only ever be a bet that this run stays
+    // surgical. Settle the bet here, where `isIncremental` and the deletion set
+    // are both known, and pay it off by running the held-back phases whenever the
+    // write plan needs a freshly derived layer:
+    //   - not incremental      → full rebuild writes the whole graph, and a graph
+    //                            with no Community/Process nodes would publish an
+    //                            index with no communities and no flows;
+    //   - added/changed/deleted files → the persisted derived layer can miss new
+    //                            symbols, keep stale memberships, or reference
+    //                            removed ids. Only an empty file-hash diff is a
+    //                            proof that Leiden/flows still match.
+    const preserveDerivedLayer = skipDerivedGraphPhases &&
+        isIncremental &&
+        !!hashDiff &&
+        shouldPreservePersistedDerivedGraph(hashDiff);
+    if (skipDerivedGraphPhases && !preserveDerivedLayer) {
+        progress('communities', 58, 'Detecting code communities and flows...');
+        await pipelineResult.runDeferredDerivedPhases?.();
+    }
     // #2 atomic index publish: on a full rebuild, build the fresh DB at a temp
     // path and swap it over the live index in one rename at the very end, so a
     // concurrent MCP reader opening mid-build only ever sees the previous
@@ -1562,6 +1747,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         // collapse check compares the whole in-memory graph against the whole DB,
         // which is only a like-for-like comparison on a full rebuild.
         let wroteChangedSubgraphOnly = false;
+        let incrementalFtsRebuildTables;
         if (isIncremental && hashDiff) {
             // ── Incremental DB writeback ───────────────────────────────────
             // 0. Expand the writable set with transitive importers of
@@ -1697,6 +1883,29 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             //    and extractChangedSubgraph — asymmetry between the two would
             //    leave stale rows or PK-conflict at COPY time.
             const effectiveWriteSet = computeEffectiveWriteSet(pipelineResult.graph, writableFiles);
+            const springConfigChanged = hashDiff.toWrite.some((filePath) => classifySpringConfigFile(filePath) !== null) ||
+                hashDiff.deleted.some((filePath) => classifySpringConfigFile(filePath) !== null);
+            if (springConfigChanged) {
+                const unresolvedPrefix = escapeCypherString(SPRING_CONFIG_UNRESOLVED_PREFIX);
+                const persistedSpringConfigConsumers = (await executeQuery('MATCH (n:Property) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description ' +
+                    'UNION ALL ' +
+                    'MATCH (n:Class) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description ' +
+                    'UNION ALL ' +
+                    'MATCH (n:Record) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description'));
+                const springConfigConsumerDriftFiles = collectSpringConfigConsumerDriftFiles(pipelineResult.graph, persistedSpringConfigConsumers);
+                for (const filePath of springConfigConsumerDriftFiles)
+                    effectiveWriteSet.add(filePath);
+                if (springConfigConsumerDriftFiles.size > 0) {
+                    log(`Incremental: +${springConfigConsumerDriftFiles.size} file(s) added for ` +
+                        'Spring config consumer property drift');
+                }
+            }
             // `frameworkAnnotations` is derived from cross-file JVM visibility, so
             // an unchanged Class row can change when a same-package declaration is
             // added or removed without producing an IMPORTS edge. Compare the fresh
@@ -1824,6 +2033,14 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             const sizeForcedRebuild = shouldEscalateIncrementalWrite(filesToDelete.length, effectiveWriteSet.size, allFilePaths.length);
             if (extensionForcedRebuild || sizeForcedRebuild) {
                 escalatedFullWrite = true;
+                // #3016: escalation converts this run into a wipe + full bulk COPY of
+                // the in-memory graph, so the derived layer the skip was betting on
+                // preserving has to exist in that graph after all. Same reasoning as
+                // the not-incremental branch above, just discovered later.
+                if (preserveDerivedLayer) {
+                    progress('communities', 63, 'Detecting code communities and flows...');
+                    await pipelineResult.runDeferredDerivedPhases?.();
+                }
                 // Every live cause is named, not just the first: a DB can carry BOTH a
                 // vector index and FTS indexes, and reporting one cause while the other
                 // is equally fatal is how #2841 stayed mis-diagnosed for so long. §5.D:
@@ -2024,7 +2241,53 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 // the snapshot type exists to enforce.
                 if (buildPath === lbugPath)
                     liveIndexMutationStarted = true;
-                await dropSearchFTSIndexes(indexCatalogRows);
+                // FTS narrowing is independent of Leiden/flow reuse: even when this
+                // run re-derives communities, Ladybug still cannot DML a live FTS
+                // index (#2589), so only the tables this write set touches should
+                // lose their index. The probe is a question about the DB rather than
+                // the fresh graph — a symbol the edit DELETED is in no fresh graph
+                // but is still a row that has to go.
+                const tablesWithRows = await nodeTablesWithRowsForFiles(filesToDelete, NODE_TABLES);
+                // Narrowing 1 — the FTS sweep, from "every configured index" to "the
+                // indexes this run must touch". Three sources, and dropping any one of
+                // them strands something:
+                //   - what the writeback DELETES (the probe above), because a symbol
+                //     the edit removed is in no fresh graph but is still a row;
+                //   - what it INSERTS (the fresh graph), because inserting under a live
+                //     FTS index is the same #2589 hazard as deleting under one;
+                //   - what is MISSING right now, because narrowing to the written
+                //     tables would otherwise leave keyword search degraded forever on
+                //     tables whose index a previous escalation dropped — the next full
+                //     rebuild would be the only thing that ever restored them.
+                // An unreadable catalog proves nothing about that third set, so it
+                // withdraws the narrowing entirely rather than guess.
+                const missingFts = await missingSearchFTSIndexTables(indexCatalogRows);
+                const touchedFts = missingFts
+                    ? new Set([
+                        ...ftsTablesAmong(tablesWithRows),
+                        ...incrementalFtsTablesFromGraph(pipelineResult.graph, new Set(filesToDelete)),
+                        ...missingFts,
+                    ])
+                    : undefined;
+                // Graph-wide Spring synthetic Class nodes are DETACH DELETEd on this
+                // branch even when Class is not in the write set
+                // (`deleteSpringAutoConfigurationSyntheticClasses`). Always include
+                // Class so class_fts is not live across that DML (#2589), including
+                // when the fresh graph no longer materializes the synthetics but the
+                // DB still holds them.
+                if (touchedFts) {
+                    touchedFts.add('Class');
+                }
+                incrementalFtsRebuildTables = touchedFts;
+                // MEMBER_OF / STEP_IN_PROCESS / ENTRY_POINT_OF edges hang off the nodes
+                // the DETACH DELETE below removes, so preserving the Community/Process
+                // nodes preserves only half the layer unless these are reattached after
+                // the subgraph write puts the member nodes back. Only the probed tables
+                // can own such an edge, so they are the only ones worth scanning.
+                const derivedSnapshot = preserveDerivedLayer
+                    ? await snapshotDerivedRelsForFiles(filesToDelete, [...tablesWithRows])
+                    : [];
+                await dropSearchFTSIndexes(indexCatalogRows, incrementalFtsRebuildTables);
                 // 1b. Remove the write set's existing rows — batched (#2409): one
                 //     DETACH DELETE per table per 200-file chunk. The former per-file
                 //     loop issued a count + delete per table per FILE — ~13k
@@ -2038,6 +2301,9 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 progress('lbug', 62, `Removing rows for changed files (0/${filesToDelete.length})...`);
                 await deleteNodesForFiles(filesToDelete, {
                     onChunk: (done, total) => progress('lbug', 62, `Removing rows for changed files (${done}/${total})...`),
+                    nodeTables: incrementalFtsRebuildTables
+                        ? nodeTablesForIncrementalDelete(NODE_TABLES, incrementalFtsRebuildTables)
+                        : undefined,
                 });
                 // Surgical path: Phase 3.5 restores exactly these files' embedding
                 // rows (FIX 3). Sound because deleteNodesForFiles propagates errors
@@ -2045,10 +2311,12 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 // deterministically — and this process holds the exclusive DB lock,
                 // so no concurrent writer can disturb the derivation.
                 deletedFilePathsForRestore = new Set(filesToDelete);
-                // 2. Drop graph-wide nodes (Community, Process). They'll be re-inserted
-                //    from the fresh pipeline output below. Required for the
-                //    "Leiden runs on the FULL graph" correctness invariant.
-                await deleteAllCommunitiesAndProcesses();
+                if (!preserveDerivedLayer) {
+                    // 2. Drop graph-wide nodes (Community, Process). They'll be re-inserted
+                    //    from the fresh pipeline output below. Required for the
+                    //    "Leiden runs on the FULL graph" correctness invariant.
+                    await deleteAllCommunitiesAndProcesses();
+                }
                 // 2a. Drop INJECTS edges (DI collection injection, #2200) — their
                 //     validity is a whole-program property (a third-file change to the
                 //     interface or an implementer creates/invalidates edges between two
@@ -2067,6 +2335,18 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 // Rebuild the complete ADVISED_BY set on every incremental writeback.
                 await deleteAllAdvisedBy();
                 await deleteSpringAopEvidenceNodes();
+                // 2b-bis. Drop the whole async messaging overlay. A RESOLVED
+                //     Destination deliberately stores no filePath (so the per-file
+                //     DETACH DELETE cannot cut a node shared across files), which also
+                //     means the per-file delete can never REMOVE one that is now
+                //     orphaned, and the endpoint-writability extract can never ADD one
+                //     introduced by a new file. Delete-all here plus the graph-wide
+                //     re-include in extractChangedSubgraph rebuilds the layer whole;
+                //     the springDestinations phase recomputes it from the full file
+                //     list on every persisting analyze, so nothing is lost. Both halves
+                //     must move together — deleting without the re-include drops the
+                //     layer, re-including without the delete duplicates its edges.
+                await deleteAllDestinations();
                 // 2c. Drop Spring-owned DECLARES edges (#2415). The
                 //     auto-configuration phase scans every metadata file and recomputes
                 //     the full set each run; exact reason filtering leaves declarations
@@ -2095,7 +2375,9 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 //    only that. Unchanged-file rows in the DB stay untouched. Pass
                 //    the SAME effectiveWriteSet so the subgraph and the deletes
                 //    cover identical files (asymmetry would silently corrupt).
-                const subgraph = extractChangedSubgraph(pipelineResult.graph, effectiveWriteSet);
+                const subgraph = extractChangedSubgraph(pipelineResult.graph, effectiveWriteSet, {
+                    includeDerivedGraphWide: !preserveDerivedLayer,
+                });
                 wroteChangedSubgraphOnly = true;
                 await saveIncrementalDirtyState('load-graph', {
                     importerExpansion,
@@ -2108,6 +2390,9 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                     const pct = Math.min(84, 65 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 19));
                     progress('lbug', pct, msg);
                 });
+                if (preserveDerivedLayer && derivedSnapshot.length > 0) {
+                    await restoreDerivedRels(derivedSnapshot);
+                }
             }
             // Boundary drain (#2409): checkpoint at the end of the incremental
             // writeback so the WAL it accumulated never lingers into the FTS and
@@ -2159,6 +2444,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             // pre-existing row (#2544/#2546) must not discard this run's otherwise-
             // successful graph/embeddings work — only keyword search degrades.
             const ftsResult = await buildSearchIndexesOrDegrade(executeQuery, {
+                tables: incrementalFtsRebuildTables,
                 onIndexStart: options.verbose
                     ? (table, indexName) => log(`FTS: creating ${table}.${indexName}`)
                     : undefined,
@@ -2771,6 +3057,22 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             lastCommit: currentCommit,
             indexedAt: new Date().toISOString(),
             runnerIdentity,
+            // Persist only normalized repo-relative exclusions, never absolute paths
+            // or payloads. Keep them after runtime enrichment is disabled so a later
+            // ordinary scan cannot rediscover an unchanged snapshot as source/FTS.
+            ...(springActuatorRequested || retainedActuatorInputs.length > 0
+                ? {
+                    springActuator: {
+                        enabled: springActuatorRequested,
+                        repoRelativeInputs: retainedActuatorInputs,
+                    },
+                }
+                : {}),
+            // Written only while enabled. Once the option is dropped, the disable
+            // transition above has already forced the cleanup rebuild, so carrying a
+            // `{ enabled: false }` stamp forward would only make every subsequent run
+            // re-decide a question that is already settled.
+            ...(asyncApiSpecRequested ? { asyncApiSpec: { enabled: true } } : {}),
             // Branch identity this index represents (#2106). Recorded for the flat
             // slot too (so resolveBranchPlacement knows which branch owns it). When
             // the label is null (detached HEAD / non-git re-analyze) we PRESERVE an
@@ -2803,8 +3105,9 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 files: pipelineResult.totalFileCount,
                 nodes: stats.nodes,
                 edges: stats.edges,
-                communities: pipelineResult.communityResult?.stats.totalCommunities,
-                processes: pipelineResult.processResult?.stats.totalProcesses,
+                communities: pipelineResult.communityResult?.stats.totalCommunities ??
+                    existingMeta?.stats?.communities,
+                processes: pipelineResult.processResult?.stats.totalProcesses ?? existingMeta?.stats?.processes,
                 embeddings: persistedEmbeddingCount,
             },
             capabilities: {
@@ -2870,6 +3173,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 ? existingMeta?.undecidedInterfaceSatisfaction
                 : summarizeUndecidedSatisfaction(pipelineResult.undecidedSatisfaction),
             analysisFeatures: currentAnalysisFeatures,
+            springVendorPrefixes: currentSpringVendorPrefixes,
             // Always stamped with the live resolved mode (#2331/#2339) — unlike
             // `pdg` below, 'none' is a meaningful value to compare, not an
             // absence, so this is never conditionally omitted.
@@ -2914,50 +3218,8 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         // meta.indexedAt = T_new while lbugPath still resolves to the pre-swap
         // inode (which latched the reader on the stale index permanently). The meta
         // object is fully computed at this point; only its write is deferred.
-        // Persist the incremental parse cache for the next run. Wraps in
-        // try/catch so a cache-write failure never breaks an otherwise
-        // successful indexing run. Prune stale chunk-hash entries first so
-        // the cache file size stays bounded across runs (chunks whose
-        // composition no longer matches anything in the current scan are
-        // dead weight; the parse phase populates `usedKeys` as it processes
-        // chunks).
-        try {
-            // #2106 R6: the parse cache + durable store are shared across branches.
-            // Before pruning to this run's keys, fold in the OTHER branches' recorded
-            // chunk keys so a branch switch doesn't evict their still-live shards.
-            // Adding to usedKeys makes them survive pruneCache AND land in the saved
-            // index (saveParseCache builds the index from usedKeys). Excludes this
-            // run's own meta dir, so a single-branch repo folds in nothing → prune
-            // set byte-identical to today.
-            const { keys: siblingKeys, complete } = await collectBranchCacheKeys(storagePath, metaDir);
-            if (complete) {
-                for (const k of siblingKeys)
-                    parseCache.usedKeys.add(k);
-            }
-            else {
-                // Fail-safe toward retention: a sibling meta was unreadable, so keep
-                // everything currently loaded rather than evict on incomplete info.
-                log('Parse cache: a branch meta was unreadable — retaining all cached chunks (#2106).');
-                for (const k of parseCache.entries.keys())
-                    parseCache.usedKeys.add(k);
-            }
-            const pruned = pruneCache(parseCache, parseCache.usedKeys);
-            if (pruned > 0) {
-                log(`Parse cache: pruned ${pruned} stale chunk entries`);
-            }
-            const savedKeys = await saveParseCache(storagePath, parseCache);
-            // Prune the durable ParsedFile store to EXACTLY the parse cache's
-            // surviving keys (#2038 warm-cache coverage), so the two content-addressed
-            // stores stay coherent: a chunk is "cached" iff both its parse-cache shard
-            // and its durable shards exist. A quarantined chunk (in usedKeys but with
-            // no parse-cache shard) drops its durable subdir here and re-dispatches
-            // next run. Same try/catch — a durable-store write failure must never
-            // break an otherwise successful run (next run treats it as a miss).
-            await pruneAndSaveDurableParsedFileStore(getDurableParsedFileDir(storagePath), PARSE_CACHE_VERSION, new Set(savedKeys));
-        }
-        catch (e) {
-            log(`Warning: could not save parse cache (${e.message}); continuing.`);
-        }
+        // Parse-cache publish waits until after that swap + saveMeta so a failed
+        // registerRepo / close / swap cannot replace live shards (#3153).
         // Forward the --name alias and the registry-collision bypass bit.
         // `allowDuplicateName` is its own concern — independent from the
         // pipeline `force` above. The CLI maps it from
@@ -2978,8 +3240,8 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         // ── #2354: the flat workspace slot has adopted this run's branch ──────
         // Drop a now-shadowed `branches/<slug>/` sub-index for the same label
         // (unreachable once the flat slot serves it) and align the registry's
-        // top-level branch label. Best-effort like the parse-cache save above
-        // (#2364 review F5): the index is complete and registered, and a failure
+        // top-level branch label. Best-effort (#2364 review F5): the index is
+        // complete and registered, and a failure
         // here leaves only a stale registry label / undeleted shadowed dir —
         // never wrong routing, because the flat meta this run already stamped is
         // what applyBranchScope trusts. Retried by the next content-changing run
@@ -3014,15 +3276,17 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                     files: pipelineResult.totalFileCount,
                     nodes: stats.nodes,
                     edges: stats.edges,
-                    communities: pipelineResult.communityResult?.stats.totalCommunities,
+                    communities: pipelineResult.communityResult?.stats.totalCommunities ??
+                        existingMeta?.stats?.communities,
                     clusters: aggregatedClusterCount,
-                    processes: pipelineResult.processResult?.stats.totalProcesses,
+                    processes: pipelineResult.processResult?.stats.totalProcesses ?? existingMeta?.stats?.processes,
                 }, undefined, {
                     skipAgentsMd: options.skipAgentsMd,
                     skipSkills: options.skipSkills,
                     noStats: options.noStats,
                     defaultBranch: options.defaultBranch,
                     hasPdg: options.pdg === true,
+                    hasSpringActuator: options.springActuatorPath !== undefined,
                 });
             }
             catch {
@@ -3086,7 +3350,51 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
         // is a crash-safety improvement: a failed swap leaves the previous index
         // live and the next run recovers via the full-rebuild path.
         await saveMeta(metaDir, meta);
+        // Persist the incremental parse cache only after a successful graph
+        // publish (#3153). try/catch so a cache-write failure never breaks an
+        // otherwise successful indexing run. Prune stale chunk-hash entries first
+        // so the cache file size stays bounded across runs (chunks whose
+        // composition no longer matches anything in the current scan are dead
+        // weight; the parse phase populates `usedKeys` as it processes chunks).
+        try {
+            // #2106 R6: the parse cache + durable store are shared across branches.
+            // Before pruning to this run's keys, fold in the OTHER branches' recorded
+            // chunk keys so a branch switch doesn't evict their still-live shards.
+            // Adding to usedKeys makes them survive pruneCache AND land in the saved
+            // index (saveParseCache builds the index from usedKeys). Excludes this
+            // run's own meta dir, so a single-branch repo folds in nothing → prune
+            // set byte-identical to today.
+            const { keys: siblingKeys, complete } = await collectBranchCacheKeys(storagePath, metaDir);
+            if (complete) {
+                for (const k of siblingKeys)
+                    parseCache.usedKeys.add(k);
+            }
+            else {
+                // Fail-safe toward retention: a sibling meta was unreadable, so keep
+                // everything currently loaded rather than evict on incomplete info.
+                log('Parse cache: a branch meta was unreadable — retaining all cached chunks (#2106).');
+                for (const k of parseCache.entries.keys())
+                    parseCache.usedKeys.add(k);
+            }
+            const pruned = pruneCache(parseCache, parseCache.usedKeys);
+            if (pruned > 0) {
+                log(`Parse cache: pruned ${pruned} stale chunk entries`);
+            }
+            const savedKeys = await saveParseCache(storagePath, parseCache);
+            // Prune the durable ParsedFile store to EXACTLY the parse cache's
+            // surviving keys (#2038 warm-cache coverage), so the two content-addressed
+            // stores stay coherent: a chunk is "cached" iff both its parse-cache shard
+            // and its durable shards exist. A quarantined chunk (in usedKeys but with
+            // no parse-cache shard) drops its durable subdir here and re-dispatches
+            // next run. Same try/catch — a durable-store write failure must never
+            // break an otherwise successful run (next run treats it as a miss).
+            await mergeStagedDurableParsedFileStore(storagePath, parseCache.storagePath ?? storagePath, PARSE_CACHE_VERSION, new Set(savedKeys));
+        }
+        catch (e) {
+            log(`Warning: could not save parse cache (${e.message}); continuing.`);
+        }
         progress('done', 100, 'Done');
+        await removeColdParseRebuildDir(coldParseRebuildDir, true);
         return {
             repoName: projectName,
             repoPath,
@@ -3144,6 +3452,7 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
                 /* swallow — orphan reclamation must never mask the real failure */
             }
         }
+        await removeColdParseRebuildDir(coldParseRebuildDir, true);
         if (liveIndexMutationStarted) {
             // Preserve the original error identity/prototype: callers distinguish
             // IndexLockTimeoutError and other domain failures with `instanceof`.