cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,395 @@
+"use strict";
+/**
+ * Phase: scopeResolution
+ *
+ * Generic registry-primary resolution phase (RFC #909 Ring 3).
+ *
+ * For every language whose provider is registered in `SCOPE_RESOLVERS`:
+ *   1. Filter scanned files by language extension.
+ *   2. Read file contents.
+ *   3. Drive the scope-based pipeline end-to-end via the generic
+ *      `runScopeResolution(input, provider)` orchestrator.
+ *   4. Emit IMPORTS / CALLS / ACCESSES / INHERITS / USES edges.
+ *
+ * This is the sole resolution path — RING4-1 (#942) deleted the legacy
+ * call-resolution DAG, so there is no longer a per-language flag gating
+ * registry-vs-legacy.
+ *
+ * Adding a language is one change: implement `ScopeResolver` in
+ * `languages/<lang>/scope-resolver.ts` and register it in
+ * `scope-resolution/pipeline/registry.ts`.
+ *
+ * @deps    parse  (needs Symbol nodes already in the graph so emit-references
+ *                  can attach edges to existing Function/Method/Class nodes)
+ * @reads   scannedFiles
+ * @writes  graph (IMPORTS, CALLS, ACCESSES, INHERITS, USES)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeResolutionPhase = void 0;
+exports.selectScopeSourcePathsToRead = selectScopeSourcePathsToRead;
+const types_js_1 = require("../../pipeline-phases/types.js");
+const index_js_1 = require("../../../../../shared/index.js");
+const filesystem_walker_js_1 = require("../../filesystem-walker.js");
+const run_js_1 = require("./run.js");
+const parser_loader_js_1 = require("../../../tree-sitter/parser-loader.js");
+const node_lookup_js_1 = require("../graph-bridge/node-lookup.js");
+const registry_js_1 = require("./registry.js");
+const env_js_1 = require("../../utils/env.js");
+const heap_probe_js_1 = require("../../utils/heap-probe.js");
+const parsedfile_store_js_1 = require("../../../../storage/parsedfile-store.js");
+const logger_js_1 = require("../../../logger.js");
+const NOOP_OUTPUT = Object.freeze({
+    ran: false,
+    filesProcessed: 0,
+    importsEmitted: 0,
+    referenceEdgesEmitted: 0,
+    resolutionOutcomes: [],
+    perLanguage: new Map(),
+});
+/** Select source files that must be materialized for one resolver pass. */
+function selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath) {
+    const hasPostExtractHooks = provider.populateWorkspaceOwners !== undefined ||
+        provider.populateNamespaceSiblings !== undefined ||
+        provider.populateRangeBindings !== undefined ||
+        provider.emitPostResolutionEdges !== undefined;
+    const needsAllSourceText = hasPostExtractHooks && provider.postExtractSourceTextPolicy !== 'uncached-files';
+    return needsAllSourceText
+        ? [...primaryFilePaths]
+        : primaryFilePaths.filter((filePath) => !preExtractedByPath.has(filePath));
+}
+exports.scopeResolutionPhase = {
+    name: 'scopeResolution',
+    // Depends on `parse` because emit-references attaches edges to
+    // already-existing Symbol nodes (Function/Method/Class) that the `parse`
+    // phase creates.
+    //
+    // The `crossFile` dep is retained for stable ordering but is no longer
+    // load-bearing: inheritance (EXTENDS/IMPLEMENTS) edges are now emitted by
+    // this phase's own `preEmitInheritanceEdges` before `buildMro` runs, and
+    // since RING4-1 (#942) `crossFile` only disposes the BindingAccumulator
+    // (the legacy cross-file re-resolution it used to run was deleted with the
+    // call-resolution DAG).
+    deps: ['parse', 'crossFile', 'structure'],
+    async execute(ctx, deps) {
+        (0, heap_probe_js_1.logHeapProbe)('scopeResolution-enter');
+        const { scannedFiles } = (0, types_js_1.getPhaseOutput)(deps, 'structure');
+        const parseOutput = (0, types_js_1.getPhaseOutput)(deps, 'parse');
+        const { model, parsedFiles: workerParsedFiles } = parseOutput;
+        // SemanticModel populated during `parse`: scope-resolution consumes
+        // TypeRegistry / MethodRegistry / SymbolTable lookups instead of
+        // rebuilding parallel indexes. See ARCHITECTURE.md § "Semantic-model
+        // source of truth".
+        // Build a per-file lookup of ParsedFile artifacts the workers (or
+        // sequential extracts) already produced. Threading this into
+        // `runScopeResolution` lets the per-language extract loop short-
+        // circuit `extractParsedFile` — the dominant cost on the warm-cache
+        // path, since workers can't return tree-sitter Trees across the
+        // MessageChannel and scope-resolution would otherwise re-parse
+        // every file from scratch on the main thread.
+        const preExtractedByPath = new Map();
+        for (const pf of workerParsedFiles) {
+            preExtractedByPath.set(pf.filePath, pf);
+        }
+        // Disk-backed ParsedFile store (#1983): on huge repos the parse phase
+        // flushes worker-produced ParsedFiles to disk (instead of `workerParsedFiles`
+        // heap) and we stream them back here per language. Reusing them means
+        // scope-resolution does ZERO tree-sitter parsing on the main thread, which
+        // is what eliminates the unbounded native re-parse leak that OOM'd large
+        // analyses. `undefined` when no storage path (tests / direct calls) — those
+        // runs use the in-heap `workerParsedFiles` above or fall back to a fresh
+        // extract per file inside runScopeResolution.
+        const parsedFileStorePath = ctx.options?.parsedFileStorePath;
+        // Standalone providers are re-extracted from source on the main thread;
+        // workers intentionally do not serialize ParsedFile artifacts for them.
+        // Drop any stale/cache-sourced entry defensively so provider-owned regex
+        // capture logic is always the source of truth for the current content.
+        for (const [path] of preExtractedByPath) {
+            const lang = (0, index_js_1.getLanguageFromFilename)(path);
+            if (lang === null)
+                continue;
+            const provider = registry_js_1.SCOPE_RESOLVERS.get(lang);
+            if (provider?.languageProvider.parseStrategy === 'standalone') {
+                preExtractedByPath.delete(path);
+            }
+        }
+        let totalFiles = 0;
+        let totalImports = 0;
+        let totalRefs = 0;
+        let anyRan = false;
+        const resolutionOutcomes = [];
+        const perLanguage = new Map();
+        // Pre-count files and languages for progress reporting. This avoids
+        // a frozen progress bar during long scope-resolution runs (#1741).
+        // Uses primary-language file counts only; languages that expand their
+        // context via collectScopeContextPaths may process more files than shown.
+        let totalScopeFiles = 0;
+        let totalScopeLangs = 0;
+        const allScannedPaths = new Set(scannedFiles.map((f) => f.path));
+        // Partition scanned files by language ONCE (O(F)). The previous code
+        // re-filtered all scannedFiles per language for the precount AND again in the
+        // per-language loop below — O(languages × files), ~2.3M getLanguageFromFilename
+        // calls on the Linux kernel. Bucketing once collapses that to O(F).
+        // Language-agnostic: keyed by the provider-supplied SupportedLanguages value.
+        const filesByLang = new Map();
+        for (const f of scannedFiles) {
+            const fileLang = (0, index_js_1.getLanguageFromFilename)(f.path);
+            if (fileLang === null)
+                continue;
+            // Tree-sitter providers require an available grammar. Standalone regex
+            // providers deliberately have none and re-extract on the main thread.
+            const resolver = registry_js_1.SCOPE_RESOLVERS.get(fileLang);
+            if (resolver?.languageProvider.parseStrategy !== 'standalone' &&
+                !(0, parser_loader_js_1.isLanguageAvailable)(fileLang)) {
+                continue;
+            }
+            let bucket = filesByLang.get(fileLang);
+            if (bucket === undefined) {
+                bucket = [];
+                filesByLang.set(fileLang, bucket);
+            }
+            bucket.push(f);
+        }
+        for (const [lang] of registry_js_1.SCOPE_RESOLVERS) {
+            const count = filesByLang.get(lang)?.length ?? 0;
+            if (count > 0) {
+                totalScopeLangs++;
+                totalScopeFiles += count;
+            }
+        }
+        const SCOPE_PCT_START = 90;
+        const SCOPE_PCT_RANGE = 8; // 90-98 internal → 54-59% display
+        let processedScopeFiles = 0;
+        let currentLangIdx = 0;
+        if (totalScopeFiles > 0) {
+            ctx.onProgress({
+                phase: 'scopeResolution',
+                percent: SCOPE_PCT_START,
+                message: 'Resolving types',
+            });
+        }
+        // Build the graph-node lookup ONCE and share it across every language pass.
+        // It scans the whole graph (~2 GB on the kernel) and is language-agnostic,
+        // so the previous per-language rebuild burned that CPU+heap N times and, on
+        // a huge repo, a tiny language's full-graph copy overlapped the next
+        // language's — a real contributor to the scope-resolution memory peak.
+        // Bracket the whole-graph node-lookup build with probes — scanning every
+        // graph node is the silent multi-minute step before the first per-language
+        // marker on huge repos, so make it observable.
+        (0, heap_probe_js_1.logHeapProbe)('scope-setup-nodeLookup-start', `langs=${totalScopeLangs} files=${totalScopeFiles}`);
+        const sharedNodeLookup = totalScopeFiles > 0 ? (0, node_lookup_js_1.buildGraphNodeLookup)(ctx.graph) : undefined;
+        (0, heap_probe_js_1.logHeapProbe)('scope-setup-nodeLookup-end', `langs=${totalScopeLangs}`);
+        // M4 (#2084 review P2-6): build the functionish-node index ONCE for the
+        // taint summary harvest, shared across every language pass (it is a whole-
+        // graph scan and language-agnostic). Only when pdg is on — off ⇒ undefined,
+        // no scan, byte-identical.
+        for (const [lang, provider] of registry_js_1.SCOPE_RESOLVERS) {
+            const primaryLangFiles = filesByLang.get(lang) ?? [];
+            if (primaryLangFiles.length === 0)
+                continue;
+            const primaryFilePaths = primaryLangFiles.map((f) => f.path);
+            // Load per-language import-resolution config (tsconfig paths,
+            // composer.json autoload, go.mod, ...). One I/O round trip per
+            // workspace pass — cached implicitly by the result handed to
+            // every `resolveImportTarget` call below.
+            const resolutionConfig = provider.loadResolutionConfig !== undefined
+                ? await provider.loadResolutionConfig(ctx.repoPath)
+                : undefined;
+            // Some languages (e.g. Vue) expand their file universe beyond the
+            // primary-language files via the `collectScopeContextPaths` hook.
+            // The hook receives raw source contents of the primary files so it
+            // can trace import closures without a second tree-sitter parse.
+            //
+            // To avoid reading primary files twice (once for the hook, once for
+            // the resolution pass), we read them upfront and merge with the
+            // extra context paths the hook may add.
+            // Stream this language's pre-built ParsedFiles in from the disk store
+            // FIRST (huge-repo path). Doing it before reading source lets us skip
+            // loading content for files the store already covers — for a provider
+            // with no content-consuming hook that source is pure dead weight once
+            // extraction is served from the store (~1.5 GB on the kernel's C pass).
+            // Merged into `preExtractedByPath`; the per-language release block below
+            // evicts these again before the next language, so only one language's
+            // ParsedFiles are resident at a time.
+            const loadStoreFor = async (paths) => {
+                if (!parsedFileStorePath)
+                    return;
+                const fromDisk = await (0, parsedfile_store_js_1.loadParsedFilesForPaths)(parsedFileStorePath, paths);
+                for (const [fp, pf] of fromDisk)
+                    preExtractedByPath.set(fp, pf);
+            };
+            let scopeFilePaths;
+            let contents;
+            if (provider.collectScopeContextPaths !== undefined) {
+                // Context-expanding providers (e.g. Vue) need every primary file's
+                // source up front for the closure hook, so load it all.
+                const entryFileContents = await (0, filesystem_walker_js_1.readFileContents)(ctx.repoPath, primaryFilePaths);
+                scopeFilePaths = provider.collectScopeContextPaths({
+                    primaryFilePaths,
+                    preExtractedByPath,
+                    entryFileContents,
+                    allScannedPaths,
+                    resolutionConfig,
+                });
+                // Read only the extra context files (TS/JS etc.) not already loaded.
+                const extraPaths = [...scopeFilePaths].filter((p) => !entryFileContents.has(p));
+                const extraContents = await (0, filesystem_walker_js_1.readFileContents)(ctx.repoPath, extraPaths);
+                contents = new Map([...entryFileContents, ...extraContents]);
+                await loadStoreFor(scopeFilePaths);
+            }
+            else {
+                scopeFilePaths = new Set(primaryFilePaths);
+                await loadStoreFor(scopeFilePaths);
+                const pathsToRead = selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath);
+                contents = await (0, filesystem_walker_js_1.readFileContents)(ctx.repoPath, pathsToRead);
+            }
+            const filePaths = [...scopeFilePaths];
+            const files = [];
+            for (const fp of filePaths) {
+                const content = contents.get(fp);
+                if (content !== undefined) {
+                    files.push({ path: fp, content });
+                }
+                else if (preExtractedByPath.has(fp)) {
+                    // Store covers extraction for this file and we deliberately skipped
+                    // reading its source; extraction uses the pre-extracted ParsedFile,
+                    // and the provider's source-text policy guarantees its hooks can
+                    // tolerate empty content for cached files.
+                    files.push({ path: fp, content: '' });
+                }
+                // else: uncovered AND unreadable → skip (unchanged from prior behavior).
+            }
+            const langFileCount = files.length;
+            (0, heap_probe_js_1.logHeapProbe)('scope-lang-start', `lang=${lang} files=${langFileCount} contentsLoaded=${contents.size}`);
+            const langLabel = lang.charAt(0).toUpperCase() + lang.slice(1);
+            currentLangIdx++;
+            const langTag = totalScopeLangs > 1 ? `${langLabel} [${currentLangIdx}/${totalScopeLangs}]` : langLabel;
+            if (totalScopeFiles > 0) {
+                const pct = SCOPE_PCT_START + Math.round((processedScopeFiles / totalScopeFiles) * SCOPE_PCT_RANGE);
+                ctx.onProgress({
+                    phase: 'scopeResolution',
+                    percent: pct,
+                    message: 'Resolving types',
+                    detail: `${langTag}, ${langFileCount.toLocaleString()} files`,
+                });
+            }
+            const stats = (0, run_js_1.runScopeResolution)({
+                graph: ctx.graph,
+                model,
+                files,
+                resolutionConfig,
+                prebuiltNodeLookup: sharedNodeLookup,
+                preExtractedParsedFiles: preExtractedByPath,
+                scopeIndexStorePath: parsedFileStorePath,
+                recordResolutionOutcome: (outcome) => {
+                    resolutionOutcomes.push(outcome);
+                },
+                onWarn: (msg) => {
+                    if ((0, env_js_1.isSemanticModelValidatorEnabled)()) {
+                        logger_js_1.logger.warn(`[scope-resolution:${lang}] ${msg}`);
+                    }
+                },
+                onProgress: totalScopeFiles > 0
+                    ? (subPhase, current, total) => {
+                        let langRatio;
+                        switch (subPhase) {
+                            case 'extracting':
+                                langRatio = total > 0 ? (current / total) * 0.5 : 0;
+                                break;
+                            case 'analyzing types':
+                                langRatio = 0.5;
+                                break;
+                            case 'resolving references':
+                                langRatio = 0.7;
+                                break;
+                            case 'linking symbols':
+                                langRatio = 0.85;
+                                break;
+                            default: {
+                                const _exhaustive = subPhase;
+                                langRatio = 0.85;
+                            }
+                        }
+                        const overallRatio = Math.min(1, (processedScopeFiles + langRatio * langFileCount) / totalScopeFiles);
+                        const pct = SCOPE_PCT_START + Math.round(overallRatio * SCOPE_PCT_RANGE);
+                        ctx.onProgress({
+                            phase: 'scopeResolution',
+                            percent: pct,
+                            message: 'Resolving types',
+                            detail: subPhase === 'extracting'
+                                ? `${langTag} — extracting ${current.toLocaleString()}/${total.toLocaleString()} files`
+                                : `${langTag} — ${subPhase}`,
+                        });
+                    }
+                    : undefined,
+            }, provider);
+            // Release file contents and pre-extracted entries after each language
+            // to reduce memory pressure. For large codebases (16K+ PHP files),
+            // holding all source code simultaneously with scope trees causes OOM.
+            // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+            //
+            // Use `filePaths` (not `primaryFilePaths`) so that any context files
+            // added by `collectScopeContextPaths` (e.g. TS/JS files pulled in for
+            // Vue cross-file resolution) are also evicted and not held until GC.
+            files.length = 0;
+            contents.clear();
+            for (const fp of filePaths) {
+                preExtractedByPath.delete(fp);
+            }
+            // This language's ParsedFiles are now unreachable (runScopeResolution has
+            // returned and the Map entries are deleted). Force a GC HERE so a heavy
+            // language's ~17-20GB set (e.g. C/C++ on the Linux kernel) is reclaimed
+            // BEFORE the next language's store-load — instead of leaving V8 to collect
+            // it lazily under the next pass's allocation pressure (which, at a cap >=
+            // RAM, degrades into swap-thrash). Collects only dead objects: the live
+            // cross-file index of the next pass is untouched. The pre/post probe
+            // confirms whether old-space fragmentation defeats the reclaim.
+            (0, heap_probe_js_1.logHeapProbe)('lang-release-pre-gc', `lang=${lang}`);
+            (0, parsedfile_store_js_1.forceGc)();
+            (0, heap_probe_js_1.logHeapProbe)('lang-release-post-gc', `lang=${lang}`);
+            (0, heap_probe_js_1.logHeapProbe)('scope-lang-end', `lang=${lang} filesProcessed=${stats.filesProcessed}`);
+            processedScopeFiles += langFileCount;
+            anyRan = true;
+            totalFiles += stats.filesProcessed;
+            totalImports += stats.importsEmitted;
+            totalRefs += stats.referenceEdgesEmitted;
+            perLanguage.set(lang, {
+                filesProcessed: stats.filesProcessed,
+                importsEmitted: stats.importsEmitted,
+                referenceEdgesEmitted: stats.referenceEdgesEmitted,
+            });
+            if (env_js_1.isDev) {
+                logger_js_1.logger.info(`[scope-resolution:${lang}] ${stats.filesProcessed} files → ${stats.importsEmitted} IMPORTS + ${stats.referenceEdgesEmitted} reference edges (${stats.resolve.unresolved} unresolved sites, ${stats.referenceSkipped} skipped)`);
+            }
+        }
+        if (totalScopeFiles > 0 && anyRan) {
+            ctx.onProgress({
+                phase: 'scopeResolution',
+                percent: SCOPE_PCT_START + SCOPE_PCT_RANGE,
+                message: 'Resolving types',
+                detail: 'complete',
+            });
+        }
+        // Scope-resolution is the sole consumer of the disk-backed ParsedFile
+        // store; remove its shards now (can be many GB on a huge repo) so they
+        // don't linger in `.cgraphx/code`. Best-effort — never fail the phase on a
+        // cleanup error.
+        if (parsedFileStorePath) {
+            try {
+                await (0, parsedfile_store_js_1.clearParsedFileStore)(parsedFileStorePath);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        if (!anyRan)
+            return NOOP_OUTPUT;
+        return {
+            ran: true,
+            filesProcessed: totalFiles,
+            importsEmitted: totalImports,
+            referenceEdgesEmitted: totalRefs,
+            resolutionOutcomes,
+            perLanguage,
+        };
+    },
+};

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

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Reconcile scope-resolution's ownership view into the SemanticModel.
+ *
+ * For migrated languages (Python in particular) the legacy `parse` phase
+ * emits class-body callables without `ownerId` because
+ * `parsing-processor`'s `resolveEnclosingOwner` is language-dependent and
+ * not every extractor carries the enclosing-class info at parse time.
+ * Scope-resolution later calls `provider.populateOwners(parsed)`, which
+ * stamps the correct `ownerId` onto `parsed.localDefs[i]`. This pass
+ * mirrors those corrections into `model.methods` and `model.fields` so
+ * downstream passes can consult `SemanticModel` as the single
+ * authoritative owner-keyed index — no parallel scope-resolution
+ * registry is needed.
+ *
+ * ## Single-source-of-truth invariant (I9)
+ *
+ * After this pass runs, every `def in parsed.localDefs` with a non-
+ * undefined `ownerId` is reachable via either:
+ *   - `model.methods.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Method / Function / Constructor, OR
+ *   - `model.fields.lookupAllByOwner(ownerId, simpleName)` — if the
+ *     def is a Property / Variable / Const / Static.
+ *
+ * This invariant is the foundation of Contract Invariant I9
+ * (`contract/scope-resolver.ts`): scope-resolution passes MUST read
+ * symbol-keyed lookups exclusively from `SemanticModel`.
+ *
+ * ## Idempotency
+ *
+ * The pass skips registration when `(ownerId, simpleName)` already
+ * contains a def with matching `nodeId`. Safe to call multiple times
+ * or after a language whose legacy extractor does populate `ownerId`
+ * (C#) — no duplicates are introduced.
+ *
+ * ## Transitional shim
+ *
+ * This reconciliation pass is an explicit shim. The architectural end
+ * state is for the legacy extractor to emit the correct `ownerId` for
+ * every language at parse time, removing the need for a second pass.
+ * See ARCHITECTURE.md § "Semantic-model source of truth" for the
+ * follow-up plan.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileOwnership = reconcileOwnership;
+exports.validateOwnershipParity = validateOwnershipParity;
+const ids_js_1 = require("../graph-bridge/ids.js");
+const NESTED_TYPE_KINDS = new Set([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+    'Namespace',
+]);
+function reconcileOwnership(parsedFiles, model) {
+    let methodsRegistered = 0;
+    let fieldsRegistered = 0;
+    let nestedTypesRegistered = 0;
+    let skippedAlreadyPresent = 0;
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            const ownerId = def.ownerId;
+            const simple = (0, ids_js_1.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);
+                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;
+                }
+                model.methods.register(ownerId, simple, def);
+                methodsRegistered++;
+            }
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const existing = model.fields.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
+                    skippedAlreadyPresent++;
+                    continue;
+                }
+                model.fields.register(ownerId, simple, def);
+                fieldsRegistered++;
+            }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const existing = model.types.lookupAllByOwner(ownerId, simple);
+                if (existing.some((e) => e.nodeId === def.nodeId)) {
+                    skippedAlreadyPresent++;
+                    continue;
+                }
+                model.types.registerByOwner(ownerId, simple, def);
+                nestedTypesRegistered++;
+            }
+        }
+    }
+    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'`.
+ *
+ * Iterates every def in `parsedFiles[i].localDefs` with an `ownerId`
+ * and asserts it is reachable via `model.methods.lookupAllByOwner` or
+ * `model.fields.lookupFieldByOwner`. On mismatch: emits a warning via
+ * `onWarn` — never throws, mirroring the pipeline's soft-fail posture.
+ *
+ * This is the enforcement of Contract Invariant I9 at runtime. In
+ * production it is a no-op; in development it surfaces drift between
+ * `parsed.localDefs` and `SemanticModel` that would otherwise silently
+ * produce wrong edges.
+ */
+function validateOwnershipParity(parsedFiles, model, onWarn) {
+    if (process.env.NODE_ENV === 'production')
+        return 0;
+    if (process.env.VALIDATE_SEMANTIC_MODEL === '0')
+        return 0;
+    let mismatches = 0;
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            const ownerId = def.ownerId;
+            if (ownerId === undefined)
+                continue;
+            const simple = (0, ids_js_1.simpleQualifiedName)(def);
+            if (simple === undefined)
+                continue;
+            if (def.type === 'Method' || def.type === 'Function' || def.type === 'Constructor') {
+                const found = model.methods.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
+                    onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
+                        `owned by ${ownerId} as "${simple}" not in MethodRegistry`);
+                    mismatches++;
+                }
+            }
+            else if (def.type === 'Property' ||
+                def.type === 'Variable' ||
+                def.type === 'Const' ||
+                def.type === 'Static') {
+                const found = model.fields.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
+                    onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
+                        `owned by ${ownerId} as "${simple}" not in FieldRegistry`);
+                    mismatches++;
+                }
+            }
+            else if (NESTED_TYPE_KINDS.has(def.type)) {
+                const found = model.types.lookupAllByOwner(ownerId, simple);
+                if (!found.some((d) => d.nodeId === def.nodeId)) {
+                    onWarn(`semantic-model parity: ${def.type} ${def.nodeId} (${parsed.filePath}) ` +
+                        `owned by ${ownerId} as "${simple}" not in TypeRegistry owner index`);
+                    mismatches++;
+                }
+            }
+        }
+    }
+    return mismatches;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Per-language `ScopeResolver` registry — the lookup the generic
+ * `scopeResolutionPhase` uses to pick the right resolver for each
+ * migrated language.
+ *
+ * Adding a language is two lines: implement a `ScopeResolver` in
+ * `languages/<lang>/scope-resolver.ts` and register it here. The
+ * phase picks it up automatically — no workflow changes, no
+ * per-language pipeline phase file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCOPE_RESOLVERS = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const scope_resolver_js_1 = require("../../languages/python/scope-resolver.js");
+const scope_resolver_js_2 = require("../../languages/csharp/scope-resolver.js");
+const scope_resolver_js_3 = require("../../languages/typescript/scope-resolver.js");
+const scope_resolver_js_4 = require("../../languages/go/scope-resolver.js");
+const scope_resolver_js_5 = require("../../languages/java/scope-resolver.js");
+const scope_resolver_js_6 = require("../../languages/c/scope-resolver.js");
+const scope_resolver_js_7 = require("../../languages/cpp/scope-resolver.js");
+const scope_resolver_js_8 = require("../../languages/php/scope-resolver.js");
+const scope_resolver_js_9 = require("../../languages/rust/scope-resolver.js");
+const scope_resolver_js_10 = require("../../languages/javascript/scope-resolver.js");
+const scope_resolver_js_11 = require("../../languages/kotlin/scope-resolver.js");
+const scope_resolver_js_12 = require("../../languages/ruby/scope-resolver.js");
+const scope_resolver_js_13 = require("../../languages/swift/scope-resolver.js");
+const scope_resolver_js_14 = require("../../languages/dart/scope-resolver.js");
+const scope_resolver_js_15 = require("../../languages/vue/scope-resolver.js");
+/** Map of `SupportedLanguages` → `ScopeResolver`. The scope-resolution phase
+ *  iterates this map directly — every registered resolver runs. This is the
+ *  single source of truth for which languages resolve via scope-resolution. */
+exports.SCOPE_RESOLVERS = new Map([
+    [index_js_1.SupportedLanguages.Python, scope_resolver_js_1.pythonScopeResolver],
+    [index_js_1.SupportedLanguages.CSharp, scope_resolver_js_2.csharpScopeResolver],
+    [index_js_1.SupportedLanguages.TypeScript, scope_resolver_js_3.typescriptScopeResolver],
+    [index_js_1.SupportedLanguages.Go, scope_resolver_js_4.goScopeResolver],
+    [index_js_1.SupportedLanguages.Java, scope_resolver_js_5.javaScopeResolver],
+    [index_js_1.SupportedLanguages.C, scope_resolver_js_6.cScopeResolver],
+    [index_js_1.SupportedLanguages.CPlusPlus, scope_resolver_js_7.cppScopeResolver],
+    [index_js_1.SupportedLanguages.PHP, scope_resolver_js_8.phpScopeResolver],
+    [index_js_1.SupportedLanguages.Rust, scope_resolver_js_9.rustScopeResolver],
+    [index_js_1.SupportedLanguages.JavaScript, scope_resolver_js_10.javascriptScopeResolver],
+    [index_js_1.SupportedLanguages.Kotlin, scope_resolver_js_11.kotlinScopeResolver],
+    [index_js_1.SupportedLanguages.Ruby, scope_resolver_js_12.rubyScopeResolver],
+    [index_js_1.SupportedLanguages.Swift, scope_resolver_js_13.swiftScopeResolver],
+    [index_js_1.SupportedLanguages.Dart, scope_resolver_js_14.dartScopeResolver],
+    [index_js_1.SupportedLanguages.Vue, scope_resolver_js_15.vueScopeResolver],
+]);