gitnexus 1.6.11-rc.1 → 1.6.11-rc.2

package/dist/core/index-freshness.d.ts

@@ -1,5 +1,5 @@
 import type { RepoMeta } from '../storage/repo-manager.js';
-export declare const INDEX_INCOMPLETE_REASONS: readonly ["incremental-in-progress", "embedding-checkpoint-pending", "embedding-count-unverified", "graph-write-collapsed"];
+export declare const INDEX_INCOMPLETE_REASONS: readonly ["incremental-in-progress", "embedding-checkpoint-pending", "embedding-count-unverified", "graph-write-collapsed", "scope-extraction-unverified", "scope-extraction-failed"];
 export type IndexIncompleteReason = (typeof INDEX_INCOMPLETE_REASONS)[number];
 /**
  * Fraction of the pipeline's relationship count that must survive into the DB
@@ -77,4 +77,4 @@ export declare function detectGraphWriteCollapse(expected: number,
  */
 persisted: number | undefined): GraphWriteCollapseVerdict;
 /** Stable machine-readable reasons an index cannot be certified complete. */
-export declare function getIndexIncompleteReasons(meta: Pick<RepoMeta, 'incrementalInProgress' | 'embeddingCheckpoint' | 'graphWriteCollapsed'> | null | undefined): IndexIncompleteReason[];
+export declare function getIndexIncompleteReasons(meta: Pick<RepoMeta, 'incrementalInProgress' | 'embeddingCheckpoint' | 'graphWriteCollapsed' | 'scopeExtractionFailures' | 'scopeExtractionReceipt'> | null | undefined): IndexIncompleteReason[];

package/dist/core/index-freshness.js

@@ -1,9 +1,12 @@
 import { checkpointKind } from './embedding-checkpoint.js';
+import { scopeExtractionFailureTotal } from './ingestion/scope-resolution/scope-extraction-failures.js';
 export const INDEX_INCOMPLETE_REASONS = [
     'incremental-in-progress',
     'embedding-checkpoint-pending',
     'embedding-count-unverified',
     'graph-write-collapsed',
+    'scope-extraction-unverified',
+    'scope-extraction-failed',
 ];
 /**
  * Fraction of the pipeline's relationship count that must survive into the DB
@@ -105,6 +108,16 @@ export function getIndexIncompleteReasons(meta) {
     // from a codebase that genuinely has no such relationships.
     if (meta?.graphWriteCollapsed)
         reasons.push('graph-write-collapsed');
+    if (meta?.scopeExtractionReceipt !== 1) {
+        reasons.push('scope-extraction-unverified');
+    }
+    else {
+        const total = scopeExtractionFailureTotal(meta.scopeExtractionFailures);
+        if (total === undefined)
+            reasons.push('scope-extraction-unverified');
+        else if (total > 0)
+            reasons.push('scope-extraction-failed');
+    }
     if (meta?.embeddingCheckpoint) {
         // The three checkpoint kinds are not one operator-facing state. GUARDRAILS
         // and the runbook document `embedding-checkpoint-pending` as "N node(s)

package/dist/core/ingestion/parsing-processor.d.ts

@@ -31,6 +31,8 @@ export interface WorkerExtractedData {
      * finalize-orchestrator.
      */
     parsedFiles: ParsedFile[];
+    /** Scope-extraction omissions represented by this worker/cache result. */
+    scopeExtractionFailures: string[];
 }
 /**
  * Merge a list of `ParseWorkerResult`s into the running graph + symbol

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

@@ -57,6 +57,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
     const allORMQueries = [];
     const fileScopeBindingsByFile = [];
     const allParsedFiles = [];
+    const scopeExtractionFailures = [];
     for (const result of chunkResults) {
         // Worker jobs and input files are already merged in stable start-index/path
         // order. Canonicalize the final per-result node boundary once so graph
@@ -123,6 +124,9 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
         if (result.parsedFiles)
             for (const item of result.parsedFiles)
                 allParsedFiles.push(item);
+        for (const filePath of result.scopeExtractionFailures ?? []) {
+            scopeExtractionFailures.push(filePath);
+        }
     }
     return {
         routes: allRoutes,
@@ -139,6 +143,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
         springTypes: allSpringTypes,
         fileScopeBindings: fileScopeBindingsByFile,
         parsedFiles: allParsedFiles,
+        scopeExtractionFailures,
     };
 };
 /**

package/dist/core/ingestion/pipeline-phases/parse-impl.d.ts

@@ -99,5 +99,8 @@ export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scanned
      *  cache analyze run can skip the dominant `extractParsedFile` cost
      *  (otherwise ~58s on a 1000-file repo). */
     parsedFiles: import('../../../_shared/index.js').ParsedFile[];
