gitnexus 1.6.6-rc.48 → 1.6.6-rc.49

package/dist/core/ingestion/pipeline.js

@@ -62,6 +62,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
+    const resolutionOutcomes = getPhaseOutput(results, 'scopeResolution').resolutionOutcomes;
     if (!options?.skipGraphPhases) {
         communityResult = getPhaseOutput(results, 'communities').communityResult;
         processResult = getPhaseOutput(results, 'processes').processResult;
@@ -84,6 +85,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         totalFileCount: totalFiles,
         communityResult,
         processResult,
+        resolutionOutcomes,
         usedWorkerPool,
     };
 };

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

@@ -23,6 +23,7 @@ import type { SemanticModel } from '../../model/semantic-model.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
+import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 import { type ConversionRankFn } from './overload-narrowing.js';
 export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, _referenceIndex: {
     readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
@@ -51,6 +52,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  fail at the call site. Three-valued; `'unknown'` keeps the
      *  candidate (monotonicity). */
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
+    readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
 }): number;
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +

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

@@ -86,7 +86,18 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                                 // Cross-file candidates are shadowing; keep first-match.
                                 const sameFile = narrowed.every((d) => d.filePath === narrowed[0].filePath);
                                 if (sameFile) {
-                                    handledSites.add(`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`);
+                                    recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                        phase: 'free-call-fallback',
+                                        filePath: parsed.filePath,
+                                        name: site.name,
+                                        range: site.atRange,
+                                        reason: suppressionReasonForOverload(narrowed, site.arity, {
+                                            conversionRankFn: options.conversionRankFn,
+                                            argumentTypes: site.argumentTypes,
+                                        }),
+                                        candidates: narrowed,
+                                    });
+                                    handledSites.add(siteKey(parsed.filePath, site));
                                     continue;
                                 }
                             }
@@ -109,7 +120,19 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             argumentTypes: site.argumentTypes,
                             atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
                         }, parsed, scopes, parsedFiles);
-                    const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+                    const key = siteKey(parsed.filePath, site);
+                    if (adlSuppressed && ordinary.length === 0) {
+                        recordSuppressedOutcome(options.recordResolutionOutcome, {
+                            phase: 'free-call-fallback',
+                            filePath: parsed.filePath,
+                            name: site.name,
+                            range: site.atRange,
+                            reason: 'adl-ordinary-lookup-blocked',
+                            candidates: ordinary,
+                        });
+                        handledSites.add(key);
+                        continue;
+                    }
                     if (adl === undefined || adl.length === 0) {
                         // No ADL contribution. Default behavior: `ordinary[0]` —
                         // scope-chain walk preserves local-shadows-import precedence.
@@ -135,7 +158,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                                 fnDef = narrowed[0];
                             }
                             else if (narrowed.length === 0) {
-                                handledSites.add(siteKey);
+                                handledSites.add(key);
                                 continue;
                             }
                             else {
@@ -145,7 +168,18 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                                 // first-match (shadowing semantics).
                                 const sameFile = narrowed.every((d) => d.filePath === narrowed[0].filePath);
                                 if (sameFile) {
-                                    handledSites.add(siteKey);
+                                    recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                        phase: 'free-call-fallback',
+                                        filePath: parsed.filePath,
+                                        name: site.name,
+                                        range: site.atRange,
+                                        reason: suppressionReasonForOverload(narrowed, site.arity, {
+                                            conversionRankFn: options.conversionRankFn,
+                                            argumentTypes: site.argumentTypes,
+                                        }),
+                                        candidates: narrowed,
+                                    });
+                                    handledSites.add(key);
                                     continue;
                                 }
                                 fnDef = ordinary[0];
@@ -174,17 +208,28 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             fnDef = narrowed[0];
                         }
                         else if (narrowed.length === 0) {
-                            handledSites.add(siteKey);
+                            handledSites.add(key);
                             continue;
                         }
                         else if (narrowed.length > 1) {
+                            recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                phase: 'free-call-fallback',
+                                filePath: parsed.filePath,
+                                name: site.name,
+                                range: site.atRange,
+                                reason: suppressionReasonForOverload(narrowed, site.arity, {
+                                    conversionRankFn: options.conversionRankFn,
+                                    argumentTypes: site.argumentTypes,
+                                }),
+                                candidates: narrowed,
+                            });
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
-                                handledSites.add(siteKey);
+                                handledSites.add(key);
                                 continue;
                             }
                             // Multiple survivors remain after conversion-rank scoring;
                             // suppress instead of picking arbitrarily.
