gitnexus 1.6.8-rc.21 → 1.6.8-rc.23

package/dist/core/incremental/subgraph-extract.js

@@ -49,6 +49,15 @@
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
 const isGraphWide = (label) => label === 'Community' || label === 'Process';
+/**
+ * Relationship types whose VALIDITY is a whole-program property, not a
+ * function of their endpoints' files (#2084 M4 U6). `TAINT_PATH` (cross-
+ * function taint) can be invalidated by a change to an INTERMEDIATE function
+ * on a third file, so the endpoint-writability rule below would skip a stale
+ * A→C edge. These are always extracted (and the orchestrator delete-alls them
+ * first, like Community/Process) so they rebuild from the fresh graph.
+ */
+const isGraphWideRelType = (type) => type === 'TAINT_PATH';
 /**
  * Build a Map<nodeId, filePath> for every File-bound node in the graph.
  * Graph-wide nodes (Community/Process) have no filePath and are filtered.
@@ -74,7 +83,9 @@ export const extractChangedSubgraph = (fullGraph, toWriteSet) => {
         }
     });
     fullGraph.forEachRelationship((r) => {
-        if (writableNodeIds.has(r.sourceId) || writableNodeIds.has(r.targetId)) {
+        if (writableNodeIds.has(r.sourceId) ||
+            writableNodeIds.has(r.targetId) ||
+            isGraphWideRelType(r.type)) {
             sub.addRelationship(r);
         }
     });

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -15,6 +15,7 @@ export { ormPhase, type ORMOutput } from './orm.js';
 export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
 export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-resolution/pipeline/phase.js';
 export { pruneLocalSymbolsPhase, type PruneLocalSymbolsOutput } from './prune-local-symbols.js';
+export { taintSummariesPhase, type TaintSummariesOutput } from './taint-summaries.js';
 export { mroPhase, type MROOutput } from './mro.js';
 export { communitiesPhase, type CommunitiesOutput } from './communities.js';
 export { processesPhase, type ProcessesOutput } from './processes.js';

package/dist/core/ingestion/pipeline-phases/index.js

@@ -16,6 +16,7 @@ export { ormPhase } from './orm.js';
 export { crossFilePhase } from './cross-file.js';
 export { scopeResolutionPhase, } from '../scope-resolution/pipeline/phase.js';
 export { pruneLocalSymbolsPhase } from './prune-local-symbols.js';
+export { taintSummariesPhase } from './taint-summaries.js';
 export { mroPhase } from './mro.js';
 export { communitiesPhase } from './communities.js';
 export { processesPhase } from './processes.js';

package/dist/core/ingestion/pipeline-phases/taint-summaries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Phase: taintSummaries (#2084 M4 U3/U5)
+ *
+ * The interprocedural taint fixpoint. Runs AFTER scope-resolution (where the
+ * complete, resolved `CALLS` graph lives in `ctx.graph` and the per-function
+ * summaries were harvested in-phase) and composes those summaries to find
+ * source→sink flows that cross function and file boundaries.
+ *
+ * Opt-in: registered with `enabledWhen: (o) => o.pdg === true` (the first real
+ * pdg-gated phase). A default `analyze` run never includes it, so the graph is
+ * byte-identical. No always-on phase depends on it (a filtered-out dep would
+ * throw in `getPhaseOutput`).
+ *
+ * @deps    scopeResolution, pruneLocalSymbols
+ * @reads   graph (CALLS edges, Function/Method nodes), scopeResolution output
+ *          (functionSummaries)
+ * @writes  graph (TAINT_PATH edges)
+ */
+import type { PipelinePhase } from './types.js';
+export interface TaintSummariesOutput {
+    /** Function summaries fed to the fixpoint. */
+    summaries: number;
+    /** Cross-function findings (pre-cap). */
+    findings: number;
+    /** TAINT_PATH edges persisted. */
+    edgesEmitted: number;
+    /** Call sites whose callee did not resolve to a summary edge (diagnostics). */
+    unmatchedCallSites: number;
+}
+export declare const taintSummariesPhase: PipelinePhase<TaintSummariesOutput>;

