gitnexus 1.6.3-rc.40 → 1.6.3-rc.41

package/README.md

@@ -155,6 +155,7 @@ gitnexus analyze --force         # Force full re-index
 gitnexus analyze --embeddings    # Enable embedding generation (slower, better search)
 gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits
 gitnexus analyze --verbose       # Log skipped files when parsers are unavailable
+gitnexus analyze --max-file-size 1024  # Skip files larger than N KB (default: 512, cap: 32768)
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
 gitnexus index                   # Register an existing .gitnexus/ folder into the global registry
@@ -307,6 +308,21 @@ echo "vendor/" >> .gitnexusignore
 echo "dist/" >> .gitnexusignore
 ```
 
+### Large files are being skipped
+
+By default the walker skips files larger than **512 KB** (see log line `Skipped N large files (>512KB)`). Raise the threshold via either the CLI flag or the environment variable — both accept a value in **KB**:
+
+```bash
+# CLI flag (takes precedence over the env var)
+npx gitnexus analyze --max-file-size 2048     # skip only files > 2 MB
+
+# Environment variable (persists across commands)
+export GITNEXUS_MAX_FILE_SIZE=2048
+npx gitnexus analyze
+```
+
+Values above **32768 KB (32 MB)** are clamped to the tree-sitter parser ceiling; invalid values fall back to the 512 KB default with a one-time warning. When an override is active, `analyze` prints the effective threshold in its startup banner (e.g. `GITNEXUS_MAX_FILE_SIZE: effective threshold 2048KB (default 512KB)`).
+
 ## Privacy
 
 - All processing happens locally on your machine

package/dist/_shared/scope-resolution/parsed-file.d.ts

@@ -37,6 +37,18 @@
  * `localDefs`. A `ParsedFile` is trivially convertible to a `FinalizeFile`
  * by picking those four fields, so the finalize orchestrator threads
  * ParsedFile through to the shared algorithm without shape-shifting.
+ *
+ * ## Source-of-truth invariant
+ *
+ * `ParsedFile` is the single semantic model consumed by both the legacy
+ * DAG (`gitnexus/src/core/ingestion/` outside `scope-resolution/`) and
+ * the scope-resolution pipeline (`gitnexus/src/core/ingestion/scope-resolution/`).
+ * Downstream passes MUST NOT build a parallel parse representation; if
+ * a pass needs AST-level facts that `ParsedFile` doesn't expose, it
+ * should reuse the orchestrator's `treeCache` rather than re-invoke
+ * `parser.parse(...)` on its own. See the
+ * `ScopeResolver` contract (`gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts`)
+ * for the full list of invariants downstream consumers rely on.
  */
 import type { Scope, ScopeId } from './types.js';
 import type { ParsedImport } from './types.js';

package/dist/_shared/scope-resolution/parsed-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsed-file.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;CACnD"}
+{"version":3,"file":"parsed-file.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;CACnD"}

package/dist/_shared/scope-resolution/parsed-file.js

@@ -37,6 +37,18 @@
  * `localDefs`. A `ParsedFile` is trivially convertible to a `FinalizeFile`
  * by picking those four fields, so the finalize orchestrator threads
  * ParsedFile through to the shared algorithm without shape-shifting.
+ *
+ * ## Source-of-truth invariant
+ *
+ * `ParsedFile` is the single semantic model consumed by both the legacy
+ * DAG (`gitnexus/src/core/ingestion/` outside `scope-resolution/`) and
+ * the scope-resolution pipeline (`gitnexus/src/core/ingestion/scope-resolution/`).
+ * Downstream passes MUST NOT build a parallel parse representation; if
+ * a pass needs AST-level facts that `ParsedFile` doesn't expose, it
+ * should reuse the orchestrator's `treeCache` rather than re-invoke
+ * `parser.parse(...)` on its own. See the
+ * `ScopeResolver` contract (`gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts`)
+ * for the full list of invariants downstream consumers rely on.
  */
 export {};
 //# sourceMappingURL=parsed-file.js.map

package/dist/_shared/scope-resolution/parsed-file.js.map

@@ -1 +1 @@
-{"version":3,"file":"parsed-file.js","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG"}
+{"version":3,"file":"parsed-file.js","sourceRoot":"","sources":["../../src/scope-resolution/parsed-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG"}

package/dist/_shared/scope-resolution/reference-site.d.ts

@@ -63,5 +63,13 @@ export interface ReferenceSite {
     };
     /** Argument count at the call site; used by `provider.arityCompatibility`. */
     readonly arity?: number;
+    /**
+     * Inferred argument types at the call site, one per argument. An
+     * empty-string entry means "unknown" — consumers narrowing overload
+     * candidates treat unknown as any-match. Populated by languages
+     * that can derive types from literals / constructor expressions
+     * (C#: `42` → `'int'`, `"alice"` → `'string'`).
+     */
+    readonly argumentTypes?: readonly string[];
 }
 //# sourceMappingURL=reference-site.d.ts.map

package/dist/_shared/scope-resolution/reference-site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,CAAC;AAEjB;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB"}
+{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,CAAC;AAEjB;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C"}

package/dist/core/ingestion/language-provider.d.ts

@@ -224,8 +224,9 @@ interface LanguageProviderConfig {
     readonly builtInNames?: ReadonlySet<string>;
     /**
      * Emit scope captures from raw source, **pre-grouped per tree-sitter
-     * query match**. Tree-sitter-based providers run a `scopes.scm` query
-     * and emit one `CaptureMatch` per query match; standalone providers
+     * query match**. Tree-sitter-based providers run a scope query
+     * (embedded as a string constant in each language's `query.ts`) and
+     * emit one `CaptureMatch` per query match; standalone providers
      * (COBOL) emit matches from a regex tagger. The return shape is
      * parser-agnostic: the central `ScopeExtractor` consumes
      * `CaptureMatch[]` without knowing which parser produced them.

package/dist/core/ingestion/languages/csharp/accessor-unwrap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export declare function unwrapCsharpCollectionAccessor(receiverType: string, accessor: string): string | undefined;

package/dist/core/ingestion/languages/csharp/accessor-unwrap.js

@@ -0,0 +1,56 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/** Extract (K, V) from `Dictionary<K, V>` / `IDictionary<K, V>` /
+ *  `IReadOnlyDictionary<K, V>` / `SortedDictionary<K, V>` /
+ *  `ConcurrentDictionary<K, V>` / `ImmutableDictionary<K, V>`.
+ *  Returns undefined if the type name doesn't match or the argument
+ *  list isn't exactly two top-level args. */
+function extractDictionaryArgs(rawName) {
+    const match = rawName.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Dictionary|IDictionary|IReadOnlyDictionary|SortedDictionary|ConcurrentDictionary|ImmutableDictionary)<(.+)>$/);
+    if (match === null)
+        return undefined;
+    const inner = match[1];
+    // Split on the top-level comma (tolerate nested `<...>`).
+    let depth = 0;
+    let commaIdx = -1;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            commaIdx = i;
+            break;
+        }
+    }
+    if (commaIdx === -1)
+        return undefined;
+    return { key: inner.slice(0, commaIdx).trim(), value: inner.slice(commaIdx + 1).trim() };
+}
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export function unwrapCsharpCollectionAccessor(receiverType, accessor) {
+    if (accessor !== 'Values' && accessor !== 'Keys')
+        return undefined;
+    const args = extractDictionaryArgs(receiverType);
+    if (args === undefined)
+        return undefined;
+    return accessor === 'Values' ? args.value : args.key;
+}

package/dist/core/ingestion/languages/csharp/arity-metadata.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface CsharpArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeCsharpArityMetadata(fnNode: SyntaxNode): CsharpArityMetadata;
+export {};

package/dist/core/ingestion/languages/csharp/arity-metadata.js

@@ -0,0 +1,46 @@
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+import { csharpMethodConfig } from '../../method-extractors/configs/csharp.js';
+export function computeCsharpArityMetadata(fnNode) {
+    const params = csharpMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('params');
+    const total = params.length;
+    // `params int[] args` declares one formal param but accepts any arg
+    // count ≥ required — mirror Python's treatment of `*args` and leave
+    // `parameterCount` undefined so the registry treats max as unknown.
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/ingestion/languages/csharp/arity.d.ts

@@ -0,0 +1,23 @@
+/**
+ * C# arity check, accommodating `params` variadic and default parameters.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has `params T[]` variadic.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and `params` variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'params'` when the method is
+ *                                variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `params` (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount is below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function csharpArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/csharp/arity.js

@@ -0,0 +1,37 @@
+/**
+ * C# arity check, accommodating `params` variadic and default parameters.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has `params T[]` variadic.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and `params` variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'params'` when the method is
+ *                                variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `params` (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount is below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+export function csharpArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === 'params' || t.startsWith('params '));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/csharp/cache-stats.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (C# mirror of `languages/python/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+export declare function recordCacheHit(): void;
+export declare function recordCacheMiss(): void;
+export declare function getCsharpCaptureCacheStats(): {
+    hits: number;
+    misses: number;
+};
+export declare function resetCsharpCaptureCacheStats(): void;

package/dist/core/ingestion/languages/csharp/cache-stats.js

@@ -0,0 +1,26 @@
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (C# mirror of `languages/python/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+export function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+export function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+export function getCsharpCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+export function resetCsharpCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * `emitScopeCaptures` for C#.
+ *
+ * Drives the C# scope query against tree-sitter-c-sharp and groups raw
+ * matches into `CaptureMatch[]` for the central extractor. Layers one
+ * synthesized stream on top today:
+ *
+ *   1. **Decomposed using directives** — each `using_directive` is
+ *      re-emitted with `@import.kind/source/name/alias` markers so
+ *      `interpretCsharpImport` can recover the ParsedImport shape
+ *      without re-parsing raw text (see `import-decomposer.ts`).
+ *
+ * Receiver-binding synthesis (`this` / `base` type anchors) and arity
+ * metadata synthesis (Unit 5) layer on top later.
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitCsharpScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

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

@@ -0,0 +1,249 @@
+/**
+ * `emitScopeCaptures` for C#.
+ *
+ * Drives the C# scope query against tree-sitter-c-sharp and groups raw
+ * matches into `CaptureMatch[]` for the central extractor. Layers one
+ * synthesized stream on top today:
+ *
+ *   1. **Decomposed using directives** — each `using_directive` is
+ *      re-emitted with `@import.kind/source/name/alias` markers so
+ *      `interpretCsharpImport` can recover the ParsedImport shape
+ *      without re-parsing raw text (see `import-decomposer.ts`).
+ *
+ * Receiver-binding synthesis (`this` / `base` type anchors) and arity
+ * metadata synthesis (Unit 5) layer on top later.
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ */
+import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { splitUsingDirective } from './import-decomposer.js';
+import { computeCsharpArityMetadata } from './arity-metadata.js';
+import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
+import { getCsharpParser, getCsharpScopeQuery } from './query.js';
+import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+/** Declaration anchors that carry function-like arity metadata. */
+const FUNCTION_DECL_TAGS = [
+    '@declaration.method',
+    '@declaration.constructor',
+    '@declaration.function',
+];
+/** tree-sitter-c-sharp node types that the method extractor accepts. */
+const FUNCTION_NODE_TYPES = [
+    'method_declaration',
+    'constructor_declaration',
+    'destructor_declaration',
+    'operator_declaration',
+    'conversion_operator_declaration',
+    'local_function_statement',
+];
+export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
+    // Skip the parse when the caller (parse phase's scopeTreeCache)
+    // already produced a Tree for this source. Cache miss = re-parse,
+    // same as before. The cachedTree parameter is typed as `unknown` at
+    // the LanguageProvider contract layer; cast here at the use site.
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = getCsharpParser().parse(sourceText);
+        recordCacheMiss();
+    }
+    else {
+        recordCacheHit();
+    }
+    const rawMatches = getCsharpScopeQuery().matches(tree.rootNode);
+    const out = [];
+    for (const m of rawMatches) {
+        // Group captures by their tag name. Tree-sitter strips the leading
+        // `@`; we put it back so the central extractor's prefix lookups
+        // (`@scope.`, `@declaration.`, …) work.
+        const grouped = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            grouped[tag] = nodeToCapture(tag, c.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Decompose each `using_directive` so `interpretCsharpImport` sees
+        // the kind/source/name/alias markers it consumes. Raw query match
+        // only carries the @import.statement anchor.
+        if (grouped['@import.statement'] !== undefined) {
+            const stmtCapture = grouped['@import.statement'];
+            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'using_directive');
+            if (stmtNode !== null) {
+                const decomposed = splitUsingDirective(stmtNode);
+                if (decomposed !== null) {
+                    out.push(decomposed);
+                    continue;
+                }
+            }
+            // Defensive fallback: emit the raw match so the extractor at
+            // least sees an anchor, even without markers.
+            out.push(grouped);
+            continue;
+        }
+        // Synthesize `this` / `base` receiver type-bindings on every
+        // instance method-like. Tree-sitter can't cleanly express "the
+        // implicit receiver of a non-static member of a class/struct/
+        // record/interface" via a static `.scm` pattern, so we walk up
+        // the AST in code. Mirrors Python's `self`/`cls` synthesis on
+        // `@scope.function` matches.
+        if (grouped['@scope.function'] !== undefined) {
+            out.push(grouped);
+            const anchor = grouped['@scope.function'];
+            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            if (fnNode !== null) {
+                for (const synth of synthesizeCsharpReceiverBinding(fnNode)) {
+                    out.push(synth);
+                }
+            }
+            continue;
+        }
+        // Synthesize arity metadata on function-like declarations so the
+        // registry can narrow overloads (C# relies heavily on this). Mirrors
+        // Python's captures.ts pattern — one anchor per match, so we find
+        // the first tag that matches.
+        const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
+        if (declTag !== undefined) {
+            const anchor = grouped[declTag];
+            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            if (fnNode !== null) {
+                const arity = computeCsharpArityMetadata(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+            }
+        }
+        // Synthesize `@reference.arity` on every callsite so the
+        // registry's arity filter can narrow overloads. Count the
+        // `argument` named children of the backing `argument_list`.
+        // Python doesn't synthesize this today; C# needs it because the
+        // language has method overloading and the suite asserts overload
+        // resolution.
+        const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
+        if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
+            const anchor = grouped[callTag];
+            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'invocation_expression') ??
+                findNodeAtRange(tree.rootNode, anchor.range, 'object_creation_expression');
+            if (callNode !== null) {
+                const argList = callNode.childForFieldName('arguments');
+                const args = argList === null
+                    ? []
+                    : argList.namedChildren.filter((c) => c !== null && c.type === 'argument');
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
+                // Infer argument types from literal nodes so overload
+                // disambiguation can narrow same-arity candidates by param
+                // type. Non-literal arguments emit empty string to indicate
+                // "unknown" — consumers treat unknown as any-match.
+                const argTypes = args.map((arg) => inferArgType(arg));
+                grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
+            }
+        }
+        out.push(grouped);
+        // Synthesize primary-constructor declarations on class/record
+        // declarations that carry a `parameter_list` child (C# 12 syntax
+        // `public class User(string name, int age) { ... }` or
+        // `public record Person(string FirstName, string LastName)`).
+        // Legacy `csharpMethodConfig.extractPrimaryConstructor` runs via
+        // the parse phase; the scope-resolution path needs its own emit so
+        // `new User(...)` resolves to a Constructor def in memberByOwner.
+        if (grouped['@declaration.class'] !== undefined ||
+            grouped['@declaration.record'] !== undefined) {
+            const anchor = grouped['@declaration.class'] ?? grouped['@declaration.record'];
+            const typeNode = findNodeAtRange(tree.rootNode, anchor.range, 'class_declaration') ??
+                findNodeAtRange(tree.rootNode, anchor.range, 'record_declaration');
+            if (typeNode !== null) {
+                const synth = synthesizePrimaryConstructor(typeNode);
+                if (synth !== null)
+                    out.push(synth);
+            }
+        }
+    }
+    return out;
+}
+/** C# 12 primary constructor: `class X(a, b) { }` / `record X(a, b)`.
+ *  The parameters are a bare `parameter_list` named child of the type
+ *  declaration (no `constructor_declaration` node). Emit a synthetic
+ *  @declaration.constructor match so the extractor creates a
+ *  Constructor def in memberByOwner — free-call-fallback's
+ *  `pickConstructorOrClass` then targets it for `new X(...)` calls. */
+function synthesizePrimaryConstructor(typeNode) {
+    // Skip types with an explicit constructor_declaration — that would
+    // create duplicate defs.
+    const body = typeNode.childForFieldName('body');
+    if (body !== null) {
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child !== null && child.type === 'constructor_declaration')
+                return null;
+        }
+    }
+    let paramList = null;
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child !== null && child.type === 'parameter_list') {
+            paramList = child;
+            break;
+        }
+    }
+    if (paramList === null)
+        return null;
+    const nameNode = typeNode.childForFieldName('name');
+    if (nameNode === null)
+        return null;
+    const paramCount = paramList.namedChildren.filter((c) => c !== null && c.type === 'parameter').length;
+    const m = {
+        '@declaration.constructor': nodeToCapture('@declaration.constructor', paramList),
+        '@declaration.name': syntheticCapture('@declaration.name', nameNode, nameNode.text),
+        '@declaration.parameter-count': syntheticCapture('@declaration.parameter-count', paramList, String(paramCount)),
+        '@declaration.required-parameter-count': syntheticCapture('@declaration.required-parameter-count', paramList, String(paramCount)),
+    };
+    return m;
+}
+/** Infer a C# argument's static type from literal / constructor
+ *  patterns. Returns `''` when the arg has no statically-derivable
+ *  type (e.g. identifier — would require full type inference). */
+function inferArgType(argNode) {
+    // `argument > expression` — tree-sitter-c-sharp wraps the value.
+    const expr = argNode.namedChild(0);
+    if (expr === null)
+        return '';
+    switch (expr.type) {
+        case 'integer_literal':
+            return 'int';
+        case 'real_literal':
+            return 'double';
+        case 'string_literal':
+        case 'verbatim_string_literal':
+        case 'interpolated_string_expression':
+        case 'raw_string_literal':
+            return 'string';
+        case 'character_literal':
+            return 'char';
+        case 'boolean_literal':
+            return 'bool';
+        case 'null_literal':
+            return 'null';
+        case 'object_creation_expression': {
+            const typeNode = expr.childForFieldName('type');
+            return typeNode?.text ?? '';
+        }
+        default:
+            return '';
+    }
+}
+/** Find the first C# function-like node at the given range. The
+ *  declaration anchor range covers the whole method/constructor/etc.
+ *  node, but the tag alone doesn't tell us which node type. */
+function findFunctionNode(rootNode, range) {
+    for (const nodeType of FUNCTION_NODE_TYPES) {
+        const n = findNodeAtRange(rootNode, range, nodeType);
+        if (n !== null)
+            return n;
+    }
+    return null;
+}