-                            handledSites.add(siteKey);
+                            handledSites.add(key);
                             continue;
                         }
                     }
@@ -215,7 +260,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // Always mark the site as handled — even when the dedup-collapse
             // means we don't add a new edge — so `emit-references` skips its
             // potentially-wrong fallback for the same site.
-            handledSites.add(`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`);
+            handledSites.add(siteKey(parsed.filePath, site));
             const relId = `rel:CALLS:${callerGraphId}->${tgtGraphId}`;
             if (seen.has(relId))
                 continue;
@@ -235,6 +280,31 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     }
     return emitted;
 }
+function siteKey(filePath, site) {
+    return `${filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+}
+function suppressionReasonForOverload(candidates, arity, ctx) {
+    if (isOverloadAmbiguousAfterNormalization(candidates, arity)) {
+        return 'overload-ambiguous-normalization';
+    }
+    if (ctx.conversionRankFn !== undefined &&
+        ctx.argumentTypes !== undefined &&
+        ctx.argumentTypes.length > 0) {
+        return 'conversion-rank-tied';
+    }
+    return 'overload-ambiguous';
+}
+function recordSuppressedOutcome(record, input) {
+    record?.({
+        kind: 'suppressed',
+        phase: input.phase,
+        filePath: input.filePath,
+        name: input.name,
+        range: input.range,
+        reason: input.reason,
+        candidateIds: input.candidates.map((d) => d.nodeId),
+    });
+}
 /**
  * Build a `simpleName -> callable defs` index from `scopes.defs` once per
  * pass. Mirrors the filter the old per-site scan applied: Function /

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

@@ -43,11 +43,14 @@ import type { SemanticModel } from '../../model/semantic-model.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
 type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
-export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel): number;
+export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel, options?: {
+    readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
+}): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate
  * sharing identical normalized parameter-types. Callers should suppress

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

@@ -84,7 +84,7 @@ function resolveClassBindingForName(scopeId, rawClassName, scopes) {
     }
     return findClassBindingInScope(scopeId, baseName, scopes);
 }
-export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, handledSites, provider, index, model) {
+export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, handledSites, provider, index, model, options = {}) {
     let emitted = 0;
     // Per-pass dedup so the multiple cases don't double-emit if two of
     // them resolve the same site to the same target. NEVER pre-seed
@@ -372,6 +372,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (memberDef === 'ambiguous') {
                     // Same-name ambiguity across inline-namespace children (#1564):
                     // suppress edge emission, mark site handled.
+                    options.recordResolutionOutcome?.({
+                        kind: 'suppressed',
+                        phase: 'receiver-bound-calls',
+                        filePath: parsed.filePath,
+                        name: site.name,
+                        range: site.atRange,
+                        reason: 'inline-ns-ambiguous',
+                        candidateIds: [],
+                    });
                     handledSites.add(siteKey);
                     continue;
                 }
@@ -518,6 +527,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
                     let ambiguous = false;
+                    let ambiguousOwnerId;
                     // Track whether the chain walk filtered out any static-only
                     // candidates. When it did and the chain ended with no
                     // legitimate instance member, we mark the site as handled so
@@ -549,6 +559,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         const picked = pickFirstNonStaticOnly(ownerId, memberName, site, model, provider);
                         if (picked === OVERLOAD_AMBIGUOUS) {
                             ambiguous = true;
+                            ambiguousOwnerId = ownerId;
                             break;
                         }
                         if (picked === STATIC_ONLY_FILTERED) {
@@ -570,6 +581,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         // Suppress and mark handled so `emitReferencesViaLookup`
                         // doesn't re-emit the pre-resolved reference. See
                         // OVERLOAD_AMBIGUOUS docstring for the upstream cause.
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId ?? ownerDef.nodeId, memberName, model, provider);
                         handledSites.add(siteKey);
                         continue;
                     }
@@ -634,6 +646,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 const ownerGraphId = resolveDefGraphId(valueDef.filePath, valueDef, nodeLookup) ?? valueDef.nodeId;
                 const picked = pickOverload(ownerGraphId, memberName, site, model, provider);
                 if (picked === OVERLOAD_AMBIGUOUS) {
+                    recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ownerGraphId, memberName, model, provider);
                     handledSites.add(siteKey);
                     continue;
                 }
@@ -798,3 +811,32 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
         return OVERLOAD_AMBIGUOUS;
     return candidates[0] ?? overloads[0];
 }
+function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memberName, model, provider) {
+    if (record === undefined)
+        return;
+    const overloads = model.methods.lookupAllByOwner(ownerId, memberName);
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
+        conversionRankFn: provider.conversionRankFn,
+        constraintCompatibility: provider.constraintCompatibility,
+    });
+    const reason = isOverloadAmbiguousAfterNormalization(candidates, site.arity)
+        ? 'overload-ambiguous-normalization'
+        : hasConversionRankingSignal(site, provider)
+            ? 'conversion-rank-tied'
+            : 'overload-ambiguous';
+    record({
+        kind: 'suppressed',
+        phase: 'receiver-bound-calls',
+        filePath,
+        name: site.name,
+        range: site.atRange,
+        reason,
+        candidateIds: candidates.map((d) => d.nodeId),
+    });
+}
+function hasConversionRankingSignal(site, provider) {
+    return (provider.conversionRankFn !== undefined &&
+        site.argumentTypes !== undefined &&
+        site.argumentTypes.length > 0);
+}

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

@@ -28,6 +28,7 @@
  */
 import type { PipelinePhase } from '../../pipeline-phases/types.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import type { ResolutionOutcome } from '../resolution-outcome.js';
 export interface ScopeResolutionOutput {
     /** True when at least one language ran. */
     readonly ran: boolean;
@@ -37,6 +38,8 @@ export interface ScopeResolutionOutput {
     readonly importsEmitted: number;
     /** Reference (CALLS / ACCESSES / INHERITS / USES) edges emitted. */
     readonly referenceEdgesEmitted: number;
+    /** Additive stream of resolver diagnostics; does not affect graph edges. */
+    readonly resolutionOutcomes: readonly ResolutionOutcome[];
     /** Per-language breakdown for telemetry / shadow-parity. */
     readonly perLanguage: ReadonlyMap<SupportedLanguages, {
         readonly filesProcessed: number;

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

@@ -39,6 +39,7 @@ const NOOP_OUTPUT = Object.freeze({
     filesProcessed: 0,
     importsEmitted: 0,
     referenceEdgesEmitted: 0,
+    resolutionOutcomes: [],
     perLanguage: new Map(),
 });
 export const scopeResolutionPhase = {
@@ -84,6 +85,7 @@ export const scopeResolutionPhase = {
         let totalImports = 0;
         let totalRefs = 0;
         let anyRan = false;
+        const resolutionOutcomes = [];
         const perLanguage = new Map();
         for (const [lang, provider] of SCOPE_RESOLVERS) {
             if (!isRegistryPrimary(lang))
@@ -113,6 +115,9 @@ export const scopeResolutionPhase = {
                 treeCache: scopeTreeCache,
                 resolutionConfig,
                 preExtractedParsedFiles: preExtractedByPath,
+                recordResolutionOutcome: (outcome) => {
+                    resolutionOutcomes.push(outcome);
+                },
                 onWarn: (msg) => {
                     if (isSemanticModelValidatorEnabled()) {
                         logger.warn(`[scope-resolution:${lang}] ${msg}`);
@@ -146,6 +151,7 @@ export const scopeResolutionPhase = {
             filesProcessed: totalFiles,
             importsEmitted: totalImports,
             referenceEdgesEmitted: totalRefs,
+            resolutionOutcomes,
             perLanguage,
         };
     },

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

@@ -27,6 +27,7 @@ import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { MutableSemanticModel } from '../../model/semantic-model.js';
 import { type ResolveStats } from '../../resolve-references.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
+import type { ResolutionOutcome, ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 interface RunScopeResolutionInput {
     readonly graph: KnowledgeGraph;
     /**
@@ -78,6 +79,11 @@ interface RunScopeResolutionInput {
      * Cache miss is safe — falls back to fresh extract.
      */
     readonly preExtractedParsedFiles?: ReadonlyMap<string, ParsedFile>;
+    /**
+     * Optional additive diagnostics sink. Resolver passes call this when they
+     * intentionally suppress an edge; the graph remains unchanged.
+     */
+    readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
 }
 interface RunScopeResolutionStats {
     readonly filesProcessed: number;
@@ -86,6 +92,7 @@ interface RunScopeResolutionStats {
     readonly resolve: ResolveStats;
     readonly referenceEdgesEmitted: number;
     readonly referenceSkipped: number;
+    readonly resolutionOutcomes: readonly ResolutionOutcome[];
 }
 export declare function runScopeResolution(input: RunScopeResolutionInput, provider: ScopeResolver): RunScopeResolutionStats;
 export {};

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

@@ -94,6 +94,11 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
     const onWarn = input.onWarn ?? (() => { });
+    const resolutionOutcomes = [];
+    const recordResolutionOutcome = (outcome) => {
+        resolutionOutcomes.push(outcome);
+        input.recordResolutionOutcome?.(outcome);
+    };
     const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
     const tStart = PROF ? process.hrtime.bigint() : 0n;
     let fileContents;
@@ -157,6 +162,7 @@ export function runScopeResolution(input, provider) {
             resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
             referenceEdgesEmitted: 0,
             referenceSkipped: 0,
+            resolutionOutcomes,
         };
     }
     const tExtract = PROF ? process.hrtime.bigint() : 0n;
@@ -242,7 +248,9 @@ export function runScopeResolution(input, provider) {
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     const handledSites = new Set(preEmittedInheritanceSites);
-    const receiverExtras = emitReceiverBoundCalls(graph, indexes, parsedFiles, nodeLookup, handledSites, provider, workspaceIndex, readonlyModel);
+    const receiverExtras = emitReceiverBoundCalls(graph, indexes, parsedFiles, nodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
+        recordResolutionOutcome,
+    });
     const unresolvedReceiverExtras = provider.emitUnresolvedReceiverEdges !== undefined
         ? provider.emitUnresolvedReceiverEdges(graph, indexes, parsedFiles, nodeLookup, handledSites, readonlyModel)
         : 0;
@@ -253,6 +261,7 @@ export function runScopeResolution(input, provider) {
         resolveAdlCandidates: provider.resolveAdlCandidates,
         conversionRankFn: provider.conversionRankFn,
         constraintCompatibility: provider.constraintCompatibility,
+        recordResolutionOutcome,
     });
     const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, nodeLookup, handledSites);
     const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
@@ -274,5 +283,6 @@ export function runScopeResolution(input, provider) {
         resolve: resolveStats,
         referenceEdgesEmitted: emitted + receiverExtras + unresolvedReceiverExtras + freeCallExtras,
         referenceSkipped: skipped,
+        resolutionOutcomes,
     };
 }

package/dist/core/ingestion/scope-resolution/resolution-outcome.d.ts

@@ -0,0 +1,24 @@
+import type { Range } from '../../../_shared/index.js';
+export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'overload-ambiguous' | 'overload-ambiguous-normalization';
+export type ResolutionOutcome = {
+    readonly kind: 'resolved';
+    readonly targetId: string;
+    readonly phase: string;
+    readonly filePath: string;
+    readonly name: string;
+    readonly range: Range;
+} | {
+    readonly kind: 'suppressed';
+    readonly reason: ResolutionSuppressionReason;
+    /**
+     * Scope-resolution definition IDs considered by the suppression decision.
+     * For `inline-ns-ambiguous` this is currently empty because the
+     * qualified namespace resolver returns only an `ambiguous` sentinel.
+     */
+    readonly candidateIds: readonly string[];
+    readonly phase: string;
+    readonly filePath: string;
+    readonly name: string;
+    readonly range: Range;
+};
+export type ResolutionOutcomeRecorder = (outcome: ResolutionOutcome) => void;

package/dist/core/ingestion/scope-resolution/resolution-outcome.js

@@ -0,0 +1 @@
+export {};

package/dist/types/pipeline.d.ts

@@ -1,6 +1,7 @@
 import type { KnowledgeGraph } from '../core/graph/types.js';
 import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
 import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
+import type { ResolutionOutcome } from '../core/ingestion/scope-resolution/resolution-outcome.js';
 export interface PipelineResult {
     graph: KnowledgeGraph;
     /** Absolute path to the repo root — used for lazy file reads during LadybugDB loading */
@@ -9,6 +10,12 @@ export interface PipelineResult {
     totalFileCount: number;
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
+    /**
+     * Additive diagnostics for registry-primary resolution decisions that
+     * deliberately suppress edge emission. Empty means no diagnostic was
+     * produced; graph edge semantics are unchanged.
+     */
+    resolutionOutcomes: readonly ResolutionOutcome[];
     /**
      * True if the parse phase spawned a worker pool for this run. False means
      * the sequential fallback handled every chunk. Primarily a test affordance

package/package.json

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