package/dist/core/ingestion/pipeline-phases/taint-summaries.js

@@ -0,0 +1,81 @@
+/**
+ * Phase: taintSummaries (#2084 M4 U3/U5)
+ *
+ * The interprocedural taint fixpoint. Runs AFTER scope-resolution (where the
+ * complete, resolved `CALLS` graph lives in `ctx.graph` and the per-function
+ * summaries were harvested in-phase) and composes those summaries to find
+ * source→sink flows that cross function and file boundaries.
+ *
+ * Opt-in: registered with `enabledWhen: (o) => o.pdg === true` (the first real
+ * pdg-gated phase). A default `analyze` run never includes it, so the graph is
+ * byte-identical. No always-on phase depends on it (a filtered-out dep would
+ * throw in `getPhaseOutput`).
+ *
+ * @deps    scopeResolution, pruneLocalSymbols
+ * @reads   graph (CALLS edges, Function/Method nodes), scopeResolution output
+ *          (functionSummaries)
+ * @writes  graph (TAINT_PATH edges)
+ */
+import { getPhaseOutput } from './types.js';
+import { solveInterprocTaint, DEFAULT_MAX_INTERPROC_HOPS, DEFAULT_PDG_MAX_INTERPROC_FINDINGS, } from '../taint/interproc-solver.js';
+import { emitInterprocTaint, DEFAULT_PDG_MAX_INTERPROC_EDGES } from '../taint/interproc-emit.js';
+import { logger } from '../../logger.js';
+const EMPTY = {
+    summaries: 0,
+    findings: 0,
+    edgesEmitted: 0,
+    unmatchedCallSites: 0,
+};
+export const taintSummariesPhase = {
+    name: 'taintSummaries',
+    deps: ['scopeResolution', 'pruneLocalSymbols'],
+    async execute(ctx, deps) {
+        const scope = getPhaseOutput(deps, 'scopeResolution');
+        const summaries = scope.functionSummaries;
+        if (summaries.length === 0)
+            return EMPTY;
+        // Index summaries by function node id.
+        const summaryMap = new Map(summaries.map((s) => [s.fnId, s]));
+        // Build the call-edge adjacency from resolved CALLS edges. The join to a
+        // summary's call-arg edge is by CALLEE NAME (base-independent — see the
+        // solver doc); recover it from the callee node's `name` property.
+        const callEdges = [];
+        for (const rel of ctx.graph.iterRelationshipsByType('CALLS')) {
+            const callee = ctx.graph.getNode(rel.targetId);
+            const calleeName = callee && typeof callee.properties.name === 'string' ? callee.properties.name : undefined;
+            if (calleeName === undefined)
+                continue;
+            callEdges.push({ callerId: rel.sourceId, calleeId: rel.targetId, calleeName });
+        }
+        // Arm the per-run caps (#2084 review P1-3) — every other pdg layer bounds
+        // its output via RepoMeta.pdg; without this the fixpoint state + TAINT_PATH
+        // edges grow unbounded on a fan-in-heavy repo (OOM). `0` ⇒ unlimited
+        // (preserved like the other pdg caps). The solver/emit already implement
+        // deterministic truncate-and-warn — this just hands them the budgets.
+        const maxFindings = ctx.options?.pdgMaxInterprocFindings ?? DEFAULT_PDG_MAX_INTERPROC_FINDINGS;
+        const maxHops = ctx.options?.pdgMaxInterprocHops ?? DEFAULT_MAX_INTERPROC_HOPS;
+        const maxEdges = ctx.options?.pdgMaxInterprocEdges ?? DEFAULT_PDG_MAX_INTERPROC_EDGES;
+        const solved = solveInterprocTaint(summaryMap, callEdges, { maxFindings, maxHops });
+        const emit = emitInterprocTaint(ctx.graph, solved.findings, { maxEdges }, (m) => logger.warn(m));
+        // Surface drops UNCONDITIONALLY (R4 — never silently truncate the layer).
+        if (solved.droppedFindings > 0 || emit.edgesDropped > 0) {
+            logger.warn(`[taint-interproc] capped: ${solved.droppedFindings} finding(s) dropped by the ` +
+                `per-run findings cap (${maxFindings}), ${emit.edgesDropped} edge(s) by the edge cap ` +
+                `(${maxEdges}) — raise pdgMaxInterprocFindings/pdgMaxInterprocEdges if intentional`);
+        }
+        if (solved.findings.length > 0 || emit.edgesEmitted > 0) {
+            logger.debug(`[taint-interproc] ${summaries.length} summaries, ${callEdges.length} CALLS edges → ` +
+                `${solved.findings.length} cross-function finding(s), ${emit.edgesEmitted} TAINT_PATH edge(s)` +
+                (emit.hopsTruncated > 0 ? `, ${emit.hopsTruncated} with truncated paths` : '') +
+                (solved.unmatchedCallSites > 0
+                    ? `, ${solved.unmatchedCallSites} unmatched call site(s)`
+                    : ''));
+        }
+        return {
+            summaries: summaries.length,
+            findings: solved.findings.length,
+            edgesEmitted: emit.edgesEmitted,
+            unmatchedCallSites: solved.unmatchedCallSites,
+        };
+    },
+};

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

