gitnexus 1.6.6-rc.90 → 1.6.6-rc.91

package/dist/core/ingestion/languages/csharp/namespace-siblings.d.ts

@@ -28,10 +28,38 @@
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
  * and preprocessor-guarded declarations correctly because the
  * tree-sitter grammar parses them as real nodes (not textual
- * coincidences).
+ * coincidences). When the orchestrator's `treeCache` has no Tree for a
+ * file — the worker path, where native Trees can't cross MessageChannels
+ * — `extractFileStructure` falls back to a line scanner rather than
+ * re-parsing every file from scratch (that re-parse dominated worker-mode
+ * scope-resolution time). See `extractCsharpStructureViaScanner`.
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export interface CsharpFileStructure {
+    /** Declared namespace names in file source order. Empty array means
+     *  the file has no `namespace X;` / `namespace X { }` declaration
+     *  and sits in the default (global) namespace. */
+    readonly namespaces: readonly string[];
+    /** Dotted paths from `using static X.Y.Z;` (including
+     *  `global using static` and aliased `using static A = X.Y.Z;`). */
+    readonly usingStaticPaths: readonly string[];
+}
+/** Line-scanner used when no cached tree is available (worker-parsed files
+ *  can't transfer native tree-sitter Trees across MessageChannels, so
+ *  `treeCache` is empty for them). Re-parsing every C# file here with
+ *  tree-sitter was the dominant scope-resolution cost on large worker-mode
+ *  runs — for a multi-thousand-file solution this loop alone re-parsed the
+ *  whole repo a second time. The scanner extracts the same `namespaces` /
+ *  `usingStaticPaths` the AST walk produces for line-anchored declarations,
+ *  while tracking block-comment and string state across lines (via
+ *  `advanceCsScanState`) so a `namespace` / `using static` keyword at the
+ *  start of a line inside a block comment, verbatim string, or raw string
+ *  literal is NOT mistaken for a declaration. The remaining trade-off vs the
+ *  AST is a declaration whose keyword is not at the start of a code line
+ *  (split across lines, or sharing a line with a comment/string closer).
+ *  Mirrors PHP's `extractNamespaceViaScanner` (issue #1741). */
+export declare function extractCsharpStructureViaScanner(content: string): CsharpFileStructure;
 /** Content + (optional) pre-parsed tree-sitter trees keyed by filePath.
  *  The orchestrator builds `fileContents` from the pipeline's file list;
  *  `treeCache` is the same `scopeTreeCache` already populated by the

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -28,21 +28,188 @@
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
  * and preprocessor-guarded declarations correctly because the
  * tree-sitter grammar parses them as real nodes (not textual
- * coincidences).
+ * coincidences). When the orchestrator's `treeCache` has no Tree for a
+ * file — the worker path, where native Trees can't cross MessageChannels
+ * — `extractFileStructure` falls back to a line scanner rather than
+ * re-parsing every file from scratch (that re-parse dominated worker-mode
+ * scope-resolution time). See `extractCsharpStructureViaScanner`.
  */
