gitnexus 1.6.8-rc.9 → 1.6.8

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

@@ -26,6 +26,9 @@
 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 { CallSummary } from '../../taint/call-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;
@@ -43,5 +46,26 @@ export interface ScopeResolutionOutput {
         readonly importsEmitted: number;
         readonly referenceEdgesEmitted: number;
     }>;
+    /**
+     * Per-function taint summaries harvested in the pdg window (#2084 M4 U1),
+     * across all languages. Empty unless `--pdg` and a registered taint model.
+     * The `taintSummaries` phase composes these over the `CALLS` graph.
+     */
+    readonly functionSummaries: readonly FunctionSummary[];
+    /**
+     * Per-function RETURN-VALUE ASCENT summaries harvested in the pdg window
+     * (PDG FU-C, U-C2), across all languages. Empty unless `--pdg`. The
+     * `callSummaries` phase materialises one `CALL_SUMMARY` self-loop edge per
+     * entry once the resolved call graph is known.
+     */
+    readonly callSummaries: readonly CallSummary[];
+    /**
+     * 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

@@ -33,6 +33,9 @@ import { SCOPE_RESOLVERS } from './registry.js';
 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,
@@ -41,6 +44,8 @@ const NOOP_OUTPUT = Object.freeze({
     referenceEdgesEmitted: 0,
     resolutionOutcomes: [],
     perLanguage: new Map(),
+    functionSummaries: [],
+    callSummaries: [],
 });
 export const scopeResolutionPhase = {
     name: 'scopeResolution',
@@ -103,6 +108,12 @@ export const scopeResolutionPhase = {
         let totalRefs = 0;
         let anyRan = false;
         const resolutionOutcomes = [];
+        // M4 (#2084 U1): per-function taint summaries accumulated across every
+        // language pass; the cross-function fixpoint phase reads this output.
+        const functionSummaries = [];
+        // FU-C (U-C2): per-function RETURN-VALUE ASCENT summaries accumulated across
+        // every language pass; the `callSummaries` emit phase reads this output.
+        const callSummaries = [];
         const perLanguage = new Map();
         // Pre-count files and languages for progress reporting. This avoids
         // a frozen progress bar during long scope-resolution runs (#1741).
@@ -167,204 +178,273 @@ export const scopeResolutionPhase = {
         logHeapProbe('scope-setup-nodeLookup-start', `langs=${totalScopeLangs} files=${totalScopeFiles}`);
         const sharedNodeLookup = totalScopeFiles > 0 ? buildGraphNodeLookup(ctx.graph) : undefined;
         logHeapProbe('scope-setup-nodeLookup-end', `langs=${totalScopeLangs}`);
-        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);
+        // M4 (#2084 review P2-6): build the functionish-node index ONCE for the
+        // taint summary harvest, shared across every language pass (it is a whole-
+        // graph scan and language-agnostic). Only when pdg is on — off ⇒ undefined,
+        // no scan, byte-identical.
+        const sharedFnNodeIndex = ctx.options?.pdg === true && totalScopeFiles > 0
+            ? buildFunctionNodeIndex(ctx.graph)
+            : undefined;
+        // 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,
-                preExtractedParsedFiles: preExtractedByPath,
-                scopeIndexStorePath: parsedFileStorePath,
-                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;
-            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);
+                callSummaries.push(...stats.callSummaries);
+                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({
@@ -386,8 +466,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,
@@ -395,6 +478,9 @@ export const scopeResolutionPhase = {
             referenceEdgesEmitted: totalRefs,
             resolutionOutcomes,
             perLanguage,
+            functionSummaries,
+            callSummaries,
+            pdgEmitManifest,
         };
     },
 };

package/dist/core/ingestion/scope-resolution/pipeline/reconcile-ownership.js

@@ -64,14 +64,39 @@ export function reconcileOwnership(parsedFiles, model) {
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
             const ownerId = def.ownerId;
-            if (ownerId === undefined)
-                continue;
             const simple = simpleQualifiedName(def);
             if (simple === undefined)
                 continue;
             if (def.type === 'Method' || def.type === 'Function' || def.type === 'Constructor') {
+                if (ownerId === undefined) {
+                    if (def.isDeleted !== true)
+                        continue;
+                    const existingDef = model.symbols
+                        .lookupExactAll(def.filePath, simple)
+                        .find((candidate) => callableSignatureMatches(candidate, def));
+                    if (existingDef !== undefined) {
+                        existingDef.isDeleted = true;
+                        skippedAlreadyPresent++;
+                        continue;
+                    }
+                    model.symbols.add(def.filePath, simple, def.nodeId, def.type, {
+                        parameterCount: def.parameterCount,
+                        requiredParameterCount: def.requiredParameterCount,
+                        parameterTypes: def.parameterTypes,
+                        parameterTypeClasses: def.parameterTypeClasses,
+                        returnType: def.returnType,
+                        qualifiedName: def.qualifiedName,
+                        isDeleted: true,
+                    });
+                    continue;
+                }
                 const existing = model.methods.lookupAllByOwner(ownerId, simple);
-                if (existing.some((e) => e.nodeId === def.nodeId)) {
+                const existingDef = existing.find((candidate) => candidate.nodeId === def.nodeId ||
+                    (def.isDeleted === true && callableSignatureMatches(candidate, def)));
+                if (existingDef !== undefined) {
+                    if (def.isDeleted === true) {
+                        existingDef.isDeleted = true;
+                    }
                     skippedAlreadyPresent++;
                     continue;
                 }
@@ -103,6 +128,21 @@ export function reconcileOwnership(parsedFiles, model) {
     }
     return { methodsRegistered, fieldsRegistered, nestedTypesRegistered, skippedAlreadyPresent };
 }
+function callableSignatureMatches(left, right) {
+    if (left.filePath !== right.filePath)
+        return false;
+    if (left.parameterCount !== right.parameterCount)
+        return false;
+    if (left.requiredParameterCount !== right.requiredParameterCount)
+        return false;
+    const leftTypes = left.parameterTypes;
+    const rightTypes = right.parameterTypes;
+    if (leftTypes === undefined || rightTypes === undefined) {
+        return leftTypes === rightTypes;
+    }
+    return (leftTypes.length === rightTypes.length &&
+        leftTypes.every((parameterType, index) => parameterType === rightTypes[index]));
+}
 /**
  * Debug-mode parity validator. Runs only when
  * `VALIDATE_SEMANTIC_MODEL !== '0'` AND `NODE_ENV !== 'production'`.