@@ -73,6 +73,19 @@ export interface PipelineOptions {
      * no-CLI-flag discipline as `pdgMaxTaintFindingsPerFunction`.
      */
     pdgMaxTaintHops?: number;
+    /**
+     * Per-run cross-function findings cap (#2084 M4 review P1-3). `undefined` ⇒
+     * `DEFAULT_PDG_MAX_INTERPROC_FINDINGS` (2000); `0` ⇒ no cap. Consumed by the
+     * `taintSummaries` phase; RepoMeta-stamped, no CLI flag (KTD8) — same
+     * discipline as the per-function taint caps.
+     */
+    pdgMaxInterprocFindings?: number;
+    /** Per-finding cross-function hop cap (#2084 review P1-3). `undefined` ⇒
+     *  `DEFAULT_MAX_INTERPROC_HOPS` (32); `0` ⇒ no cap. */
+    pdgMaxInterprocHops?: number;
+    /** Per-run `TAINT_PATH` edge cap (#2084 review P1-3). `undefined` ⇒
+     *  `DEFAULT_PDG_MAX_INTERPROC_EDGES` (1000); `0` ⇒ no cap. */
+    pdgMaxInterprocEdges?: 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

@@ -15,7 +15,7 @@
  * See ARCHITECTURE.md for the full phase dependency diagram.
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
-import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, pruneLocalSymbolsPhase, mroPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
+import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, pruneLocalSymbolsPhase, taintSummariesPhase, mroPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
 // ── Phase registry ─────────────────────────────────────────────────────────
 /**
  * All pipeline phases with their dependency relationships.
@@ -49,6 +49,10 @@ export function buildPhaseList(options) {
         .register(crossFilePhase)
         .register(scopeResolutionPhase)
         .register(pruneLocalSymbolsPhase)
+        // M4 (#2084): interprocedural taint fixpoint — the first real opt-in
+        // pdg-gated phase. Off ⇒ absent ⇒ byte-identical graph. No always-on
+        // phase depends on it (a filtered-out dep would throw in getPhaseOutput).
+        .register(taintSummariesPhase, { enabledWhen: (o) => o.pdg === true })
         .register(mroPhase, { enabledWhen: (o) => !o.skipGraphPhases })
         .register(communitiesPhase, { enabledWhen: (o) => !o.skipGraphPhases })
         .register(processesPhase, { enabledWhen: (o) => !o.skipGraphPhases })

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

@@ -26,6 +26,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';
 export interface ScopeResolutionOutput {
     /** True when at least one language ran. */
     readonly ran: boolean;
@@ -43,5 +44,11 @@ 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[];
 }
 export declare const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput>;

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

