gitnexus 1.6.9 → 1.6.10-aptos.1

package/dist/core/ingestion/frameworks/spring/bean-candidates.js

@@ -0,0 +1,182 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+import { SPRING_BEAN_STEREOTYPES } from './bean-catalog.js';
+/** Per-language store for capture facts that cross the worker boundary. */
+export function createClassAnnotationFactStore() {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        set: (filePath, facts) => {
+            if (facts.length === 0)
+                factsByFile.delete(filePath);
+            else
+                factsByFile.set(filePath, facts);
+        },
+        get: (filePath) => factsByFile.get(filePath) ?? [],
+    };
+}
+/** Record one annotation from the language's existing scope-query traversal. */
+export function recordClassAnnotationCapture(facts, filePath, classCapture, annotationName) {
+    const classScopeId = makeScopeId({ filePath, range: classCapture.range, kind: 'Class' });
+    const names = facts.get(classScopeId) ?? new Set();
+    names.add(annotationName.trim());
+    facts.set(classScopeId, names);
+}
+export function materializeClassAnnotationFacts(facts) {
+    return [...facts].map(([classScopeId, annotationNames]) => ({
+        classScopeId,
+        annotationNames: [...annotationNames],
+    }));
+}
+function simpleNameOf(def) {
+    const qualifiedName = def.qualifiedName;
+    if (qualifiedName === undefined)
+        return undefined;
+    const separator = qualifiedName.lastIndexOf('.');
+    return separator === -1 ? qualifiedName : qualifiedName.slice(separator + 1);
+}
+function buildOwnedTypeNamesByOwner(indexes) {
+    const namesByOwner = new Map();
+    for (const def of indexes.defs.byId.values()) {
+        if (def.ownerId === undefined)
+            continue;
+        if (!isClassLike(def.type) && def.type !== 'Annotation')
+            continue;
+        const simpleName = simpleNameOf(def);
+        if (simpleName === undefined)
+            continue;
+        const names = namesByOwner.get(def.ownerId) ?? new Set();
+        names.add(simpleName);
+        namesByOwner.set(def.ownerId, names);
+    }
+    return namesByOwner;
+}
+function hasLexicalTypeDeclaration(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const locals = scope.bindings.get(simpleName);
+        if (locals?.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function explicitImportTargets(parsed, simpleName) {
+    const targets = new Set();
+    for (const entry of parsed.parsedImports) {
+        if (entry.kind !== 'named' && entry.kind !== 'alias')
+            continue;
+        if (entry.localName !== simpleName)
+            continue;
+        targets.add(entry.targetRaw);
+    }
+    return targets;
+}
+function hasInheritedTypeDeclaration(startScope, simpleName, indexes, ownedTypeNamesByOwner) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => isClassLike(def.type));
+            if (classDef !== undefined) {
+                for (const ancestorId of indexes.methodDispatch.mroFor(classDef.nodeId)) {
+                    if (ownedTypeNamesByOwner.get(ancestorId)?.has(simpleName) === true)
+                        return true;
+                }
+            }
+        }
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function hasVisibleTypeBinding(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes);
+        if (visible.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function wildcardImportTarget(parsed, simpleName, recognizedAnnotations) {
+    const wildcardPackages = new Set(parsed.parsedImports
+        .filter((entry) => entry.kind === 'wildcard')
+        .map((entry) => entry.targetRaw.replace(/\.\*$/, '')));
+    if (wildcardPackages.size !== 1)
+        return undefined;
+    const [packageName] = wildcardPackages;
+    const target = `${packageName}.${simpleName}`;
+    return recognizedAnnotations.has(target) ? target : undefined;
+}
+/** Build a scope-aware Spring annotation resolver shared by framework hooks. */
+export function createSpringAnnotationNameResolver(indexes) {
+    const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+    return (rawName, parsed, enclosingScope, recognizedAnnotations, isPackageVisibilityIncomplete) => {
+        if (rawName.includes('.')) {
+            return recognizedAnnotations.has(rawName) ? rawName : undefined;
+        }
+        if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
+            return undefined;
+        if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
+            return undefined;
+        }
+        const explicitImports = explicitImportTargets(parsed, rawName);
+        if (explicitImports.size > 0) {
+            if (explicitImports.size !== 1)
+                return undefined;
+            const [imported] = explicitImports;
+            return recognizedAnnotations.has(imported) ? imported : undefined;
+        }
+        const wildcardTarget = wildcardImportTarget(parsed, rawName, recognizedAnnotations);
+        if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
+            return undefined;
+        return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+    };
+}
+/** Build a language hook that enriches Class nodes after scope resolution. */
+export function createSpringBeanCandidateAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveSpringAnnotation = createSpringAnnotationNameResolver(indexes);
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getClassAnnotationFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((def) => def.type === 'Class');
+                if (classDef === undefined)
+                    continue;
+                const graphId = resolveDefGraphId(parsed.filePath, classDef, nodeLookup);
+                if (graphId === undefined)
+                    continue;
+                const classNode = graph.getNode(graphId);
+                if (classNode === undefined || classNode.label !== 'Class')
+                    continue;
+                const recognized = new Set();
+                for (const rawName of fact.annotationNames) {
+                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, SPRING_BEAN_STEREOTYPES, adapter.isPackageVisibilityIncomplete(parsed.filePath));
+                    if (annotation !== undefined)
+                        recognized.add(annotation);
+                }
+                if (recognized.size === 1) {
+                    classNode.properties.frameworkAnnotations = [...recognized];
+                }
+            }
+        }
+    };
+}