+    scopeExtractionFailures: string[];
+    /** Files excluded because their non-standalone language parser was unavailable. */
+    unavailableScopeLanguageFiles: number;
 }>;
 export {};

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

@@ -366,6 +366,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             logger.warn(`Skipping ${count} ${lang} file(s) — ${lang} parser not available (native binding may not have built). Try: npm rebuild tree-sitter-${lang}`);
         }
     }
+    const unavailableScopeLanguageFiles = [...skippedByLang.values()].reduce((total, count) => total + count, 0);
     // Sort parseableScanned alphabetically for stable chunk membership
     // across runs (Finding 4). Without this, filesystem-scan order can
     // shift between runs (notably on macOS APFS where directory entry
@@ -563,6 +564,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // the second-half of the parse-cache speedup since scope-resolution's
     // re-parse otherwise dominates the warm-cache wall-clock time.
     const allParsedFiles = [];
+    const scopeExtractionFailures = new Set();
     // Incremental parse cache (Option B): chunk-level content-addressed.
     // When the chunk's (filePath, content-hash) signature matches a prior
     // run's, replay the cached ParseWorkerResult[] instead of dispatching
@@ -638,6 +640,9 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         // (which was the only path that passed null) is gone.
         const applyChunkResults = async (chunkWorkerData, chunkIdx, chunkFiles, chunkStartMs) => {
             if (chunkWorkerData) {
+                for (const filePath of chunkWorkerData.scopeExtractionFailures) {
+                    scopeExtractionFailures.add(filePath);
+                }
                 if (chunkWorkerData.parsedFiles?.length) {
                     if (parsedFileStorePath) {
                         await persistParsedFileChunk(parsedFileStorePath, `chunk-${chunkIdx}`, chunkWorkerData.parsedFiles);
@@ -1336,5 +1341,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         // cache: when the file's ParsedFile is here, scope-resolution skips its own
         // `extractParsedFile` call.
         parsedFiles: allParsedFiles,
+        scopeExtractionFailures: [...scopeExtractionFailures].sort(),
+        unavailableScopeLanguageFiles,
     };
 }

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

@@ -68,5 +68,9 @@ export interface ParseOutput {
      * costing ~58s on a 1000-file repo).
      */
     readonly parsedFiles: readonly ParsedFile[];
+    /** Files whose scope extraction failed while legacy parsing continued. */
+    readonly scopeExtractionFailures: readonly string[];
+    /** Files omitted because their non-standalone language parser was unavailable. */
+    readonly unavailableScopeLanguageFiles: number;
 }
 export declare const parsePhase: PipelinePhase<ParseOutput>;

package/dist/core/ingestion/pipeline.js

@@ -109,10 +109,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         graphEmitSink?.close();
     }
     // Extract final results for the PipelineResult contract
-    const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
+    const { totalFiles, usedWorkerPool, unavailableScopeLanguageFiles } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
     const scopeResolutionOutput = getPhaseOutput(results, 'scopeResolution');
+    const scopeExtractionFailures = scopeResolutionOutput.scopeExtractionFailures;
     const resolutionOutcomes = scopeResolutionOutput.resolutionOutcomes;
     const undecidedSatisfaction = scopeResolutionOutput.undecidedSatisfaction;
     // Streamed PDG-emit manifest (#2202): present only when streaming was on.
@@ -155,6 +156,8 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         resolutionOutcomes,
         undecidedSatisfaction,
         usedWorkerPool,
+        scopeExtractionFailures,
+        unavailableScopeLanguageFiles,
         pdgEmitManifest,
         propertyInference,
     };

package/dist/core/ingestion/scope-extractor-bridge.js

@@ -49,8 +49,14 @@ export function extractParsedFile(provider, sourceText, filePath, onWarn, cached
     }
     catch (err) {
         const message = `scope extraction failed for ${filePath}: ${err instanceof Error ? err.message : String(err)}`;
-        if (onWarn !== undefined)
-            onWarn(message);
+        if (onWarn !== undefined) {
+            try {
+                onWarn(message);
+            }
+            catch (warnErr) {
+                logger.warn(`scope extraction warning callback failed for ${filePath}: ${warnErr instanceof Error ? warnErr.message : String(warnErr)}`);
+            }
+        }
         logger.warn(message);
         return undefined;
     }

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

