gitnexus 1.6.6-rc.95 → 1.6.6-rc.96

package/dist/core/ingestion/csharp-namespace-gate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure predicates gating C# `using` suffix-fallback resolution so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881).
+ *
+ * Lives in the shared `ingestion/` layer — NOT under `languages/csharp/` — so
+ * BOTH the registry-primary scope resolver (`languages/csharp/import-target.ts`)
+ * and the legacy DAG resolver (`import-resolvers/csharp.ts`) can import it
+ * without an `import-resolvers/ -> languages/` dependency inversion (#5).
+ */
+import type { CSharpNamespaceEvidence } from './language-config.js';
+/**
+ * Whether the unanchored suffix fallback may run for `targetRaw`.
+ *
+ * Fails OPEN when the namespace scan was truncated (large repos must not
+ * silently lose legitimate edges, #1881 #11) and when no evidence was
+ * threaded at all (preserves legacy permissive behavior). The truncation
+ * fail-open is carved out for clearly-external roots (BCL / well-known
+ * packages) that the repo does not declare, so one incomplete scan can't
+ * re-open the #1881 hole repo-wide. Otherwise defers to
+ * {@link importAlignsWithDeclaredNamespaces}.
+ */
+export declare function csharpSuffixFallbackAllowed(targetRaw: string, evidence: CSharpNamespaceEvidence | undefined): boolean;
+/** True when `targetRaw` plausibly refers to a namespace declared in-repo. */
+export declare function importAlignsWithDeclaredNamespaces(targetRaw: string, declaredNamespaces: ReadonlySet<string> | undefined, rootNamespaces?: ReadonlySet<string>): boolean;

package/dist/core/ingestion/csharp-namespace-gate.js

@@ -0,0 +1,129 @@
+/**
+ * Pure predicates gating C# `using` suffix-fallback resolution so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881).
+ *
+ * Lives in the shared `ingestion/` layer — NOT under `languages/csharp/` — so
+ * BOTH the registry-primary scope resolver (`languages/csharp/import-target.ts`)
+ * and the legacy DAG resolver (`import-resolvers/csharp.ts`) can import it
+ * without an `import-resolvers/ -> languages/` dependency inversion (#5).
+ */
+/**
+ * Top-level namespace segments that clearly belong to the BCL / runtime / a
+ * ubiquitous third-party package — i.e. roots a normal repo does NOT declare.
+ * These stay gated even when the namespace scan is truncated, so a single
+ * unreadable file / capped subtree can't silently re-enable BCL→local suffix
+ * matches repo-wide (#1881). A repo that legitimately declares one of these
+ * roots is still allowed via the alignment escape hatch below.
+ */
+const CSHARP_EXTERNAL_ROOTS = new Set([
+    // .NET BCL / runtime
+    'System',
+    'Microsoft',
+    'Windows',
+    'Mono',
+    // ubiquitous third-party NuGet roots
+    'Newtonsoft',
+    'Serilog',
+    'AutoMapper',
+    'MediatR',
+    'Polly',
+    'FluentValidation',
+    'Grpc',
+    'Google',
+    'Azure',
+    'Amazon',
+    'AWSSDK',
+    // common test frameworks
+    'Xunit',
+    'NUnit',
+    'Moq',
+    'FluentAssertions',
+    'NSubstitute',
+    'Shouldly',
+]);
+/** Whether `targetRaw`'s top-level segment is a clearly-external root. */
+function isExternalRoot(targetRaw) {
+    const dot = targetRaw.indexOf('.');
+    const top = dot === -1 ? targetRaw : targetRaw.slice(0, dot);
+    return CSHARP_EXTERNAL_ROOTS.has(top);
+}
+/**
+ * Whether the unanchored suffix fallback may run for `targetRaw`.
+ *
+ * Fails OPEN when the namespace scan was truncated (large repos must not
+ * silently lose legitimate edges, #1881 #11) and when no evidence was
+ * threaded at all (preserves legacy permissive behavior). The truncation
+ * fail-open is carved out for clearly-external roots (BCL / well-known
+ * packages) that the repo does not declare, so one incomplete scan can't
+ * re-open the #1881 hole repo-wide. Otherwise defers to
+ * {@link importAlignsWithDeclaredNamespaces}.
+ */
+export function csharpSuffixFallbackAllowed(targetRaw, evidence) {
+    if (evidence === undefined)
+        return true;
+    if (evidence.truncated) {
+        // Keep clearly-external roots blocked through truncation UNLESS the repo
+        // actually declares an aligning namespace (the alignment check is the
+        // escape hatch — a repo that declares `namespace System;` still resolves).
+        if (isExternalRoot(targetRaw) &&
+            !importAlignsWithDeclaredNamespaces(targetRaw, evidence.declaredNamespaces, evidence.rootNamespaces)) {
+            return false;
+        }
+        return true;
+    }
+    return importAlignsWithDeclaredNamespaces(targetRaw, evidence.declaredNamespaces, evidence.rootNamespaces);
+}
+/** True when `targetRaw` plausibly refers to a namespace declared in-repo. */
+export function importAlignsWithDeclaredNamespaces(targetRaw, declaredNamespaces, rootNamespaces) {
+    if (declaredNamespaces === undefined || declaredNamespaces.size === 0)
+        return false;
+    // Exact: the import IS a declared in-repo namespace.
+    if (declaredNamespaces.has(targetRaw))
+        return true;
+    // Child-of: the import's IMMEDIATE parent namespace is declared in-repo.
+    // Anchoring on the direct parent — not "any declared prefix" — is what stops
+    // a declared BCL prefix from green-lighting an unrelated BCL using: a repo
+    // that declares `namespace System;` must NOT make `using
+    // System.Threading.Tasks;` resolve to a coincidental local `Tasks.cs`,
+    // because the import's parent `System.Threading` is not itself declared
+    // (#1881). The case this still allows is a type / `using static` import under
+    // a declared namespace laid out without its full path on disk, e.g.
+    // `using static MyApp.Utils.Logger;` when `MyApp.Utils` is declared.
+    const lastDot = targetRaw.lastIndexOf('.');
+    if (lastDot > 0 && declaredNamespaces.has(targetRaw.slice(0, lastDot)))
+        return true;
+    // Ancestor-of: the import is a strict prefix of some declared namespace
+    // (e.g. `using MyApp;` when `MyApp.Models` is declared). Only honored when
+    // the import also sits at or above an in-repo root namespace, so a BCL prefix
+    // can't qualify merely because a file declares something deeper under it
+    // (e.g. `System.Threading.Tasks.Extensions`) (#1881).
+    const childPrefix = targetRaw + '.';
+    for (const ns of declaredNamespaces) {
+        if (ns.startsWith(childPrefix)) {
+            return isAtOrAboveInRepoRoot(targetRaw, declaredNamespaces, rootNamespaces);
+        }
+    }
+    return false;
+}
+function isAtOrAboveInRepoRoot(targetRaw, declaredNamespaces, rootNamespaces) {
+    const descendantPrefix = targetRaw + '.';
+    if (rootNamespaces !== undefined && rootNamespaces.size > 0) {
+        for (const root of rootNamespaces) {
+            // targetRaw equals a root, or is an ancestor of one (e.g. `using MyApp;`
+            // for csproj RootNamespace `MyApp.Core`).
+            if (root === targetRaw || root.startsWith(descendantPrefix))
+                return true;
+        }
+        return false;
+    }
+    // No explicit roots (e.g. no csproj): treat the top-level segment of each
+    // declared namespace as the implied root.
+    for (const ns of declaredNamespaces) {
+        const dot = ns.indexOf('.');
+        const top = dot === -1 ? ns : ns.slice(0, dot);
+        if (top === targetRaw)
+            return true;
+    }
+    return false;
+}

package/dist/core/ingestion/import-resolvers/configs/csharp.js

@@ -5,21 +5,36 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { createStandardStrategy } from '../standard.js';
 import { resolveCSharpImportInternal, resolveCSharpNamespaceDir } from '../csharp.js';
+import { csharpSuffixFallbackAllowed } from '../../csharp-namespace-gate.js';
 /** C# namespace-based resolution strategy via .csproj configs. */
 export const csharpNamespaceStrategy = (rawImportPath, _filePath, ctx) => {
     const csharpConfigs = ctx.configs.csharpConfigs;
-    if (csharpConfigs.length > 0) {
-        const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-        if (resolvedFiles.length > 1) {
-            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
-            if (dirSuffix) {
-                return { kind: 'package', files: resolvedFiles, dirSuffix };
-            }
+    const evidence = ctx.configs.csharpNamespaces;
+    if (csharpConfigs.length === 0) {
+        // No csproj → there's no namespace→directory mapping to apply, so the
+        // generic strategy would normally take over. But that generic suffix match
+        // is UNGATED: it re-introduces the BCL→local spurious match the #1881 gate
+        // exists to stop. Mirror the registry leg's no-csproj path — defer to the
+        // generic strategy ONLY for imports that align with an in-repo declared
+        // namespace; for everything else (BCL usings) return an authoritative empty
+        // result that STOPS the chain (#2 parity). With no evidence threaded the
+        // gate fails open, so behavior is unchanged when the scan didn't run.
+        if (!csharpSuffixFallbackAllowed(rawImportPath, evidence)) {
+            return { kind: 'files', files: [] };
         }
-        if (resolvedFiles.length > 0)
-            return { kind: 'files', files: resolvedFiles };
+        return null;
     }
-    return null;
+    const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index, evidence);
+    if (resolvedFiles.length > 1) {
+        const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
+        if (dirSuffix) {
+            return { kind: 'package', files: resolvedFiles, dirSuffix };
+        }
+    }
+    // Authoritative once csproj configs exist: return even an empty result to
+    // STOP the chain, so the generic suffix fallback can't re-introduce the
+    // gated BCL→local match this resolver just suppressed (#1881).
+    return { kind: 'files', files: resolvedFiles };
 };
 export const csharpImportConfig = {
     language: SupportedLanguages.CSharp,

package/dist/core/ingestion/import-resolvers/csharp.d.ts

@@ -5,12 +5,16 @@
  * This file contains shared helpers for namespace-based resolution.
  */
 import type { SuffixIndex } from './utils.js';
-import type { CSharpProjectConfig } from '../language-config.js';
+import type { CSharpProjectConfig, CSharpNamespaceEvidence } from '../language-config.js';
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * Tries single-file match first, then directory match for namespace imports.
+ *
+ * The final unanchored suffix fallback is gated on `evidence` so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881). When `evidence` is omitted the fallback stays permissive.
  */
-export declare function resolveCSharpImportInternal(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string[];
+export declare function resolveCSharpImportInternal(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex, evidence?: CSharpNamespaceEvidence): string[];
 /**
  * Compute the directory suffix for a C# namespace import (for PackageMap).
  * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.

package/dist/core/ingestion/import-resolvers/csharp.js

@@ -5,11 +5,16 @@
  * This file contains shared helpers for namespace-based resolution.
  */
 import { suffixResolve } from './utils.js';
+import { csharpSuffixFallbackAllowed } from '../csharp-namespace-gate.js';
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * Tries single-file match first, then directory match for namespace imports.
+ *
+ * The final unanchored suffix fallback is gated on `evidence` so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881). When `evidence` is omitted the fallback stays permissive.
  */
-export function resolveCSharpImportInternal(importPath, csharpConfigs, normalizedFileList, allFileList, index) {
+export function resolveCSharpImportInternal(importPath, csharpConfigs, normalizedFileList, allFileList, index, evidence) {
     const namespacePath = importPath.replace(/\./g, '/');
     const results = [];
     for (const config of csharpConfigs) {
@@ -79,7 +84,11 @@ export function resolveCSharpImportInternal(importPath, csharpConfigs, normalize
                 return results;
         }
     }
-    // Fallback: suffix matching without namespace stripping (single file)
+    // Fallback: suffix matching without namespace stripping (single file).
+    // Gated on in-repo declared-namespace evidence (#1881).
+    if (!csharpSuffixFallbackAllowed(importPath, evidence)) {
+        return [];
+    }
     const pathParts = namespacePath.split('/').filter(Boolean);
     const fallback = suffixResolve(pathParts, normalizedFileList, allFileList, index);
     return fallback ? [fallback] : [];

package/dist/core/ingestion/import-resolvers/types.d.ts

@@ -3,7 +3,7 @@
  *
  * Extracted from import-resolution.ts to co-locate types with their consumers.
  */
-import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from '../language-config.js';
+import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, CSharpNamespaceEvidence, ComposerConfig } from '../language-config.js';
 import type { SwiftPackageConfig } from '../language-config.js';
 import type { SuffixIndex } from './utils.js';
 import type { SupportedLanguages } from '../../../_shared/index.js';
@@ -28,6 +28,8 @@ export interface ImportConfigs {
     composerConfig: ComposerConfig | null;
     swiftPackageConfig: SwiftPackageConfig | null;
     csharpConfigs: CSharpProjectConfig[];
+    /** In-repo namespace evidence gating C# suffix-fallback resolution (#1881). */
+    csharpNamespaces?: CSharpNamespaceEvidence;
 }
 /** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */
 export interface ImportResolutionContext {

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

@@ -26,6 +26,35 @@ export interface CSharpProjectConfig {
     /** Directory containing the .csproj file */
     projectDir: string;
 }
+/**
+ * Declared-namespace evidence used to gate C# suffix-fallback resolution so
+ * BCL usings (e.g. `System.Threading.Tasks`) can't match a coincidentally-
+ * named local file (#1881).
+ */
+export interface CSharpNamespaceEvidence {
+    /** Every `namespace X.Y` declared in-repo (scan may be capped — see `truncated`). */
+    readonly declaredNamespaces?: ReadonlySet<string>;
+    /** csproj RootNamespace values plus the top-level segment of each declared
+     *  namespace — the anchor set for the parent-namespace gate direction. */
+    readonly rootNamespaces?: ReadonlySet<string>;
+    /** True when the BFS hit its dir/depth cap, so the namespace set may be
+     *  incomplete; the gate fails open (allows) in that case. */
+    readonly truncated?: boolean;
+}
+/** Result of a single BFS over a repo collecting both csproj configs and
+ *  declared `.cs` namespaces (one disk traversal — see `scanCSharpProject`). */
+export interface CSharpProjectScan {
+    readonly configs: CSharpProjectConfig[];
+    readonly declaredNamespaces: ReadonlySet<string>;
+    readonly rootNamespaces: ReadonlySet<string>;
+    readonly truncated: boolean;
+}
+/** Project the one-pass {@link CSharpProjectScan} into the
+ *  {@link CSharpNamespaceEvidence} both import-resolution legs thread to the
+ *  #1881 gate — one shape, two carriers (`ImportConfigs.csharpNamespaces` for
+ *  the legacy DAG, `CsharpResolutionConfig.namespaces` for the scope resolver).
+ *  Keeps the field mapping in one place so the two carriers can't drift. */
+export declare function csharpScanToEvidence(scan: CSharpProjectScan): CSharpNamespaceEvidence;
 /** Swift Package Manager module config */
 export interface SwiftPackageConfig {
     /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
@@ -43,10 +72,18 @@ export declare function loadGoModulePath(repoRoot: string): Promise<GoModuleConf
 /** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
 export declare function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null>;
 /**
- * Parse .csproj files to extract RootNamespace.
- * Scans the repo root for .csproj files and returns configs for each.
+ * Single BFS over a repo that collects BOTH .csproj configs and the set of
+ * `namespace` declarations from `.cs` files.
+ *
+ * The csproj walk is cheap (a handful of project files); the namespace scan
+ * is NOT — it opens and reads every `.cs` file in the repo to collect its
+ * `namespace` declarations. That `.cs` read cost is the price of the #1881
+ * gate, not a saving: collapsing the csproj and namespace walks into one BFS
+ * avoids a second directory traversal, but the per-file `.cs` reads are new
+ * work this scan introduces. Reads within a directory are issued in bounded
+ * windows (see below); directories are still visited breadth-first.
  */
-export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
+export declare function scanCSharpProject(repoRoot: string): Promise<CSharpProjectScan>;
 export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
 /** Load all language-specific configs once for an ingestion run. */
 export declare function loadImportConfigs(repoRoot: string): Promise<ImportConfigs>;

package/dist/core/ingestion/language-config.js

@@ -1,7 +1,21 @@
 import fs from 'fs/promises';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 import path from 'path';
 import { isDev } from './utils/env.js';
 import { logger } from '../logger.js';
+/** Project the one-pass {@link CSharpProjectScan} into the
+ *  {@link CSharpNamespaceEvidence} both import-resolution legs thread to the
+ *  #1881 gate — one shape, two carriers (`ImportConfigs.csharpNamespaces` for
+ *  the legacy DAG, `CsharpResolutionConfig.namespaces` for the scope resolver).
+ *  Keeps the field mapping in one place so the two carriers can't drift. */
+export function csharpScanToEvidence(scan) {
+    return {
+        declaredNamespaces: scan.declaredNamespaces,
+        rootNamespaces: scan.rootNamespaces,
+        truncated: scan.truncated,
+    };
+}
 // ============================================================================
 // LANGUAGE-SPECIFIC CONFIG LOADERS
 // ============================================================================
@@ -89,55 +103,236 @@ export async function loadComposerConfig(repoRoot) {
         return null;
     }
 }
+// BFS bounds shared by the C# project/namespace scan. Sized to comfortably
+// exceed normal C# repos so `truncated` stays the rare exception it was meant
+// to be: a too-low cap trips `truncated=true` on ordinary repos, which makes
+// `csharpSuffixFallbackAllowed` fail OPEN for every import and silently
+// disables the #1881 gate. Truncation remains the safety valve for genuinely
+// pathological trees (deep generated output, huge monorepos).
+const CSHARP_SCAN_MAX_DEPTH = 24;
+const CSHARP_SCAN_MAX_DIRS = 20000;
+// Bound on in-flight file reads per directory so a directory with thousands of
+// `.cs` files can't exhaust file descriptors / spike memory. Mirrors the
+// Phase-1 walker's `READ_CONCURRENCY` (see `filesystem-walker.ts`).
+const CSHARP_SCAN_READ_CONCURRENCY = 32;
+const CSHARP_SCAN_SKIP_DIRS = new Set(['node_modules', '.git', 'bin', 'obj']);
+const CSHARP_ROOT_NAMESPACE_RE = /<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/;
+// Declared `namespace` names are extracted with the comment/string-aware
+// scanner shared with the scope-resolution namespace-siblings pass
+// (`extractCsharpStructureViaScanner`), not a bare regex: a regex matches
+// `namespace` inside comments and string literals, seeding the #1881 gate
+// with phantom namespaces. Imported lazily (and memoized) so the always-on
+// `loadImportConfigs` path — every repo, every language — doesn't eagerly
+// pull tree-sitter-c-sharp in via `namespace-siblings.ts` → `query.ts`.
+let csharpScannerFactoryPromise;
+function getCsharpStructureScannerFactory() {
+    if (csharpScannerFactoryPromise === undefined) {
+        csharpScannerFactoryPromise = import('./languages/csharp/namespace-siblings.js').then((mod) => mod.createCsharpStructureScanner);
+    }
+    return csharpScannerFactoryPromise;
+}
 /**
- * Parse .csproj files to extract RootNamespace.
- * Scans the repo root for .csproj files and returns configs for each.
+ * Single BFS over a repo that collects BOTH .csproj configs and the set of
+ * `namespace` declarations from `.cs` files.
+ *
+ * The csproj walk is cheap (a handful of project files); the namespace scan
+ * is NOT — it opens and reads every `.cs` file in the repo to collect its
+ * `namespace` declarations. That `.cs` read cost is the price of the #1881
+ * gate, not a saving: collapsing the csproj and namespace walks into one BFS
+ * avoids a second directory traversal, but the per-file `.cs` reads are new
+ * work this scan introduces. Reads within a directory are issued in bounded
+ * windows (see below); directories are still visited breadth-first.
  */
-export async function loadCSharpProjectConfig(repoRoot) {
+export async function scanCSharpProject(repoRoot) {
     const configs = [];
-    // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning
+    const declaredNamespaces = new Set();
+    const rootNamespaces = new Set();
     const scanQueue = [{ dir: repoRoot, depth: 0 }];
-    const maxDepth = 5;
-    const maxDirs = 100;
     let dirsScanned = 0;
-    while (scanQueue.length > 0 && dirsScanned < maxDirs) {
+    let truncated = false;
+    while (scanQueue.length > 0) {
+        if (dirsScanned >= CSHARP_SCAN_MAX_DIRS) {
+            truncated = true;
+            break;
+        }
         const { dir, depth } = scanQueue.shift();
         dirsScanned++;
+        let entries;
         try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory() && depth < maxDepth) {
-                    // Skip common non-project directories
-                    if (entry.name === 'node_modules' ||
-                        entry.name === '.git' ||
-                        entry.name === 'bin' ||
-                        entry.name === 'obj')
-                        continue;
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            // Unreadable directory → its `.cs` namespaces are missed, so the scan is
+            // incomplete. Mark truncated so the #1881 gate fails OPEN (allows the
+            // suffix fallback) rather than wrongly blocking an import whose declaring
+            // namespace lived in the unread subtree (#5).
+            truncated = true;
+            continue;
+        }
+        // Collect read targets, then issue them in bounded windows (rather than all
+        // at once) so a directory with thousands of `.cs` files can't exhaust file
+        // descriptors / spike memory. csproj reads keep entry order (config
+        // precedence matters); `.cs` namespace results land in shared Sets where
+        // order is irrelevant.
+        const csprojNames = [];
+        const csNames = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (CSHARP_SCAN_SKIP_DIRS.has(entry.name))
+                    continue;
+                if (depth < CSHARP_SCAN_MAX_DEPTH) {
                     scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
                 }
-                if (entry.isFile() && entry.name.endsWith('.csproj')) {
-                    try {
-                        const csprojPath = path.join(dir, entry.name);
-                        const content = await fs.readFile(csprojPath, 'utf-8');
-                        const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
-                        const rootNamespace = nsMatch ? nsMatch[1].trim() : entry.name.replace(/\.csproj$/, '');
-                        const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
-                        configs.push({ rootNamespace, projectDir });
-                        if (isDev) {
-                            logger.info(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
-                        }
-                    }
-                    catch {
-                        // Can't read .csproj
-                    }
+                else {
+                    truncated = true; // a real subtree was pruned at the depth cap
                 }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name.endsWith('.csproj')) {
+                csprojNames.push(entry.name);
+            }
+            else if (entry.name.endsWith('.cs')) {
+                csNames.push(entry.name);
             }
         }
-        catch {
-            // Can't read directory
+        for (let i = 0; i < csprojNames.length; i += CSHARP_SCAN_READ_CONCURRENCY) {
+            const batch = csprojNames.slice(i, i + CSHARP_SCAN_READ_CONCURRENCY);
+            const settled = await Promise.allSettled(batch.map((name) => readCsprojConfig(path.join(dir, name), name, repoRoot, dir)));
+            for (const r of settled) {
+                const config = r.status === 'fulfilled' ? r.value : null;
+                if (config) {
+                    configs.push(config);
+                    rootNamespaces.add(config.rootNamespace);
+                }
+            }
+        }
+        for (let i = 0; i < csNames.length; i += CSHARP_SCAN_READ_CONCURRENCY) {
+            const batch = csNames.slice(i, i + CSHARP_SCAN_READ_CONCURRENCY);
+            const settled = await Promise.allSettled(batch.map((name) => collectDeclaredNamespaces(path.join(dir, name), declaredNamespaces, rootNamespaces)));
+            // A `.cs` that was unreadable (or whose read/scan unexpectedly rejected)
+            // leaves its namespaces uncollected → mark truncated to fail the #1881
+            // gate OPEN rather than wrongly suppress an import. The scan streams each
+            // file, so file size no longer trips truncation.
+            for (const r of settled) {
+                if (r.status !== 'fulfilled' || r.value === 'truncated')
+                    truncated = true;
+            }
         }
     }
-    return configs;
+    if (truncated) {
+        // Surface the fail-open so an incomplete scan (dir/depth cap, or an
+        // unreadable directory or `.cs` file) silently disabling the #1881 gate
+        // repo-wide is observable (#4) rather than a mystery edge regression.
+        logger.warn(`[csharp] namespace scan of ${repoRoot} truncated (dir cap ${CSHARP_SCAN_MAX_DIRS}, depth cap ${CSHARP_SCAN_MAX_DEPTH}, an unreadable directory, or an unreadable .cs file); the #1881 suffix-fallback gate fails open for unmatched usings`);
+    }
+    return { configs, declaredNamespaces, rootNamespaces, truncated };
+}
+// Generous soft budget for locating `<RootNamespace>`: a real .csproj declares
+// it in the first PropertyGroup near the top, so this is only reached by a
+// pathological project file with a huge leading ItemGroup and no early
+// RootNamespace. On hit we OMIT the config rather than guess a root (Codex F4).
+const CSPROJ_ROOT_SCAN_MAX_BYTES = 4 * 1024 * 1024;
+// Overlap kept across stream chunks so a `<RootNamespace>` tag straddling a
+// chunk boundary is still matched (the tag + a short namespace value fit well
+// within this window).
+const CSPROJ_TAG_OVERLAP = 512;
+/**
+ * Stream a `.csproj` just far enough to find `<RootNamespace>`, in constant
+ * memory and without a stat-then-read filesystem race. Returns the namespace
+ * when found; otherwise `rootNamespace: null` with `capHit` distinguishing a
+ * genuine read-to-EOF absence (`false`) from "not found within the soft budget"
+ * (`true`) — so the caller never synthesizes a wrong filename root for a late
+ * tag (Codex F4).
+ */
+async function findCsprojRootNamespace(csprojPath) {
+    const stream = createReadStream(csprojPath, { encoding: 'utf-8' });
+    let window = '';
+    let bytesRead = 0;
+    try {
+        for await (const chunk of stream) {
+            const text = chunk;
+            bytesRead += text.length;
+            window =
+                (window.length > CSPROJ_TAG_OVERLAP ? window.slice(-CSPROJ_TAG_OVERLAP) : window) + text;
+            const match = window.match(CSHARP_ROOT_NAMESPACE_RE);
+            if (match) {
+                stream.destroy();
+                return { rootNamespace: match[1].trim(), capHit: false };
+            }
+            if (bytesRead >= CSPROJ_ROOT_SCAN_MAX_BYTES) {
+                stream.destroy();
+                return { rootNamespace: null, capHit: true };
+            }
+        }
+    }
+    catch {
+        // Unreadable .csproj: don't guess a filename root either — omit the config.
+        return { rootNamespace: null, capHit: true };
+    }
+    return { rootNamespace: null, capHit: false }; // read to EOF, tag genuinely absent
+}
+async function readCsprojConfig(csprojPath, fileName, repoRoot, dir) {
+    const { rootNamespace: found, capHit } = await findCsprojRootNamespace(csprojPath);
+    // A late `<RootNamespace>` we couldn't reach (capHit) or an unreadable file
+    // must NOT synthesize a filename root — a wrong authoritative root would make
+    // imports under the real root resolve to nothing and suppress the fallback
+    // (Codex F4). Omit the config so the no-csproj fallback stays available. Only
+    // fall back to the filename on a genuine read-to-EOF absence of the tag.
+    if (capHit)
+        return null;
+    const rootNamespace = found ?? fileName.replace(/\.csproj$/, '');
+    const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
+    if (isDev) {
+        logger.info(`📦 Loaded C# project: ${fileName} (namespace: ${rootNamespace}, dir: ${projectDir})`);
+    }
+    return { rootNamespace, projectDir };
+}
+/**
+ * Stream one `.cs` file line-by-line and collect its declared `namespace` names
+ * into the shared Sets.
+ *
+ * Streaming (rather than reading the whole file into a string) keeps memory
+ * constant regardless of file size, so a large generated `.cs` (`*.g.cs`, EF /
+ * gRPC output) is fully scanned instead of skipped by a per-file size cap —
+ * which would otherwise trip `truncated` and disable the #1881 gate repo-wide.
+ * Only the cheap line scan streams here; the tree-sitter PARSE path keeps its
+ * own size cap.
+ *
+ * Returns `'truncated'` when the file could not be read, so the caller marks the
+ * scan truncated and the #1881 gate fails OPEN rather than wrongly suppress an
+ * import declared in the unread file. Returns `'ok'` on a complete read.
+ */
+async function collectDeclaredNamespaces(filePath, declaredNamespaces, rootNamespaces) {
+    const createScanner = await getCsharpStructureScannerFactory();
+    const scanner = createScanner();
+    try {
+        // `crlfDelay: Infinity` treats every `\r\n` as a single break; the line
+        // scanner is terminator-agnostic, so a streamed scan yields the same
+        // namespaces as scanning the whole file content at once.
+        const lines = createInterface({
+            input: createReadStream(filePath, { encoding: 'utf-8' }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of lines) {
+            scanner.pushLine(line);
+        }
+    }
+    catch {
+        return 'truncated'; // unreadable source → signal truncation (fail open)
+    }
+    const structure = scanner.result();
+    for (const ns of structure.namespaces) {
+        declaredNamespaces.add(ns);
+        const dot = ns.indexOf('.');
+        rootNamespaces.add(dot === -1 ? ns : ns.slice(0, dot));
+    }
+    // A declaration the scanner could not fully capture (Codex F3) means the
+    // collected namespaces are an incomplete picture of this file — treat it like
+    // a truncated read so the #1881 gate fails OPEN rather than over-block an
+    // import whose namespace was dropped.
+    return structure.incomplete ? 'truncated' : 'ok';
 }
 export async function loadSwiftPackageConfig(repoRoot) {
     // Swift imports are module-name based (e.g., `import SiuperModel`)
@@ -172,11 +367,13 @@ export async function loadSwiftPackageConfig(repoRoot) {
 // ============================================================================
 /** Load all language-specific configs once for an ingestion run. */
 export async function loadImportConfigs(repoRoot) {
+    const csharpScan = await scanCSharpProject(repoRoot);
     return {
         tsconfigPaths: await loadTsconfigPaths(repoRoot),
         goModule: await loadGoModulePath(repoRoot),
         composerConfig: await loadComposerConfig(repoRoot),
         swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
-        csharpConfigs: await loadCSharpProjectConfig(repoRoot),
+        csharpConfigs: csharpScan.configs,
+        csharpNamespaces: csharpScanToEvidence(csharpScan),
     };
 }

package/dist/core/ingestion/languages/csharp/import-target.d.ts

@@ -9,17 +9,21 @@
  * match. Cross-file partial-class aggregation runs at graph-bridge
  * time (Unit 6) via `populateOwners`.
  *
- * The legacy csproj-based `resolveCSharpImportInternal` needs config
- * objects the scope-resolver doesn't carry; the Unit 7 parity gate
- * will surface cases where the suffix-match diverges from the
- * namespace-based resolver and we'll adjust the contract if needed.
+ * When `.csproj` configs are available, consults the legacy
+ * namespace-directory resolver first. Both that resolver's suffix
+ * fallback and the progressive prefix stripping below are gated on
+ * declared in-repo namespaces so BCL usings like `System.Threading.Tasks`
+ * cannot spuriously match a local `Tasks.cs` (#1881).
  *
  * Returning `null` lets the finalize algorithm mark the edge as
  * `linkStatus: 'unresolved'`.
  */
 import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+import type { CSharpProjectConfig, CSharpNamespaceEvidence } from '../../language-config.js';
 export interface CsharpResolveContext {
     readonly fromFile: string;
     readonly allFilePaths: ReadonlySet<string>;
+    readonly csharpConfigs?: readonly CSharpProjectConfig[];
+    readonly namespaces?: CSharpNamespaceEvidence;
 }
 export declare function resolveCsharpImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;

package/dist/core/ingestion/languages/csharp/import-target.js

@@ -9,84 +9,143 @@
  * match. Cross-file partial-class aggregation runs at graph-bridge
  * time (Unit 6) via `populateOwners`.
  *
- * The legacy csproj-based `resolveCSharpImportInternal` needs config
- * objects the scope-resolver doesn't carry; the Unit 7 parity gate
- * will surface cases where the suffix-match diverges from the
- * namespace-based resolver and we'll adjust the contract if needed.
+ * When `.csproj` configs are available, consults the legacy
+ * namespace-directory resolver first. Both that resolver's suffix
+ * fallback and the progressive prefix stripping below are gated on
+ * declared in-repo namespaces so BCL usings like `System.Threading.Tasks`
+ * cannot spuriously match a local `Tasks.cs` (#1881).
  *
  * Returning `null` lets the finalize algorithm mark the edge as
  * `linkStatus: 'unresolved'`.
  */
+import { resolveCSharpImportInternal } from '../../import-resolvers/csharp.js';
+import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+import { csharpSuffixFallbackAllowed } from '../../csharp-namespace-gate.js';
+// Memoize on Set identity: the orchestrator passes the SAME `allFilePaths`
+// Set through every `resolveImportTarget` call in a pass, so this rebuilds
+// the normalized list + suffix index once instead of once per import (#1881 #2).
+const workspaceFileIndexCache = new WeakMap();
+function getWorkspaceFileIndex(allFilePaths) {
+    const cached = workspaceFileIndexCache.get(allFilePaths);
+    if (cached)
+        return cached;
+    const all = [...allFilePaths];
+    const normalized = all.map((f) => f.replace(/\\/g, '/'));
+    const built = { normalized, all, index: buildSuffixIndex(normalized, all) };
+    workspaceFileIndexCache.set(allFilePaths, built);
+    return built;
+}
 export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
-    // WorkspaceIndex is `unknown` in the shared contract (Ring 1
-    // placeholder). The scope-resolution orchestrator hands us a
-    // CsharpResolveContext-shaped object; narrow structurally rather
-    // than via a cast chain so unexpected shapes return null cleanly.
-    const ctx = workspaceIndex;
-    if (ctx === undefined ||
-        typeof ctx.fromFile !== 'string' ||
-        !(ctx.allFilePaths instanceof Set)) {
+    const ctx = narrowContext(workspaceIndex);
+    if (ctx === null)
         return null;
-    }
     if (parsedImport.kind === 'dynamic-unresolved')
         return null;
     if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
         return null;
+    const targetRaw = parsedImport.targetRaw;
+    const evidence = ctx.namespaces;
+    const csharpConfigs = ctx.csharpConfigs ?? [];
+    if (csharpConfigs.length > 0) {
+        const { normalized, all, index } = getWorkspaceFileIndex(ctx.allFilePaths);
+        const fromCsproj = resolveCSharpImportInternal(targetRaw, [...csharpConfigs], normalized, all, index, evidence);
+        if (fromCsproj.length > 0)
+            return fromCsproj[0];
+        // csproj configs are authoritative: mirror legacy `configs/csharp.ts`,
+        // which returns an empty result to STOP the chain. Falling through to the
+        // ungated `resolveDirectMatch` would re-introduce the BCL→local match the
+        // internal resolver's gate just suppressed (#1881 parity, #2).
+        return null;
+    }
     // Namespace path: `System.Collections.Generic` → `System/Collections/Generic`.
-    const pathLike = parsedImport.targetRaw.replace(/\./g, '/');
-    const suffix = `/${pathLike}`;
-    // Exact file match: `System/Collections/Generic.cs` (rare but legal).
-    // Suffix match for nested layouts: `src/lib/System/Collections/Generic.cs`.
-    // Directory match: first `.cs` file directly inside the namespace dir
-    // (e.g. `System/Collections/Generic/List.cs` matches namespace Generic).
-    let exactFile = null;
+    const pathLike = targetRaw.replace(/\./g, '/');
+    // Gate the WHOLE no-csproj path on declared in-repo namespaces — the direct
+    // path/suffix match INCLUDED — so a BCL using can't resolve to a
+    // coincidentally path-aligned local file (e.g. `Legacy/System/Threading/
+    // Tasks.cs` satisfying `using System.Threading.Tasks;`). Running the gate
+    // before `resolveDirectMatch` mirrors the legacy leg's gate-first ordering
+    // (`import-resolvers/configs/csharp.ts`), so the two legs are equivalent
+    // (#1881 parity, Codex F2). The gate keeps its fail-open for
+    // undefined/truncated evidence, so legitimate edges in unscanned repos are
+    // unaffected.
+    if (!csharpSuffixFallbackAllowed(targetRaw, evidence)) {
+        return null;
+    }
+    // Exact file / nested-suffix / namespace-dir direct-child match.
+    const direct = resolveDirectMatch(ctx.allFilePaths, pathLike);
+    if (direct !== null)
+        return direct;
+    // Progressive prefix stripping — mirrors csproj's root-namespace mapping
+    // without the csproj.
+    return resolveByProgressiveStripping(ctx.allFilePaths, pathLike);
+}
+/**
+ * `WorkspaceIndex` is an opaque `unknown` placeholder in the shared contract;
+ * the orchestrator hands us a `CsharpResolveContext`-shaped object. Narrow
+ * structurally rather than via a cast chain so unexpected shapes fail cleanly.
+ */
+function narrowContext(workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    return ctx;
+}
+/**
+ * First-pass resolution against the full namespace path:
+ * exact whole-path file > nested suffix file > first `.cs` directly inside
+ * the namespace directory.
+ */
+function resolveDirectMatch(allFilePaths, pathLike) {
+    const exactName = `${pathLike}.cs`;
+    const nestedSuffix = `/${exactName}`;
     let suffixFile = null;
-    let directoryChild = null;
-    const dirPrefix = `${pathLike}/`;
-    const suffixDirPrefix = `/${dirPrefix}`;
-    for (const raw of ctx.allFilePaths) {
+    for (const raw of allFilePaths) {
         const f = raw.replace(/\\/g, '/');
         if (!f.endsWith('.cs'))
             continue;
-        if (f === `${pathLike}.cs`) {
-            exactFile = raw;
-            break;
-        }
-        if (suffixFile === null && f.endsWith(`${suffix}.cs`)) {
+        if (f === exactName)
+            return raw; // exact whole-path match wins
+        if (suffixFile === null && f.endsWith(nestedSuffix))
             suffixFile = raw;
-        }
-        if (directoryChild === null) {
-            // Namespace-to-directory match: pick the first `.cs` directly in
-            // the namespace dir (not nested deeper). Legacy resolver emits
-            // all of them; we take one so the scope-resolver contract stays
-            // single-target.
-            const atRoot = f.startsWith(dirPrefix);
-            const atNested = f.includes(suffixDirPrefix);
-            if (atRoot || atNested) {
-                const idx = atRoot ? 0 : f.indexOf(suffixDirPrefix) + 1;
-                const after = f.slice(idx + dirPrefix.length);
-                if (after.length > 0 && !after.includes('/')) {
-                    directoryChild = raw;
-                }
-            }
-        }
     }
-    if (exactFile !== null)
-        return exactFile;
     if (suffixFile !== null)
         return suffixFile;
-    if (directoryChild !== null)
-        return directoryChild;
-    // Progressive prefix stripping — mirrors csproj's root-namespace
-    // mapping without the csproj. `using CrossFile.Models;` in a repo
-    // laid out `Models/User.cs` (no `CrossFile/` prefix) works because
-    // the legacy resolver consults csproj; the scope-resolver layer
-    // doesn't have csproj, so we try each suffix of the namespace path
-    // against `.cs` files and directories.
-    //
-    // Also handles `using static CrossFile.Models.UserFactory;` —
-    // strip the leading segment, try `Models/UserFactory.cs`; strip
-    // two, try `UserFactory.cs`.
+    return findDirectChild(allFilePaths, pathLike);
+}
+/**
+ * First `.cs` file that lives directly inside the namespace directory
+ * `dirSegment` (at repo root or nested under a project prefix), not deeper.
+ * The legacy resolver emits all of them; the scope-resolver contract is
+ * single-target so we take one.
+ */
+function findDirectChild(allFilePaths, dirSegment) {
+    const dirPrefix = `${dirSegment}/`;
+    const nestedDirPrefix = `/${dirPrefix}`;
+    for (const raw of allFilePaths) {
+        const f = raw.replace(/\\/g, '/');
+        if (!f.endsWith('.cs'))
+            continue;
+        const atRoot = f.startsWith(dirPrefix);
+        const atNested = f.includes(nestedDirPrefix);
+        if (!atRoot && !atNested)
+            continue;
+        const idx = atRoot ? 0 : f.indexOf(nestedDirPrefix) + 1;
+        const after = f.slice(idx + dirPrefix.length);
+        if (after.length > 0 && !after.includes('/'))
+            return raw;
+    }
+    return null;
+}
+/**
+ * Try each suffix of the namespace path against `.cs` files and directories,
+ * stripping leading segments one at a time. Models `using CrossFile.Models;`
+ * resolving to `Models/User.cs` in a repo laid out without the `CrossFile/`
+ * prefix (the scope-resolver layer has no csproj to consult).
+ */
+function resolveByProgressiveStripping(allFilePaths, pathLike) {
     const segments = pathLike.split('/').filter(Boolean);
     for (let skip = 1; skip < segments.length; skip++) {
         const tail = segments.slice(skip).join('/');
@@ -94,30 +153,21 @@ export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
             continue;
         const tailFile = `${tail}.cs`;
         const tailSuffix = `/${tailFile}`;
-        const tailDir = `${tail}/`;
-        const tailSuffixDir = `/${tailDir}`;
-        let tailDirectChild = null;
-        for (const raw of ctx.allFilePaths) {
+        let tailFileMatch = null;
+        for (const raw of allFilePaths) {
             const f = raw.replace(/\\/g, '/');
             if (!f.endsWith('.cs'))
                 continue;
-            if (f === tailFile)
-                return raw;
-            if (f.endsWith(tailSuffix))
-                return raw;
-            if (tailDirectChild === null) {
-                const atRoot = f.startsWith(tailDir);
-                const atNested = f.includes(tailSuffixDir);
-                if (atRoot || atNested) {
-                    const idx = atRoot ? 0 : f.indexOf(tailSuffixDir) + 1;
-                    const after = f.slice(idx + tailDir.length);
-                    if (after.length > 0 && !after.includes('/'))
-                        tailDirectChild = raw;
-                }
+            if (f === tailFile || f.endsWith(tailSuffix)) {
+                tailFileMatch = raw;
+                break;
             }
         }
-        if (tailDirectChild !== null)
-            return tailDirectChild;
+        if (tailFileMatch !== null)
+            return tailFileMatch;
+        const child = findDirectChild(allFilePaths, tail);
+        if (child !== null)
+            return child;
     }
     return null;
 }

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

@@ -44,6 +44,13 @@ export interface CsharpFileStructure {
     /** Dotted paths from `using static X.Y.Z;` (including
      *  `global using static` and aliased `using static A = X.Y.Z;`). */
     readonly usingStaticPaths: readonly string[];
+    /** True when the scanner saw a `namespace` / `using static` declaration it
+     *  could not fully capture (keyword not at line start, split across lines, or
+     *  an unparseable identifier form). Callers feeding the #1881 gate must treat
+     *  this like a truncated scan and fail OPEN, since a dropped namespace would
+     *  otherwise over-block a legitimate import (Codex F3). Absent/false on a
+     *  cleanly-scanned file. */
+    readonly incomplete?: boolean;
 }
 /** Line-scanner used when no cached tree is available (worker-parsed files
  *  can't transfer native tree-sitter Trees across MessageChannels, so
@@ -59,6 +66,21 @@ export interface CsharpFileStructure {
  *  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). */
+/** Incremental form of {@link extractCsharpStructureViaScanner}: feed lines one
+ *  at a time via `pushLine` (in source order), then read the accumulated
+ *  structure with `result()`. Lets a caller stream a file off disk
+ *  (`createReadStream` + `readline`) and scan it for `namespace` / `using
+ *  static` declarations in CONSTANT memory rather than buffering the whole file
+ *  into a string — the line splitting and per-line matching are identical, so a
+ *  streamed scan yields the same result as scanning the full content. The line
+ *  terminator must be stripped (as `readline` does, or `String.split('\n')`); a
+ *  trailing `\r` on a CRLF line is inert to both the matchers and the lexer. */
+export interface CsharpStructureLineScanner {
+    pushLine(line: string): void;
+    result(): CsharpFileStructure;
+}
+/** Create a fresh stateful line scanner — see {@link CsharpStructureLineScanner}. */
+export declare function createCsharpStructureScanner(): CsharpStructureLineScanner;
 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;

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

@@ -34,16 +34,45 @@
  * re-parsing every file from scratch (that re-parse dominated worker-mode
  * scope-resolution time). See `extractCsharpStructureViaScanner`.
  */
+// A dotted C# namespace identifier: each segment is an optional verbatim `@`
+// followed by a Unicode letter/`_` and Unicode letters/digits/`_`. The `u` flag
+// makes the classes Unicode-aware so `namespace Café.Models;` is captured (the
+// old ASCII `[A-Za-z…]` truncated it). The `@` markers are stripped from the
+// capture so it matches the tree-sitter AST's `name` text.
+const CS_NS_IDENT = String.raw `@?[\p{L}_][\p{L}\p{N}_]*(?:\.@?[\p{L}_][\p{L}\p{N}_]*)*`;
 // 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_.]*)/;
+const CS_NAMESPACE_RE = new RegExp(String.raw `^[ \t]*namespace[ \t]+(${CS_NS_IDENT})`, 'u');
 // `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_.]*)/;
+const CS_USING_STATIC_RE = new RegExp(String.raw `^[ \t]*(?:global[ \t]+)?using[ \t]+static[ \t]+(?:@?[\p{L}_][\p{L}\p{N}_]*[ \t]*=[ \t]*)?(${CS_NS_IDENT})`, 'u');
+// Incompleteness detectors — used ONLY when the precise matchers above failed,
+// to flag a declaration the scanner could not capture (so the file fails the
+// #1881 gate OPEN instead of silently dropping the namespace). Kept
+// high-precision so ordinary files never trip them (which would wrongly disable
+// the gate repo-wide):
+//   - `…_BARE`: the keyword alone on a line (the name is on the next line).
+//   - `…_AT_START`: a line-start declaration the precise matcher couldn't parse.
+//   - `CS_NAMESPACE_AFTER_CODE`: a `namespace` keyword right after a `}`/`;`/`{`/`]`
+//     (real code, NOT a `//` comment), i.e. not at line start.
+const CS_NAMESPACE_BARE = /^[ \t]*namespace[ \t]*\r?$/;
+const CS_USING_STATIC_BARE = /^[ \t]*(?:global[ \t]+)?using[ \t]+static[ \t]*\r?$/;
+const CS_NAMESPACE_AT_START = /^[ \t]*namespace[ \t]+\S/;
+const CS_USING_STATIC_AT_START = /^[ \t]*(?:global[ \t]+)?using[ \t]+static[ \t]+\S/;
+const CS_NAMESPACE_AFTER_CODE = /[}\];{][ \t]*namespace[ \t]+@?[\p{L}_]/u;
+/** Whether a `code`-state line declares a namespace / using-static the precise
+ *  matchers could not capture — see the detectors above. */
+function looksLikeUncapturedDeclaration(line) {
+    return (CS_NAMESPACE_BARE.test(line) ||
+        CS_USING_STATIC_BARE.test(line) ||
+        CS_NAMESPACE_AT_START.test(line) ||
+        CS_USING_STATIC_AT_START.test(line) ||
+        CS_NAMESPACE_AFTER_CODE.test(line));
+}
 /** 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
@@ -160,42 +189,48 @@ function advanceCsScanState(line, state, rawFence) {
     }
     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) {
+/** Create a fresh stateful line scanner — see {@link CsharpStructureLineScanner}. */
+export function createCsharpStructureScanner() {
     const namespaces = [];
     const usingStaticPaths = [];
+    let incomplete = false;
     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]);
+    return {
+        pushLine(line) {
+            // 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].replace(/@/g, ''));
+                }
+                else {
+                    const us = CS_USING_STATIC_RE.exec(line);
+                    if (us !== null) {
+                        usingStaticPaths.push(us[1].replace(/@/g, ''));
+                    }
+                    else if (looksLikeUncapturedDeclaration(line)) {
+                        // A declaration the precise matchers couldn't capture → mark the
+                        // file incomplete so the #1881 gate fails OPEN (Codex F3).
+                        incomplete = true;
+                    }
+                }
             }
-        }
-        [state, rawFence] = advanceCsScanState(line, state, rawFence);
-    }
-    return { namespaces, usingStaticPaths };
+            [state, rawFence] = advanceCsScanState(line, state, rawFence);
+        },
+        result() {
+            return incomplete
+                ? { namespaces, usingStaticPaths, incomplete }
+                : { namespaces, usingStaticPaths };
+        },
+    };
+}
+export function extractCsharpStructureViaScanner(content) {
+    const scanner = createCsharpStructureScanner();
+    for (const line of content.split('\n'))
+        scanner.pushLine(line);
+    return scanner.result();
 }
 /** Build a structural view of a C# file. Prefers `cachedTree` (handed in
  *  via `treeCache`) and walks the tree-sitter AST — the authoritative

package/dist/core/ingestion/languages/csharp/resolution-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-workspace config for C# scope-resolution import targeting.
+ *
+ * Loaded once per analyze pass via `csharpScopeResolver.loadResolutionConfig`
+ * and threaded into `resolveCsharpImportTarget`. The pure gate predicates live
+ * in `../../csharp-namespace-gate.ts` (shared with the legacy DAG resolver).
+ */
+import { type CSharpProjectConfig, type CSharpNamespaceEvidence } from '../../language-config.js';
+export interface CsharpResolutionConfig {
+    readonly csharpConfigs: readonly CSharpProjectConfig[];
+    /** In-repo declared-namespace evidence gating suffix-fallback resolution (#1881). */
+    readonly namespaces?: CSharpNamespaceEvidence;
+}
+export declare function loadCsharpResolutionConfig(repoRoot: string): Promise<CsharpResolutionConfig>;

package/dist/core/ingestion/languages/csharp/resolution-config.js

@@ -0,0 +1,15 @@
+/**
+ * Per-workspace config for C# scope-resolution import targeting.
+ *
+ * Loaded once per analyze pass via `csharpScopeResolver.loadResolutionConfig`
+ * and threaded into `resolveCsharpImportTarget`. The pure gate predicates live
+ * in `../../csharp-namespace-gate.ts` (shared with the legacy DAG resolver).
+ */
+import { scanCSharpProject, csharpScanToEvidence, } from '../../language-config.js';
+export async function loadCsharpResolutionConfig(repoRoot) {
+    const scan = await scanCSharpProject(repoRoot);
+    return {
+        csharpConfigs: scan.configs,
+        namespaces: csharpScanToEvidence(scan),
+    };
+}

package/dist/core/ingestion/languages/csharp/scope-resolver.js

@@ -11,13 +11,21 @@ import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.
 import { csharpProvider } from '../csharp.js';
 import { csharpArityCompatibility, csharpMergeBindings, resolveCsharpImportTarget, } from './index.js';
 import { populateCsharpNamespaceSiblings } from './namespace-siblings.js';
+import { loadCsharpResolutionConfig } from './resolution-config.js';
 import { unwrapCsharpCollectionAccessor } from './accessor-unwrap.js';
 const csharpScopeResolver = {
     language: SupportedLanguages.CSharp,
     languageProvider: csharpProvider,
     importEdgeReason: 'csharp-scope: using',
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        const ws = { fromFile, allFilePaths };
+    loadResolutionConfig: (repoPath) => loadCsharpResolutionConfig(repoPath),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        const config = resolutionConfig;
+        const ws = {
+            fromFile,
+            allFilePaths,
+            csharpConfigs: config?.csharpConfigs,
+            namespaces: config?.namespaces,
+        };
         // `WorkspaceIndex` is an opaque `unknown` placeholder in the
         // shared contract, so `ws` passes structurally without a cast.
         return resolveCsharpImportTarget({ kind: 'namespace', localName: '_', importedName: '_', targetRaw }, ws);

package/package.json

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