@@ -33,6 +33,7 @@ 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 { logger } from '../../../logger.js';
 const NOOP_OUTPUT = Object.freeze({
     ran: false,
@@ -41,6 +42,7 @@ const NOOP_OUTPUT = Object.freeze({
     referenceEdgesEmitted: 0,
     resolutionOutcomes: [],
     perLanguage: new Map(),
+    functionSummaries: [],
 });
 export const scopeResolutionPhase = {
     name: 'scopeResolution',
@@ -103,6 +105,9 @@ 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 = [];
         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,6 +172,13 @@ 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}`);
+        // 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;
         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:
@@ -283,6 +295,7 @@ export const scopeResolutionPhase = {
                 files,
                 resolutionConfig,
                 prebuiltNodeLookup: sharedNodeLookup,
+                prebuiltFunctionNodeIndex: sharedFnNodeIndex,
                 preExtractedParsedFiles: preExtractedByPath,
                 scopeIndexStorePath: parsedFileStorePath,
                 // CFG/PDG emission (#2081 M1) — opt-in; off ⇒ byte-identical graph.
@@ -360,6 +373,7 @@ export const scopeResolutionPhase = {
             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;
@@ -401,6 +415,7 @@ export const scopeResolutionPhase = {
             referenceEdgesEmitted: totalRefs,
             resolutionOutcomes,
             perLanguage,
+            functionSummaries,
         };
     },
 };

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

@@ -27,6 +27,8 @@ import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { MutableSemanticModel } from '../../model/semantic-model.js';
 import { type ResolveStats } from '../../resolve-references.js';
 import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import { type FunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
+import type { FunctionSummary } from '../../taint/summary-model.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
 import type { ResolutionOutcome, ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 export type ScopeResolutionSubPhase = 'extracting' | 'analyzing types' | 'resolving references' | 'linking symbols';
@@ -91,6 +93,14 @@ interface RunScopeResolutionInput {
      * base is safe.
      */
     readonly prebuiltNodeLookup?: ReturnType<typeof buildGraphNodeLookup>;
+    /**
+     * Functionish-node index built ONCE by the caller and shared across every
+     * language pass (#2084 review P2-6). Like `prebuiltNodeLookup`,
+     * `buildFunctionNodeIndex` is a whole-graph scan and is language-agnostic, so
+     * rebuilding it per language wastes a full scan each time. When omitted
+     * (tests / isolated calls) it is built locally for the pdg-enabled language.
+     */
+    readonly prebuiltFunctionNodeIndex?: FunctionNodeIndex;
     /**
      * Opaque per-language import-resolution config (e.g. tsconfig path
      * aliases for TypeScript). Loaded once by the caller via
@@ -148,6 +158,13 @@ interface RunScopeResolutionStats {
     readonly referenceEdgesEmitted: number;
     readonly referenceSkipped: number;
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
+    /**
+     * Per-function taint summaries harvested in the pdg window (#2084 M4 U1).
+     * Empty unless `input.pdg === true` and the language has a registered taint
+     * model. Keyed by resolved `Function`/`Method` node id; the cross-function
+     * fixpoint phase composes them over the complete `CALLS` graph.
+     */
+    readonly functionSummaries: readonly FunctionSummary[];
 }
 export declare function runScopeResolution(input: RunScopeResolutionInput, provider: ScopeResolver): RunScopeResolutionStats;
 export {};

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

@@ -30,10 +30,11 @@ import { extractParsedFile } from '../../scope-extractor-bridge.js';
 import { finalizeScopeModel } from '../../finalize-orchestrator.js';
 import { resolveReferenceSites } from '../../resolve-references.js';
 import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
-import { emitFileCfgs, emitFileReachingDefs, isEmitSafeCfg, DEFAULT_MAX_CFG_EDGES_PER_FUNCTION, DEFAULT_PDG_MAX_REACHING_DEF_EDGES_PER_FUNCTION, REACHING_DEF_FACTS_PER_EDGE_CAP, } from '../../cfg/emit.js';
+import { emitFileCfgs, emitFileReachingDefs, isEmitSafeCfg, DEFAULT_MAX_CFG_EDGES_PER_FUNCTION, DEFAULT_PDG_MAX_REACHING_DEF_EDGES_PER_FUNCTION, DEFAULT_PDG_MAX_REACHING_DEF_FACTS_PER_FUNCTION, REACHING_DEF_FACTS_PER_EDGE_CAP, } from '../../cfg/emit.js';
 import { emitFileTaint, DEFAULT_PDG_MAX_TAINT_FINDINGS_PER_FUNCTION, DEFAULT_PDG_MAX_TAINT_HOPS, } from '../../taint/emit.js';
 import { registerBuiltinTaintModels } from '../../taint/typescript-model.js';
 import { getSourceSinkConfig } from '../../taint/source-sink-registry.js';
+import { buildFunctionNodeIndex, harvestFileSummaries, } from '../../taint/summary-harvest-driver.js';
 import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { buildPopulatedMethodDispatch } from '../graph-bridge/method-dispatch.js';
 import { propagateImportedReturnTypes } from '../passes/imported-return-types.js';
@@ -290,6 +291,7 @@ export function runScopeResolution(input, provider) {
             referenceEdgesEmitted: 0,
             referenceSkipped: 0,
             resolutionOutcomes,
+            functionSummaries: [],
         };
     }
     const tExtract = PROF ? process.hrtime.bigint() : 0n;
@@ -471,6 +473,11 @@ export function runScopeResolution(input, provider) {
     // pair can't bracket them; without this accumulator the M2 cost would
     // silently disappear into `emit=` and field regressions would be invisible.
     let pdgMs = 0;
+    // M4 (#2084 U1): per-function taint summaries harvested in the pdg window,
+    // returned on the stats for the cross-function fixpoint phase. Function-scoped
+    // so the return (below the pdg block) can read it; empty on non-pdg runs.
+    const harvestedSummaries = [];
+    let summaryUnresolved = 0;
     // M3 (#2083 U4): accumulated taint time (match + taint-side solve +
     // propagate + TAINTED/SANITIZES emit), a sibling of `pdgMs` for the same
     // reason — it interleaves per file inside `emit=`, so only an accumulator
@@ -523,6 +530,13 @@ export function runScopeResolution(input, provider) {
             gapExamples: [],
             dropExamples: [],
         };
+        // M4 (#2084 U1): per-function summary harvest. The functionish-node index
+        // is built ONCE (whole-graph scan) and reused across every file; summaries
+        // accumulate here and ride out on the stats for the cross-function fixpoint
+        // phase. Only built when the language has a registered taint model.
+        const fnNodeIndex = taintSpec !== undefined
+            ? (input.prebuiltFunctionNodeIndex ?? buildFunctionNodeIndex(graph))
+            : undefined;
         for (const pf of emitParsedFiles) {
             const cfgs = pf.cfgSideChannel;
             // Defensive: cfgSideChannel is opaque (`unknown`) and crosses the cache /
@@ -595,6 +609,19 @@ export function runScopeResolution(input, provider) {
                         if (taintTotals.dropExamples.length < 5)
                             taintTotals.dropExamples.push(ex);
                     }
+                    // M4 (#2084 U1): harvest per-function summaries over the SAME
+                    // emit-safe CFGs, inside the SAME per-file try. Pure aside from the
+                    // read-only node-index lookup; the cross-function fixpoint phase
+                    // consumes `harvestedSummaries` once the whole call graph is built.
+                    if (fnNodeIndex !== undefined) {
+                        const harvest = harvestFileSummaries(fnNodeIndex, wellFormed, pf.parsedImports, taintSpec, 
+                        // Same fact cap the taint-side RD solve uses (coverage parity).
+                        taintLimits.maxFacts && taintLimits.maxFacts > 0
+                            ? taintLimits.maxFacts
+                            : DEFAULT_PDG_MAX_REACHING_DEF_FACTS_PER_FUNCTION);
+                        harvestedSummaries.push(...harvest.summaries);
+                        summaryUnresolved += harvest.unresolved;
+                    }
                 }
             }
             catch (err) {
@@ -657,6 +684,14 @@ export function runScopeResolution(input, provider) {
                 logger.warn(`[taint] lang=${provider.language}: ${parts.join('; ')}`);
             }
         }
+        // M4 (#2084 U1): summary harvest volume + anchor-resolution diagnostics.
+        if (harvestedSummaries.length > 0 || summaryUnresolved > 0) {
+            logger.debug(`[taint-summary] lang=${provider.language}: ${harvestedSummaries.length} function ` +
+                `summary/summaries harvested` +
+                (summaryUnresolved > 0
+                    ? `, ${summaryUnresolved} CFG anchor(s) unresolved (same-line collision or missing node)`
+                    : ''));
+        }
     }
     if (PROF) {
         const tEnd = process.hrtime.bigint();
@@ -681,5 +716,6 @@ export function runScopeResolution(input, provider) {
         referenceEdgesEmitted: emitted + receiverExtras + unresolvedReceiverExtras + freeCallExtras,
         referenceSkipped: skipped,
         resolutionOutcomes,
+        functionSummaries: harvestedSummaries,
     };
 }

package/dist/core/ingestion/taint/interproc-emit.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Interprocedural taint emission (#2084 M4 U4) — materialise `TAINT_PATH`.
+ *
+ * Persists each cross-function {@link InterprocFinding} as ONE `TAINT_PATH`
+ * edge from the source function node to the sink function node, with the
+ * function-level hop chain + sink kind encoded in `reason` via the SHARED
+ * `path-codec` (the same versioned wire format M3's intra-procedural `TAINTED`
+ * edges use — never a second hand-rolled codec). The MCP `explain` tool decodes
+ * it for cross-function path rendering (U7).
+ *
+ * `TAINT_PATH` was reserved at M0 (the RelationshipType + the `CodeRelation`
+ * Function/Method node-pairs already exist), so materialisation needs zero
+ * schema work. Like `TAINTED`, it stays out of `VALID_RELATION_TYPES` and the
+ * web schema — `explain` is the discovery surface.
+ *
+ * Boundedness mirrors the M3 emit driver: dedup-before-cap (the solver already
+ * deduped by `(source, sink, kind)`), a per-run findings cap, and unconditional
+ * truncate-and-warn — never a silent drop.
+ */
+import type { KnowledgeGraph } from '../../graph/types.js';
+import type { InterprocFinding } from './interproc-solver.js';
+/** Confidence stamped on interprocedural `TAINT_PATH` edges. Lower than the
+ *  intra-procedural `TAINTED` 1.0 — context-insensitive composition is a
+ *  coarser signal (return/call-site merging). */
+export declare const INTERPROC_TAINT_CONFIDENCE = 0.6;
+/**
+ * Default per-run cap on emitted `TAINT_PATH` edges (#2084 review P1-3).
+ * Resolved into `RepoMeta.pdg` like the other pdg caps; `0` ⇒ unlimited.
+ */
+export declare const DEFAULT_PDG_MAX_INTERPROC_EDGES = 1000;
+export interface InterprocEmitLimits {
+    /** Max `TAINT_PATH` edges per run (post-dedup). `undefined`/0 ⇒ unlimited. */
+    readonly maxEdges?: number;
+}
+export interface InterprocEmitResult {
+    /** TAINT_PATH edges persisted. */
+    edgesEmitted: number;
+    /** Findings dropped by the per-run cap. */
+    edgesDropped: number;
+    /** Findings whose persisted hop path is a truncated prefix. */
+    hopsTruncated: number;
+    /** Findings skipped because an endpoint node was missing from the graph. */
+    skippedMissingEndpoint: number;
+}
+/**
+ * Persist cross-function findings as `TAINT_PATH` edges. `findings` is assumed
+ * deduped + deterministically ordered (the solver's contract). Never throws on
+ * valid input.
+ */
+export declare function emitInterprocTaint(graph: KnowledgeGraph, findings: readonly InterprocFinding[], limits?: InterprocEmitLimits, onWarn?: (message: string) => void): InterprocEmitResult;

package/dist/core/ingestion/taint/interproc-emit.js

@@ -0,0 +1,88 @@
+/**
+ * Interprocedural taint emission (#2084 M4 U4) — materialise `TAINT_PATH`.
+ *
+ * Persists each cross-function {@link InterprocFinding} as ONE `TAINT_PATH`
+ * edge from the source function node to the sink function node, with the
+ * function-level hop chain + sink kind encoded in `reason` via the SHARED
+ * `path-codec` (the same versioned wire format M3's intra-procedural `TAINTED`
+ * edges use — never a second hand-rolled codec). The MCP `explain` tool decodes
+ * it for cross-function path rendering (U7).
+ *
+ * `TAINT_PATH` was reserved at M0 (the RelationshipType + the `CodeRelation`
+ * Function/Method node-pairs already exist), so materialisation needs zero
+ * schema work. Like `TAINTED`, it stays out of `VALID_RELATION_TYPES` and the
+ * web schema — `explain` is the discovery surface.
+ *
+ * Boundedness mirrors the M3 emit driver: dedup-before-cap (the solver already
+ * deduped by `(source, sink, kind)`), a per-run findings cap, and unconditional
+ * truncate-and-warn — never a silent drop.
+ */
+import { encodeTaintPath } from './path-codec.js';
+/** Confidence stamped on interprocedural `TAINT_PATH` edges. Lower than the
+ *  intra-procedural `TAINTED` 1.0 — context-insensitive composition is a
+ *  coarser signal (return/call-site merging). */
+export const INTERPROC_TAINT_CONFIDENCE = 0.6;
+/**
+ * Default per-run cap on emitted `TAINT_PATH` edges (#2084 review P1-3).
+ * Resolved into `RepoMeta.pdg` like the other pdg caps; `0` ⇒ unlimited.
+ */
+export const DEFAULT_PDG_MAX_INTERPROC_EDGES = 1000;
+/**
+ * Persist cross-function findings as `TAINT_PATH` edges. `findings` is assumed
+ * deduped + deterministically ordered (the solver's contract). Never throws on
+ * valid input.
+ */
+export function emitInterprocTaint(graph, findings, limits, onWarn) {
+    const result = {
+        edgesEmitted: 0,
+        edgesDropped: 0,
+        hopsTruncated: 0,
+        skippedMissingEndpoint: 0,
+    };
+    const maxEdges = limits?.maxEdges && limits.maxEdges > 0 ? limits.maxEdges : Infinity;
+    const seen = new Set();
+    for (const finding of findings) {
+        if (result.edgesEmitted >= maxEdges) {
+            result.edgesDropped++;
+            continue;
+        }
+        const sourceNode = graph.getNode(finding.sourceFnId);
+        const sinkNode = graph.getNode(finding.sinkFnId);
+        if (!sourceNode || !sinkNode) {
+            result.skippedMissingEndpoint++;
+            continue;
+        }
+        // Map function hops → codec hops. The hop "name" is the function's display
+        // name (identifier charset — codec-safe); the line is its start line.
+        const hops = finding.hops.map((h) => {
+            const node = graph.getNode(h.fnId);
+            const name = typeof node?.properties.name === 'string' ? node.properties.name : 'fn';
+            const line = typeof node?.properties.startLine === 'number' ? node.properties.startLine : 0;
+            return { name, line };
+        });
+        const encoded = encodeTaintPath(hops, {
+            kind: finding.sinkKind,
+            truncated: finding.hopsTruncated,
+        });
+        if (encoded.truncated)
+            result.hopsTruncated++;
+        const id = `rel:TAINT_PATH:${finding.sinkKind}:${finding.sourceFnId}=>${finding.sinkFnId}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        graph.addRelationship({
+            id,
+            sourceId: finding.sourceFnId,
+            targetId: finding.sinkFnId,
+            type: 'TAINT_PATH',
+            confidence: INTERPROC_TAINT_CONFIDENCE,
+            reason: encoded.reason,
+        });
+        result.edgesEmitted++;
+    }
+    if (result.edgesDropped > 0) {
+        onWarn?.(`[taint-interproc] ${result.edgesDropped} cross-function finding(s) dropped by the ` +
+            `per-run TAINT_PATH cap (${maxEdges})`);
+    }
+    return result;
+}