@veewo/gitnexus 1.5.0-rc.4 → 1.5.0

package/dist/cli/sync-manifest.test.js

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { enforceSyncManifestConsistency } from './sync-manifest.js';
+async function writeManifest(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+test('when explicit CLI values differ from manifest, TTY mode asks whether to update manifest', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    let promptMessage = '';
+    const result = await enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'ask',
+        stdinIsTTY: true,
+        prompt: async (message) => {
+            promptMessage = message;
+            return 'keep';
+        },
+    });
+    assert.equal(result.decision, 'keep');
+    assert.match(promptMessage, /@extensions/i);
+    assert.match(promptMessage, /sync-manifest\.txt/i);
+    assert.match(promptMessage, /update/i);
+    assert.match(promptMessage, /keep/i);
+});
+test('non-TTY without explicit policy exits with actionable error', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        stdinIsTTY: false,
+    }), /--sync-manifest-policy/i);
+});
+test('policy=update rewrites manifest with normalized directives', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', 'Packages/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    const result = await enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts,.tsx',
+        embeddings: true,
+        policy: 'update',
+    });
+    const rewritten = await fs.readFile(manifestPath, 'utf-8');
+    assert.equal(result.decision, 'update');
+    assert.equal(rewritten, ['Assets', 'Packages', '@extensions=.ts,.tsx', '@repoAlias=demo-repo', '@embeddings=true', ''].join('\n'));
+});
+test('rejects placeholder manifest path values', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-placeholder-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest-placeholder.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'keep',
+    }), /placeholder manifest path/i);
+});
+test('TTY prompt branch requires concrete stdin.isTTY evidence', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-tty-evidence-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.ts',
+        policy: 'ask',
+        prompt: async () => 'keep',
+    }), /stdin\.isTTY evidence/i);
+});
+test('manifest rewrite requires non-empty diff entries', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-sync-manifest-noop-'));
+    const manifestPath = path.join(tmpDir, '.gitnexus', 'sync-manifest.txt');
+    await writeManifest(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=demo-repo', '@embeddings=false'].join('\n'));
+    await assert.rejects(enforceSyncManifestConsistency({
+        manifestPath,
+        extensions: '.cs,.meta',
+        repoAlias: 'demo-repo',
+        embeddings: false,
+        policy: 'update',
+    }), /non-empty diff/i);
+});

package/dist/core/config/unity-config.d.ts

