@veewo/gitnexus 1.5.0-rc.4 → 1.5.0

package/dist/benchmark/analyze-runner.d.ts

@@ -1,5 +1,5 @@
 export interface AnalyzeRunOptions {
-    extensions: string;
+    extensions?: string;
     repoAlias?: string;
     scopeManifest?: string;
     scopePrefix?: string[];

package/dist/benchmark/analyze-runner.js

@@ -13,10 +13,11 @@ export function buildAnalyzeArgs(repoPath, options) {
         'dist/cli/index.js',
         'analyze',
         '--force',
-        '--extensions',
-        options.extensions,
-        repoPath,
     ];
+    if (options.extensions !== undefined) {
+        args.push('--extensions', options.extensions);
+    }
+    args.push(repoPath);
     if (options.repoAlias) {
         args.push('--repo-alias', options.repoAlias);
     }

package/dist/benchmark/analyze-runner.test.js

@@ -35,3 +35,10 @@ test('buildAnalyzeArgs forwards alias and scope options', () => {
         'Packages/com.veewo.*',
     ]);
 });
+test('buildAnalyzeArgs omits --extensions when not explicitly provided', () => {
+    const args = buildAnalyzeArgs('/repo/path', {
+        repoAlias: 'neonspark-v1-subset',
+        scopeManifest: '/tmp/scope-manifest.txt',
+    });
+    assert.equal(args.includes('--extensions'), false);
+});

package/dist/cli/ai-context.d.ts