@@ -40,6 +40,8 @@ export interface ScopeResolutionOutput {
     readonly importsEmitted: number;
     /** Reference (CALLS / ACCESSES / INHERITS / USES) edges emitted. */
     readonly referenceEdgesEmitted: number;
+    /** Files still missing scope captures after the main-thread fallback. */
+    readonly scopeExtractionFailures: readonly string[];
     /** Additive stream of resolver diagnostics; does not affect graph edges. */
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
     /**

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

@@ -37,12 +37,14 @@ import { buildFunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
 import { buildPropertyNameIndex } from '../passes/unique-name-properties.js';
 import { PdgEmitSink } from '../../../lbug/pdg-emit-sink.js';
 import { resolveNativeSafeStorageDir } from '../../../lbug/lbug-config.js';
+import { reconcileScopeExtractionFailures } from '../scope-extraction-failures.js';
 import { logger } from '../../../logger.js';
 const NOOP_OUTPUT = Object.freeze({
     ran: false,
     filesProcessed: 0,
     importsEmitted: 0,
     referenceEdgesEmitted: 0,
+    scopeExtractionFailures: [],
     resolutionOutcomes: [],
     // Deliberately absent, not `[]`: nothing ran, so nothing was decided either.
     perLanguage: new Map(),
@@ -79,6 +81,7 @@ export const scopeResolutionPhase = {
         const { scannedFiles } = getPhaseOutput(deps, 'structure');
         const parseOutput = getPhaseOutput(deps, 'parse');
         const { model, parsedFiles: workerParsedFiles } = parseOutput;
+        const scopeExtractionFailures = new Set(parseOutput.scopeExtractionFailures);
         // SemanticModel populated during `parse`: scope-resolution consumes
         // TypeRegistry / MethodRegistry / SymbolTable lookups instead of
         // rebuilding parallel indexes. See ARCHITECTURE.md § "Semantic-model
@@ -395,6 +398,9 @@ export const scopeResolutionPhase = {
                         }
                         : undefined,
                 }, provider);
+                // Worker warnings are provisional: scope-resolution retries missing
+                // ParsedFiles on the main thread. Persist only final omissions.
+                reconcileScopeExtractionFailures(scopeExtractionFailures, files.map((file) => file.path), stats.scopeExtractionFailedPaths);
                 // 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.
@@ -503,13 +509,19 @@ export const scopeResolutionPhase = {
         // Even when no language ran, surface a finalized manifest (its CSVs are on
         // disk) so loadGraphToLbug COPYs them rather than orphaning them — empty in
         // the no-files case, harmless.
-        if (!anyRan)
-            return pdgEmitManifest ? { ...NOOP_OUTPUT, pdgEmitManifest } : NOOP_OUTPUT;
+        if (!anyRan) {
+            return {
+                ...NOOP_OUTPUT,
+                scopeExtractionFailures: [...scopeExtractionFailures].sort(),
+                ...(pdgEmitManifest ? { pdgEmitManifest } : {}),
+            };
+        }
         return {
             ran: true,
             filesProcessed: totalFiles,
             importsEmitted: totalImports,
             referenceEdgesEmitted: totalRefs,
+            scopeExtractionFailures: [...scopeExtractionFailures].sort(),
             resolutionOutcomes,
             undecidedSatisfaction,
             perLanguage,

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

@@ -190,6 +190,8 @@ interface RunScopeResolutionInput {
 interface RunScopeResolutionStats {
     readonly filesProcessed: number;
     readonly filesSkipped: number;
+    /** Files still missing a ParsedFile after the main-thread fallback. */
+    readonly scopeExtractionFailedPaths: readonly string[];
     readonly importsEmitted: number;
     readonly resolve: ResolveStats;
     readonly referenceEdgesEmitted: number;

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

@@ -250,6 +250,7 @@ export function runScopeResolution(input, provider) {
     };
     // ── Phase 1: extract each file → ParsedFile ────────────────────────────
     const parsedFiles = [];
+    const scopeExtractionFailedPaths = [];
     let filesSkipped = 0;
     const treeCache = input.treeCache;
     const preExtracted = input.preExtractedParsedFiles;
@@ -273,9 +274,15 @@ export function runScopeResolution(input, provider) {
         }
         if (parsed === undefined) {
             const cachedTree = treeCache?.get(file.path);
-            parsed = extractParsedFile(provider.languageProvider, file.content, file.path, onWarn, cachedTree);
+            let extractionWarned = false;
+            parsed = extractParsedFile(provider.languageProvider, file.content, file.path, (warning) => {
+                extractionWarned = true;
+                onWarn(warning);
+            }, cachedTree);
             if (parsed === undefined) {
                 filesSkipped++;
+                if (extractionWarned)
+                    scopeExtractionFailedPaths.push(file.path);
                 continue;
             }
         }
@@ -314,6 +321,7 @@ export function runScopeResolution(input, provider) {
         return {
             filesProcessed: parsedFiles.length,
             filesSkipped,
+            scopeExtractionFailedPaths,
             importsEmitted: 0,
             resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
             referenceEdgesEmitted: 0,
@@ -349,6 +357,7 @@ export function runScopeResolution(input, provider) {
         return {
             filesProcessed: 0,
             filesSkipped,
+            scopeExtractionFailedPaths,
             importsEmitted: 0,
             resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
             referenceEdgesEmitted: 0,
@@ -1136,6 +1145,7 @@ export function runScopeResolution(input, provider) {
     return {
         filesProcessed: parsedFiles.length,
         filesSkipped,
+        scopeExtractionFailedPaths,
         importsEmitted,
         resolve: resolveStats,
         referenceEdgesEmitted: emitted +

package/dist/core/ingestion/scope-resolution/scope-extraction-failures.d.ts

@@ -0,0 +1,14 @@
+export interface ScopeExtractionFailureSummary {
+    /** Exact number of unique files whose scope extraction failed. */
+    readonly total: number;
+    /** Deterministic sample of repo-relative paths for diagnostics. */
+    readonly paths: readonly string[];
+    /** True when `paths` is a capped sample rather than the full set. */
+    readonly truncated?: boolean;
+}
+export declare const SCOPE_EXTRACTION_FAILURE_PATH_LIMIT = 25;
+/** Read a persisted summary without trusting its runtime JSON shape. */
+export declare function scopeExtractionFailureTotal(summary: unknown): number | undefined;
+/** Replace provisional worker failures with the final fallback outcome. */
+export declare function reconcileScopeExtractionFailures(failures: Set<string>, attemptedPaths: readonly string[], failedPaths: readonly string[]): void;
+export declare function summarizeScopeExtractionFailures(paths?: readonly string[], limit?: number): ScopeExtractionFailureSummary | undefined;

package/dist/core/ingestion/scope-resolution/scope-extraction-failures.js

@@ -0,0 +1,35 @@
+export const SCOPE_EXTRACTION_FAILURE_PATH_LIMIT = 25;
+/** Read a persisted summary without trusting its runtime JSON shape. */
+export function scopeExtractionFailureTotal(summary) {
+    if (summary === undefined)
+        return 0;
+    if (typeof summary !== 'object' || summary === null)
+        return undefined;
+    const total = summary.total;
+    if (total === 0)
+        return 0;
+    return typeof total === 'number' && Number.isInteger(total) && total > 0 ? total : undefined;
+}
+/** Replace provisional worker failures with the final fallback outcome. */
+export function reconcileScopeExtractionFailures(failures, attemptedPaths, failedPaths) {
+    const stillFailed = new Set(failedPaths);
+    for (const filePath of attemptedPaths) {
+        if (stillFailed.has(filePath))
+            failures.add(filePath);
+        else
+            failures.delete(filePath);
+    }
+}
+export function summarizeScopeExtractionFailures(paths = [], limit = SCOPE_EXTRACTION_FAILURE_PATH_LIMIT) {
+    const unique = [
+        ...new Set(paths.filter((path) => typeof path === 'string' && path.length > 0)),
+    ].sort();
+    if (unique.length === 0)
+        return undefined;
+    const boundedLimit = Number.isInteger(limit) && limit >= 0 ? limit : SCOPE_EXTRACTION_FAILURE_PATH_LIMIT;
+    return {
+        total: unique.length,
+        paths: unique.slice(0, boundedLimit),
+        ...(unique.length > boundedLimit ? { truncated: true } : {}),
+    };
+}

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -270,6 +270,12 @@ export interface ParseWorkerResult {
      * finalize-orchestrator.
      */
     parsedFiles: ParsedFile[];
+    /**
+     * Repo-relative paths whose scope-capture/extraction step threw. Optional for
+     * parse-cache compatibility; unlike transient worker telemetry this must be
+     * replayed on a cache hit so the persisted index cannot claim completeness.
+     */
+    scopeExtractionFailures?: string[];
     skippedLanguages: Record<string, number>;
     /**
      * Files whose parse output carried a value the structured-clone algorithm

package/dist/core/ingestion/workers/parse-worker.js

@@ -1039,7 +1039,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // see parsedfile-store.ts). parse-impl flushes `result.parsedFiles` to disk
         // per chunk and does NOT retain them in main-thread heap, so this no longer
         // costs ~1× the semantic model in RAM during parse.
-        const parsedFile = extractParsedFile(provider, parseContent, file.path, reportWarning, tree, scopeSourceKind);
+        let scopeExtractionFailed = false;
+        const parsedFile = extractParsedFile(provider, parseContent, file.path, (message) => {
+            scopeExtractionFailed = true;
+            reportWarning(message);
+        }, tree, scopeSourceKind);
+        if (scopeExtractionFailed)
+            (result.scopeExtractionFailures ??= []).push(file.path);
         if (parsedFile !== undefined) {
             // Capture-time side-channel (#1983): `extractParsedFile` just ran the
             // provider's `emitScopeCaptures`, which (for C++ ADL/namespace marks,

package/dist/core/ingestion/workers/result-merge.js

@@ -45,11 +45,14 @@ export const mergeResult = (target, src) => {
     appendAll(target.constructorBindings, src.constructorBindings);
     appendAll(target.fileScopeBindings, src.fileScopeBindings);
     appendAll(target.parsedFiles, src.parsedFiles);
+    if (src.scopeExtractionFailures && src.scopeExtractionFailures.length > 0) {
+        appendAll((target.scopeExtractionFailures ??= []), src.scopeExtractionFailures);
+    }
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
     if (src.skippedPaths && src.skippedPaths.length > 0) {
-        (target.skippedPaths ??= []).push(...src.skippedPaths);
+        appendAll((target.skippedPaths ??= []), src.skippedPaths);
     }
     target.fileCount += src.fileCount;
 };

package/dist/core/run-analyze.js

@@ -18,6 +18,7 @@ import { acquireIndexLock } from '../storage/index-lock.js';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { logUnresolvedReceiverFiles, summarizeUnresolvedReceivers, } from './ingestion/scope-resolution/unresolved-receivers.js';
 import { summarizeUndecidedSatisfaction } from './ingestion/scope-resolution/undecided-satisfaction.js';
+import { summarizeScopeExtractionFailures } from './ingestion/scope-resolution/scope-extraction-failures.js';
 import { resetDegradedParseCounter } from './tree-sitter/safe-parse.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, ensureEmbeddingRowDmlSafe, ensureFtsRowDmlSafe, readIndexCatalogSnapshot, INDEX_CATALOG_UNREADABLE, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, deleteAllAdvisedBy, deleteSpringAopEvidenceNodes, deleteSpringAutoConfigurationDeclarations, deleteSpringAutoConfigurationSyntheticClasses, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
 import { estimateBufferPool, setBufferPoolSizeHint, resolveNativeSafeStorageDir, } from './lbug/lbug-config.js';
@@ -2802,6 +2803,11 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             // Git-only: non-git repos never take the incremental path.
             schemaFingerprint: hasGitDir(repoPath) ? SCHEMA_FINGERPRINT : undefined,
             unresolvedReceiverMembers: summarizeUnresolvedReceivers(resolutionOutcomes),
+            scopeExtractionFailures: summarizeScopeExtractionFailures(pipelineResult.scopeExtractionFailures),
+            // A receipt certifies that every scope-capable source file was inspected.
+            // Optional grammars may be unavailable by design; omitting the receipt in
+            // that case makes readers report an unverified lower bound.
+            scopeExtractionReceipt: pipelineResult.unavailableScopeLanguageFiles === 0 ? 1 : undefined,
             // Carried forward ONLY when this run could not measure — `saveMeta` writes
             // a fresh object, so omitting the key deletes a prior record and turns a
             // hedged answer back into a confident one. A run that DID measure always

package/dist/mcp/local/local-backend.d.ts

@@ -87,6 +87,8 @@ export interface CodebaseContext {
  * number of SENTENCES, which has no relation to how much is missing.
  */
 export interface EpistemicCauses {
+    /** Files whose scope-extraction output is absent from this index. */
+    readonly scopeExtractionFiles: number;
     /**
      * Call SITES dropped at index time because the receiver's type could not be
      * established. Unit: call sites, taken from the index's

package/dist/mcp/local/local-backend.js

@@ -57,6 +57,7 @@ import { decodeReachingDefReason } from '../../core/ingestion/cfg/reaching-def-r
 import { EXTENSIONS } from '../../core/ingestion/import-resolvers/utils.js';
 import { compareCodeUnits } from '../../lib/utils.js';
 import { lookupExternalCallCount, lookupUnresolvedCallCount, } from '../../core/ingestion/scope-resolution/unresolved-receivers.js';
+import { scopeExtractionFailureTotal } from '../../core/ingestion/scope-resolution/scope-extraction-failures.js';
 import { lookupCount } from '../../core/ingestion/scope-resolution/summary-maps.js';
 import { DEFERRED_IMPORT_REASON_SUFFIX, TYPE_ONLY_IMPORT_REASON_SUFFIX, } from '../../core/ingestion/scope-resolution/graph-bridge/imports-to-edges.js';
 import { fnLineOf, isPdgDegradedLayerStatus, makePdgImpactErrorResult, makePdgLayerDegradedResult, pdgLayerStatus, pdgStampForMode, runImpactPDG, validateImpactMode, pdgBridgeEvidenceForImpact, betterBridgeEvidence, composeUnifiedPdgImpactResult, splitCalleeIds, } from './pdg-impact.js';
@@ -464,6 +465,7 @@ function epistemicFrom(dropped) {
             ? {
                 epistemic: 'exact',
                 causes: {
+                    scopeExtractionFiles: dropped.scopeExtraction,
                     receiverTyping: 0,
                     dispatchBoundary: dropped.dispatch,
                     externalBoundary: dropped.external,
@@ -479,6 +481,7 @@ function epistemicFrom(dropped) {
             // prose saying `2 call sites` — a consumer branching on the number
             // would read a different magnitude than the human reading the text.
             causes: {
+                scopeExtractionFiles: dropped.scopeExtraction,
                 receiverTyping: dropped.sites,
                 dispatchBoundary: dropped.dispatch,
                 externalBoundary: dropped.external,
@@ -486,6 +489,28 @@ function epistemicFrom(dropped) {
             },
         };
 }
+function scopeExtractionBoundaries(summary, receipt) {
+    const unknown = {
+        notes: [
+            'Scope-extraction completeness was not recorded for this index, so actual impact may be higher.',
+        ],
+        files: 0,
+    };
+    if (receipt !== 1)
+        return unknown;
+    const total = scopeExtractionFailureTotal(summary);
+    if (total === undefined)
+        return unknown;
+    if (total === 0)
+        return { notes: [], files: 0 };
+    return {
+        notes: [
+            `Scope extraction failed for ${total} ${total === 1 ? 'file' : 'files'} while this index was built. ` +
+                `Scope-resolution edges from ${total === 1 ? 'that file are' : 'those files are'} absent, so actual impact may be higher.`,
+        ],
+        files: total,
+    };
+}
 /**
  * Boundary notes for call sites the analyzer dropped because it could not type
  * their receiver, when the queried symbol's name is among them (#2744).
@@ -5561,6 +5586,7 @@ export class LocalBackend {
             meta = undefined;
         }
         const receiverDrops = unresolvedReceiverBoundaries(meta?.unresolvedReceiverMembers, symName);
+        const scopeExtractionDrops = scopeExtractionBoundaries(meta?.scopeExtractionFailures, meta?.scopeExtractionReceipt);
         // #2873 — satisfaction checks the analyzer never completed. Read on the
         // same footing as the receiver drops, and BEFORE the heritage probe for the
         // same reason: this cause leaves no edge for that probe to find, so a
@@ -5592,6 +5618,7 @@ export class LocalBackend {
             ...receiverDrops,
             notes: [
                 ...receiverDrops.notes,
+                ...scopeExtractionDrops.notes,
                 ...undecidedDrops.notes,
                 ...(convexDispatch === undefined ? [] : [convexDispatch.boundary]),
             ],
@@ -5600,6 +5627,7 @@ export class LocalBackend {
             // count of omitted symbols. Keep the magnitude at zero rather than
             // inventing one from the presence of a note.
             dispatch: 0,
+            scopeExtraction: scopeExtractionDrops.files,
         };
         try {
             // Discover the interface / abstract supertypes on the target's boundary.
@@ -5675,6 +5703,7 @@ export class LocalBackend {
                 epistemic: 'lower-bound',
                 boundaries: [...droppedBoundaries.notes, ...boundaries],
                 causes: {
+                    scopeExtractionFiles: droppedBoundaries.scopeExtraction,
                     receiverTyping: droppedBoundaries.sites,
                     dispatchBoundary: droppedBoundaries.dispatch + dispatchBoundarySymbols,
                     externalBoundary: droppedBoundaries.external,

package/dist/mcp/tools.js

@@ -248,13 +248,14 @@ NOTE: ACCESSES edges (field read/write tracking) are included in context results
 COMPLETENESS OF incoming: alongside symbol/incoming/outgoing the result carries the same epistemic envelope impact() returns:
 - epistemic: 'exact' | 'lower-bound' — 'lower-bound' means callers exist that this view provably does not list.
 - boundaries: string[] — one plain-language sentence per reason. Prose for humans; branch on causes instead.
-- causes: { receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — machine-readable WHY. Every field counts MISSING THINGS, never sentences:
+- causes: { scopeExtractionFiles, receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — machine-readable WHY. Every field counts MISSING THINGS, never sentences:
+  - causes.scopeExtractionFiles (unit: files) > 0 — scope extraction still failed after the fallback pass, so scope-resolution edges from those files are absent. A value of 0 does not prove completeness when epistemic is 'lower-bound' because an older or unverified index has no measured file count. Re-run \`gitnexus analyze --force\`; if the reason persists, inspect the extraction warnings.
   - causes.receiverTyping (unit: call sites) > 0 — RESOLVER GAP: the analyzer dropped that many call sites on this name because it could not type the receiver, so they are missing from incoming. Do not read an absent caller as proof none exists.
   - causes.externalBoundary (unit: call sites) > 0 — the calls left the indexed program (System.out.println, fetch(...)). NOT a defect: no in-graph node could have been reached. An epistemic:'exact' result can carry this.
   - causes.dispatchBoundary (unit: symbols) > 0 — DI or interface dispatch: that many symbols sit on or beyond a boundary static analysis cannot cross. Irreducible. A symbol count, not a site count — per-site multiplicity is not retained for these edges — so compare its magnitude with receiverTyping, not its exact value. A framework runtime-proxy boundary can make epistemic lower-bound while this value remains 0 because endpoint metadata proves the gap but cannot count omitted symbols.
   - causes.undecidedSatisfaction (unit: unjudged interface/type pairs) > 0 — the analyzer could not decide whether a type satisfies an interface, so no IMPLEMENTS edge exists and no dispatch boundary was left for the walk to notice. Usually fixable by making the missing dependency available to analysis.
 
-REQUIRES RE-INDEX: causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
+REQUIRES RE-INDEX: causes.scopeExtractionFiles, causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
 
 GROUP MODE: set "repo" to "@<groupName>" to run context in each member repo (aggregated list), or "@<groupName>/<groupRepoPath>" for one member. If you use "@<groupName>" only, the member defaults to the lexicographically first key in group.yaml "repos".
 
@@ -438,14 +439,15 @@ Output includes:
 - byDepth: affected symbols grouped by traversal depth (paginated by limit/offset; omitted when summaryOnly:true — use byDepthCounts for totals per depth, pagination object when truncated). Each item includes a processes:[{id,label,processType,step}] field listing the execution flows that symbol participates in. Empty when the symbol has no process membership. Can ALSO be empty when partial:true is set — either the process-aggregation pass hit its cap before detecting affected processes, or per-symbol enrichment was capped on a very large page. When partial:true, do NOT treat processes:[] as proof of no participation; cross-check the top-level affected_processes list.
 - epistemic: 'exact' | 'lower-bound' — whether impactedCount is the whole story. 'lower-bound' means the walk provably missed callers, so the count is a floor. Absent only on skipped probes (ambiguous-candidate lists, group fan-out).
 - boundaries: string[] — one plain-language sentence per reason the count is short. Prose for humans; branch on causes instead.
-- causes: { receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — the machine-readable split of WHY, so an agent gating its own edits can tell a fixable analyzer gap from an irreducible one. Every field counts MISSING THINGS, never sentences:
+- causes: { scopeExtractionFiles, receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — the machine-readable split of WHY, so an agent gating its own edits can tell a fixable analyzer gap from an irreducible one. Every field counts MISSING THINGS, never sentences:
+  - causes.scopeExtractionFiles (unit: files) > 0 — scope extraction still failed after the fallback pass, so scope-resolution edges from those files are absent. A value of 0 does not prove completeness when epistemic is 'lower-bound' because an older or unverified index has no measured file count. Re-run \`gitnexus analyze --force\`; if the reason persists, inspect the extraction warnings.
   - causes.receiverTyping (unit: call sites) > 0 — the RESOLVER GAP signal: the analyzer dropped that many call sites because it could not establish the receiver's type (unresolved constructor, factory, chained expression). Those callers are absent from byDepth. Treat the result as incomplete: grep the symbol name before deleting or renaming.
   - causes.externalBoundary (unit: call sites) > 0 — those calls left the indexed program (System.out.println, fetch(...), os.environ.*). NOT a defect and NOT a reason the count is short: there is no in-graph node any edge could have reached. An epistemic:'exact' result can carry this.
   - causes.dispatchBoundary (unit: symbols) > 0 — DI or interface dispatch: that many symbols sit on or beyond a boundary a static walk cannot cross. Irreducible. A symbol count, not a site count — per-site multiplicity is not retained for these edges — so compare its magnitude with receiverTyping, not its exact value. A framework runtime-proxy boundary can make epistemic lower-bound while this value remains 0 because endpoint metadata proves the gap but cannot count omitted symbols.
 
   - causes.undecidedSatisfaction (unit: unjudged interface/type pairs) > 0 — the analyzer could not DECIDE whether a type satisfies an interface (a type in a required signature named a package it could not resolve), so no IMPLEMENTS edge exists and no dispatch boundary was left for the walk to notice. Distinct from every cause above, which count decided facts that could not be attributed; this one counts questions never answered. It is the only cause that shortens a result WITHOUT leaving a trace in the graph, so an unhedged zero on a symbol reached only through such an interface would otherwise read as 'nobody calls this'. Usually fixable: it most often means a dependency is missing from the analyzed tree.
 
-REQUIRES RE-INDEX: causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
+REQUIRES RE-INDEX: causes.scopeExtractionFiles, causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
 
 Depth groups:
 - d=1: WILL BREAK (direct callers/importers)

package/dist/storage/parse-cache.js

@@ -621,11 +621,11 @@ import { fileURLToPath } from 'url';
 // the re-check line below is for, and why it says AT MERGE rather than
 // when you pick the number.
 //
-// 77 is free at this merge: origin/main is 76, and the open PRs touching this
-// constant are #2840 (a stale 71) and #1616 (a stale 2). Scan with the contents
-// API at each PR head, not `gh pr diff` — that exits non-zero on an
-// inaccessible fork and prints nothing, so a grep over its output skips the PR
-// silently. #2840 was missed exactly that way this round.
+// 78 was claimed concurrently by #3060 while this branch was in review. Both
+// branches keep the same package version, so sharing 78 would replay
+// incompatible worker output without a textual merge conflict. This branch
+// therefore takes 79, the next free value above origin/main and every open PR
+// found by the contents-API scan at their exact head SHAs.
 //
 // WHY THIS IS STILL A HAND-PICKED NUMBER, when `SCHEMA_FINGERPRINT` next door
 // is a derived sha256 that cannot collide. The derivation exists and already
@@ -645,7 +645,7 @@ import { fileURLToPath } from 'url';
 // `route-extractors/` and `workers/` module content — would close the missing-
 // bump axis without invalidating on unrelated churn, and is the real follow-up.
 // RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
-const SCHEMA_BUMP = 77;
+const SCHEMA_BUMP = 79;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/dist/storage/repo-meta.d.ts

@@ -21,11 +21,12 @@
  * `isMissingFilesystemError`) so every existing import site keeps working
  * unchanged.
  *
- * Imports `node:fs`/`node:path` and two type-only shapes. Keep it that way: a
+ * Imports `node:fs`/`node:path` and a few type-only summary shapes. Keep it that way: a
  * value import here would land in every consumer of `storage/`.
  */
 import type { UnresolvedReceiverSummary } from '../core/ingestion/scope-resolution/unresolved-receivers.js';
 import type { UndecidedSatisfactionSummary } from '../core/ingestion/scope-resolution/undecided-satisfaction.js';
+import type { ScopeExtractionFailureSummary } from '../core/ingestion/scope-resolution/scope-extraction-failures.js';
 /** The `.gitnexus` directory name, relative to a repo root. */
 export declare const GITNEXUS_DIR = ".gitnexus";
 export declare const INDEX_METADATA_FILE = "gitnexus.json";
@@ -240,6 +241,21 @@ export interface RepoMeta {
      * this adds no runtime dependency from storage/ on core/.
      */
     unresolvedReceiverMembers?: UnresolvedReceiverSummary;
+    /**
+     * Files omitted from scope-resolution because their provider capture or
+     * extraction step threw. The rest of each file may still be present in the
+     * graph, so this is an index-completeness signal rather than a parse failure.
+     * Absent means the successful run recorded no such omission; older indexes
+     * also read as absent until re-analyzed.
+     */
+    scopeExtractionFailures?: ScopeExtractionFailureSummary;
+    /**
+     * Completeness receipt for scope extraction in the successful run represented
+     * by this metadata. A missing or different value means completeness is
+     * unknown (legacy, malformed, or unreadable metadata), not that zero files
+     * were omitted.
+     */
+    scopeExtractionReceipt?: 1;
     /**
      * Interfaces whose structural-satisfaction check this run could not COMPLETE
      * (#2873) — not interfaces found to have no implementors.

package/dist/storage/repo-meta.js

@@ -21,7 +21,7 @@
  * `isMissingFilesystemError`) so every existing import site keeps working
  * unchanged.
  *
- * Imports `node:fs`/`node:path` and two type-only shapes. Keep it that way: a
+ * Imports `node:fs`/`node:path` and a few type-only summary shapes. Keep it that way: a
  * value import here would land in every consumer of `storage/`.
  */
 import fs from 'fs/promises';

package/dist/types/pipeline.d.ts

@@ -38,6 +38,10 @@ export interface PipelineResult {
      * affordance so regression suites can prove the pool engaged.
      */
     usedWorkerPool: boolean;
+    /** Files omitted from scope-resolution while the rest of analysis continued. */
+    scopeExtractionFailures: readonly string[];
+    /** Files scope resolution could not inspect because their parser was unavailable. */
+    unavailableScopeLanguageFiles: number;
     /**
      * Streamed PDG-emit COPY manifest (#2202). Present only when streaming/chunked
      * PDG emit was active (full rebuild + `--pdg` + enabled): the BasicBlock node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.1",
+  "version": "1.6.11-rc.2",
   "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",