-import { getCsharpParser } from './query.js';
-import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
-/** Build a structural view of a C# file by walking the tree-sitter
- *  AST. Prefers `cachedTree` (handed in via `treeCache`) so we don't
- *  re-parse files the orchestrator already parsed for `extractParsedFile`;
- *  falls back to a fresh parse on cache miss. Parser singleton is
- *  shared across calls. */
+// Line-anchored matchers for the worker-path fallback (see
+// `extractCsharpStructureViaScanner`). Anchored at line start (after
+// indentation); the scanner additionally tracks block-comment / string
+// state across lines so a keyword at the start of a line inside one of
+// those regions is skipped.
+const CS_NAMESPACE_RE = /^[ \t]*namespace[ \t]+([A-Za-z_@][A-Za-z0-9_.]*)/;
+// `global using static`, plain `using static`, and the aliased
+// `using static Alias = NS.Type;` form (the AST keeps the RHS path, so
+// the optional `Alias =` is skipped and only the dotted path captured).
+const CS_USING_STATIC_RE = /^[ \t]*(?:global[ \t]+)?using[ \t]+static[ \t]+(?:[A-Za-z_@][A-Za-z0-9_]*[ \t]*=[ \t]*)?([A-Za-z_@][A-Za-z0-9_.]*)/;
+/** Advance the scanner's lexical state across one line, consuming block
+ *  comments (slash-star), line comments (`//`), single-line regular /
+ *  interpolated strings, verbatim strings (`@"…"`), and raw string literals
+ *  (`"""…"""`, fence length tracked in `rawFence`). Returns the state and
+ *  raw-fence length in effect at the START of the next line. Single-line
+ *  strings and `//` comments resolve back to `code` before end of line; only
+ *  block comments and multi-line strings carry state forward. */
+function advanceCsScanState(line, state, rawFence) {
+    const n = line.length;
+    let i = 0;
+    while (i < n) {
+        if (state === 'block') {
+            const end = line.indexOf('*/', i);
+            if (end === -1)
+                return ['block', rawFence];
+            i = end + 2;
+            state = 'code';
+        }
+        else if (state === 'verbatim') {
+            // Ends at a `"` that is not doubled (`""` is an escaped quote).
+            while (i < n) {
+                if (line[i] === '"') {
+                    if (line[i + 1] === '"') {
+                        i += 2;
+                        continue;
+                    }
+                    break;
+                }
+                i++;
+            }
+            if (i >= n)
+                return ['verbatim', rawFence];
+            i += 1;
+            state = 'code';
+        }
+        else if (state === 'raw') {
+            // Ends at a run of `"` at least `rawFence` long.
+            let closed = false;
+            while (i < n) {
+                if (line[i] === '"') {
+                    let k = i;
+                    while (k < n && line[k] === '"')
+                        k++;
+                    if (k - i >= rawFence) {
+                        i = k;
+                        state = 'code';
+                        rawFence = 0;
+                        closed = true;
+                        break;
+                    }
+                    i = k;
+                }
+                else {
+                    i++;
+                }
+            }
+            if (!closed)
+                return ['raw', rawFence];
+        }
+        else {
+            const c = line[i];
+            const next = line[i + 1];
+            if (c === '/' && next === '/')
+                return ['code', rawFence]; // line comment to EOL
+            if (c === '/' && next === '*') {
+                state = 'block';
+                i += 2;
+            }
+            else if (c === '@' && next === '"') {
+                state = 'verbatim';
+                i += 2;
+            }
+            else if ((c === '$' && next === '@') || (c === '@' && next === '$')) {
+                if (line[i + 2] === '"') {
+                    state = 'verbatim'; // interpolated verbatim ($@"…" / @$"…")
+                    i += 3;
+                }
+                else {
+                    i++;
+                }
+            }
+            else if (c === '"') {
+                let k = i;
+                while (k < n && line[k] === '"')
+                    k++;
+                const run = k - i;
+                if (run >= 3) {
+                    state = 'raw';
+                    rawFence = run;
+                    i = k;
+                }
+                else if (run === 2) {
+                    i = k; // "" — empty string
+                }
+                else {
+                    // single-line regular / interpolated string; consume to closer
+                    let j = i + 1;
+                    while (j < n) {
+                        if (line[j] === '\\') {
+                            j += 2;
+                            continue;
+                        }
+                        if (line[j] === '"')
+                            break;
+                        j++;
+                    }
+                    i = j >= n ? n : j + 1;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    return [state, rawFence];
+}
+/** Line-scanner used when no cached tree is available (worker-parsed files
+ *  can't transfer native tree-sitter Trees across MessageChannels, so
+ *  `treeCache` is empty for them). Re-parsing every C# file here with
+ *  tree-sitter was the dominant scope-resolution cost on large worker-mode
+ *  runs — for a multi-thousand-file solution this loop alone re-parsed the
+ *  whole repo a second time. The scanner extracts the same `namespaces` /
+ *  `usingStaticPaths` the AST walk produces for line-anchored declarations,
+ *  while tracking block-comment and string state across lines (via
+ *  `advanceCsScanState`) so a `namespace` / `using static` keyword at the
+ *  start of a line inside a block comment, verbatim string, or raw string
+ *  literal is NOT mistaken for a declaration. The remaining trade-off vs the
+ *  AST is a declaration whose keyword is not at the start of a code line
+ *  (split across lines, or sharing a line with a comment/string closer).
+ *  Mirrors PHP's `extractNamespaceViaScanner` (issue #1741). */
+export function extractCsharpStructureViaScanner(content) {
+    const namespaces = [];
+    const usingStaticPaths = [];
+    let state = 'code';
+    let rawFence = 0;
+    for (const line of content.split('\n')) {
+        // Only match when the line START is real code — keywords reached while
+        // inside a block comment / multi-line string are skipped.
+        if (state === 'code') {
+            const ns = CS_NAMESPACE_RE.exec(line);
+            if (ns !== null) {
+                namespaces.push(ns[1]);
+            }
+            else {
+                const us = CS_USING_STATIC_RE.exec(line);
+                if (us !== null)
+                    usingStaticPaths.push(us[1]);
+            }
+        }
+        [state, rawFence] = advanceCsScanState(line, state, rawFence);
+    }
+    return { namespaces, usingStaticPaths };
+}
+/** Build a structural view of a C# file. Prefers `cachedTree` (handed in
+ *  via `treeCache`) and walks the tree-sitter AST — the authoritative
+ *  path that sees `global using static`, aliased `using static X = Y.Z;`,
+ *  attributed namespace declarations, and preprocessor-guarded nodes
+ *  correctly. On cache miss (worker-parsed files, whose native Trees
+ *  can't cross MessageChannels) it falls back to the line scanner instead
+ *  of a fresh tree-sitter parse — the parse here dominated worker-mode
+ *  scope-resolution time. Parser singleton is shared across calls. */
 function extractFileStructure(content, cachedTree) {
-    const tree = cachedTree ??
-        parseSourceSafe(getCsharpParser(), content, undefined, {
-            bufferSize: getTreeSitterBufferSize(content),
-        });
+    if (!cachedTree) {
+        return extractCsharpStructureViaScanner(content);
+    }
+    const tree = cachedTree;
     const namespaces = [];
     const usingStaticPaths = [];
     const visit = (node) => {
@@ -238,6 +405,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
     // scope, so `Record(...)` (without `Logger.` qualifier) resolves
     // to `Logger.Record`. AST walk above captured these (including
     // `global using static` and aliased forms).
+    // Pre-index files by path once: the member-injection lookup below would
+    // otherwise be an O(files) scan per `using static` import.
+    const fileByPath = new Map(parsedFiles.map((p) => [p.filePath, p]));
     for (const parsed of parsedFiles) {
         const struct = structureByFile.get(parsed.filePath);
         if (struct === undefined)
@@ -245,6 +415,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
+        // Per-file de-dup sets keyed by simple name, seeded lazily from the
+        // augmentation bucket — replaces the per-member O(A) `.some` scan below.
+        const seenByName = new Map();
         for (const fullPath of struct.usingStaticPaths) {
             const lastDot = fullPath.lastIndexOf('.');
             if (lastDot === -1)
@@ -265,7 +438,7 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             // Inject the class's member methods into the importer's module
             // scope. `memberByOwner` wasn't built yet here, so we walk the
             // file's localDefs to find members with `ownerId === targetDef.nodeId`.
-            const targetFile = parsedFiles.find((p) => p.filePath === targetDef.filePath);
+            const targetFile = fileByPath.get(targetDef.filePath);
             if (targetFile === undefined)
                 continue;
             for (const memberDef of targetFile.localDefs) {
@@ -282,8 +455,16 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 // `lookupBindingsAt`, which fans out across `bindings` +
                 // `bindingAugmentations`.
                 const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
-                if (bucketArr.some((b) => b.def.nodeId === memberDef.nodeId))
+                let seen = seenByName.get(simpleName);
+                if (seen === undefined) {
+                    seen = new Set();
+                    for (const b of bucketArr)
+                        seen.add(b.def.nodeId);
+                    seenByName.set(simpleName, seen);
+                }
+                if (seen.has(memberDef.nodeId))
                     continue;
+                seen.add(memberDef.nodeId);
                 bucketArr.push({ def: memberDef, origin: 'import' });
             }
         }
@@ -299,6 +480,9 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
+        // Per-file de-dup sets keyed by simple name, seeded lazily from the
+        // augmentation bucket — replaces the per-def O(A) `.some` scan below.
+        const seenByName = new Map();
         for (const imp of parsed.parsedImports) {
             if (imp.kind !== 'namespace')
                 continue;
@@ -316,16 +500,35 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 if (simpleName === '')
                     continue;
                 const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
-                if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
+                let seen = seenByName.get(simpleName);
+                if (seen === undefined) {
+                    seen = new Set();
+                    for (const b of bucketArr)
+                        seen.add(b.def.nodeId);
+                    seenByName.set(simpleName, seen);
+                }
+                if (seen.has(def.nodeId))
                     continue;
+                seen.add(def.nodeId);
                 bucketArr.push({ def, origin: 'namespace' });
             }
         }
     }
-    for (const [, bucket] of buckets) {
-        // De-dup by (nodeId, filePath) across multiple declarations (e.g.
-        // partial classes declaring the same name in two files — we take
-        // both and leave de-dup to downstream consumers of bindings).
+    // Workspace-level binding channel for global-namespace types (see the
+    // global fast-path below). `lookupBindingsAt` consults this as a third
+    // source after finalized + per-scope augmented bindings. Its inner arrays
+    // are mutable by contract (append-only, like `bindingAugmentations` — see
+    // the ScopeResolutionIndexes doc + validateBindingsImmutability), so the
+    // ReadonlyMap→Map cast is localized to this one line and all writes go
+    // through `getWorkspaceBucket`.
+    const workspace = indexes.workspaceFqnBindings;
+    for (const [nsName, bucket] of buckets) {
+        // Group sibling defs by simple name. Append in place — the previous
+        // `[...prev, def]` copy made this O(D²) per bucket, which on the
+        // global (`''`) namespace bucket of a large Unity solution (tens of
+        // thousands of type defs) was a primary slowness/OOM source. We keep
+        // every declaration (e.g. partial classes across files) and leave
+        // de-dup to downstream consumers.
         const defsByName = new Map();
         for (const def of bucket.classDefs) {
             // Simple name = last segment of qualifiedName (e.g. `App.User` → `User`).
@@ -333,27 +536,81 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             const key = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
             if (key === '')
                 continue;
-            const arr = [...(defsByName.get(key) ?? [])];
+            let arr = defsByName.get(key);
+            if (arr === undefined) {
+                arr = [];
+                defsByName.set(key, arr);
+            }
             arr.push(def);
-            defsByName.set(key, arr);
+        }
+        // Global-namespace fast path (Unity OOM guard). Types declared in the
+        // default (global) namespace are visible from EVERY file in C# — the
+        // global namespace is always implicitly in scope — so one workspace-
+        // level entry per simple name is both semantically correct and O(D)
+        // instead of the O(S·D) per-scope augmentation that materialized
+        // billions of BindingRefs on large Unity solutions (tens of thousands
+        // of global types × tens of thousands of scopes). `walkScopeChain`
+        // checks local `scope.bindings` first, so local declarations still
+        // shadow these workspace entries; a file resolving its own global type
+        // hits the local binding before this map. Dedup by `def.nodeId` keeps
+        // partial-class / duplicate declarations from double-emitting.
+        if (nsName === '') {
+            for (const [name, defs] of defsByName) {
+                const bucket = getWorkspaceBucket(workspace, name);
+                const seen = new Set();
+                for (const b of bucket)
+                    seen.add(b.def.nodeId);
+                for (const def of defs) {
+                    if (seen.has(def.nodeId))
+                        continue; // dedup by nodeId (keeps partials, drops re-emits)
+                    seen.add(def.nodeId);
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+            continue;
+        }
+        // Pre-index the first scope per file once (O(S)) instead of an
+        // O(S) `.find` re-run for every (scope, name) pair, which made the
+        // injection loop O(S²·D) and was the dominant cost on large buckets.
+        // Multiple scopes share a filePath (Module + Namespace); the local
+        // shadow check only needs that file's lexical `Scope.bindings`, which
+        // is identical regardless of which of those scopes we read.
+        const firstScopeByFile = new Map();
+        for (const s of bucket.scopes) {
+            if (!firstScopeByFile.has(s.filePath))
+                firstScopeByFile.set(s.filePath, s.scope);
         }
         for (const { scopeId, filePath } of bucket.scopes) {
+            const localScope = firstScopeByFile.get(filePath);
             for (const [name, defs] of defsByName) {
                 // Skip names already present locally — `origin: 'local'` in
                 // scope.bindings would naturally shadow the cross-file
                 // namespace entry, but we also keep this index lean.
-                const local = bucket.scopes.find((s) => s.filePath === filePath)?.scope.bindings.get(name);
+                const local = localScope?.bindings.get(name);
                 if (local !== undefined && local.some((b) => b.origin === 'local'))
                     continue;
-                let bucketArr = null;
+                // Bind the augmentation bucket and its seeded de-dup set together
+                // under one nullable lifecycle, so neither needs a non-null
+                // assertion (they are always set or unset as a pair). Stays lazy:
+                // nothing is allocated for a name with no cross-file defs.
+                let inject = null;
                 for (const def of defs) {
                     if (def.filePath === filePath)
                         continue; // don't self-reference
-                    if (bucketArr === null)
-                        bucketArr = getAugmentationBucket(augmentations, scopeId, name);
-                    if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
+                    if (inject === null) {
+                        const bucket = getAugmentationBucket(augmentations, scopeId, name);
+                        // Seed the de-dup set from any entries an earlier pass
+                        // (using-static / cross-namespace imports) already added,
+                        // replacing the per-def O(A) `.some` scan.
+                        const seen = new Set();
+                        for (const b of bucket)
+                            seen.add(b.def.nodeId);
+                        inject = { bucket, seen };
+                    }
+                    if (inject.seen.has(def.nodeId))
                         continue;
-                    bucketArr.push({ def, origin: 'namespace' });
+                    inject.seen.add(def.nodeId);
+                    inject.bucket.push({ def, origin: 'namespace' });
                 }
             }
         }
@@ -378,6 +635,21 @@ function getAugmentationBucket(augmentations, scopeId, name) {
     }
     return bucketArr;
 }
+/** Get-or-create a mutable inner bucket inside the `workspaceFqnBindings`
+ *  channel (the scope-independent third channel; see
+ *  `ScopeResolutionIndexes.workspaceFqnBindings`). Like
+ *  `getAugmentationBucket`, the inner arrays are mutable by contract —
+ *  callers `push` directly. Keeping the get-or-create here means the one
+ *  ReadonlyMap→Map cast at the call site is the only place the mutable
+ *  view is taken. */
+function getWorkspaceBucket(workspace, name) {
+    let bucketArr = workspace.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        workspace.set(name, bucketArr);
+    }
+    return bucketArr;
+}
 function isTypeDef(def) {
     return (def.type === 'Class' ||
         def.type === 'Interface' ||

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -63,11 +63,15 @@ export interface ScopeResolutionIndexes {
      *  are returned first and win duplicate `def.nodeId` metadata, with
      *  unique augmentations appended after. See I8. */
     readonly bindingAugmentations: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
-    /** Workspace-level FQN binding lookup. Populated by PHP namespace-
-     *  siblings Step 3b as a shared map instead of per-scope duplication.
-     *  Consulted by `lookupBindingsAt` as a third source after finalized
-     *  and per-scope augmented bindings. Keys are backslash-separated FQNs
-     *  (e.g. `App\Models\User`). */
+    /** Workspace-level binding lookup, shared instead of per-scope
+     *  duplication. Consulted by `lookupBindingsAt` as a third source after
+     *  finalized and per-scope augmented bindings. Language-specific
+     *  namespace-sibling hooks populate it with disjoint key formats that
+     *  never collide — e.g. backslash-separated FQNs (`App\Models\User`) for
+     *  backslash-namespace languages, and bare simple names (`User`) for
+     *  global-/default-namespace types that are visible from every file. The
+     *  shared map gives those workspace-wide names one entry each instead of
+     *  O(scopes × defs) per-scope augmentation. */
     readonly workspaceFqnBindings: ReadonlyMap<string, readonly BindingRef[]>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.d.ts

@@ -1,6 +1,6 @@
 /**
- * Dev-mode runtime validator for the two-channel binding lifecycle
- * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ * Dev-mode runtime validator for the post-finalize binding-channel
+ * lifecycle (Contract Invariant I8 in `contract/scope-resolver.ts`).
  *
  * The two channels:
  *   - `indexes.bindings` — finalize-output channel. After

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.js

@@ -1,6 +1,6 @@
 /**
- * Dev-mode runtime validator for the two-channel binding lifecycle
- * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ * Dev-mode runtime validator for the post-finalize binding-channel
+ * lifecycle (Contract Invariant I8 in `contract/scope-resolver.ts`).
  *
  * The two channels:
  *   - `indexes.bindings` — finalize-output channel. After
@@ -61,5 +61,18 @@ export function validateBindingsImmutability(indexes, onWarn) {
             }
         }
     }
+    // Third channel: `workspaceFqnBindings` (scope-independent, shared map
+    // populated by language namespace-sibling hooks — PHP FQN keys, C#
+    // global-namespace simple names). Like bindingAugmentations its inner
+    // arrays are mutable by contract (hooks `push()` directly), so freezing
+    // one is the same defect as freezing an augmentation bucket.
+    for (const [name, bucket] of indexes.workspaceFqnBindings) {
+        if (Object.isFrozen(bucket)) {
+            onWarn(`binding-immutability: indexes.workspaceFqnBindings[${name}] is FROZEN — ` +
+                `the workspace channel is mutable by contract; freezing it defeats the ` +
+                `append-only purpose. See ScopeResolver Invariant I8.`);
+            violations++;
+        }
+    }
     return violations;
 }

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

@@ -55,6 +55,14 @@ export declare function lookupBindingsAt(scopeId: ScopeId, name: string, scopes:
  * Fast paths (zero allocation) when at most one channel is populated:
  * returns the underlying `Map.keys()` iterator directly. Only when both
  * channels carry names do we materialize a `Set` for deduplication.
+ *
+ * Scope: enumerates only the per-scope `bindings` and `bindingAugmentations`
+ * channels. It deliberately EXCLUDES the scope-independent
+ * `workspaceFqnBindings` channel (PHP FQN keys, C# global-namespace simple
+ * names). `lookupBindingsAt` consults that third channel when resolving a
+ * specific name, but name *enumeration* here does not — those names apply at
+ * every scope and would flood per-scope callers. Callers that need
+ * workspace-level names must read `workspaceFqnBindings` directly.
  */
 export declare function namesAtScope(scopeId: ScopeId, scopes: ScopeResolutionIndexes): Iterable<string>;
 /**

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

@@ -92,6 +92,14 @@ const EMPTY_NAMES = Object.freeze([]);
  * Fast paths (zero allocation) when at most one channel is populated:
  * returns the underlying `Map.keys()` iterator directly. Only when both
  * channels carry names do we materialize a `Set` for deduplication.
+ *
+ * Scope: enumerates only the per-scope `bindings` and `bindingAugmentations`
+ * channels. It deliberately EXCLUDES the scope-independent
+ * `workspaceFqnBindings` channel (PHP FQN keys, C# global-namespace simple
+ * names). `lookupBindingsAt` consults that third channel when resolving a
+ * specific name, but name *enumeration* here does not — those names apply at
+ * every scope and would flood per-scope callers. Callers that need
+ * workspace-level names must read `workspaceFqnBindings` directly.
  */
 export function namesAtScope(scopeId, scopes) {
     const finalized = scopes.bindings.get(scopeId);

package/package.json

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