gitnexus 1.6.8-rc.41 → 1.6.8-rc.43

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

@@ -95,6 +95,23 @@ export interface PipelineOptions {
     /** Per-run `TAINT_PATH` edge cap (#2084 review P1-3). `undefined` ⇒
      *  `DEFAULT_PDG_MAX_INTERPROC_EDGES` (1000); `0` ⇒ no cap. */
     pdgMaxInterprocEdges?: number;
+    /**
+     * Streaming/chunked PDG graph emit (#2202). When true, the BasicBlock +
+     * intra-file PDG-edge layer (CFG / REACHING_DEF / CDG / POST_DOMINATE /
+     * TAINTED / SANITIZES) is streamed to CSV-on-disk during the scope-resolution
+     * emit loop instead of being materialized in the in-memory graph, bounding
+     * peak RSS to O(chunk) rather than O(graph) at full-kernel scale. Already
+     * gated by the caller to full-rebuild runs only (the incremental writeback
+     * reads BasicBlocks back from the in-memory graph). Memory-only — produces a
+     * byte-identical persisted graph and is NOT part of `RepoMeta.pdg`, so
+     * toggling it never trips `pdgModeMismatch`. Default/false ⇒ today's
+     * whole-graph emit.
+     */
+    streamPdgEmit?: boolean;
+    /** Streamed PDG-emit write buffer (rows) when `streamPdgEmit` is on (#2202).
+     *  `undefined` ⇒ `DEFAULT_PDG_EMIT_CHUNK_ROWS`. Memory-only; does not affect
+     *  emitted bytes. */
+    pdgEmitChunkSize?: number;
     /**
      * Request parsing with the worker pool disabled. The sequential parser was
      * removed — the worker pool is the sole parse path — so setting this now

package/dist/core/ingestion/pipeline.js

@@ -76,7 +76,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
-    const resolutionOutcomes = getPhaseOutput(results, 'scopeResolution').resolutionOutcomes;
+    const scopeResolutionOutput = getPhaseOutput(results, 'scopeResolution');
+    const resolutionOutcomes = scopeResolutionOutput.resolutionOutcomes;
+    // Streamed PDG-emit manifest (#2202): present only when streaming was on.
+    const pdgEmitManifest = scopeResolutionOutput.pdgEmitManifest;
     if (!options?.skipGraphPhases) {
         communityResult = getPhaseOutput(results, 'communities').communityResult;
         processResult = getPhaseOutput(results, 'processes').processResult;
@@ -101,5 +104,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         processResult,
         resolutionOutcomes,
         usedWorkerPool,
+        pdgEmitManifest,
     };
 };

package/dist/core/ingestion/scope-resolution/pipeline/phase.d.ts

@@ -27,6 +27,7 @@ import type { PipelinePhase } from '../../pipeline-phases/types.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import type { ResolutionOutcome } from '../resolution-outcome.js';
 import type { FunctionSummary } from '../../taint/summary-model.js';
+import { type PdgEmitManifest } from '../../../lbug/pdg-emit-sink.js';
 export interface ScopeResolutionOutput {
     /** True when at least one language ran. */
     readonly ran: boolean;
@@ -50,5 +51,13 @@ export interface ScopeResolutionOutput {
      * The `taintSummaries` phase composes these over the `CALLS` graph.
      */
     readonly functionSummaries: readonly FunctionSummary[];
+    /**
+     * Streamed PDG-emit COPY manifest (#2202). Present only when streaming was on
+     * (full rebuild + `--pdg` + enabled): the BasicBlock node CSV + per-pair PDG
+     * edge CSVs that were flushed to disk during the emit loop, for the persistence
+     * step to COPY alongside the structural CSVs. Absent ⇒ the PDG layer (if any)
+     * is in the in-memory graph and persists via the normal whole-graph emit.
+     */
+    readonly pdgEmitManifest?: PdgEmitManifest;
 }
 export declare const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput>;

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -34,6 +34,8 @@ import { isDev, isSemanticModelValidatorEnabled } from '../../utils/env.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
 import { clearParsedFileStore, loadParsedFilesForPaths, forceGc, } from '../../../../storage/parsedfile-store.js';
 import { buildFunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
+import { PdgEmitSink } from '../../../lbug/pdg-emit-sink.js';
+import { resolveNativeSafeStorageDir } from '../../../lbug/lbug-config.js';
 import { logger } from '../../../logger.js';
 const NOOP_OUTPUT = Object.freeze({
     ran: false,
@@ -179,213 +181,265 @@ export const scopeResolutionPhase = {
         const sharedFnNodeIndex = ctx.options?.pdg === true && totalScopeFiles > 0
             ? buildFunctionNodeIndex(ctx.graph)
             : undefined;
-        for (const [lang, provider] of SCOPE_RESOLVERS) {
-            // Standalone providers (COBOL, JCL) don't emit graph edges yet
-            // through the scope-resolution path. This is the canonical guard:
-            // runScopeResolution is never called for standalone providers, which
-            // keeps cobolPhase as the sole IMPORTS edge producer. Keep this guard
-            // in sync with any additional standalone providers added to
-            // SCOPE_RESOLVERS.
-            if (provider.languageProvider.parseStrategy === 'standalone')
-                continue;
-            const primaryLangFiles = filesByLang.get(lang) ?? [];
-            if (primaryLangFiles.length === 0)
-                continue;
-            const primaryFilePaths = primaryLangFiles.map((f) => f.path);
-            // Load per-language import-resolution config (tsconfig paths,
-            // composer.json autoload, go.mod, ...). One I/O round trip per
-            // workspace pass — cached implicitly by the result handed to
-            // every `resolveImportTarget` call below.
-            const resolutionConfig = provider.loadResolutionConfig !== undefined
-                ? await provider.loadResolutionConfig(ctx.repoPath)
-                : undefined;
-            // Some languages (e.g. Vue) expand their file universe beyond the
-            // primary-language files via the `collectScopeContextPaths` hook.
-            // The hook receives raw source contents of the primary files so it
-            // can trace import closures without a second tree-sitter parse.
-            //
-            // To avoid reading primary files twice (once for the hook, once for
-            // the resolution pass), we read them upfront and merge with the
-            // extra context paths the hook may add.
-            // Stream this language's pre-built ParsedFiles in from the disk store
-            // FIRST (huge-repo path). Doing it before reading source lets us skip
-            // loading content for files the store already covers — for a provider
-            // with no content-consuming hook that source is pure dead weight once
-            // extraction is served from the store (~1.5 GB on the kernel's C pass).
-            // Merged into `preExtractedByPath`; the per-language release block below
-            // evicts these again before the next language, so only one language's
-            // ParsedFiles are resident at a time.
-            const loadStoreFor = async (paths) => {
-                if (!parsedFileStorePath)
-                    return;
-                const fromDisk = await loadParsedFilesForPaths(parsedFileStorePath, paths);
-                for (const [fp, pf] of fromDisk)
-                    preExtractedByPath.set(fp, pf);
-            };
-            // A provider that feeds source text into a post-extract hook
-            // (populateWorkspaceOwners / populateNamespaceSiblings /
-            // populateRangeBindings / emitPostResolutionEdges) needs content for ALL
-            // its files; one without those hooks only needs content for files the
-            // store does NOT cover (fresh-extract fallback). Keep this in sync with
-            // the getFileContents() call-sites in run.ts.
-            const providerNeedsAllContent = provider.populateWorkspaceOwners !== undefined ||
-                provider.populateNamespaceSiblings !== undefined ||
-                provider.populateRangeBindings !== undefined ||
-                provider.emitPostResolutionEdges !== undefined;
-            let scopeFilePaths;
-            let contents;
-            if (provider.collectScopeContextPaths !== undefined) {
-                // Context-expanding providers (e.g. Vue) need every primary file's
-                // source up front for the closure hook, so load it all.
-                const entryFileContents = await readFileContents(ctx.repoPath, primaryFilePaths);
-                scopeFilePaths = provider.collectScopeContextPaths({
-                    primaryFilePaths,
-                    preExtractedByPath,
-                    entryFileContents,
-                    allScannedPaths,
-                    resolutionConfig,
-                });
-                // Read only the extra context files (TS/JS etc.) not already loaded.
-                const extraPaths = [...scopeFilePaths].filter((p) => !entryFileContents.has(p));
-                const extraContents = await readFileContents(ctx.repoPath, extraPaths);
-                contents = new Map([...entryFileContents, ...extraContents]);
-                await loadStoreFor(scopeFilePaths);
+        // Streaming/chunked PDG emit (#2202): when enabled (the caller has already
+        // gated this to full-rebuild + `--pdg`), route the BasicBlock + intra-file
+        // PDG-edge layer to CSV-on-disk through one sink shared across every
+        // language pass, so it never accumulates in `ctx.graph` (peak RSS O(chunk)).
+        // Needs the storage dir (the parse-cache store path, the same `.gitnexus`
+        // dir loadGraphToLbug COPYs from); if that is somehow absent we skip
+        // streaming and fall back to the in-memory whole-graph emit.
+        let pdgEmitSink;
+        if (ctx.options?.streamPdgEmit === true && totalScopeFiles > 0) {
+            if (parsedFileStorePath) {
+                pdgEmitSink = new PdgEmitSink(ctx.graph, 
+                // Same ASCII-safe relocation the structural CSVs get (#2202 review #2):
+                // on Windows non-ASCII storage paths the COPY can't open files under
+                // the native path, so the dir is relocated to a hashed os.tmpdir().
+                resolveNativeSafeStorageDir(parsedFileStorePath, 'pdg-csv'), ctx.options?.pdgEmitChunkSize);
             }
             else {
-                scopeFilePaths = new Set(primaryFilePaths);
-                await loadStoreFor(scopeFilePaths);
-                const pathsToRead = providerNeedsAllContent
-                    ? primaryFilePaths
-                    : primaryFilePaths.filter((p) => !preExtractedByPath.has(p));
-                contents = await readFileContents(ctx.repoPath, pathsToRead);
+                logger.warn('[scope-resolution] streaming PDG emit requested but no storage path is ' +
+                    'available; falling back to in-memory whole-graph emit');
             }
-            const filePaths = [...scopeFilePaths];
-            const files = [];
-            for (const fp of filePaths) {
-                const content = contents.get(fp);
-                if (content !== undefined) {
-                    files.push({ path: fp, content });
+        }
+        // Cross-pass per-file dedup set for the streaming sink (#2202): one set
+        // shared across every language pass so a file emitted in two passes (e.g. a
+        // `.ts` module pulled into the Vue context pass) streams its PDG layer once.
+        // Only created when streaming — the in-memory-graph path dedups via its Map.
+        const pdgEmittedFiles = pdgEmitSink !== undefined ? new Set() : undefined;
+        // Stream the PDG layer with guaranteed writer cleanup: a throw escaping the
+        // per-language loop (outside run.ts's per-file try/catch — e.g. from
+        // finalize/propagate/a provider hook) must still release the sink's file
+        // descriptors. finalize() runs on the success path; the finally closes the
+        // sink only when finalize did not (idempotent via the sink's `finalized`).
+        let pdgEmitManifest;
+        let pdgSinkSettled = false;
+        try {
+            for (const [lang, provider] of SCOPE_RESOLVERS) {
+                // Standalone providers (COBOL, JCL) don't emit graph edges yet
+                // through the scope-resolution path. This is the canonical guard:
+                // runScopeResolution is never called for standalone providers, which
+                // keeps cobolPhase as the sole IMPORTS edge producer. Keep this guard
+                // in sync with any additional standalone providers added to
+                // SCOPE_RESOLVERS.
+                if (provider.languageProvider.parseStrategy === 'standalone')
+                    continue;
+                const primaryLangFiles = filesByLang.get(lang) ?? [];
+                if (primaryLangFiles.length === 0)
+                    continue;
+                const primaryFilePaths = primaryLangFiles.map((f) => f.path);
+                // Load per-language import-resolution config (tsconfig paths,
+                // composer.json autoload, go.mod, ...). One I/O round trip per
+                // workspace pass — cached implicitly by the result handed to
+                // every `resolveImportTarget` call below.
+                const resolutionConfig = provider.loadResolutionConfig !== undefined
+                    ? await provider.loadResolutionConfig(ctx.repoPath)
+                    : undefined;
+                // Some languages (e.g. Vue) expand their file universe beyond the
+                // primary-language files via the `collectScopeContextPaths` hook.
+                // The hook receives raw source contents of the primary files so it
+                // can trace import closures without a second tree-sitter parse.
+                //
+                // To avoid reading primary files twice (once for the hook, once for
+                // the resolution pass), we read them upfront and merge with the
+                // extra context paths the hook may add.
+                // Stream this language's pre-built ParsedFiles in from the disk store
+                // FIRST (huge-repo path). Doing it before reading source lets us skip
+                // loading content for files the store already covers — for a provider
+                // with no content-consuming hook that source is pure dead weight once
+                // extraction is served from the store (~1.5 GB on the kernel's C pass).
+                // Merged into `preExtractedByPath`; the per-language release block below
+                // evicts these again before the next language, so only one language's
+                // ParsedFiles are resident at a time.
+                const loadStoreFor = async (paths) => {
+                    if (!parsedFileStorePath)
+                        return;
+                    const fromDisk = await loadParsedFilesForPaths(parsedFileStorePath, paths);
+                    for (const [fp, pf] of fromDisk)
+                        preExtractedByPath.set(fp, pf);
+                };
+                // A provider that feeds source text into a post-extract hook
+                // (populateWorkspaceOwners / populateNamespaceSiblings /
+                // populateRangeBindings / emitPostResolutionEdges) needs content for ALL
+                // its files; one without those hooks only needs content for files the
+                // store does NOT cover (fresh-extract fallback). Keep this in sync with
+                // the getFileContents() call-sites in run.ts.
+                const providerNeedsAllContent = provider.populateWorkspaceOwners !== undefined ||
+                    provider.populateNamespaceSiblings !== undefined ||
+                    provider.populateRangeBindings !== undefined ||
+                    provider.emitPostResolutionEdges !== undefined;
+                let scopeFilePaths;
+                let contents;
+                if (provider.collectScopeContextPaths !== undefined) {
+                    // Context-expanding providers (e.g. Vue) need every primary file's
+                    // source up front for the closure hook, so load it all.
+                    const entryFileContents = await readFileContents(ctx.repoPath, primaryFilePaths);
+                    scopeFilePaths = provider.collectScopeContextPaths({
+                        primaryFilePaths,
+                        preExtractedByPath,
+                        entryFileContents,
+                        allScannedPaths,
+                        resolutionConfig,
+                    });
+                    // Read only the extra context files (TS/JS etc.) not already loaded.
+                    const extraPaths = [...scopeFilePaths].filter((p) => !entryFileContents.has(p));
+                    const extraContents = await readFileContents(ctx.repoPath, extraPaths);
+                    contents = new Map([...entryFileContents, ...extraContents]);
+                    await loadStoreFor(scopeFilePaths);
                 }
-                else if (preExtractedByPath.has(fp)) {
-                    // Store covers extraction for this file and we deliberately skipped
-                    // reading its source; the empty string is never consumed (the
-                    // extract loop uses the pre-extracted ParsedFile and this provider
-                    // has no content hook).
-                    files.push({ path: fp, content: '' });
+                else {
+                    scopeFilePaths = new Set(primaryFilePaths);
+                    await loadStoreFor(scopeFilePaths);
+                    const pathsToRead = providerNeedsAllContent
+                        ? primaryFilePaths
+                        : primaryFilePaths.filter((p) => !preExtractedByPath.has(p));
+                    contents = await readFileContents(ctx.repoPath, pathsToRead);
                 }
-                // else: uncovered AND unreadable → skip (unchanged from prior behavior).
-            }
-            const langFileCount = files.length;
-            logHeapProbe('scope-lang-start', `lang=${lang} files=${langFileCount} contentsLoaded=${contents.size}`);
-            const langLabel = lang.charAt(0).toUpperCase() + lang.slice(1);
-            currentLangIdx++;
-            const langTag = totalScopeLangs > 1 ? `${langLabel} [${currentLangIdx}/${totalScopeLangs}]` : langLabel;
-            if (totalScopeFiles > 0) {
-                const pct = SCOPE_PCT_START + Math.round((processedScopeFiles / totalScopeFiles) * SCOPE_PCT_RANGE);
-                ctx.onProgress({
-                    phase: 'scopeResolution',
-                    percent: pct,
-                    message: 'Resolving types',
-                    detail: `${langTag}, ${langFileCount.toLocaleString()} files`,
-                });
-            }
-            const stats = runScopeResolution({
-                graph: ctx.graph,
-                model,
-                files,
-                resolutionConfig,
-                prebuiltNodeLookup: sharedNodeLookup,
-                prebuiltFunctionNodeIndex: sharedFnNodeIndex,
-                preExtractedParsedFiles: preExtractedByPath,
-                scopeIndexStorePath: parsedFileStorePath,
-                // CFG/PDG emission (#2081 M1) — opt-in; off ⇒ byte-identical graph.
-                pdg: ctx.options?.pdg === true,
-                pdgMaxEdgesPerFunction: ctx.options?.pdgMaxEdgesPerFunction,
-                pdgMaxReachingDefEdgesPerFunction: ctx.options?.pdgMaxReachingDefEdgesPerFunction,
-                pdgMaxCdgEdgesPerFunction: ctx.options?.pdgMaxCdgEdgesPerFunction,
-                pdgMaxTaintFindingsPerFunction: ctx.options?.pdgMaxTaintFindingsPerFunction,
-                pdgMaxTaintHops: ctx.options?.pdgMaxTaintHops,
-                recordResolutionOutcome: (outcome) => {
-                    resolutionOutcomes.push(outcome);
-                },
-                onWarn: (msg) => {
-                    if (isSemanticModelValidatorEnabled()) {
-                        logger.warn(`[scope-resolution:${lang}] ${msg}`);
+                const filePaths = [...scopeFilePaths];
+                const files = [];
+                for (const fp of filePaths) {
+                    const content = contents.get(fp);
+                    if (content !== undefined) {
+                        files.push({ path: fp, content });
                     }
-                },
-                onProgress: totalScopeFiles > 0
-                    ? (subPhase, current, total) => {
-                        let langRatio;
-                        switch (subPhase) {
-                            case 'extracting':
-                                langRatio = total > 0 ? (current / total) * 0.5 : 0;
-                                break;
-                            case 'analyzing types':
-                                langRatio = 0.5;
-                                break;
-                            case 'resolving references':
-                                langRatio = 0.7;
-                                break;
-                            case 'linking symbols':
-                                langRatio = 0.85;
-                                break;
-                            default: {
-                                const _exhaustive = subPhase;
-                                langRatio = 0.85;
+                    else if (preExtractedByPath.has(fp)) {
+                        // Store covers extraction for this file and we deliberately skipped
+                        // reading its source; the empty string is never consumed (the
+                        // extract loop uses the pre-extracted ParsedFile and this provider
+                        // has no content hook).
+                        files.push({ path: fp, content: '' });
+                    }
+                    // else: uncovered AND unreadable → skip (unchanged from prior behavior).
+                }
+                const langFileCount = files.length;
+                logHeapProbe('scope-lang-start', `lang=${lang} files=${langFileCount} contentsLoaded=${contents.size}`);
+                const langLabel = lang.charAt(0).toUpperCase() + lang.slice(1);
+                currentLangIdx++;
+                const langTag = totalScopeLangs > 1 ? `${langLabel} [${currentLangIdx}/${totalScopeLangs}]` : langLabel;
+                if (totalScopeFiles > 0) {
+                    const pct = SCOPE_PCT_START + Math.round((processedScopeFiles / totalScopeFiles) * SCOPE_PCT_RANGE);
+                    ctx.onProgress({
+                        phase: 'scopeResolution',
+                        percent: pct,
+                        message: 'Resolving types',
+                        detail: `${langTag}, ${langFileCount.toLocaleString()} files`,
+                    });
+                }
+                const stats = runScopeResolution({
+                    graph: ctx.graph,
+                    model,
+                    files,
+                    resolutionConfig,
+                    prebuiltNodeLookup: sharedNodeLookup,
+                    prebuiltFunctionNodeIndex: sharedFnNodeIndex,
+                    preExtractedParsedFiles: preExtractedByPath,
+                    scopeIndexStorePath: parsedFileStorePath,
+                    // CFG/PDG emission (#2081 M1) — opt-in; off ⇒ byte-identical graph.
+                    pdg: ctx.options?.pdg === true,
+                    pdgMaxEdgesPerFunction: ctx.options?.pdgMaxEdgesPerFunction,
+                    pdgMaxReachingDefEdgesPerFunction: ctx.options?.pdgMaxReachingDefEdgesPerFunction,
+                    pdgMaxCdgEdgesPerFunction: ctx.options?.pdgMaxCdgEdgesPerFunction,
+                    pdgMaxTaintFindingsPerFunction: ctx.options?.pdgMaxTaintFindingsPerFunction,
+                    pdgMaxTaintHops: ctx.options?.pdgMaxTaintHops,
+                    // Streaming PDG-emit sink (#2202) — undefined ⇒ emit to the in-memory graph.
+                    pdgEmitSink,
+                    // Cross-pass per-file dedup set (#2202) — undefined when not streaming.
+                    pdgEmittedFiles,
+                    recordResolutionOutcome: (outcome) => {
+                        resolutionOutcomes.push(outcome);
+                    },
+                    onWarn: (msg) => {
+                        if (isSemanticModelValidatorEnabled()) {
+                            logger.warn(`[scope-resolution:${lang}] ${msg}`);
+                        }
+                    },
+                    onProgress: totalScopeFiles > 0
+                        ? (subPhase, current, total) => {
+                            let langRatio;
+                            switch (subPhase) {
+                                case 'extracting':
+                                    langRatio = total > 0 ? (current / total) * 0.5 : 0;
+                                    break;
+                                case 'analyzing types':
+                                    langRatio = 0.5;
+                                    break;
+                                case 'resolving references':
+                                    langRatio = 0.7;
+                                    break;
+                                case 'linking symbols':
+                                    langRatio = 0.85;
+                                    break;
+                                default: {
+                                    const _exhaustive = subPhase;
+                                    langRatio = 0.85;
+                                }
                             }
+                            const overallRatio = Math.min(1, (processedScopeFiles + langRatio * langFileCount) / totalScopeFiles);
+                            const pct = SCOPE_PCT_START + Math.round(overallRatio * SCOPE_PCT_RANGE);
+                            ctx.onProgress({
+                                phase: 'scopeResolution',
+                                percent: pct,
+                                message: 'Resolving types',
+                                detail: subPhase === 'extracting'
+                                    ? `${langTag} — extracting ${current.toLocaleString()}/${total.toLocaleString()} files`
+                                    : `${langTag} — ${subPhase}`,
+                            });
                         }
-                        const overallRatio = Math.min(1, (processedScopeFiles + langRatio * langFileCount) / totalScopeFiles);
-                        const pct = SCOPE_PCT_START + Math.round(overallRatio * SCOPE_PCT_RANGE);
-                        ctx.onProgress({
-                            phase: 'scopeResolution',
-                            percent: pct,
-                            message: 'Resolving types',
-                            detail: subPhase === 'extracting'
-                                ? `${langTag} — extracting ${current.toLocaleString()}/${total.toLocaleString()} files`
-                                : `${langTag} — ${subPhase}`,
-                        });
-                    }
-                    : undefined,
-            }, provider);
-            // Release file contents and pre-extracted entries after each language
-            // to reduce memory pressure. For large codebases (16K+ PHP files),
-            // holding all source code simultaneously with scope trees causes OOM.
-            // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
-            //
-            // Use `filePaths` (not `primaryFilePaths`) so that any context files
-            // added by `collectScopeContextPaths` (e.g. TS/JS files pulled in for
-            // Vue cross-file resolution) are also evicted and not held until GC.
-            files.length = 0;
-            contents.clear();
-            for (const fp of filePaths) {
-                preExtractedByPath.delete(fp);
-            }
-            // This language's ParsedFiles are now unreachable (runScopeResolution has
-            // returned and the Map entries are deleted). Force a GC HERE so a heavy
-            // language's ~17-20GB set (e.g. C/C++ on the Linux kernel) is reclaimed
-            // BEFORE the next language's store-load — instead of leaving V8 to collect
-            // it lazily under the next pass's allocation pressure (which, at a cap >=
-            // RAM, degrades into swap-thrash). Collects only dead objects: the live
-            // cross-file index of the next pass is untouched. The pre/post probe
-            // confirms whether old-space fragmentation defeats the reclaim.
-            logHeapProbe('lang-release-pre-gc', `lang=${lang}`);
-            forceGc();
-            logHeapProbe('lang-release-post-gc', `lang=${lang}`);
-            logHeapProbe('scope-lang-end', `lang=${lang} filesProcessed=${stats.filesProcessed}`);
-            processedScopeFiles += langFileCount;
-            anyRan = true;
-            functionSummaries.push(...stats.functionSummaries);
-            totalFiles += stats.filesProcessed;
-            totalImports += stats.importsEmitted;
-            totalRefs += stats.referenceEdgesEmitted;
-            perLanguage.set(lang, {
-                filesProcessed: stats.filesProcessed,
-                importsEmitted: stats.importsEmitted,
-                referenceEdgesEmitted: stats.referenceEdgesEmitted,
-            });
-            if (isDev) {
-                logger.info(`[scope-resolution:${lang}] ${stats.filesProcessed} files → ${stats.importsEmitted} IMPORTS + ${stats.referenceEdgesEmitted} reference edges (${stats.resolve.unresolved} unresolved sites, ${stats.referenceSkipped} skipped)`);
+                        : undefined,
+                }, provider);
+                // Release file contents and pre-extracted entries after each language
+                // to reduce memory pressure. For large codebases (16K+ PHP files),
+                // holding all source code simultaneously with scope trees causes OOM.
+                // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+                //
+                // Use `filePaths` (not `primaryFilePaths`) so that any context files
+                // added by `collectScopeContextPaths` (e.g. TS/JS files pulled in for
+                // Vue cross-file resolution) are also evicted and not held until GC.
+                files.length = 0;
+                contents.clear();
+                for (const fp of filePaths) {
+                    preExtractedByPath.delete(fp);
+                }
+                // This language's ParsedFiles are now unreachable (runScopeResolution has
+                // returned and the Map entries are deleted). Force a GC HERE so a heavy
+                // language's ~17-20GB set (e.g. C/C++ on the Linux kernel) is reclaimed
+                // BEFORE the next language's store-load — instead of leaving V8 to collect
+                // it lazily under the next pass's allocation pressure (which, at a cap >=
+                // RAM, degrades into swap-thrash). Collects only dead objects: the live
+                // cross-file index of the next pass is untouched. The pre/post probe
+                // confirms whether old-space fragmentation defeats the reclaim.
+                logHeapProbe('lang-release-pre-gc', `lang=${lang}`);
+                forceGc();
+                logHeapProbe('lang-release-post-gc', `lang=${lang}`);
+                logHeapProbe('scope-lang-end', `lang=${lang} filesProcessed=${stats.filesProcessed}`);
+                processedScopeFiles += langFileCount;
+                anyRan = true;
+                functionSummaries.push(...stats.functionSummaries);
+                totalFiles += stats.filesProcessed;
+                totalImports += stats.importsEmitted;
+                totalRefs += stats.referenceEdgesEmitted;
+                perLanguage.set(lang, {
+                    filesProcessed: stats.filesProcessed,
+                    importsEmitted: stats.importsEmitted,
+                    referenceEdgesEmitted: stats.referenceEdgesEmitted,
+                });
+                if (isDev) {
+                    logger.info(`[scope-resolution:${lang}] ${stats.filesProcessed} files → ${stats.importsEmitted} IMPORTS + ${stats.referenceEdgesEmitted} reference edges (${stats.resolve.unresolved} unresolved sites, ${stats.referenceSkipped} skipped)`);
+                }
             }
+            // Finalize the streaming PDG sink (#2202) once after the last language:
+            // flush + close its CSV writers and capture the COPY manifest. forceGc at
+            // the boundary reclaims transient write buffers (mirrors the per-language
+            // release below).
+            pdgEmitManifest = pdgEmitSink?.finalize();
+            pdgSinkSettled = true;
+            if (pdgEmitSink !== undefined)
+                forceGc();
+        }
+        finally {
+            // Release fds if a throw skipped finalize (idempotent with finalize()).
+            if (pdgEmitSink !== undefined && !pdgSinkSettled)
+                pdgEmitSink.close();
         }
         if (totalScopeFiles > 0 && anyRan) {
             ctx.onProgress({
@@ -407,8 +461,11 @@ export const scopeResolutionPhase = {
                 /* best-effort cleanup */
             }
         }
+        // Even when no language ran, surface a finalized manifest (its CSVs are on
+        // disk) so loadGraphToLbug COPYs them rather than orphaning them — empty in
+        // the no-files case, harmless.
         if (!anyRan)
-            return NOOP_OUTPUT;
+            return pdgEmitManifest ? { ...NOOP_OUTPUT, pdgEmitManifest } : NOOP_OUTPUT;
         return {
             ran: true,
             filesProcessed: totalFiles,
@@ -417,6 +474,7 @@ export const scopeResolutionPhase = {
             resolutionOutcomes,
             perLanguage,
             functionSummaries,
+            pdgEmitManifest,
         };
     },
 };

package/dist/core/ingestion/scope-resolution/pipeline/run.d.ts

@@ -84,6 +84,30 @@ interface RunScopeResolutionInput {
      *  `reason`; consumed by the U4 taint emit step). `undefined` ⇒
      *  `DEFAULT_PDG_MAX_TAINT_HOPS` (32); `0` ⇒ no cap. */
     readonly pdgMaxTaintHops?: number;
+    /**
+     * Streaming PDG-emit sink (#2202). When present (streaming on, full rebuild),
+     * the `--pdg` emit routes BasicBlock nodes + intra-file PDG edges to THIS
+     * graph-shaped target instead of the in-memory `graph`, so the bulky PDG
+     * layer never accumulates in memory (peak RSS O(chunk)). Typed as a plain
+     * `KnowledgeGraph` so this module stays decoupled from the persistence layer;
+     * the caller (the scope-resolution phase) owns its lifecycle and finalizes it
+     * after the last language. Absent ⇒ the emit writes to `graph` as before
+     * (byte-identical default).
+     */
+    readonly pdgEmitSink?: KnowledgeGraph;
+    /**
+     * Cross-pass per-file dedup set for streaming PDG emit (#2202). Shared across
+     * every language pass (owned by the scope-resolution phase). A file imported
+     * by more than one language (e.g. a `.ts` module pulled into the Vue context
+     * pass) is PDG-emitted in each pass over the same `cfgSideChannel`, producing
+     * identical ids; the in-memory graph dedups that by id, but the streaming sink
+     * is dedup-free (to stay O(write buffer), not O(total ids)). So when present
+     * (streaming on), the emit loop skips a file whose PDG already streamed and
+     * records the rest — keeping the streamed set byte-identical to the
+     * Map-deduped whole-graph emit, for any language-pass order. Absent ⇒ no skip
+     * (the graph Map dedups), so the default path is unchanged.
+     */
+    readonly pdgEmittedFiles?: Set<string>;
     /**
      * Optional graph-node lookup built ONCE by the caller and shared across
      * every language pass. `buildGraphNodeLookup` scans the whole graph and is