@@ -20,7 +20,6 @@ interface RepoStats {
  */
 export declare function generateAIContextFiles(repoPath: string, _storagePath: string, projectName: string, stats: RepoStats, options?: {
     skillScope?: SkillScope;
-    cliPackageSpec?: string;
 }, generatedSkills?: GeneratedSkillInfo[]): Promise<{
     files: string[];
 }>;

package/dist/cli/ai-context.js

@@ -8,7 +8,6 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { buildNpxCommand, resolveCliSpec } from '../config/cli-spec.js';
 // ESM equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -25,14 +24,13 @@ const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->';
  * - Exact tool commands with parameters — vague directives get ignored
  * - Self-review checklist — forces model to verify its own work
  */
-function generateGitNexusContent(projectName, stats, skillScope, cliPackageSpec, generatedSkills) {
+function generateGitNexusContent(projectName, stats, skillScope, generatedSkills) {
     const skillRoot = skillScope === 'global'
         ? '~/.agents/skills/gitnexus'
         : '.agents/skills/gitnexus';
     const generatedRows = (generatedSkills && generatedSkills.length > 0)
         ? `\n${generatedSkills.map((s) => `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |`).join('\n')}`
         : '';
-    const reindexCmd = buildNpxCommand(cliPackageSpec, 'analyze');
     return `${GITNEXUS_START_MARKER}
 # GitNexus MCP
 
@@ -44,7 +42,7 @@ function generateGitNexusContent(projectName, stats, skillScope, cliPackageSpec,
 4. **Follow config/state file rules:** \`docs/gitnexus-config-files.md\`
 5. **If user asks to release/publish a specific version and this repo has \`DISTRIBUTION.md\`, execute that workflow in full-release mode by default** (unless user explicitly asks \`prepare-only\` or \`publish-only\`).
 
-> If step 1 warns the index is stale, ask user whether to rebuild index via \`gitnexus analyze\` when local CLI exists; otherwise resolve the pinned npx package spec from \`~/.gitnexus/config.json\` (\`cliPackageSpec\` first, then \`cliVersion\`) and run \`${reindexCmd}\` with that exact package spec (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
+> If step 1 warns the index is stale, ask user whether to rebuild index via \`gitnexus analyze\` when local CLI exists; otherwise resolve the pinned npx package spec from \`~/.gitnexus/config.json\` (\`cliPackageSpec\` first, then \`cliVersion\`) and run \`npx -y <resolved-spec> analyze\` (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
 
 ## Skills
 
@@ -58,6 +56,18 @@ function generateGitNexusContent(projectName, stats, skillScope, cliPackageSpec,
 | Index, status, clean, wiki CLI commands | \`${skillRoot}/gitnexus-cli/SKILL.md\` |
 | Create Unity analyze_rules interactively | \`${skillRoot}/gitnexus-unity-rule-gen/SKILL.md\` |${generatedRows}
 
+## Dev Workflow (Source Build)
+
+To use a locally built dist instead of the globally installed package (useful when testing unreleased changes):
+
+\`\`\`bash
+cd /path/to/GitNexus/gitnexus
+npm run build
+npm link   # replaces global install with symlink to local dist/cli/index.js
+\`\`\`
+
+After \`npm link\`, \`gitnexus\` on this machine points to the local dist. All repos using \`gitnexus mcp\` in their MCP config will pick up the new build after restarting the agent session. To restore the published package: \`npm unlink -g @veewo/gitnexus && npm install -g @veewo/gitnexus\`.
+
 ${GITNEXUS_END_MARKER}`;
 }
 /**
@@ -204,8 +214,7 @@ async function copyDirRecursive(src, dest) {
  */
 export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats, options, generatedSkills) {
     const skillScope = options?.skillScope === 'global' ? 'global' : 'project';
-    const cliPackageSpec = options?.cliPackageSpec || resolveCliSpec().packageSpec;
-    const content = generateGitNexusContent(projectName, stats, skillScope, cliPackageSpec, generatedSkills);
+    const content = generateGitNexusContent(projectName, stats, skillScope, generatedSkills);
     const createdFiles = [];
     // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Codex, Cline, etc.)
     const agentsPath = path.join(repoPath, 'AGENTS.md');

package/dist/cli/analyze-options.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { normalizeScopeRules, parseScopeRules } from '../core/ingestion/scope-filter.js';
+import { normalizeScopeRules } from '../core/ingestion/scope-filter.js';
+import { parseScopeManifestConfig } from './scope-manifest-config.js';
 const REPO_ALIAS_REGEX = /^[a-zA-Z0-9._-]{3,64}$/;
 export function parseExtensionList(rawExtensions) {
     return (rawExtensions || '')
@@ -21,38 +22,16 @@ export function normalizeRepoAlias(repoAlias) {
     return normalized;
 }
 export async function resolveAnalyzeScopeRules(options) {
-    const rules = [];
+    let manifestRules = [];
     if (options?.scopeManifest) {
         const manifestPath = path.resolve(options.scopeManifest);
-        let content;
-        try {
-            content = await fs.readFile(manifestPath, 'utf-8');
-        }
-        catch {
-            throw new Error(`Scope manifest not found: ${manifestPath}`);
-        }
-        const manifestRules = parseScopeRules(content);
+        const manifest = await readScopeManifestConfig(manifestPath);
+        manifestRules = manifest.scopeRules;
         if (manifestRules.length === 0) {
             throw new Error(`Scope manifest has no valid scope rules: ${manifestPath}`);
         }
-        rules.push(...manifestRules);
-    }
-    const prefixesRaw = Array.isArray(options?.scopePrefix)
-        ? options?.scopePrefix || []
-        : options?.scopePrefix
-            ? [options.scopePrefix]
-            : [];
-    for (const prefix of prefixesRaw) {
-        const trimmed = prefix.trim();
-        if (trimmed) {
-            rules.push(trimmed);
-        }
     }
-    const normalizedRules = normalizeScopeRules(rules);
-    if ((options?.scopeManifest || prefixesRaw.length > 0) && normalizedRules.length === 0) {
-        throw new Error('No valid scope rules provided.');
-    }
-    return normalizedRules;
+    return resolveScopeRulesFromInput(manifestRules, normalizeScopePrefixes(options?.scopePrefix), Boolean(options?.scopeManifest));
 }
 function parseScopePrefixCount(scopePrefix) {
     if (Array.isArray(scopePrefix))
@@ -62,26 +41,36 @@ function parseScopePrefixCount(scopePrefix) {
     return 0;
 }
 export async function resolveEffectiveAnalyzeOptions(options, stored) {
+    const manifestConfig = options?.scopeManifest
+        ? await readScopeManifestConfig(path.resolve(options.scopeManifest))
+        : undefined;
     const includeExtensionsFromCli = parseExtensionList(options?.extensions);
-    const scopeRulesFromCli = await resolveAnalyzeScopeRules({
-        scopeManifest: options?.scopeManifest,
-        scopePrefix: options?.scopePrefix,
-    });
+    const scopeRulesFromCli = resolveScopeRulesFromInput(manifestConfig?.scopeRules || [], normalizeScopePrefixes(options?.scopePrefix), Boolean(options?.scopeManifest));
     const repoAliasFromCli = normalizeRepoAlias(options?.repoAlias);
+    const manifestExtensions = manifestConfig?.directives.extensions;
+    const manifestRepoAlias = manifestConfig?.directives.repoAlias;
+    const manifestEmbeddings = manifestConfig?.directives.embeddings;
     const hasCliExtensions = options?.extensions !== undefined;
     const hasCliScope = Boolean(options?.scopeManifest) || parseScopePrefixCount(options?.scopePrefix) > 0;
     const hasCliRepoAlias = options?.repoAlias !== undefined;
     const canReuse = options?.reuseOptions !== false;
     const includeExtensions = hasCliExtensions
         ? includeExtensionsFromCli
-        : (canReuse ? (stored?.includeExtensions || []) : []);
+        : (manifestExtensions !== undefined
+            ? parseExtensionList(manifestExtensions)
+            : (canReuse ? (stored?.includeExtensions || []) : []));
     const scopeRules = hasCliScope
         ? scopeRulesFromCli
         : (canReuse ? (stored?.scopeRules || []) : []);
     const repoAlias = hasCliRepoAlias
         ? repoAliasFromCli
-        : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined);
-    const embeddings = options?.embeddings ?? (canReuse ? Boolean(stored?.embeddings) : false);
+        : (manifestRepoAlias !== undefined
+            ? normalizeRepoAlias(manifestRepoAlias)
+            : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined));
+    const embeddings = options?.embeddings
+        ?? (manifestEmbeddings !== undefined
+            ? parseManifestEmbeddings(manifestEmbeddings)
+            : (canReuse ? Boolean(stored?.embeddings) : false));
     return {
         includeExtensions: [...includeExtensions],
         scopeRules: [...scopeRules],
@@ -89,3 +78,38 @@ export async function resolveEffectiveAnalyzeOptions(options, stored) {
         embeddings,
     };
 }
+function normalizeScopePrefixes(scopePrefix) {
+    const prefixesRaw = Array.isArray(scopePrefix)
+        ? scopePrefix || []
+        : scopePrefix
+            ? [scopePrefix]
+            : [];
+    return prefixesRaw
+        .map((prefix) => prefix.trim())
+        .filter(Boolean);
+}
+function resolveScopeRulesFromInput(manifestRules, prefixes, hasScopeManifest) {
+    const normalizedRules = normalizeScopeRules([...manifestRules, ...prefixes]);
+    if ((hasScopeManifest || prefixes.length > 0) && normalizedRules.length === 0) {
+        throw new Error('No valid scope rules provided.');
+    }
+    return normalizedRules;
+}
+async function readScopeManifestConfig(manifestPath) {
+    let content;
+    try {
+        content = await fs.readFile(manifestPath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Scope manifest not found: ${manifestPath}`);
+    }
+    return parseScopeManifestConfig(content);
+}
+function parseManifestEmbeddings(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    throw new Error(`Invalid @embeddings directive value: ${raw}. Expected true or false.`);
+}

package/dist/cli/analyze-options.test.js

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules, resolveEffectiveAnalyzeOptions, } from './analyze-options.js';
+import { parseScopeManifestConfig } from './scope-manifest-config.js';
 test('parseExtensionList normalizes dot prefixes', () => {
     const exts = parseExtensionList('cs,.ts, go ');
     assert.deepEqual(exts, ['.cs', '.ts', '.go']);
@@ -75,3 +76,59 @@ test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored set
     assert.equal(resolved.repoAlias, 'new-alias');
     assert.equal(resolved.embeddings, false);
 });
+test('resolveEffectiveAnalyzeOptions reads @extensions/@repoAlias/@embeddings from manifest', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-directives-'));
+    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
+    await fs.writeFile(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=neonspark-core', '@embeddings=false'].join('\n'), 'utf-8');
+    const resolved = await resolveEffectiveAnalyzeOptions({ scopeManifest: manifestPath }, {
+        includeExtensions: ['.ts'],
+        scopeRules: ['src'],
+        repoAlias: 'stored-alias',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.scopeRules, ['Assets']);
+    assert.deepEqual(resolved.includeExtensions, ['.cs', '.meta']);
+    assert.equal(resolved.repoAlias, 'neonspark-core');
+    assert.equal(resolved.embeddings, false);
+});
+test('resolveEffectiveAnalyzeOptions enforces precedence CLI > manifest > meta', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-precedence-'));
+    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
+    await fs.writeFile(manifestPath, ['Assets/', '@extensions=.cs,.meta', '@repoAlias=manifest-alias', '@embeddings=false'].join('\n'), 'utf-8');
+    const resolved = await resolveEffectiveAnalyzeOptions({
+        scopeManifest: manifestPath,
+        extensions: '.ts',
+    }, {
+        includeExtensions: ['.js'],
+        scopeRules: ['tools'],
+        repoAlias: 'meta-alias',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.scopeRules, ['Assets']);
+    assert.deepEqual(resolved.includeExtensions, ['.ts']);
+    assert.equal(resolved.repoAlias, 'manifest-alias');
+    assert.equal(resolved.embeddings, false);
+});
+test('resolveEffectiveAnalyzeOptions rejects unknown manifest directives', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-manifest-unknown-'));
+    const manifestPath = path.join(tmpDir, 'sync-manifest.txt');
+    await fs.writeFile(manifestPath, ['Assets/', '@foo=bar'].join('\n'), 'utf-8');
+    await assert.rejects(resolveEffectiveAnalyzeOptions({ scopeManifest: manifestPath }), /unknown manifest directive/i);
+});
+test('parseScopeManifestConfig splits scope rules and directives', () => {
+    const parsed = parseScopeManifestConfig([
+        '# comment',
+        'Assets/',
+        'Packages/com.veewo.*',
+        '',
+        '@extensions=.cs,.meta',
+        '@repoAlias=demo-repo',
+        '@embeddings=false',
+    ].join('\n'));
+    assert.deepEqual(parsed.scopeRules, ['Assets', 'Packages/com.veewo.*']);
+    assert.deepEqual(parsed.directives, {
+        extensions: '.cs,.meta',
+        repoAlias: 'demo-repo',
+        embeddings: 'false',
+    });
+});

package/dist/cli/analyze-runtime-summary.js

@@ -5,5 +5,6 @@ export function toPipelineRuntimeSummary(input) {
         processResult: input.processResult,
         unityResult: input.unityResult,
         scopeDiagnostics: input.scopeDiagnostics,
+        csharpPreprocDiagnostics: input.csharpPreprocDiagnostics,
     };
 }

package/dist/cli/analyze-runtime-summary.test.js

@@ -7,8 +7,18 @@ test('toPipelineRuntimeSummary drops graph reference and preserves reporting fie
         communityResult: { stats: { totalCommunities: 3 } },
         processResult: { stats: { totalProcesses: 2 } },
         unityResult: { diagnostics: ['scanContext: scripts=1'] },
+        csharpPreprocDiagnostics: {
+            enabled: true,
+            defineSymbolCount: 2,
+            normalizedFiles: 1,
+            fallbackFiles: 0,
+            skippedFiles: 3,
+            expressionErrors: 0,
+            undefinedSymbols: [],
+        },
     });
     assert.equal('graph' in out, false);
     assert.equal(out.totalFileCount, 12);
     assert.equal(out.communityResult?.stats.totalCommunities, 3);
+    assert.equal(out.csharpPreprocDiagnostics?.normalizedFiles, 1);
 });

package/dist/cli/analyze-summary.d.ts

@@ -1,8 +1,10 @@
+import type { CSharpPreprocDiagnostics } from '../types/pipeline.js';
 export interface FallbackInsertStats {
     attempted: number;
     succeeded: number;
     failed: number;
 }
+export declare function formatCSharpPreprocDiagnosticsSummary(diagnostics: CSharpPreprocDiagnostics | undefined, previewLimit?: number): string[];
 export declare function formatUnityDiagnosticsSummary(diagnostics: string[] | undefined, previewLimit?: number): string[];
 export declare function formatFallbackSummary(warnings: string[] | undefined, stats: FallbackInsertStats | undefined, previewLimit?: number): string[];
 export declare function resolveFallbackStats(warnings: string[] | undefined, stats: FallbackInsertStats | undefined): FallbackInsertStats;

package/dist/cli/analyze-summary.js

@@ -1,3 +1,22 @@
+export function formatCSharpPreprocDiagnosticsSummary(diagnostics, previewLimit = 5) {
+    if (!diagnostics?.enabled)
+        return [];
+    const lines = [
+        `CSharp Preproc: defines=${diagnostics.defineSymbolCount}, normalized=${diagnostics.normalizedFiles}, fallback=${diagnostics.fallbackFiles}, skipped=${diagnostics.skippedFiles}, exprErrors=${diagnostics.expressionErrors}`,
+    ];
+    if (diagnostics.sourcePath) {
+        lines.push(`- source: ${diagnostics.sourcePath}`);
+    }
+    if (diagnostics.undefinedSymbols.length > 0) {
+        const limit = previewLimit > 0 ? previewLimit : diagnostics.undefinedSymbols.length;
+        const preview = diagnostics.undefinedSymbols.slice(0, limit);
+        lines.push(`- undefined symbols: ${preview.join(', ')}`);
+        if (diagnostics.undefinedSymbols.length > preview.length) {
+            lines.push(`... ${diagnostics.undefinedSymbols.length - preview.length} more`);
+        }
+    }
+    return lines;
+}
 export function formatUnityDiagnosticsSummary(diagnostics, previewLimit = 3) {
     if (!diagnostics || diagnostics.length === 0) {
         return [];

package/dist/cli/analyze.d.ts

@@ -3,15 +3,26 @@
  *
  * Indexes a repository and stores the knowledge graph in .gitnexus/
  */
+import { type SyncManifestPolicy } from './sync-manifest.js';
 export interface AnalyzeOptions {
     force?: boolean;
     embeddings?: boolean;
     extensions?: string;
     repoAlias?: string;
+    csharpDefineCsproj?: string;
     scopeManifest?: string;
     scopePrefix?: string[];
+    syncManifestPolicy?: SyncManifestPolicy;
     reuseOptions?: boolean;
     skills?: boolean;
     verbose?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;
+export declare function buildPipelineRunOptionsForAnalyze(resolvedOptions: {
+    includeExtensions: string[];
+    scopeRules: string[];
+}, options?: AnalyzeOptions): {
+    includeExtensions: string[];
+    scopeRules: string[];
+    csharpDefineCsproj?: string;
+};

package/dist/cli/analyze.js

@@ -19,10 +19,10 @@ import { generateAIContextFiles } from './ai-context.js';
 import { generateSkillFiles } from './skill-gen.js';
 import fs from 'fs/promises';
 import { resolveEffectiveAnalyzeOptions } from './analyze-options.js';
-import { formatFallbackSummary, formatUnityDiagnosticsSummary, resolveFallbackStats } from './analyze-summary.js';
+import { formatCSharpPreprocDiagnosticsSummary, formatFallbackSummary, formatUnityDiagnosticsSummary, resolveFallbackStats } from './analyze-summary.js';
 import { resolveChildProcessExit } from './exit-code.js';
 import { toPipelineRuntimeSummary } from './analyze-runtime-summary.js';
-import { resolveCliSpec } from '../config/cli-spec.js';
+import { enforceSyncManifestConsistency, resolveScopeManifestForAnalyze } from './sync-manifest.js';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Re-exec the process with an 8GB heap if we're currently below that. */
@@ -112,9 +112,21 @@ export const analyzeCommand = async (inputPath, options) => {
     let repoAlias;
     let embeddingsEnabled = false;
     try {
+        const scopeManifest = await resolveScopeManifestForAnalyze(repoPath, {
+            scopeManifest: options?.scopeManifest,
+            scopePrefix: options?.scopePrefix,
+        });
+        await enforceSyncManifestConsistency({
+            manifestPath: scopeManifest,
+            extensions: options?.extensions,
+            repoAlias: options?.repoAlias,
+            embeddings: options?.embeddings,
+            policy: options?.syncManifestPolicy,
+            stdinIsTTY: Boolean(process.stdin.isTTY),
+        });
         const effectiveOptions = await resolveEffectiveAnalyzeOptions({
             extensions: options?.extensions,
-            scopeManifest: options?.scopeManifest,
+            scopeManifest,
             scopePrefix: options?.scopePrefix,
             repoAlias: options?.repoAlias,
             embeddings: options?.embeddings,
@@ -241,11 +253,12 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Phase 1: Full Pipeline (0–60%) ─────────────────────────────────
     let pipelineResult;
     try {
+        const pipelineRunOptions = buildPipelineRunOptionsForAnalyze({ includeExtensions, scopeRules }, options);
         pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
             const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
             const scaled = Math.round(progress.percent * 0.6);
             updateBar(scaled, phaseLabel);
-        }, { includeExtensions, scopeRules });
+        }, pipelineRunOptions);
     }
     catch (error) {
         clearInterval(elapsedTimer);
@@ -391,7 +404,6 @@ export const analyzeCommand = async (inputPath, options) => {
         processes: pipelineRuntime.processResult?.stats.totalProcesses,
     }, {
         skillScope: (cliConfig.setupScope === 'global') ? 'global' : 'project',
-        cliPackageSpec: resolveCliSpec({ config: cliConfig }).packageSpec,
     }, generatedSkills);
     await closeLbug();
     // Note: we intentionally do NOT call disposeEmbedder() here.
@@ -432,6 +444,10 @@ export const analyzeCommand = async (inputPath, options) => {
     for (const line of unitySummaryLines) {
         console.log(`  ${line}`);
     }
+    const csharpPreprocSummaryLines = formatCSharpPreprocDiagnosticsSummary(pipelineRuntime.csharpPreprocDiagnostics);
+    for (const line of csharpPreprocSummaryLines) {
+        console.log(`  ${line}`);
+    }
     console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineRuntime.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineRuntime.processResult?.stats.totalProcesses || 0} flows`);
     console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
     if (includeExtensions.length > 0) {
@@ -460,6 +476,15 @@ export const analyzeCommand = async (inputPath, options) => {
     // platforms (#38, #40). Force-exit to ensure clean termination.
     process.exit(0);
 };
+export function buildPipelineRunOptionsForAnalyze(resolvedOptions, options) {
+    return {
+        includeExtensions: resolvedOptions.includeExtensions,
+        scopeRules: resolvedOptions.scopeRules,
+        ...(options?.csharpDefineCsproj
+            ? { csharpDefineCsproj: options.csharpDefineCsproj }
+            : {}),
+    };
+}
 async function persistUnityParitySeed(storagePath, seed) {
     const seedPath = path.join(storagePath, 'unity-parity-seed.json');
     if (!seed) {

package/dist/cli/analyze.test.d.ts

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

package/dist/cli/analyze.test.js

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { buildPipelineRunOptionsForAnalyze } from './analyze.js';
+import { resolveScopeManifestForAnalyze } from './sync-manifest.js';
+test('analyze auto-loads .gitnexus/sync-manifest.txt when CLI scope options are omitted', async () => {
+    const repoPath = path.join('/tmp', 'demo-repo');
+    const expectedManifest = path.join(repoPath, '.gitnexus', 'sync-manifest.txt');
+    const resolved = await resolveScopeManifestForAnalyze(repoPath, {}, async (candidate) => candidate === expectedManifest);
+    assert.equal(resolved, expectedManifest);
+});
+test('explicit --scope-manifest still wins over auto-detected default file', async () => {
+    const repoPath = path.join('/tmp', 'demo-repo');
+    const explicitManifest = path.join(repoPath, 'custom-manifest.txt');
+    const resolved = await resolveScopeManifestForAnalyze(repoPath, { scopeManifest: explicitManifest }, async () => true);
+    assert.equal(resolved, explicitManifest);
+});
+test('buildPipelineRunOptionsForAnalyze passes csharp define csproj option through to pipeline', () => {
+    const out = buildPipelineRunOptionsForAnalyze({ includeExtensions: ['.cs'], scopeRules: ['Assets/**'] }, { csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj' });
+    assert.deepEqual(out, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/**'],
+        csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj',
+    });
+});

package/dist/cli/benchmark-agent-context.js

@@ -27,7 +27,7 @@ export async function benchmarkAgentContextCommand(dataset, options, deps) {
         }
         const analyzePath = path.resolve(options.targetPath);
         const analyzeOptions = {
-            extensions: options.extensions || '.cs',
+            extensions: options.extensions,
             repoAlias: options.repoAlias,
             scopeManifest: options.scopeManifest,
             scopePrefix: options.scopePrefix,

package/dist/cli/benchmark-unity.js

@@ -18,7 +18,7 @@ export async function benchmarkUnityCommand(dataset, options) {
         targetPath: options.targetPath,
         profile: profileConfig,
         reportDir: options.reportDir,
-        extensions: options.extensions || '.cs',
+        extensions: options.extensions,
         scopeManifest: options.scopeManifest,
         scopePrefix: options.scopePrefix,
         skipAnalyze: options.skipAnalyze ?? false,

package/dist/cli/benchmark-unity.test.js

@@ -1,14 +1,18 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { resolveProfileConfig } from './benchmark-unity.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const packagePath = path.resolve(here, '..', '..', 'package.json');
 test('quick profile uses reduced sample limits', () => {
     const c = resolveProfileConfig('quick');
     assert.equal(c.maxSymbols, 10);
     assert.equal(c.maxTasks, 5);
 });
 test('package scripts include neonspark benchmark commands', async () => {
-    const raw = await fs.readFile('package.json', 'utf-8');
+    const raw = await fs.readFile(packagePath, 'utf-8');
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts || {};
     assert.ok(scripts['benchmark:neonspark:full']);

package/dist/cli/index.js

@@ -29,6 +29,8 @@ program
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--extensions <list>', 'Comma-separated file extensions to include (e.g. .cs,.ts)')
     .option('--repo-alias <name>', 'Override indexed repository name with a stable alias')
+    .option('--csharp-define-csproj <path>', 'Load C# DefineConstants from the specified .csproj and normalize conditional-compilation blocks before parsing')
+    .option('--sync-manifest-policy <policy>', 'When CLI options differ from sync manifest directives: ask|update|keep|error (default: ask)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .option('--scope-manifest <path>', 'Manifest file with scope rules (supports comments and * wildcard; recommended: .gitnexus/sync-manifest.txt)')
@@ -150,7 +152,7 @@ program
     .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
     .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
     .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark')
-    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--extensions <list>', 'Analyze extension filter (comma-separated, optional)')
     .option('--scope-manifest <path>', 'Analyze scope manifest file')
     .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
     .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
@@ -163,7 +165,7 @@ program
     .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
     .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
     .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark-agent-context')
-    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--extensions <list>', 'Analyze extension filter (comma-separated, optional)')
     .option('--scope-manifest <path>', 'Analyze scope manifest file')
     .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
     .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')

package/dist/cli/scope-manifest-config.d.ts

@@ -0,0 +1,9 @@
+export interface ScopeManifestConfig {
+    scopeRules: string[];
+    directives: {
+        extensions?: string;
+        repoAlias?: string;
+        embeddings?: string;
+    };
+}
+export declare function parseScopeManifestConfig(raw: string): ScopeManifestConfig;

package/dist/cli/scope-manifest-config.js

@@ -0,0 +1,37 @@
+import { normalizeScopeRules, normalizeScopedPath } from '../core/ingestion/scope-filter.js';
+const SUPPORTED_DIRECTIVES = new Set(['extensions', 'repoalias', 'embeddings']);
+export function parseScopeManifestConfig(raw) {
+    const scopeRules = [];
+    const directives = {};
+    const lines = raw.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        if (trimmed.startsWith('@')) {
+            const separatorIndex = trimmed.indexOf('=');
+            if (separatorIndex <= 1) {
+                throw new Error(`Invalid manifest directive at line ${index + 1}: ${trimmed}`);
+            }
+            const key = trimmed.slice(1, separatorIndex).trim().toLowerCase();
+            const value = trimmed.slice(separatorIndex + 1).trim();
+            if (!SUPPORTED_DIRECTIVES.has(key)) {
+                throw new Error(`Unknown manifest directive: @${key}`);
+            }
+            if (key === 'extensions')
+                directives.extensions = value;
+            else if (key === 'repoalias')
+                directives.repoAlias = value;
+            else if (key === 'embeddings')
+                directives.embeddings = value;
+            continue;
+        }
+        const normalized = normalizeScopedPath(trimmed);
+        if (normalized)
+            scopeRules.push(normalized);
+    }
+    return {
+        scopeRules: normalizeScopeRules(scopeRules),
+        directives,
+    };
+}