gitnexus 1.6.6-rc.70 → 1.6.6-rc.71

package/dist/core/ingestion/languages/cobol/captures.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `emitScopeCaptures` for COBOL.
+ *
+ * Wraps the existing regex tagger (`extractCobolSymbolsWithRegex`) and
+ * produces parser-agnostic `CaptureMatch[]` matching the RFC §5.1
+ * vocabulary. The central `ScopeExtractor` consumes these captures
+ * without knowing whether they came from tree-sitter or regex.
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ * The regex tagger is synchronous — no async needed.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitCobolScopeCaptures(sourceText: string, _filePath: string, _cachedTree?: unknown): readonly CaptureMatch[];

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

@@ -0,0 +1,227 @@
+/**
+ * `emitScopeCaptures` for COBOL.
+ *
+ * Wraps the existing regex tagger (`extractCobolSymbolsWithRegex`) and
+ * produces parser-agnostic `CaptureMatch[]` matching the RFC §5.1
+ * vocabulary. The central `ScopeExtractor` consumes these captures
+ * without knowing whether they came from tree-sitter or regex.
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ * The regex tagger is synchronous — no async needed.
+ */
+import { extractCobolSymbolsWithRegex, preprocessCobolSource, } from '../../cobol/cobol-preprocessor.js';
+// ---------------------------------------------------------------------------
+// Capture building helpers
+// ---------------------------------------------------------------------------
+function capture(name, range, text) {
+    return { name, range, text };
+}
+function rangeOf(startLine, startCol, endLine, endCol) {
+    return { startLine, startCol, endLine, endCol };
+}
+/**
+ * Build a single CaptureMatch from a record of captures.
+ * Returns null if the record is empty.
+ */
+function matchFrom(grouped) {
+    if (Object.keys(grouped).length === 0)
+        return null;
+    return Object.freeze(grouped);
+}
+/**
+ * Compute end column for a single-line capture from the source lines array.
+ */
+function endColFrom(line) {
+    return line.length > 0 ? line.length - 1 : 0;
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
+    const lines = sourceText.split(/\r?\n/);
+    // Preprocess: strip patch markers from columns 1-6
+    const cleaned = preprocessCobolSource(sourceText);
+    // Run the regex tagger on the preprocessed source
+    const extracted = extractCobolSymbolsWithRegex(cleaned, _filePath);
+    const out = [];
+    // ── 1. PROGRAM-ID → @scope.module ───────────────────────────────────
+    // The primary program name (first PROGRAM-ID encountered)
+    if (extracted.programName) {
+        const name = extracted.programName;
+        const lastLine = lines.length;
+        const progDef = extracted.programs.find((p) => p.name.toUpperCase() === name.toUpperCase());
+        const startLine = progDef?.startLine ?? 1;
+        const endLine = progDef?.endLine ?? lastLine;
+        const startCol = 0;
+        const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
+        const progIdLine = findProgramIdLine(cleaned, name);
+        const nameRange = progIdLine !== -1
+            ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
+            : rangeOf(startLine, startCol, endLine, endCol);
+        const grouped = {
+            '@scope.module': capture('@scope.module', nameRange, name),
+            '@declaration.program': capture('@declaration.program', rangeOf(startLine, startCol, endLine, endCol), name),
+            '@declaration.name': capture('@declaration.name', nameRange, name),
+        };
+        if (progDef?.procedureUsing && progDef.procedureUsing.length > 0) {
+            grouped['@declaration.parameter-count'] = capture('@declaration.parameter-count', nameRange, String(progDef.procedureUsing.length));
+        }
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 2. Nested / additional programs → @scope.module ──────────────
+    for (const prog of extracted.programs) {
+        if (extracted.programName && prog.name.toUpperCase() === extracted.programName.toUpperCase())
+            continue;
+        const startLine = prog.startLine;
+        const endLine = prog.endLine;
+        const startCol = 0;
+        const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
+        const progIdLine = findProgramIdLine(cleaned, prog.name);
+        const nameRange = progIdLine !== -1
+            ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
+            : rangeOf(startLine, startCol, endLine, endCol);
+        const grouped = {
+            '@scope.module': capture('@scope.module', nameRange, prog.name),
+            '@declaration.program': capture('@declaration.program', rangeOf(startLine, startCol, endLine, endCol), prog.name),
+            '@declaration.name': capture('@declaration.name', nameRange, prog.name),
+        };
+        if (prog.procedureUsing && prog.procedureUsing.length > 0) {
+            grouped['@declaration.parameter-count'] = capture('@declaration.parameter-count', nameRange, String(prog.procedureUsing.length));
+        }
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 3. PROCEDURE DIVISION sections → @scope.function ─────────────
+    for (const section of extracted.sections) {
+        const lineIdx = section.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const sectionLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(sectionLine);
+        const nameRange = rangeOf(section.line, startCol, section.line, endCol);
+        const grouped = {
+            '@scope.function': capture('@scope.function', nameRange, section.name),
+            '@declaration.function': capture('@declaration.function', nameRange, section.name),
+            '@declaration.name': capture('@declaration.name', nameRange, section.name),
+        };
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 4. Paragraphs → @scope.function ──────────────────────────────
+    for (const para of extracted.paragraphs) {
+        const lineIdx = para.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const paraLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(paraLine);
+        const nameRange = rangeOf(para.line, startCol, para.line, endCol);
+        const grouped = {
+            '@scope.function': capture('@scope.function', nameRange, para.name),
+            '@declaration.function': capture('@declaration.function', nameRange, para.name),
+            '@declaration.name': capture('@declaration.name', nameRange, para.name),
+        };
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 5. COPY → @import.statement ──────────────────────────────────
+    for (const copy of extracted.copies) {
+        const lineIdx = copy.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const copyLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(copyLine);
+        const stmtRange = rangeOf(copy.line, startCol, copy.line, endCol);
+        const grouped = {
+            '@import.statement': capture('@import.statement', stmtRange, copy.target),
+            '@import.name': capture('@import.name', stmtRange, copy.target),
+        };
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 6. CALL (quoted/referenced) → @reference.call ────────────────
+    for (const call of extracted.calls) {
+        const lineIdx = call.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const callLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(callLine);
+        const stmtRange = rangeOf(call.line, startCol, call.line, endCol);
+        const grouped = {
+            '@reference.call': capture('@reference.call', stmtRange, call.target),
+            '@reference.name': capture('@reference.name', stmtRange, call.target),
+        };
+        // Arity from CALL USING parameters
+        if (call.parameters && call.parameters.length > 0) {
+            grouped['@reference.arity'] = capture('@reference.arity', stmtRange, String(call.parameters.length));
+        }
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 7. PERFORM → @reference.call ─────────────────────────────────
+    for (const perf of extracted.performs) {
+        const lineIdx = perf.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const perfLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(perfLine);
+        const stmtRange = rangeOf(perf.line, startCol, perf.line, endCol);
+        const grouped = {
+            '@reference.call': capture('@reference.call', stmtRange, perf.target),
+            '@reference.name': capture('@reference.name', stmtRange, perf.target),
+        };
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    // ── 8. GO TO → @reference.call ───────────────────────────────────
+    for (const gt of extracted.gotos) {
+        const lineIdx = gt.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const gtLine = lines[lineIdx];
+        const startCol = 0;
+        const endCol = endColFrom(gtLine);
+        const stmtRange = rangeOf(gt.line, startCol, gt.line, endCol);
+        const grouped = {
+            '@reference.call': capture('@reference.call', stmtRange, gt.target),
+            '@reference.name': capture('@reference.name', stmtRange, gt.target),
+        };
+        const m = matchFrom(grouped);
+        if (m !== null)
+            out.push(m);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Find the PROGRAM-ID. line for a given program name in the cleaned source.
+ * Returns 1-based line number, or -1 if not found.
+ */
+function findProgramIdLine(cleanedSource, programName) {
+    const lines = cleanedSource.split(/\r?\n/);
+    const upper = programName.toUpperCase();
+    const re = new RegExp(`\\bPROGRAM-ID\\.\\s*${escapeRegex(upper)}\\b`, 'i');
+    for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i]))
+            return i + 1; // 1-based
+    }
+    return -1;
+}
+/** Simple regex escape for special chars. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/core/ingestion/languages/cobol/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * COBOL scope-resolution public API barrel.
+ *
+ * Consumers should import from this file rather than the individual
+ * modules — that keeps the per-hook organization an implementation
+ * detail we can refactor without touching the provider wiring.
+ *
+ * Module layout:
+ *
+ *   - `captures.ts`   — `emitCobolScopeCaptures` (wraps the regex tagger)
+ *   - `interpret.ts`  — import/type-binding/receiver hooks
+ */
+export { emitCobolScopeCaptures } from './captures.js';
+export { interpretCobolImport, interpretCobolTypeBinding, cobolImportOwningScope, cobolReceiverBinding, } from './interpret.js';

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

@@ -0,0 +1,14 @@
+/**
+ * COBOL scope-resolution public API barrel.
+ *
+ * Consumers should import from this file rather than the individual
+ * modules — that keeps the per-hook organization an implementation
+ * detail we can refactor without touching the provider wiring.
+ *
+ * Module layout:
+ *
+ *   - `captures.ts`   — `emitCobolScopeCaptures` (wraps the regex tagger)
+ *   - `interpret.ts`  — import/type-binding/receiver hooks
+ */
+export { emitCobolScopeCaptures } from './captures.js';
+export { interpretCobolImport, interpretCobolTypeBinding, cobolImportOwningScope, cobolReceiverBinding, } from './interpret.js';

package/dist/core/ingestion/languages/cobol/interpret.d.ts

@@ -0,0 +1,46 @@
+/**
+ * COBOL scope-resolution interpret hooks.
+ *
+ * Interprets raw `@import.statement` capture matches (from COPY statements)
+ * into `ParsedImport` for the central finalize algorithm.
+ *
+ * COBOL's import semantic is simple: `COPY bookname` means the copybook's
+ * content is inlined at compile time. There is no module-system equivalent
+ * of `export` — everything is text-inclusion. The scope-resolution pipeline
+ * models this as a `'named'` import where the imported name is the copybook
+ * name and the target is the copybook file path.
+ */
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding, ScopeId, ScopeTree, Scope, TypeRef } from '../../../../_shared/index.js';
+/**
+ * Interpret a COPY statement as a `ParsedImport`.
+ *
+ * The `@import.name` capture contains the copybook target name (e.g.,
+ * `CPSESP` from `COPY CPSESP.`). Returns a `'named'` import with the
+ * copybook name as both `localName` and `importedName`.
+ *
+ * Returns `null` for any match that doesn't carry an `@import.name` (e.g.,
+ * malformed COPY statements the regex tagger might emit).
+ */
+export declare function interpretCobolImport(match: CaptureMatch): ParsedImport | null;
+/**
+ * COBOL has no type system — no type bindings to interpret.
+ * Always returns `null`.
+ */
+export declare function interpretCobolTypeBinding(_match: CaptureMatch): ParsedTypeBinding | null;
+/**
+ * COPY statements in COBOL are module-level — they expand inline at
+ * compile time and their bindings belong to the enclosing PROGRAM-ID
+ * (Module) scope. Walk up from the innermost scope through ancestors
+ * to find the enclosing Module scope.
+ *
+ * For the edge case of a COPY inside a paragraph (unusual but possible
+ * with some vendors), we walk the scope tree to ensure the import is
+ * attached to the program scope, not the paragraph Function scope.
+ */
+export declare function cobolImportOwningScope(_imp: ParsedImport, innermost: Scope, tree: ScopeTree): ScopeId | null;
+/**
+ * COBOL has no implicit receiver (no `self`, `this`, or equivalent).
+ * All function calls are explicit CALL statements or PERFORM/GO TO
+ * control flow. Always returns `null`.
+ */
+export declare function cobolReceiverBinding(_functionScope: Scope): TypeRef | null;

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

@@ -0,0 +1,79 @@
+/**
+ * COBOL scope-resolution interpret hooks.
+ *
+ * Interprets raw `@import.statement` capture matches (from COPY statements)
+ * into `ParsedImport` for the central finalize algorithm.
+ *
+ * COBOL's import semantic is simple: `COPY bookname` means the copybook's
+ * content is inlined at compile time. There is no module-system equivalent
+ * of `export` — everything is text-inclusion. The scope-resolution pipeline
+ * models this as a `'named'` import where the imported name is the copybook
+ * name and the target is the copybook file path.
+ */
+// ─── interpretImport ──────────────────────────────────────────────────────
+/**
+ * Interpret a COPY statement as a `ParsedImport`.
+ *
+ * The `@import.name` capture contains the copybook target name (e.g.,
+ * `CPSESP` from `COPY CPSESP.`). Returns a `'named'` import with the
+ * copybook name as both `localName` and `importedName`.
+ *
+ * Returns `null` for any match that doesn't carry an `@import.name` (e.g.,
+ * malformed COPY statements the regex tagger might emit).
+ */
+export function interpretCobolImport(match) {
+    const nameCap = match['@import.name'];
+    if (nameCap === undefined)
+        return null;
+    const name = nameCap.text;
+    if (name === '')
+        return null;
+    return {
+        kind: 'named',
+        localName: name,
+        importedName: name,
+        targetRaw: name,
+    };
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+/**
+ * COBOL has no type system — no type bindings to interpret.
+ * Always returns `null`.
+ */
+export function interpretCobolTypeBinding(_match) {
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/**
+ * COPY statements in COBOL are module-level — they expand inline at
+ * compile time and their bindings belong to the enclosing PROGRAM-ID
+ * (Module) scope. Walk up from the innermost scope through ancestors
+ * to find the enclosing Module scope.
+ *
+ * For the edge case of a COPY inside a paragraph (unusual but possible
+ * with some vendors), we walk the scope tree to ensure the import is
+ * attached to the program scope, not the paragraph Function scope.
+ */
+export function cobolImportOwningScope(_imp, innermost, tree) {
+    // If already in a Module scope, use it directly.
+    if (innermost.kind === 'Module')
+        return innermost.id;
+    // Walk through ancestors to find the enclosing Module.
+    const ancestors = tree.getAncestors(innermost.id);
+    for (const ancId of ancestors) {
+        const anc = tree.getScope(ancId);
+        if (anc !== undefined && anc.kind === 'Module')
+            return ancId;
+    }
+    // Fallback: delegate to central default.
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/**
+ * COBOL has no implicit receiver (no `self`, `this`, or equivalent).
+ * All function calls are explicit CALL statements or PERFORM/GO TO
+ * control flow. Always returns `null`.
+ */
+export function cobolReceiverBinding(_functionScope) {
+    return null;
+}

package/dist/core/ingestion/languages/cobol/scope-resolver.d.ts

@@ -0,0 +1,13 @@
+/**
+ * COBOL `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed
+ * by the generic `runScopeResolution` orchestrator.
+ *
+ * The provider is a thin wiring object — COBOL's simple scope model
+ * (Module + Function only, no inheritance, no type system) plugs into
+ * `runScopeResolution` with minimal configuration.
+ *
+ * Reference: `languages/python/scope-resolver.ts`.
+ */
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+declare const cobolScopeResolver: ScopeResolver;
+export { cobolScopeResolver };

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

@@ -0,0 +1,69 @@
+/**
+ * COBOL `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed
+ * by the generic `runScopeResolution` orchestrator.
+ *
+ * The provider is a thin wiring object — COBOL's simple scope model
+ * (Module + Function only, no inheritance, no type system) plugs into
+ * `runScopeResolution` with minimal configuration.
+ *
+ * Reference: `languages/python/scope-resolver.ts`.
+ */
+import path from 'node:path';
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { cobolProvider } from '../cobol.js';
+// Copybook file extensions for COPY name resolution
+const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
+const cobolScopeResolver = {
+    language: SupportedLanguages.Cobol,
+    languageProvider: cobolProvider,
+    importEdgeReason: 'cobol-scope: copy',
+    // ── Resolve COPY bookname to file path ─────────────────────────────
+    resolveImportTarget: (targetRaw, _fromFile, allFilePaths) => {
+        const upper = targetRaw.toUpperCase();
+        // Check copybook files first
+        for (const fp of allFilePaths) {
+            const ext = path.extname(fp).toLowerCase();
+            if (!COPYBOOK_EXTENSIONS.has(ext))
+                continue;
+            const basename = path.basename(fp, ext).toUpperCase();
+            if (basename === upper)
+                return fp;
+        }
+        // Also search COBOL source files (.cbl, .cob, .cobol)
+        const COBOL_SOURCE_EXTS = new Set(['.cbl', '.cob', '.cobol']);
+        for (const fp of allFilePaths) {
+            const ext = path.extname(fp).toLowerCase();
+            if (!COBOL_SOURCE_EXTS.has(ext))
+                continue;
+            const basename = path.basename(fp, ext).toUpperCase();
+            if (basename === upper)
+                return fp;
+        }
+        return null;
+    },
+    // COBOL has no binding-merge rules beyond the default (local-first-then-imports).
+    mergeBindings: (existing) => [...existing],
+    // COBOL arity: compare CALL USING param count against def's parameterCount.
+    // COBOL requires exact arity match for CALL USING.
+    arityCompatibility: (callsite, def) => {
+        if (callsite.arity === undefined)
+            return 'unknown';
+        const defParamCount = def.parameterCount;
+        if (defParamCount === undefined)
+            return 'unknown';
+        if (callsite.arity === defParamCount)
+            return 'compatible';
+        return 'incompatible';
+    },
+    // No inheritance in COBOL — empty MRO map.
+    buildMro: () => new Map(),
+    // Everything lives under the PROGRAM-ID Module scope.
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // COBOL has no super calls.
+    isSuperReceiver: () => false,
+    // ── Optional toggles ─────────────────────────────────────────────
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: false,
+};
+export { cobolScopeResolver };

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

@@ -6,11 +6,13 @@
  * processed by cobol-processor.ts in pipeline Phase 2.6, not by the
  * tree-sitter pipeline.
  *
- * This provider exists to satisfy the SupportedLanguages exhaustiveness
- * checks and to declare parseStrategy: 'standalone'.
+ * This provider supports scope-based resolution (RFC #909 Ring 3) via
+ * `emitScopeCaptures` which wraps the regex tagger. COPY statements are
+ * interpreted as imports; there is no type system and no implicit receiver.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { defineLanguage } from '../language-provider.js';
+import { emitCobolScopeCaptures, interpretCobolImport, cobolImportOwningScope, cobolReceiverBinding, } from './cobol/index.js';
 export const cobolProvider = defineLanguage({
     id: SupportedLanguages.Cobol,
     parseStrategy: 'standalone',
@@ -25,4 +27,9 @@ export const cobolProvider = defineLanguage({
     },
     exportChecker: () => false,
     importResolver: () => null,
+    // ── Scope-resolution hooks ───────────────────────────────────────
+    emitScopeCaptures: emitCobolScopeCaptures,
+    interpretImport: interpretCobolImport,
+    importOwningScope: cobolImportOwningScope,
+    receiverBinding: cobolReceiverBinding,
 });

package/dist/core/ingestion/registry-primary-flag.d.ts

@@ -11,8 +11,9 @@
  * ## Contract
  *
  *   - Env-var name per language: `REGISTRY_PRIMARY_<UPPER(enum-value)>`.
- *     Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
- *     `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
+ *   Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
+ *   `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
+ *   `SupportedLanguages.Cobol` (value `'cobol'`) → `REGISTRY_PRIMARY_COBOL`.
  *   - Truthy values: `'true'`, `'1'`, `'yes'` (case-insensitive,
  *     whitespace-trimmed). Anything else — including `undefined`, empty
  *     string, or unknown tokens — is `false`.

package/dist/core/ingestion/registry-primary-flag.js

@@ -11,8 +11,9 @@
  * ## Contract
  *
  *   - Env-var name per language: `REGISTRY_PRIMARY_<UPPER(enum-value)>`.
- *     Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
- *     `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
+ *   Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
+ *   `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
+ *   `SupportedLanguages.Cobol` (value `'cobol'`) → `REGISTRY_PRIMARY_COBOL`.
  *   - Truthy values: `'true'`, `'1'`, `'yes'` (case-insensitive,
  *     whitespace-trimmed). Anything else — including `undefined`, empty
  *     string, or unknown tokens — is `false`.

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

@@ -21,6 +21,7 @@ import { rustScopeResolver } from '../../languages/rust/scope-resolver.js';
 import { javascriptScopeResolver } from '../../languages/javascript/scope-resolver.js';
 import { kotlinScopeResolver } from '../../languages/kotlin/scope-resolver.js';
 import { rubyScopeResolver } from '../../languages/ruby/scope-resolver.js';
+import { cobolScopeResolver } from '../../languages/cobol/scope-resolver.js';
 /** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
  *  this map intersected with `MIGRATED_LANGUAGES` (the per-language
  *  flag set) so adding a resolver here without flipping the flag is
@@ -38,4 +39,5 @@ export const SCOPE_RESOLVERS = new Map([
     [SupportedLanguages.JavaScript, javascriptScopeResolver],
     [SupportedLanguages.Kotlin, kotlinScopeResolver],
     [SupportedLanguages.Ruby, rubyScopeResolver],
+    [SupportedLanguages.Cobol, cobolScopeResolver],
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.70",
+  "version": "1.6.6-rc.71",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",