@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/benchmark/u2-e2e/retrieval-runner.test.js

@@ -43,6 +43,52 @@ test('runSymbolScenario executes context off/on + deepDive and records metrics',
     assert.ok(out.steps.every((s) => s.totalTokensEst >= 0));
     assert.equal(out.assertions.pass, true);
 });
+test('runSymbolScenario injects response_profile=full for legacy context/query steps', async () => {
+    const seen = [];
+    const runner = {
+        context: async (input) => {
+            seen.push({ tool: 'context', input });
+            if (input.unity_resources === 'on') {
+                return {
+                    status: 'found',
+                    hydrationMeta: {
+                        requestedMode: 'compact',
+                        effectiveMode: 'compact',
+                        isComplete: false,
+                        needsParityRetry: true,
+                    },
+                    resourceBindings: [{ resourcePath: 'Assets/Prefabs/UI.prefab', resourceType: 'prefab' }],
+                };
+            }
+            return { status: 'found' };
+        },
+        query: async (input) => {
+            seen.push({ tool: 'query', input });
+            return {
+                process_symbols: [{ id: 'Class:MainUIManager' }],
+                definitions: [{ name: 'DoorObj', resourceBindings: [{ resourcePath: 'Assets/A.prefab' }] }],
+            };
+        },
+        impact: async (input) => {
+            seen.push({ tool: 'impact', input });
+            return { impactedCount: 1 };
+        },
+        cypher: async (input) => {
+            seen.push({ tool: 'cypher', input });
+            return { rows: [] };
+        },
+    };
+    await runSymbolScenario(runner, {
+        symbol: 'MainUIManager',
+        kind: 'component',
+        objectives: ['verify context'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'MainUIManager' } }],
+    });
+    const contextCalls = seen.filter((entry) => entry.tool === 'context');
+    const queryCalls = seen.filter((entry) => entry.tool === 'query');
+    assert.equal(contextCalls.every((entry) => entry.input.response_profile === 'full'), true);
+    assert.equal(queryCalls.every((entry) => entry.input.response_profile === 'full'), true);
+});
 test('AssetRef requires context(on) resourceBindings after serializable-class coverage', async () => {
     const noEvidenceRunner = {
         context: async () => ({

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,9 @@ 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.
+> \`query/context\` slim guidance is narrowing-first: inspect \`decision.recommended_follow_up\`, \`missing_proof_targets\`, and \`suggested_context_targets\` before upgrading to \`response_profile=full\`.
+> Query-time runtime closure is graph-only and does not require \`verification_rules\` / \`trigger_tokens\`; if you need hydration diagnostics such as \`needsParityRetry\` or strict fallback state, rerun with \`response_profile=full\` and then use parity before closure claims.
 
 ## Skills
 
@@ -204,8 +204,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/ai-context.test.js

@@ -21,10 +21,14 @@ test('generateAIContextFiles installs repo skills under .agents/skills/gitnexus'
         const claudeContent = await fs.readFile(claudePath, 'utf-8');
         await fs.access(skillPath);
         await fs.access(sharedRuntimeContractPath);
+        assert.match(agentsContent, /slim guidance is narrowing-first/);
+        assert.match(agentsContent, /Query-time runtime closure is graph-only/);
         assert.match(agentsContent, /\.agents\/skills\/gitnexus\/gitnexus-exploring\/SKILL\.md/);
         assert.match(claudeContent, /\.agents\/skills\/gitnexus\/gitnexus-exploring\/SKILL\.md/);
         assert.doesNotMatch(agentsContent, /## Unity Runtime Process 真理源/);
         assert.doesNotMatch(claudeContent, /## Unity Runtime Process 真理源/);
+        assert.doesNotMatch(agentsContent, /## Dev Workflow \(Source Build\)/);
+        assert.doesNotMatch(claudeContent, /## Dev Workflow \(Source Build\)/);
         assert.equal(agentsContent, claudeContent, 'AGENTS.md and CLAUDE.md should stay content-identical');
         assert.ok(result.files.some((entry) => entry.includes('.agents/skills/gitnexus/')), 'expected generated file summary to include .agents/skills/gitnexus/');
         await assert.rejects(fs.access(legacyClaudeSkillsDir));
@@ -46,10 +50,14 @@ test('generateAIContextFiles with global scope skips repo skill install', async
         const localSkillsDir = path.join(repoPath, '.agents', 'skills', 'gitnexus');
         const agentsContent = await fs.readFile(agentsPath, 'utf-8');
         const claudeContent = await fs.readFile(claudePath, 'utf-8');
+        assert.match(agentsContent, /slim guidance is narrowing-first/);
+        assert.match(agentsContent, /Query-time runtime closure is graph-only/);
         assert.match(agentsContent, /~\/\.agents\/skills\/gitnexus\/gitnexus-exploring\/SKILL\.md/);
         assert.match(claudeContent, /~\/\.agents\/skills\/gitnexus\/gitnexus-exploring\/SKILL\.md/);
         assert.doesNotMatch(agentsContent, /## Unity Runtime Process 真理源/);
         assert.doesNotMatch(claudeContent, /## Unity Runtime Process 真理源/);
+        assert.doesNotMatch(agentsContent, /## Dev Workflow \(Source Build\)/);
+        assert.doesNotMatch(claudeContent, /## Dev Workflow \(Source Build\)/);
         assert.equal(agentsContent, claudeContent, 'AGENTS.md and CLAUDE.md should stay content-identical');
         assert.ok(!result.files.some((entry) => entry.includes('.agents/skills/gitnexus/')), 'did not expect repo-local skills in generated file summary');
         await assert.rejects(fs.access(localSkillsDir));

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

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

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

@@ -7,8 +7,20 @@ test('toPipelineRuntimeSummary drops graph reference and preserves reporting fie
         communityResult: { stats: { totalCommunities: 3 } },
         processResult: { stats: { totalProcesses: 2 } },
         unityResult: { diagnostics: ['scanContext: scripts=1'] },
+        unityRuleBindingResult: { edgesInjected: 1, ruleResults: [], diagnostics: { summary: [] } },
+        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.unityRuleBindingResult?.edgesInjected, 1);
+    assert.equal(out.csharpPreprocDiagnostics?.normalizedFiles, 1);
 });

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

@@ -1,8 +1,12 @@
+import type { CSharpPreprocDiagnostics } from '../types/pipeline.js';
+import type { UnityRuntimeBindingResult } from '../core/ingestion/unity-runtime-binding-rules.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 formatUnityRuleBindingSummary(result: UnityRuntimeBindingResult | 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 [];
@@ -13,6 +32,30 @@ export function formatUnityDiagnosticsSummary(diagnostics, previewLimit = 3) {
     }
     return lines;
 }
+export function formatUnityRuleBindingSummary(result, previewLimit = 3) {
+    if (!result)
+        return [];
+    const diagnostics = result.diagnostics;
+    const lines = ['Unity Rule Binding Diagnostics:'];
+    for (const message of diagnostics.summary) {
+        if (!message.startsWith('rule_binding.anomaly:')) {
+            lines.push(`- ${message}`);
+        }
+    }
+    const anomalies = diagnostics.anomalies;
+    if (anomalies.length === 0) {
+        return lines;
+    }
+    lines.push(`- rule_binding.anomalies: count=${anomalies.length}`);
+    const limit = previewLimit > 0 ? previewLimit : anomalies.length;
+    for (const message of anomalies.slice(0, limit)) {
+        lines.push(`- rule_binding.anomaly: ${message}`);
+    }
+    if (anomalies.length > limit) {
+        lines.push(`- rule_binding.anomaly: ... ${anomalies.length - limit} more`);
+    }
+    return lines;
+}
 export function formatFallbackSummary(warnings, stats, previewLimit = 5) {
     if (!warnings || warnings.length === 0) {
         return [];

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

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { formatFallbackSummary, formatUnityDiagnosticsSummary, resolveFallbackStats } from './analyze-summary.js';
+import { formatFallbackSummary, formatUnityDiagnosticsSummary, formatUnityRuleBindingSummary, resolveFallbackStats, } from './analyze-summary.js';
 test('formatUnityDiagnosticsSummary returns empty when diagnostics are missing', () => {
     const lines = formatUnityDiagnosticsSummary([]);
     assert.deepEqual(lines, []);
@@ -29,6 +29,70 @@ test('formatUnityDiagnosticsSummary truncates output after max preview items', (
         '... 1 more',
     ]);
 });
+test('formatUnityRuleBindingSummary renders diagnostics and agent report status', () => {
+    const lines = formatUnityRuleBindingSummary({
+        edgesInjected: 3,
+        ruleResults: [{ ruleId: 'unity.global-init', edgesInjected: 3 }],
+        diagnostics: {
+            rulesEvaluated: 1,
+            bindingsEvaluated: 1,
+            bindingsByKind: { method_triggers_scene_load: 1 },
+            methodLookupCalls: 5,
+            methodLookupCacheHits: 4,
+            sceneRuntimeTraversalCalls: 3,
+            sceneRuntimeTraversalCacheHits: 2,
+            sceneRuntimeResourcesVisited: 6,
+            anomalies: [],
+            shouldAgentReport: false,
+            agentReportReason: 'no anomalies detected',
+            summary: [
+                'rule_binding.summary: rules=1, bindings=1, edges=3',
+                'rule_binding.lookup: method_calls=5, cache_hits=4',
+                'rule_binding.agent_report: should_report=false reason="no anomalies detected"',
+            ],
+        },
+    });
+    assert.deepEqual(lines, [
+        'Unity Rule Binding Diagnostics:',
+        '- rule_binding.summary: rules=1, bindings=1, edges=3',
+        '- rule_binding.lookup: method_calls=5, cache_hits=4',
+        '- rule_binding.agent_report: should_report=false reason="no anomalies detected"',
+    ]);
+});
+test('formatUnityRuleBindingSummary renders anomaly preview', () => {
+    const lines = formatUnityRuleBindingSummary({
+        edgesInjected: 0,
+        ruleResults: [],
+        diagnostics: {
+            rulesEvaluated: 1,
+            bindingsEvaluated: 1,
+            bindingsByKind: { method_triggers_scene_load: 1 },
+            methodLookupCalls: 0,
+            methodLookupCacheHits: 0,
+            sceneRuntimeTraversalCalls: 0,
+            sceneRuntimeTraversalCacheHits: 0,
+            sceneRuntimeResourcesVisited: 0,
+            anomalies: [
+                'rule=unity.global-init: scene "Global" not found in File(.unity) index',
+                'rule=unity.global-init: method_triggers_scene_load missing host_class_pattern, loader_methods, or scene_name',
+            ],
+            shouldAgentReport: true,
+            agentReportReason: 'rule-binding anomalies detected',
+            summary: [
+                'rule_binding.summary: rules=1, bindings=1, edges=0',
+                'rule_binding.agent_report: should_report=true reason="rule-binding anomalies detected"',
+            ],
+        },
+    }, 1);
+    assert.deepEqual(lines, [
+        'Unity Rule Binding Diagnostics:',
+        '- rule_binding.summary: rules=1, bindings=1, edges=0',
+        '- rule_binding.agent_report: should_report=true reason="rule-binding anomalies detected"',
+        '- rule_binding.anomalies: count=2',
+        '- rule_binding.anomaly: rule=unity.global-init: scene "Global" not found in File(.unity) index',
+        '- rule_binding.anomaly: ... 1 more',
+    ]);
+});
 test('formatFallbackSummary returns empty when no warnings exist', () => {
     const lines = formatFallbackSummary([], {
         attempted: 0,

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, formatUnityRuleBindingSummary, 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,14 @@ export const analyzeCommand = async (inputPath, options) => {
     for (const line of unitySummaryLines) {
         console.log(`  ${line}`);
     }
+    const unityRuleBindingSummaryLines = formatUnityRuleBindingSummary(pipelineRuntime.unityRuleBindingResult);
+    for (const line of unityRuleBindingSummaryLines) {
+        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 +480,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 {};