@@ -1,6 +1,7 @@
 export interface UnityConfig {
     maxSyntheticEdgesPerClass: number;
     maxSyntheticEdgesTotal: number;
+    enableContainerNodes: boolean;
     lazyMaxPaths: number;
     lazyBatchSize: number;
     lazyMaxMs: number;

package/dist/core/config/unity-config.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 const DEFAULTS = {
     maxSyntheticEdgesPerClass: 12,
     maxSyntheticEdgesTotal: 256,
+    enableContainerNodes: false,
     lazyMaxPaths: 120,
     lazyBatchSize: 30,
     lazyMaxMs: 5000,

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

@@ -5,7 +5,8 @@ import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorB
 export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, onRawFallbackParse?: (count: number) => void) => Promise<ExtractedHeritage[]>;
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.

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

@@ -1,11 +1,10 @@
 import Parser from 'tree-sitter';
 import { TIER_CONFIDENCE } from './resolution-context.js';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
 import { buildTypeEnv } from './type-env.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
 import { extractReturnTypeName } from './type-extractors/shared.js';
 /**
@@ -86,7 +85,7 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     }
     return verified;
 };
-export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
+export const processCalls = async (graph, files, astCache, ctx, onProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const logSkipped = isVerboseIngestionEnabled();
@@ -112,10 +111,33 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
         let tree = astCache.get(file.path);
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             astCache.set(file.path, tree);
         }

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

@@ -20,7 +20,8 @@ import type { ResolutionContext } from './resolution-context.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, onRawFallbackParse?: (count: number) => void) => Promise<void>;
 /**
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.

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

@@ -14,12 +14,11 @@
  *   - All other languages: default to EXTENDS
  */
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
-import { getTreeSitterBufferSize } from './constants.js';
 /** C#/Java convention: interfaces start with I followed by an uppercase letter */
 const INTERFACE_NAME_RE = /^I[A-Z]/;
 /**
@@ -65,7 +64,7 @@ const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
     }
     return generateId(fallbackLabel, fallbackKey ?? name);
 };
-export const processHeritage = async (graph, files, astCache, ctx, onProgress) => {
+export const processHeritage = async (graph, files, astCache, ctx, onProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const logSkipped = isVerboseIngestionEnabled();
     const skippedByLang = logSkipped ? new Map() : null;
@@ -94,11 +93,35 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         if (!tree) {
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                // Skip files that can't be parsed
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        // Skip files that can't be parsed
+                        continue;
+                    }
+                }
+                else {
+                    // Skip files that can't be parsed
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             // Cache re-parsed tree for potential future use
             astCache.set(file.path, tree);

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

@@ -28,7 +28,8 @@ export declare function buildImportResolutionContext(allPaths: string[]): Import
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[]) => Promise<void>;
+    rawContent?: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[], onRawFallbackParse?: (count: number) => void) => Promise<void>;
 export declare const processImportsFromExtracted: (graph: KnowledgeGraph, files: {
     path: string;
 }[], extractedImports: ExtractedImport[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext) => Promise<void>;

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

@@ -1,11 +1,10 @@
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 import { extractNamedBindings } from './named-binding-extraction.js';
-import { getTreeSitterBufferSize } from './constants.js';
 import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
 import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, resolvePythonImport, } from './resolvers/index.js';
 import { callRouters } from './call-routing.js';
@@ -173,7 +172,7 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
 // ============================================================================
 // MAIN IMPORT PROCESSOR
 // ============================================================================
-export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
+export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths, onRawFallbackParse) => {
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
@@ -249,10 +248,33 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         let wasReparsed = false;
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parseContent(file.content);
             }
-            catch (parseError) {
-                continue;
+            catch {
+                if (file.rawContent && file.rawContent !== file.content) {
+                    try {
+                        tree = parseContent(file.rawContent);
+                        onRawFallbackParse?.(1);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                else {
+                    continue;
+                }
+            }
+            if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+                try {
+                    const rawTree = parseContent(file.rawContent);
+                    if (!rawTree.rootNode?.hasError) {
+                        tree = rawTree;
+                        onRawFallbackParse?.(1);
+                    }
+                }
+                catch {
+                    // Keep normalized parse result when raw fallback fails
+                }
             }
             wasReparsed = true;
             // Cache re-parsed tree so call/heritage phases get hits

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

@@ -11,8 +11,10 @@ export interface WorkerExtractedData {
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
 }
-export { isNodeExported } from './export-detection.js';
-export declare const processParsing: (graph: KnowledgeGraph, files: {
+export interface ParsingFileInput {
     path: string;
     content: string;
-}[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool) => Promise<WorkerExtractedData | null>;
+    rawContent?: string;
+}
+export { isNodeExported } from './export-detection.js';
+export declare const processParsing: (graph: KnowledgeGraph, files: ParsingFileInput[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool, onRawFallbackParse?: (count: number) => void) => Promise<WorkerExtractedData | null>;

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

@@ -1,25 +1,30 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage, isLanguageAvailable, parseContent } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
 import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { typeConfigs } from './type-extractors/index.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+import { TREE_SITTER_MAX_BUFFER } from './constants.js';
 // isNodeExported imported from ./export-detection.js (shared module)
 // Re-export for backward compatibility with any external consumers
 export { isNodeExported } from './export-detection.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
-const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress) => {
+const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress, onRawFallbackParse) => {
     // Filter to parseable files only
     const parseableFiles = [];
     for (const file of files) {
         const lang = getLanguageFromFilename(file.path);
-        if (lang)
-            parseableFiles.push({ path: file.path, content: file.content });
+        if (lang) {
+            parseableFiles.push({
+                path: file.path,
+                content: file.content,
+                ...(file.rawContent ? { rawContent: file.rawContent } : {}),
+            });
+        }
     }
     if (parseableFiles.length === 0)
         return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
@@ -34,6 +39,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allHeritage = [];
     const allRoutes = [];
     const allConstructorBindings = [];
+    let rawFallbackCount = 0;
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -57,7 +63,10 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
         allConstructorBindings.push(...result.constructorBindings);
+        rawFallbackCount += result.csharpPreprocFallbackFiles;
     }
+    if (rawFallbackCount > 0)
+        onRawFallbackParse?.(rawFallbackCount);
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
     for (const result of chunkResults) {
@@ -78,7 +87,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 // ============================================================================
 // Sequential fallback (original implementation)
 // ============================================================================
-const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
+const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress, onRawFallbackParse) => {
     const parser = await loadParser();
     const total = files.length;
     const skippedLanguages = new Map();
@@ -106,11 +115,35 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            tree = parseContent(file.content);
         }
-        catch (parseError) {
-            console.warn(`Skipping unparseable file: ${file.path}`);
-            continue;
+        catch {
+            if (file.rawContent && file.rawContent !== file.content) {
+                try {
+                    tree = parseContent(file.rawContent);
+                    onRawFallbackParse?.(1);
+                }
+                catch {
+                    console.warn(`Skipping unparseable file: ${file.path}`);
+                    continue;
+                }
+            }
+            else {
+                console.warn(`Skipping unparseable file: ${file.path}`);
+                continue;
+            }
+        }
+        if (file.rawContent && file.rawContent !== file.content && tree.rootNode?.hasError) {
+            try {
+                const rawTree = parseContent(file.rawContent);
+                if (!rawTree.rootNode?.hasError) {
+                    tree = rawTree;
+                    onRawFallbackParse?.(1);
+                }
+            }
+            catch {
+                // Keep normalized parse result when raw fallback fails
+            }
         }
         astCache.set(file.path, tree);
         const queryString = LANGUAGE_QUERIES[language];
@@ -274,16 +307,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
 // ============================================================================
 // Public API
 // ============================================================================
-export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool) => {
+export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool, onRawFallbackParse) => {
     if (workerPool) {
         try {
-            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
+            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress, onRawFallbackParse);
         }
         catch (err) {
             console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
         }
     }
     // Fallback: sequential parsing (no pre-extracted data)
-    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress);
+    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress, onRawFallbackParse);
     return null;
 };

package/dist/core/ingestion/pipeline.js

@@ -11,11 +11,14 @@ import { processUnityResources } from './unity-resource-processor.js';
 import { applyUnityLifecycleSyntheticCalls } from './unity-lifecycle-synthetic-calls.js';
 import { applyUnityRuntimeBindingRules } from './unity-runtime-binding-rules.js';
 import { resolveUnityConfig } from '../config/unity-config.js';
+import { loadCSharpDefineProfileFromCsproj } from '../tree-sitter/csharp-define-profile.js';
+import { normalizeCSharpPreprocessorBranches } from '../tree-sitter/csharp-preproc-normalizer.js';
 import { loadAnalyzeRules } from '../../mcp/local/runtime-claim-rule-registry.js';
 import { createResolutionContext } from './resolution-context.js';
 import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents, walkUnityResourcePaths } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { createWorkerPool } from './workers/worker-pool.js';
 import { selectEntriesByScopeRules } from './scope-filter.js';
@@ -39,7 +42,24 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         astCache.clear();
         ctx.clear();
     };
+    let csharpDefineSymbols;
+    const csharpUndefinedSymbols = new Set();
+    let csharpPreprocDiagnostics;
     try {
+        if (options?.csharpDefineCsproj) {
+            const defineProfile = await loadCSharpDefineProfileFromCsproj(options.csharpDefineCsproj);
+            csharpDefineSymbols = defineProfile.symbols;
+            csharpPreprocDiagnostics = {
+                enabled: true,
+                sourcePath: defineProfile.sourcePath,
+                defineSymbolCount: defineProfile.symbols.size,
+                normalizedFiles: 0,
+                fallbackFiles: 0,
+                skippedFiles: 0,
+                expressionErrors: 0,
+                undefinedSymbols: [],
+            };
+        }
         // ── Phase 1: Scan paths only (no content read) ─────────────────────
         onProgress({
             phase: 'extracting',
@@ -184,7 +204,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         // Calls/heritage use the symbol table built so far (symbols from earlier chunks
         // are already registered). This trades ~5% cross-chunk resolution accuracy for
         // 200-400MB less memory — critical for Linux-kernel-scale repos.
-        const sequentialChunkPaths = [];
+        const sequentialChunkFiles = [];
         try {
             for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
                 const chunkPaths = chunks[chunkIdx];
@@ -192,7 +212,27 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                 const chunkContents = await readFileContents(repoPath, chunkPaths);
                 const chunkFiles = chunkPaths
                     .filter(p => chunkContents.has(p))
-                    .map(p => ({ path: p, content: chunkContents.get(p) }));
+                    .map((p) => {
+                    const originalContent = chunkContents.get(p);
+                    if (!csharpDefineSymbols || getLanguageFromFilename(p) !== SupportedLanguages.CSharp) {
+                        return { path: p, content: originalContent };
+                    }
+                    const normalized = normalizeCSharpPreprocessorBranches(originalContent, csharpDefineSymbols);
+                    csharpPreprocDiagnostics.expressionErrors += normalized.diagnostics.expressionErrors;
+                    for (const symbol of normalized.diagnostics.undefinedSymbols) {
+                        csharpUndefinedSymbols.add(symbol);
+                    }
+                    if (!normalized.changed) {
+                        csharpPreprocDiagnostics.skippedFiles += 1;
+                        return { path: p, content: originalContent };
+                    }
+                    csharpPreprocDiagnostics.normalizedFiles += 1;
+                    return {
+                        path: p,
+                        content: normalized.normalizedText,
+                        rawContent: originalContent,
+                    };
+                });
                 // Parse this chunk (workers or sequential fallback)
                 const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
                     const globalCurrent = filesParsedSoFar + current;
@@ -204,7 +244,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                         detail: filePath,
                         stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
                     });
-                }, workerPool);
+                }, workerPool, (count) => {
+                    if (csharpPreprocDiagnostics)
+                        csharpPreprocDiagnostics.fallbackFiles += count;
+                });
                 const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
                 if (chunkWorkerData) {
                     // Imports
@@ -251,8 +294,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                     ]);
                 }
                 else {
-                    await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
-                    sequentialChunkPaths.push(chunkPaths);
+                    await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths, (count) => {
+                        if (csharpPreprocDiagnostics)
+                            csharpPreprocDiagnostics.fallbackFiles += count;
+                    });
+                    sequentialChunkFiles.push(chunkFiles);
                 }
                 filesParsedSoFar += chunkFiles.length;
                 // Clear AST cache between chunks to free memory
@@ -263,15 +309,17 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         finally {
             await workerPool?.terminate();
         }
-        // Sequential fallback chunks: re-read source for call/heritage resolution
-        for (const chunkPaths of sequentialChunkPaths) {
-            const chunkContents = await readFileContents(repoPath, chunkPaths);
-            const chunkFiles = chunkPaths
-                .filter(p => chunkContents.has(p))
-                .map(p => ({ path: p, content: chunkContents.get(p) }));
+        // Sequential fallback chunks: use the same normalized-or-raw source for call/heritage resolution
+        for (const chunkFiles of sequentialChunkFiles) {
             astCache = createASTCache(chunkFiles.length);
-            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx);
-            await processHeritage(graph, chunkFiles, astCache, ctx);
+            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, (count) => {
+                if (csharpPreprocDiagnostics)
+                    csharpPreprocDiagnostics.fallbackFiles += count;
+            });
+            await processHeritage(graph, chunkFiles, astCache, ctx, undefined, (count) => {
+                if (csharpPreprocDiagnostics)
+                    csharpPreprocDiagnostics.fallbackFiles += count;
+            });
             if (rubyHeritage.length > 0) {
                 await processHeritageFromExtracted(graph, rubyHeritage, ctx);
             }
@@ -459,6 +507,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             },
         });
         astCache.clear();
+        if (csharpPreprocDiagnostics) {
+            csharpPreprocDiagnostics.undefinedSymbols = [...csharpUndefinedSymbols].sort();
+        }
         return {
             graph,
             repoPath,
@@ -467,6 +518,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             processResult,
             unityResult,
             scopeDiagnostics: scopeSelection.diagnostics,
+            csharpPreprocDiagnostics,
         };
     }
     catch (error) {

package/dist/core/ingestion/unity-runtime-binding-rules.d.ts

@@ -8,4 +8,4 @@ export interface UnityRuntimeBindingResult {
         edgesInjected: number;
     }>;
 }
-export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], _config: UnityConfig): UnityRuntimeBindingResult;
+export declare function applyUnityRuntimeBindingRules(graph: KnowledgeGraph, rules: RuntimeClaimRule[], config: UnityConfig): UnityRuntimeBindingResult;