package/dist/core/ingestion/frameworks/spring/bean-catalog.d.ts

@@ -0,0 +1,12 @@
+export interface SpringBeanMetadata {
+    framework: 'spring';
+    role: string;
+    annotation: string;
+}
+export interface SpringBeanStereotype {
+    role: string;
+}
+export declare const SPRING_BEAN_STEREOTYPES: Map<string, SpringBeanStereotype>;
+export declare function deriveSpringBeanMetadata(frameworkAnnotations: readonly string[]): SpringBeanMetadata | undefined;
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export declare function isSpringBeanCandidateSourceFile(filePath: string): boolean;

package/dist/core/ingestion/frameworks/spring/bean-catalog.js

@@ -0,0 +1,26 @@
+export const SPRING_BEAN_STEREOTYPES = new Map([
+    ['org.springframework.stereotype.Component', { role: 'component' }],
+    ['org.springframework.stereotype.Service', { role: 'service' }],
+    ['org.springframework.stereotype.Repository', { role: 'repository' }],
+    ['org.springframework.stereotype.Controller', { role: 'controller' }],
+    ['org.springframework.web.bind.annotation.RestController', { role: 'rest-controller' }],
+    ['org.springframework.context.annotation.Configuration', { role: 'configuration' }],
+]);
+export function deriveSpringBeanMetadata(frameworkAnnotations) {
+    const recognized = [
+        ...new Set(frameworkAnnotations.filter((annotation) => SPRING_BEAN_STEREOTYPES.has(annotation))),
+    ];
+    if (recognized.length !== 1)
+        return undefined;
+    const annotation = recognized[0];
+    const stereotype = SPRING_BEAN_STEREOTYPES.get(annotation);
+    if (!stereotype)
+        return undefined;
+    return { framework: 'spring', role: stereotype.role, annotation };
+}
+const SPRING_BEAN_SOURCE_EXTENSIONS = ['.java', '.kt', '.kts'];
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export function isSpringBeanCandidateSourceFile(filePath) {
+    const normalized = filePath.toLowerCase();
+    return SPRING_BEAN_SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+}

package/dist/core/ingestion/frameworks/spring/config-bindings.d.ts

