gitnexus 1.6.8-rc.11 → 1.6.8-rc.13

package/dist/core/ingestion/languages/typescript.js

@@ -9,6 +9,7 @@ import { SupportedLanguages } from '../../../_shared/index.js';
 import { defineLanguage } from '../language-provider.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
 import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
+import { createTypeScriptCfgVisitor } from '../cfg/visitors/typescript.js';
 import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
 import { tsExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
@@ -293,6 +294,8 @@ export const typescriptProvider = defineLanguage({
     // canonical capture vocabulary in ./typescript/query.ts
     // (TYPESCRIPT_SCOPE_QUERY constant).
     emitScopeCaptures: emitTsScopeCaptures,
+    // CFG/PDG substrate (#2081 M1) — runs in the worker on a --pdg run.
+    cfgVisitor: createTypeScriptCfgVisitor(),
     interpretImport: interpretTsImport,
     interpretTypeBinding: interpretTsTypeBinding,
     bindingScopeFor: tsBindingScopeFor,
@@ -352,6 +355,8 @@ export const javascriptProvider = defineLanguage({
     // JSDoc type bindings) live in ./javascript/captures.ts.
     // See ./javascript/index.ts for the full per-module rationale.
     emitScopeCaptures: emitJsScopeCaptures,
+    // CFG/PDG substrate (#2081 M1) — TS and JS share the same grammar family.
+    cfgVisitor: createTypeScriptCfgVisitor(),
     interpretImport: interpretJsImport,
     interpretTypeBinding: interpretJsTypeBinding,
     bindingScopeFor: jsBindingScopeFor,

package/dist/core/ingestion/method-extractors/configs/c-cpp.js

@@ -33,18 +33,12 @@ function findFunctionDeclarator(node) {
     }
     return null;
 }
-/**
- * Detect `= delete` and `= default` special member function declarations.
- * These are not callable methods and should be suppressed from extraction.
- * tree-sitter-cpp ^0.23.4 emits `delete_method_clause` / `default_method_clause`
- * as named children of the function_definition node.
- */
-function isDeletedOrDefaulted(node) {
+/** Detect a C++ special member clause by its tree-sitter node type. */
+function hasSpecialMethodClause(node, clauseType) {
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
-        if (child?.type === 'delete_method_clause' || child?.type === 'default_method_clause') {
+        if (child?.type === clauseType)
             return true;
-        }
     }
     return false;
 }
@@ -57,10 +51,6 @@ function extractCppMethodName(node) {
     const funcDecl = findFunctionDeclarator(node);
     if (!funcDecl)
         return undefined;
-    // Suppress `= delete` and `= default` special members — these are not callable
-    // methods and should not appear in HAS_METHOD edges.
-    if (isDeletedOrDefaulted(node))
-        return undefined;
     const nameNode = funcDecl.childForFieldName('declarator');
     if (!nameNode)
         return undefined;
@@ -360,6 +350,9 @@ export const cppMethodConfig = {
         }
         return false;
     },
+    isDeleted(node) {
+        return hasSpecialMethodClause(node, 'delete_method_clause');
+    },
 };
 // ---------------------------------------------------------------------------
 // C config (minimal — C has no classes/methods, only struct function pointers)

package/dist/core/ingestion/method-extractors/generic.js

@@ -198,6 +198,7 @@ function buildMethod(node, ownerNode, context, config) {
         ...(config.isAsync?.(node) ? { isAsync: true } : {}),
         ...(config.isPartial?.(node) ? { isPartial: true } : {}),
         ...(config.isConst?.(node) ? { isConst: true } : {}),
+        ...(config.isDeleted?.(node) ? { isDeleted: true } : {}),
         annotations: config.extractAnnotations?.(node) ?? [],
         sourceFile: context.filePath,
         line: node.startPosition.row + 1,

package/dist/core/ingestion/method-types.d.ts

@@ -27,6 +27,7 @@ export interface MethodInfo {
     isAsync?: boolean;
     isPartial?: boolean;
     isConst?: boolean;
+    isDeleted?: boolean;
     annotations: string[];
     sourceFile: string;
     line: number;
@@ -74,6 +75,7 @@ export interface MethodExtractionConfig {
     isAsync?: (node: SyntaxNode) => boolean;
     isPartial?: (node: SyntaxNode) => boolean;
     isConst?: (node: SyntaxNode) => boolean;
+    isDeleted?: (node: SyntaxNode) => boolean;
     /** Owner node types where member functions are effectively static (e.g.
      *  Ruby singleton_class, Kotlin companion_object / object_declaration).
      *  When the ownerNode matches one of these types, isStatic is forced true. */

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -102,6 +102,7 @@ export interface AddMetadata {
     templateArguments?: string[];
     ownerId?: string;
     qualifiedName?: string;
+    isDeleted?: boolean;
 }
 /**
  * Pure read-only view over the file and callable indexes. Does NOT

package/dist/core/ingestion/model/symbol-table.js

@@ -136,6 +136,7 @@ export const createSymbolTable = () => {
                 ? { templateArguments: metadata.templateArguments }
                 : {}),
             ...(metadata?.ownerId !== undefined ? { ownerId: metadata.ownerId } : {}),
+            ...(metadata?.isDeleted === true ? { isDeleted: true } : {}),
         };
         // A. File Index — unconditional.
         if (!fileIndex.has(filePath)) {

package/dist/core/ingestion/parsing-processor.js

@@ -49,6 +49,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
                 templateArguments: sym.templateArguments,
                 ownerId: sym.ownerId,
                 qualifiedName: sym.qualifiedName,
+                isDeleted: sym.isDeleted,
             });
         }
         if (exportedTypeMap) {

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

@@ -18,6 +18,7 @@ import { BindingAccumulator, enrichExportedTypeMap, } from '../binding-accumulat
 import { mergeChunkResults, dispatchChunkParse } from '../parsing-processor.js';
 import { fileContentHash, computeChunkHash, loadParseCacheChunk, persistParseCacheChunk, PARSE_CACHE_VERSION, } from '../../../storage/parse-cache.js';
 import { clearParsedFileStore, persistParsedFileChunk, getDurableParsedFileDir, loadDurableParsedFileIndex, restoreDurableParsedFileShard, } from '../../../storage/parsedfile-store.js';
+import { DEFAULT_PDG_MAX_FUNCTION_LINES } from '../cfg/collect.js';
 import { processRoutesFromExtracted, buildExportedTypeMapFromGraph, } from '../call-processor.js';
 import { createSemanticModel } from '../model/index.js';
 import { getLanguageFromFilename, } from '../../../_shared/index.js';
@@ -319,6 +320,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 // Initialized below before the chunk loop (same deferred-init pattern
                 // as `parsedFileStorePath`); this closure only runs from the loop.
                 durableParsedFileStoragePath: durableParsedFileDir,
+                // CFG/PDG opt-in (#2081 M1) — baked into each worker's workerData so the
+                // worker builds + attaches cfgSideChannel. Off by default.
+                pdg: options?.pdg === true,
+                pdgMaxFunctionLines: options?.pdgMaxFunctionLines,
                 // Fan each chunk across the whole pool (#worker-idle): without this a
                 // chunk smaller than the 8 MB sub-batch cap became a single job on a
                 // single worker. Honors an explicit `subBatchMaxBytes` / env override.
@@ -566,7 +571,19 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     filePath: f.path,
                     contentHash: fileContentHash(f.content),
                 }));
-                chunkHash = computeChunkHash(entries);
+                chunkHash = computeChunkHash(entries, 
+                // Only worker-visible pdg config participates in the key —
+                // pdgMaxEdgesPerFunction is emit-time-only and deliberately
+                // excluded (see PdgCacheKey in parse-cache.ts; #2099 F3). The line
+                // cap is RESOLVED to the worker's default before folding so an
+                // explicit-default run shares the default run's keys (the worker
+                // output is byte-identical either way).
+                options?.pdg === true
+                    ? {
+                        pdg: true,
+                        maxFunctionLines: options?.pdgMaxFunctionLines ?? DEFAULT_PDG_MAX_FUNCTION_LINES,
+                    }
+                    : false);
             }
             const cachedRaw = chunkHash && parseCache ? await loadParseCacheChunk(parseCache, chunkHash) : undefined;
             // Track every chunk hash we touched so the orchestrator can

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

@@ -25,6 +25,29 @@ export interface PipelineOptions {
      * to retain those nodes under `skipGraphPhases`.
      */
     skipGraphPhases?: boolean;
+    /**
+     * Build the control-flow-graph / PDG substrate (#2081 M1, opt-in via `--pdg`).
+     * Off by default: workers skip all CFG work and emit no `cfgSideChannel`, and
+     * scope-resolution emits no BasicBlock nodes or CFG edges — so the default
+     * graph is byte-identical to a pre-#2081 run. Folded into the parse-cache key
+     * so a pdg-off warm cache is not reused on a `--pdg` run.
+     */
+    pdg?: boolean;
+    /**
+     * Per-function source-line cap for worker-side CFG construction.
+     * `undefined` ⇒ the worker applies `DEFAULT_PDG_MAX_FUNCTION_LINES`; `0` ⇒ no
+     * cap (unlimited). Bounds the cost of a pathological mega-function; over-cap
+     * functions are skipped (no CFG emitted for them). No CLI flag in M1 —
+     * programmatic / server analyze-worker path only.
+     */
+    pdgMaxFunctionLines?: number;
+    /**
+     * Per-function CFG edge cap for the scope-resolution emit step.
+     * `undefined` ⇒ `DEFAULT_MAX_CFG_EDGES_PER_FUNCTION`; `0` ⇒ no cap (unlimited).
+     * Over-cap functions stop at the cap and log a structured drop warning (no
+     * silent truncation). No CLI flag in M1 — programmatic / server path only.
+     */
+    pdgMaxEdgesPerFunction?: 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/scope-extractor.js

@@ -399,6 +399,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
     const returnType = match['@declaration.return-type']?.text;
     const templateConstraints = parseJsonCapture(match['@declaration.template-constraints']);
     const isExplicit = parseBooleanCapture(match['@declaration.is-explicit']);
+    const isDeleted = parseBooleanCapture(match['@declaration.is-deleted']);
     return {
         nodeId: makeDefId(filePath, anchor.range, type, nameCap.text),
         filePath,
@@ -413,6 +414,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
         ...(templateArguments !== undefined ? { templateArguments } : {}),
         ...(templateConstraints !== undefined ? { templateConstraints } : {}),
         ...(isExplicit === true ? { isExplicit: true } : {}),
+        ...(isDeleted === true ? { isDeleted: true } : {}),
     };
 }
 /** Parse an opaque JSON payload synthesized by per-language captures
@@ -922,6 +924,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@declaration.return-type',
     '@declaration.template-constraints',
     '@declaration.is-explicit',
+    '@declaration.is-deleted',
 ]);
 /**
  * Return the anchor capture for a match — the one whose name begins with

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -289,6 +289,18 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             }
             if (fnDef === undefined)
                 continue;
+            if (fnDef.isDeleted === true) {
+                recordSuppressedOutcome(options.recordResolutionOutcome, {
+                    phase: 'free-call-fallback',
+                    filePath: parsed.filePath,
+                    name: site.name,
+                    range: site.atRange,
+                    reason: 'selected-callable-deleted',
+                    candidates: [fnDef],
+                });
+                handledSites.add(siteKey(parsed.filePath, site));
+                continue;
+            }
             if ((fnDefFromImplicitThis || fnDef.type === 'Method' || fnDef.type === 'Constructor') &&
                 options.isCallableVisibleFromCaller !== undefined &&
                 !options.isCallableVisibleFromCaller({

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -138,9 +138,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             return 0;
         let n = 0;
         for (const implDef of impls) {
-            const implMember = findOwnedMember(implDef.nodeId, memberName, model);
-            if (implMember === undefined)
+            const implMember = pickOverload(implDef.nodeId, memberName, site, model, provider);
+            if (implMember === undefined ||
+                implMember === OVERLOAD_AMBIGUOUS ||
+                implMember.isDeleted === true) {
                 continue;
+            }
             if (implMember.nodeId === primaryMemberDef.nodeId)
                 continue;
             const ok = tryEmitEdge(graph, scopes, nodeLookup, site, implMember, 'interface-dispatch', seen, confidence, collapse);
@@ -179,12 +182,30 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         ? extendsOnly(enclosingClass.nodeId)
                         : scopes.methodDispatch.mroFor(enclosingClass.nodeId);
                     let memberDef;
+                    let ambiguousOwnerId;
                     for (const ownerId of ancestors) {
-                        memberDef = findOwnedMember(ownerId, memberName, model);
-                        if (memberDef !== undefined)
+                        const picked = site.kind === 'call'
+                            ? pickOverload(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked !== undefined) {
+                            memberDef = picked;
                             break;
+                        }
+                    }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // Super/base calls resolve through the MRO chain, not
                         // through imports — the ancestor method is found by
                         // walking `methodDispatch.mroFor(enclosingClass)`, which
@@ -219,9 +240,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (currentClass !== undefined) {
                     const chain = [currentClass.nodeId, ...scopes.methodDispatch.mroFor(currentClass.nodeId)];
                     let memberDef;
+                    let ambiguousOwnerId;
                     // Static-only filter (#1756 / U3): same shape as Case 4's
-                    // chain walk (skip-and-walk-on) but without overload
-                    // narrowing — Case 0 uses `findOwnedMember` directly. When
+                    // overload-aware chain walk (skip-and-walk-on). When
                     // an owner's resolved candidate is static-only (Kotlin
                     // companion-promoted), continue to the next ancestor in
                     // the MRO chain so a legitimate instance member can bind.
@@ -233,17 +254,29 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // shapes like `Logger.create("a")`), so there's no wrong
                     // target to suppress.
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
-                            // Skip static-only candidate; walk to next ancestor.
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -290,6 +323,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -357,6 +394,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -373,11 +414,16 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             }
             // ── Case 1: namespace receiver ───────────────────────────────
             const targetFiles = namespaceTargets.get(receiverName);
-            if (targetFiles !== undefined) {
+            if (targetFiles !== undefined && provider.resolveQualifiedReceiverMember === undefined) {
                 let found = false;
                 for (const targetFile of targetFiles) {
                     const memberDef = findExportedDef(targetFile, memberName, index);
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            found = true;
+                            break;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -413,6 +459,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (memberDef !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                     if (ok)
                         emitted++;
@@ -425,9 +475,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             if (classDef !== undefined) {
                 const chain = [classDef.nodeId, ...scopes.methodDispatch.mroFor(classDef.nodeId)];
                 let memberDef;
+                let ambiguousOwnerId;
                 for (const ownerId of chain) {
-                    memberDef = findOwnedMember(ownerId, memberName, model);
-                    if (memberDef !== undefined) {
+                    const picked = site.kind === 'call'
+                        ? pickOverload(ownerId, memberName, site, model, provider)
+                        : findOwnedMember(ownerId, memberName, model);
+                    if (picked === OVERLOAD_AMBIGUOUS) {
+                        ambiguousOwnerId = ownerId;
+                        break;
+                    }
+                    if (picked !== undefined) {
+                        memberDef = picked;
                         // The MRO chain is most-derived-first ([classDef, ...ancestors]).
                         // If the most-derived definition is arity-incompatible with the
                         // call site, PHP throws ArgumentCountError at runtime — it does
@@ -441,7 +499,16 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         break;
                     }
                 }
+                if (ambiguousOwnerId !== undefined) {
+                    recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                    handledSites.add(siteKey);
+                    continue;
+                }
                 if (memberDef !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const reason = site.kind === 'write' || site.kind === 'read'
                         ? site.kind
                         : memberDef.filePath !== parsed.filePath
@@ -466,8 +533,22 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     for (const targetFile3 of targetFiles3) {
                         const classDef3 = findExportedDef(targetFile3, className, index);
                         if (classDef3 !== undefined) {
-                            const memberDef = findOwnedMember(classDef3.nodeId, memberName, model);
-                            if (memberDef !== undefined) {
+                            const picked = site.kind === 'call'
+                                ? pickOverload(classDef3.nodeId, memberName, site, model, provider)
+                                : findOwnedMember(classDef3.nodeId, memberName, model);
+                            if (picked === OVERLOAD_AMBIGUOUS) {
+                                recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, classDef3.nodeId, memberName, model, provider);
+                                handledSites.add(siteKey);
+                                found3 = true;
+                                break;
+                            }
+                            if (picked !== undefined) {
+                                const memberDef = picked;
+                                if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                                    handledSites.add(siteKey);
+                                    found3 = true;
+                                    break;
+                                }
                                 const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen);
                                 if (ok) {
                                     emitted++;
@@ -504,8 +585,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (ownerDef !== undefined) {
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
-                    // Static-only filter (#1756 / U3): mirrors Case 0's chain
-                    // walk — `findOwnedMember` without overload narrowing. When
+                    let ambiguousOwnerId;
+                    // Static-only filter (#1756 / U3): mirrors Case 0's
+                    // overload-aware chain walk. When
                     // a static-only candidate is found at an ancestor, walk on
                     // so a legitimate instance member can bind. If the entire
                     // chain is static-only, no edge is emitted (Case 3b is fed
@@ -513,16 +595,29 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // `emitReferencesViaLookup` for compound shapes, so no
                     // handled-site marker is needed for chain-only-static).
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -574,6 +669,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -657,6 +756,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // For read/write ACCESSES, mirror the legacy DAG's reason
                         // convention so consumers asserting `reason === 'write'`
                         // keep working.
@@ -713,6 +816,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (picked !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, picked)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     // Static-only filter (#1756 / U3): unlike Case 4 there's no
                     // MRO chain to walk here — Case 5 dispatches on a single
                     // owner via `pickOverload`. When the picked candidate is
@@ -873,6 +980,20 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
         return OVERLOAD_AMBIGUOUS;
     return candidates[0] ?? overloads[0];
 }
+function suppressDeletedCallTarget(record, filePath, site, target) {
+    if (site.kind !== 'call' || target.isDeleted !== true)
+        return false;
+    record?.({
+        kind: 'suppressed',
+        phase: 'receiver-bound-calls',
+        filePath,
+        name: site.name,
+        range: site.atRange,
+        reason: 'selected-callable-deleted',
+        candidateIds: [target.nodeId],
+    });
+    return true;
+}
 function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memberName, model, provider) {
     if (record === undefined)
         return;

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

@@ -285,6 +285,9 @@ export const scopeResolutionPhase = {
                 prebuiltNodeLookup: sharedNodeLookup,
                 preExtractedParsedFiles: preExtractedByPath,
                 scopeIndexStorePath: parsedFileStorePath,
+                // CFG/PDG emission (#2081 M1) — opt-in; off ⇒ byte-identical graph.
+                pdg: ctx.options?.pdg === true,
+                pdgMaxEdgesPerFunction: ctx.options?.pdgMaxEdgesPerFunction,
                 recordResolutionOutcome: (outcome) => {
                     resolutionOutcomes.push(outcome);
                 },

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'`.

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

@@ -58,6 +58,16 @@ interface RunScopeResolutionInput {
     readonly treeCache?: {
         get(filePath: string): unknown;
     };
+    /**
+     * CFG/PDG opt-in (#2081 M1). When true, emit BasicBlock nodes + CFG edges
+     * from each ParsedFile's worker-built `cfgSideChannel` during Phase-4 graph
+     * emission (while the disk store is still live). Default/false ⇒ no CFG
+     * nodes or edges and a byte-identical graph.
+     */
+    readonly pdg?: boolean;
+    /** Per-function CFG edge cap. `undefined` ⇒ {@link DEFAULT_MAX_CFG_EDGES_PER_FUNCTION};
+     *  `0` ⇒ no cap (unlimited). */
+    readonly pdgMaxEdgesPerFunction?: number;
     /**
      * Optional graph-node lookup built ONCE by the caller and shared across
      * every language pass. `buildGraphNodeLookup` scans the whole graph and is