@@ -0,0 +1,24 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+export declare const SPRING_CONFIG_DESCRIPTION = "Spring configuration property";
+export interface SpringValueConsumer {
+    readonly kind: 'value';
+    readonly fieldName: string;
+    readonly line: number;
+    readonly keys: readonly string[];
+}
+export interface SpringConfigurationPropertiesConsumer {
+    readonly kind: 'configuration-properties';
+    readonly className: string;
+    readonly line: number;
+    readonly prefix: string;
+}
+export type SpringConfigConsumer = SpringValueConsumer | SpringConfigurationPropertiesConsumer;
+export interface SpringConfigConsumerBatch {
+    readonly filePath: string;
+    readonly consumers: readonly SpringConfigConsumer[];
+}
+/**
+ * Attach normalized, language-provider-produced Spring consumers to config
+ * keys already present in the shared graph.
+ */
+export declare function bindSpringConfigConsumers(graph: KnowledgeGraph, batches: readonly SpringConfigConsumerBatch[]): void;

package/dist/core/ingestion/frameworks/spring/config-bindings.js

@@ -0,0 +1,115 @@
+import { generateId } from '../../../../lib/utils.js';
+export const SPRING_CONFIG_DESCRIPTION = 'Spring configuration property';
+function closestNode(candidates, filePath, name, line) {
+    return candidates
+        .filter((node) => node.properties.filePath === filePath && node.properties.name === name)
+        .sort((left, right) => Math.abs(Number(left.properties.startLine ?? 0) - line) -
+        Math.abs(Number(right.properties.startLine ?? 0) - line))[0];
+}
+function markUnresolved(node, key) {
+    const marker = `Spring config unresolved: ${key}`;
+    const existing = typeof node.properties.description === 'string' ? node.properties.description : '';
+    if (existing.includes(marker))
+        return;
+    node.properties.description = existing.length > 0 ? `${existing}; ${marker}` : marker;
+}
+function relaxedName(value) {
+    return value.toLowerCase().replace(/[-_.]/g, '');
+}
+function isSpringConfigNode(node) {
+    return (node.label === 'Property' &&
+        typeof node.properties.description === 'string' &&
+        node.properties.description.startsWith(SPRING_CONFIG_DESCRIPTION));
+}
+/**
+ * Attach normalized, language-provider-produced Spring consumers to config
+ * keys already present in the shared graph.
+ */
+export function bindSpringConfigConsumers(graph, batches) {
+    if (batches.length === 0)
+        return;
+    const configNodes = [];
+    const propertyNodes = [];
+    const classNodes = [];
+    for (const node of graph.iterNodes()) {
+        if (isSpringConfigNode(node))
+            configNodes.push(node);
+        else if (node.label === 'Property')
+            propertyNodes.push(node);
+        else if (node.label === 'Class' || node.label === 'Record')
+            classNodes.push(node);
+    }
+    const keyNodes = new Map();
+    for (const node of configNodes) {
+        const key = String(node.properties.name);
+        const bucket = keyNodes.get(key) ?? [];
+        bucket.push(node);
+        keyNodes.set(key, bucket);
+    }
+    const propertiesByOwner = new Map();
+    for (const rel of graph.iterRelationshipsByType('HAS_PROPERTY')) {
+        const property = graph.getNode(rel.targetId);
+        if (property?.label !== 'Property' || isSpringConfigNode(property))
+            continue;
+        const members = propertiesByOwner.get(rel.sourceId) ?? [];
+        members.push(property);
+        propertiesByOwner.set(rel.sourceId, members);
+    }
+    const addBinding = (source, target, reason, confidence) => {
+        const edgeId = generateId('USES', `${source.id}->${target.id}:${reason}`);
+        graph.addRelationship({
+            id: edgeId,
+            sourceId: source.id,
+            targetId: target.id,
+            type: 'USES',
+            confidence,
+            reason,
+        });
+    };
+    for (const { filePath, consumers } of batches) {
+        for (const consumer of consumers) {
+            if (consumer.kind === 'value') {
+                const field = closestNode(propertyNodes, filePath, consumer.fieldName, consumer.line);
+                if (field === undefined)
+                    continue;
+                for (const key of consumer.keys) {
+                    const matches = keyNodes.get(key) ?? [];
+                    if (matches.length === 0) {
+                        markUnresolved(field, key);
+                        continue;
+                    }
+                    for (const match of matches) {
+                        addBinding(field, match, `spring-config:@Value ${key}`, 1);
+                    }
+                }
+                continue;
+            }
+            const owner = closestNode(classNodes, filePath, consumer.className, consumer.line);
+            if (owner === undefined)
+                continue;
+            const prefix = `${consumer.prefix}.`;
+            const matches = configNodes.filter((node) => {
+                const key = String(node.properties.name);
+                return key === consumer.prefix || key.startsWith(prefix);
+            });
+            if (matches.length === 0) {
+                markUnresolved(owner, consumer.prefix);
+                continue;
+            }
+            for (const match of matches) {
+                addBinding(owner, match, `spring-config:@ConfigurationProperties ${consumer.prefix}`, 0.95);
+            }
+            for (const field of propertiesByOwner.get(owner.id) ?? []) {
+                const fieldName = relaxedName(String(field.properties.name));
+                for (const match of matches) {
+                    const key = String(match.properties.name);
+                    const suffix = key === consumer.prefix ? '' : key.slice(prefix.length);
+                    const firstSegment = suffix.split(/[.\[]/, 1)[0];
+                    if (firstSegment.length === 0 || relaxedName(firstSegment) !== fieldName)
+                        continue;
+                    addBinding(field, match, `spring-config:@ConfigurationProperties field ${consumer.prefix}`, 0.95);
+                }
+            }
+        }
+    }
+}

package/dist/core/ingestion/languages/c/captures.js

@@ -5,6 +5,20 @@ import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitCInclude } from './import-decomposer.js';
 import { computeCDeclarationArity, computeCCallArity } from './arity-metadata.js';
 import { markStaticName } from './static-linkage.js';
+import { synthesizeCallableFlowCaptures, } from '../../utils/callable-flow-captures.js';
+const C_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_definition']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration']),
+    bindingNodeTypes: new Set(['init_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'field_identifier', 'type_identifier']),
+    callableSignatureDeclarationNodeTypes: new Set(['declaration', 'parameter_declaration']),
+    emitCanonicalInvokeReference: true,
+    parameterPassingMode: (parameter) => containsNodeType(parameter, 'pointer_declarator') ? 'pointer' : 'value',
+    expectedSignature: (container, destination) => functionDeclaratorSignature(destination) ?? functionDeclaratorSignature(container),
+};
 export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -106,8 +120,50 @@ export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, C_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function functionDeclaratorSignature(node) {
+    const declarator = findDescendantOfType(node, 'function_declarator');
+    const parameters = declarator?.childForFieldName('parameters');
+    if (parameters === null || parameters === undefined)
+        return undefined;
+    const parameterNodes = parameters.namedChildren.filter((child) => child !== null && child.type === 'parameter_declaration');
+    // tree-sitter-c materializes `...` as a NAMED `variadic_parameter` node —
+    // the anonymous-token checks never matched, so variadic signatures were
+    // emitted with a wrong fixed arity (#2522 review). Keep the token checks
+    // for grammar variants that expose `...` as an anonymous literal.
+    const hasEllipsis = parameters.children.some((child) => child.type === 'variadic_parameter' ||
+        child.type === '...' ||
+        (!child.isNamed && child.text === '...'));
+    const isVoidOnly = parameterNodes.length === 1 &&
+        parameterNodes[0].namedChildCount === 1 &&
+        parameterNodes[0].firstNamedChild?.text === 'void';
+    if (isVoidOnly)
+        return { parameterCount: 0, parameterTypes: [] };
+    const parameterTypes = parameterNodes.map((parameter) => parameter.childForFieldName('type')?.text ?? 'unknown');
+    if (hasEllipsis)
+        parameterTypes.push('...');
+    return {
+        ...(hasEllipsis ? {} : { parameterCount: parameterNodes.length }),
+        parameterTypes,
+    };
+}
+function containsNodeType(root, type) {
+    return findDescendantOfType(root, type) !== null;
+}
+function findDescendantOfType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === type)
+            return node;
+        for (const child of node.namedChildren)
+            if (child !== null)
+                stack.push(child);
+    }
+    return null;
+}
 /**
  * Check if a C function_definition or declaration has `static` storage class.
  * Walks direct children for a `storage_class_specifier` node with text `static`.

package/dist/core/ingestion/languages/c/query.js

@@ -117,6 +117,23 @@ const C_SCOPE_QUERY = `
   declarator: (pointer_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; Declarations — function-pointer variables (\`void (*fp)(int);\`), with and
+;; without initializer. Without these the file-scope pointer has no scope-tree
+;; binding, so callable-flow cells written in one function and read in another
+;; canonicalize to different keys and never join (#2522 review, H1).
+(declaration
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (pointer_declarator
+        declarator: (identifier) @declaration.name)))) @declaration.variable
+
+(declaration
+  declarator: (init_declarator
+    declarator: (function_declarator
+      declarator: (parenthesized_declarator
+        (pointer_declarator
+          declarator: (identifier) @declaration.name))))) @declaration.variable
+
 ;; Declarations — macro definitions
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

package/dist/core/ingestion/languages/c/scope-resolver.js

@@ -100,4 +100,10 @@ export const cScopeResolver = {
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         return isStaticName(def.filePath, simple);
     },
+    // Precise linkage-only variant used to associate a visible prototype with
+    // its implementation during callable-value actual-to-formal propagation.
+    hasFileLocalCallableLinkage: (def) => {
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return isStaticName(def.filePath, simple);
+    },
 };

package/dist/core/ingestion/languages/cobol/captures.js

@@ -44,6 +44,20 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
     // Run the regex tagger on the preprocessed source
     const extracted = extractCobolSymbolsWithRegex(cleaned, _filePath);
     const out = [];
+    const procedurePointers = new Set(extracted.dataItems
+        .filter((item) => /(?:PROCEDURE|FUNCTION)-POINTER/.test(item.usage?.toUpperCase() ?? ''))
+        .map((item) => item.name.toUpperCase()));
+    // Fallback for declarations the clause parser missed. Scan CLEANED lines —
+    // on raw fixed-format sources the sequence number (cols 1-6) satisfied
+    // `\d+` and the LEVEL NUMBER got captured as the name, so the set never
+    // contained the real pointer name and the whole feature no-op'd (#2522
+    // review, H3). COBOL data names must contain a letter, so `[A-Z]` first
+    // rejects level numbers.
+    for (const line of cleaned.split(/\r?\n/)) {
+        const declaration = line.match(/^\s*\d{1,2}\s+([A-Z][A-Z0-9-]*).*\b(?:PROCEDURE|FUNCTION)-POINTER\b/i);
+        if (declaration !== null)
+            procedurePointers.add(declaration[1].toUpperCase());
+    }
     // ── 1. PROGRAM-ID → @scope.module ───────────────────────────────────
     // The primary program name (first PROGRAM-ID encountered)
     if (extracted.programName) {
@@ -208,6 +222,85 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
         if (m !== null)
             out.push(m);
     }
+    // ── 9. Procedure-pointer value flow ────────────────────────────────
+    // ISO COBOL exposes callable values through USAGE PROCEDURE-POINTER,
+    // SET ... TO ENTRY, and dynamic CALL data-items. The regex provider emits
+    // the same normalized facts as AST-backed providers so shared ingestion
+    // remains language-agnostic.
+    for (const program of extracted.programs) {
+        for (let index = 0; index < (program.procedureUsing?.length ?? 0); index++) {
+            const parameter = program.procedureUsing[index];
+            const ownerRange = rangeOf(program.startLine, 0, program.endLine, 0);
+            out.push({
+                '@callable-flow.formal': capture('@callable-flow.formal', ownerRange, program.name),
+                '@callable-flow.owner': capture('@callable-flow.owner', ownerRange, program.name),
+                '@callable-flow.binding': capture('@callable-flow.binding', rangeOf(program.startLine, 0, program.startLine, parameter.length), parameter),
+                '@callable-flow.parameter-index': capture('@callable-flow.parameter-index', ownerRange, String(index)),
+                '@callable-flow.passing-mode': capture('@callable-flow.passing-mode', ownerRange, 'reference'),
+            });
+        }
+    }
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        // Comment lines must not seed flows — a commented-out SET produced a
+        // live seed and a false CALLS edge from dead code (#2522 review, M1).
+        // Fixed format marks comments with '*'/'/' in indicator column 7; free
+        // format uses '*>' (also valid inline, so strip the tail).
+        if (line[6] === '*' || line[6] === '/')
+            continue;
+        const code = line.split('*>')[0];
+        const lineNumber = index + 1;
+        const lineRange = rangeOf(lineNumber, 0, lineNumber, endColFrom(line));
+        const entry = code.match(/\bSET\s+([A-Z0-9][A-Z0-9-]*)\s+TO\s+ENTRY\s+(?:"([^"]+)"|'([^']+)')/i);
+        if (entry !== null) {
+            const destination = entry[1];
+            const target = entry[2] ?? entry[3];
+            if (procedurePointers.has(destination.toUpperCase())) {
+                out.push({
+                    '@callable-flow.seed': capture('@callable-flow.seed', lineRange, line),
+                    '@callable-flow.destination': capture('@callable-flow.destination', lineRange, destination),
+                    '@callable-flow.target': capture('@callable-flow.target', lineRange, target),
+                    '@callable-flow.target-name': capture('@callable-flow.target-name', lineRange, target),
+                });
+            }
+            continue;
+        }
+        const copy = code.match(/\bSET\s+([A-Z0-9][A-Z0-9-]*)\s+TO\s+([A-Z0-9][A-Z0-9-]*)\b/i);
+        if (copy !== null &&
+            procedurePointers.has(copy[1].toUpperCase()) &&
+            procedurePointers.has(copy[2].toUpperCase())) {
+            out.push({
+                '@callable-flow.copy': capture('@callable-flow.copy', lineRange, line),
+                '@callable-flow.destination': capture('@callable-flow.destination', lineRange, copy[1]),
+                '@callable-flow.source': capture('@callable-flow.source', lineRange, copy[2]),
+            });
+        }
+    }
+    for (const call of extracted.calls) {
+        const line = lines[call.line - 1] ?? '';
+        const lineRange = rangeOf(call.line, 0, call.line, endColFrom(line));
+        for (let index = 0; index < (call.parameters?.length ?? 0); index++) {
+            const parameter = call.parameters[index];
+            out.push({
+                '@callable-flow.argument': capture('@callable-flow.argument', lineRange, line),
+                '@callable-flow.source': capture('@callable-flow.source', lineRange, parameter),
+                '@callable-flow.parameter-index': capture('@callable-flow.parameter-index', lineRange, String(index)),
+                ...(!call.isQuoted && procedurePointers.has(call.target.toUpperCase())
+                    ? {}
+                    : {
+                        '@callable-flow.direct-callee-name': capture('@callable-flow.direct-callee-name', lineRange, call.target),
+                    }),
+            });
+        }
+        if (!call.isQuoted && procedurePointers.has(call.target.toUpperCase())) {
+            out.push({
+                '@callable-flow.invoke': capture('@callable-flow.invoke', lineRange, line),
+                '@callable-flow.callee': capture('@callable-flow.callee', lineRange, call.target),
+                '@callable-flow.invocation-kind': capture('@callable-flow.invocation-kind', lineRange, 'indirect'),
+                '@callable-flow.arity': capture('@callable-flow.arity', lineRange, String(call.parameters?.length ?? 0)),
+            });
+        }
+    }
     return out;
 }
 // ---------------------------------------------------------------------------

package/dist/core/ingestion/languages/cobol/scope-resolver.js

@@ -56,6 +56,13 @@ const cobolScopeResolver = {
             return 'compatible';
         return 'incompatible';
     },
+    // PROGRAM-ID declarations bridge to legacy Module graph nodes. COBOL's
+    // procedure-pointer ENTRY values therefore target Module defs, while every
+    // AST-backed provider keeps the shared callable-label default.
+    isCallableValueTarget: (def) => def.type === 'Module',
+    // Structural COBOL CALLS/IMPORTS remain owned by the established regex
+    // processor; this resolver contributes only procedure-pointer CALLS.
+    scopeResolutionEdgeMode: 'callable-flow-only',
     // No inheritance in COBOL — empty MRO map.
     buildMro: () => new Map(),
     // Everything lives under the PROGRAM-ID Module scope.