@veewo/gitnexus 1.5.7 → 1.5.9

package/dist/cli/ai-context.js

@@ -44,7 +44,6 @@ function generateGitNexusContent(projectName, stats, skillScope, generatedSkills
 
 > 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
 
@@ -55,8 +54,7 @@ function generateGitNexusContent(projectName, stats, skillScope, generatedSkills
 | Trace bugs / "Why is X failing?" | \`${skillRoot}/gitnexus-debugging/SKILL.md\` |
 | Rename / extract / split / refactor | \`${skillRoot}/gitnexus-refactoring/SKILL.md\` |
 | Tools, resources, schema reference | \`${skillRoot}/gitnexus-guide/SKILL.md\` |
-| Index, status, clean, wiki CLI commands | \`${skillRoot}/gitnexus-cli/SKILL.md\` |
-| Create Unity analyze_rules interactively | \`${skillRoot}/gitnexus-unity-rule-gen/SKILL.md\` |${generatedRows}
+| Index, status, clean, wiki CLI commands | \`${skillRoot}/gitnexus-cli/SKILL.md\` |${generatedRows}
 
 ${GITNEXUS_END_MARKER}`;
 }
@@ -135,10 +133,6 @@ async function installSkills(repoPath) {
             name: 'gitnexus-cli',
             description: 'Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: "Index this repo", "Reanalyze the codebase", "Generate a wiki"',
         },
-        {
-            name: 'gitnexus-unity-rule-gen',
-            description: 'Use when the user wants to create Unity analyze_rules for a Unity project repo — interactively collecting chain clues, exploring the graph, generating rule YAML, compiling, and verifying. Examples: "Create unity rules", "Generate analyze rules", "Add resource binding rules for this Unity project"',
-        },
     ];
     for (const skill of skills) {
         const skillDir = path.join(skillsDir, skill.name);

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

@@ -4,6 +4,7 @@ export interface StoredAnalyzeOptions {
     repoAlias?: string;
     embeddings?: boolean;
     csharpDefineCsproj?: string;
+    aiContext?: boolean;
 }
 export interface ResolveAnalyzeOptionsInput {
     extensions?: string;
@@ -12,6 +13,7 @@ export interface ResolveAnalyzeOptionsInput {
     embeddings?: boolean;
     reuseOptions?: boolean;
     csharpDefineCsproj?: string;
+    aiContext?: boolean;
 }
 export interface EffectiveAnalyzeOptions {
     includeExtensions: string[];
@@ -19,6 +21,7 @@ export interface EffectiveAnalyzeOptions {
     repoAlias?: string;
     embeddings: boolean;
     csharpDefineCsproj?: string;
+    aiContext: boolean;
 }
 export declare function parseExtensionList(rawExtensions?: string): string[];
 /** Parse comma-separated scope rules (e.g. "Assets/,Packages/com.veewo.*"). */
@@ -30,6 +33,7 @@ export interface ValidatedStoredOptions {
     repoAlias?: string;
     embeddings: boolean;
     csharpDefineCsproj?: string;
+    aiContext: boolean;
 }
 /**
  * Validate stored options from meta.json.analyzeOptions before reusing them.

package/dist/cli/analyze-options.js

@@ -35,7 +35,14 @@ export function normalizeRepoAlias(repoAlias) {
  */
 export async function validateStoredOptions(stored, repoPath) {
     if (!stored) {
-        return { includeExtensions: [], scopeRules: [], repoAlias: undefined, embeddings: false, csharpDefineCsproj: undefined };
+        return {
+            includeExtensions: [],
+            scopeRules: [],
+            repoAlias: undefined,
+            embeddings: false,
+            csharpDefineCsproj: undefined,
+            aiContext: true,
+        };
     }
     // Validate repoAlias
     let repoAlias;
@@ -84,6 +91,7 @@ export async function validateStoredOptions(stored, repoPath) {
         repoAlias,
         embeddings: Boolean(stored.embeddings),
         csharpDefineCsproj,
+        aiContext: stored.aiContext !== false,
     };
 }
 export async function resolveEffectiveAnalyzeOptions(options, stored) {
@@ -94,6 +102,7 @@ export async function resolveEffectiveAnalyzeOptions(options, stored) {
     const hasCliScope = options?.scope !== undefined;
     const hasCliRepoAlias = options?.repoAlias !== undefined;
     const hasCliCsproj = options?.csharpDefineCsproj !== undefined;
+    const hasCliAiContext = options?.aiContext !== undefined;
     const canReuse = options?.reuseOptions !== false;
     const includeExtensions = hasCliExtensions
         ? includeExtensionsFromCli
@@ -110,11 +119,15 @@ export async function resolveEffectiveAnalyzeOptions(options, stored) {
     const csharpDefineCsproj = hasCliCsproj
         ? options.csharpDefineCsproj
         : (canReuse ? stored?.csharpDefineCsproj : undefined);
+    const aiContext = hasCliAiContext
+        ? options.aiContext !== false
+        : (canReuse ? stored?.aiContext !== false : true);
     return {
         includeExtensions: [...includeExtensions],
         scopeRules: [...scopeRules],
         repoAlias,
         embeddings,
         csharpDefineCsproj,
+        aiContext,
     };
 }

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

@@ -20,11 +20,13 @@ test('resolveEffectiveAnalyzeOptions reuses stored settings when CLI omits them'
         scopeRules: ['Assets/NEON/Code'],
         repoAlias: 'neonspark-v1-subset',
         embeddings: true,
+        aiContext: false,
     });
     assert.deepEqual(resolved.includeExtensions, ['.cs']);
     assert.deepEqual(resolved.scopeRules, ['Assets/NEON/Code']);
     assert.equal(resolved.repoAlias, 'neonspark-v1-subset');
     assert.equal(resolved.embeddings, true);
+    assert.equal(resolved.aiContext, false);
 });
 test('resolveEffectiveAnalyzeOptions disables reuse via reuseOptions=false', async () => {
     const resolved = await resolveEffectiveAnalyzeOptions({ reuseOptions: false }, {
@@ -33,12 +35,14 @@ test('resolveEffectiveAnalyzeOptions disables reuse via reuseOptions=false', asy
         repoAlias: 'neonspark-v1-subset',
         embeddings: true,
         csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj',
+        aiContext: false,
     });
     assert.deepEqual(resolved.includeExtensions, []);
     assert.deepEqual(resolved.scopeRules, []);
     assert.equal(resolved.repoAlias, undefined);
     assert.equal(resolved.embeddings, false);
     assert.equal(resolved.csharpDefineCsproj, undefined);
+    assert.equal(resolved.aiContext, true);
 });
 test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored settings', async () => {
     const resolved = await resolveEffectiveAnalyzeOptions({
@@ -46,16 +50,19 @@ test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored set
         scope: 'src/',
         repoAlias: 'new-alias',
         embeddings: false,
+        aiContext: true,
     }, {
         includeExtensions: ['.cs'],
         scopeRules: ['Assets/NEON/Code'],
         repoAlias: 'old-alias',
         embeddings: true,
+        aiContext: false,
     });
     assert.deepEqual(resolved.includeExtensions, ['.ts']);
     assert.deepEqual(resolved.scopeRules, ['src']);
     assert.equal(resolved.repoAlias, 'new-alias');
     assert.equal(resolved.embeddings, false);
+    assert.equal(resolved.aiContext, true);
 });
 test('resolveEffectiveAnalyzeOptions no stored uses defaults', async () => {
     const resolved = await resolveEffectiveAnalyzeOptions({}, undefined);
@@ -64,6 +71,7 @@ test('resolveEffectiveAnalyzeOptions no stored uses defaults', async () => {
     assert.equal(resolved.repoAlias, undefined);
     assert.equal(resolved.embeddings, false);
     assert.equal(resolved.csharpDefineCsproj, undefined);
+    assert.equal(resolved.aiContext, true);
 });
 test('resolveEffectiveAnalyzeOptions reuses stored scopeRules when CLI scope is omitted', async () => {
     const resolved = await resolveEffectiveAnalyzeOptions({ extensions: '.ts' }, {
@@ -87,6 +95,18 @@ test('resolveEffectiveAnalyzeOptions CLI csharpDefineCsproj overrides stored', a
     });
     assert.equal(resolved.csharpDefineCsproj, '/new/path.csproj');
 });
+test('resolveEffectiveAnalyzeOptions reuses stored aiContext=false', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({}, {
+        aiContext: false,
+    });
+    assert.equal(resolved.aiContext, false);
+});
+test('resolveEffectiveAnalyzeOptions CLI aiContext=true overrides stored false', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ aiContext: true }, {
+        aiContext: false,
+    });
+    assert.equal(resolved.aiContext, true);
+});
 // ─── validateStoredOptions tests ────────────────────────────────────
 test('validateStoredOptions returns defaults when stored is undefined', async () => {
     const result = await validateStoredOptions(undefined, '/tmp');
@@ -95,6 +115,7 @@ test('validateStoredOptions returns defaults when stored is undefined', async ()
     assert.equal(result.repoAlias, undefined);
     assert.equal(result.embeddings, false);
     assert.equal(result.csharpDefineCsproj, undefined);
+    assert.equal(result.aiContext, true);
 });
 test('validateStoredOptions passes valid options unchanged', async () => {
     const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-validate-'));
@@ -106,12 +127,14 @@ test('validateStoredOptions passes valid options unchanged', async () => {
         repoAlias: 'my-repo',
         csharpDefineCsproj: csprojPath,
         embeddings: true,
+        aiContext: false,
     }, tmpDir);
     assert.deepEqual(result.includeExtensions, ['.cs', '.ts']);
     assert.deepEqual(result.scopeRules, ['Assets/']);
     assert.equal(result.repoAlias, 'my-repo');
     assert.equal(result.csharpDefineCsproj, csprojPath);
     assert.equal(result.embeddings, true);
+    assert.equal(result.aiContext, false);
 });
 test('validateStoredOptions warns on invalid repoAlias and falls back', async () => {
     const result = await validateStoredOptions({

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

@@ -4,7 +4,6 @@ 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,7 +7,6 @@ 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,
@@ -21,6 +20,5 @@ test('toPipelineRuntimeSummary drops graph reference and preserves reporting fie
     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,5 +1,4 @@
 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;
@@ -7,6 +6,5 @@ export interface FallbackInsertStats {
 }
 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

@@ -32,30 +32,6 @@ 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, formatUnityRuleBindingSummary, resolveFallbackStats, } from './analyze-summary.js';
+import { formatFallbackSummary, formatUnityDiagnosticsSummary, resolveFallbackStats, } from './analyze-summary.js';
 test('formatUnityDiagnosticsSummary returns empty when diagnostics are missing', () => {
     const lines = formatUnityDiagnosticsSummary([]);
     assert.deepEqual(lines, []);
@@ -29,70 +29,6 @@ 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

@@ -5,6 +5,7 @@
  */
 export interface AnalyzeOptions {
     force?: boolean;
+    aiContext?: boolean;
     embeddings?: boolean;
     extensions?: string;
     scope?: string;

package/dist/cli/analyze.js

@@ -19,7 +19,7 @@ import { generateAIContextFiles } from './ai-context.js';
 import { generateSkillFiles } from './skill-gen.js';
 import fs from 'fs/promises';
 import { resolveEffectiveAnalyzeOptions, validateStoredOptions } from './analyze-options.js';
-import { formatCSharpPreprocDiagnosticsSummary, formatFallbackSummary, formatUnityDiagnosticsSummary, formatUnityRuleBindingSummary, 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';
 const HEAP_MB = 8192;
@@ -111,6 +111,7 @@ export const analyzeCommand = async (inputPath, options) => {
     let repoAlias;
     let embeddingsEnabled = false;
     let csharpDefineCsproj;
+    let aiContextEnabled = true;
     try {
         const validatedStored = await validateStoredOptions(options?.reuseOptions !== false ? existingMeta?.analyzeOptions : undefined, repoPath);
         const effectiveOptions = await resolveEffectiveAnalyzeOptions({
@@ -120,12 +121,14 @@ export const analyzeCommand = async (inputPath, options) => {
             embeddings: options?.embeddings,
             reuseOptions: options?.reuseOptions,
             csharpDefineCsproj: options?.csharpDefineCsproj,
+            aiContext: options?.aiContext,
         }, validatedStored);
         includeExtensions = effectiveOptions.includeExtensions;
         scopeRules = effectiveOptions.scopeRules;
         repoAlias = effectiveOptions.repoAlias;
         embeddingsEnabled = effectiveOptions.embeddings;
         csharpDefineCsproj = effectiveOptions.csharpDefineCsproj;
+        aiContextEnabled = effectiveOptions.aiContext;
     }
     catch (error) {
         console.log(`  ${error?.message || String(error)}\n`);
@@ -141,6 +144,7 @@ export const analyzeCommand = async (inputPath, options) => {
             options?.repoAlias !== undefined ||
             options?.csharpDefineCsproj !== undefined ||
             options?.embeddings !== undefined ||
+            options?.aiContext !== undefined ||
             options?.reuseOptions === false;
         if (!hasCliOverrides) {
             console.log('  Already up to date\n');
@@ -150,7 +154,8 @@ export const analyzeCommand = async (inputPath, options) => {
             includeExtensions.length === 0 &&
             scopeRules.length === 0 &&
             !repoAlias &&
-            !embeddingsEnabled) {
+            !embeddingsEnabled &&
+            aiContextEnabled) {
             console.log('  Already up to date\n');
             return;
         }
@@ -350,6 +355,7 @@ export const analyzeCommand = async (inputPath, options) => {
             scopeRules,
             repoAlias,
             embeddings: embeddingsEnabled,
+            aiContext: aiContextEnabled,
             ...(csharpDefineCsproj ? { csharpDefineCsproj } : {}),
         },
         stats: {
@@ -382,17 +388,20 @@ export const analyzeCommand = async (inputPath, options) => {
         const skillResult = await generateSkillFiles(repoPath, projectName, pipelineForSkills);
         generatedSkills = skillResult.skills;
     }
-    const cliConfig = await loadCLIConfig();
-    const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
-        files: pipelineRuntime.totalFileCount,
-        nodes: stats.nodes,
-        edges: stats.edges,
-        communities: pipelineRuntime.communityResult?.stats.totalCommunities,
-        clusters: aggregatedClusterCount,
-        processes: pipelineRuntime.processResult?.stats.totalProcesses,
-    }, {
-        skillScope: (cliConfig.setupScope === 'global') ? 'global' : 'project',
-    }, generatedSkills);
+    let aiContext = { files: [] };
+    if (aiContextEnabled) {
+        const cliConfig = await loadCLIConfig();
+        aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
+            files: pipelineRuntime.totalFileCount,
+            nodes: stats.nodes,
+            edges: stats.edges,
+            communities: pipelineRuntime.communityResult?.stats.totalCommunities,
+            clusters: aggregatedClusterCount,
+            processes: pipelineRuntime.processResult?.stats.totalProcesses,
+        }, {
+            skillScope: (cliConfig.setupScope === 'global') ? 'global' : 'project',
+        }, generatedSkills);
+    }
     await closeLbug();
     // Note: we intentionally do NOT call disposeEmbedder() here.
     // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
@@ -432,10 +441,6 @@ 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}`);
@@ -446,7 +451,10 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log(`  File filter: ${includeExtensions.join(', ')}`);
     }
     console.log(`  ${repoPath}`);
-    if (aiContext.files.length > 0) {
+    if (!aiContextEnabled) {
+        console.log('  Context: skipped (--no-ai-context)');
+    }
+    else if (aiContext.files.length > 0) {
         console.log(`  Context: ${aiContext.files.join(', ')}`);
     }
     if (lbugWarnings.length > 0) {

package/dist/cli/clean.js

@@ -5,7 +5,28 @@
  * Also unregisters the repo from the global registry.
  */
 import fs from 'fs/promises';
+import path from 'path';
 import { findRepo, unregisterRepo, listRegisteredRepos } from '../storage/repo-manager.js';
+/**
+ * Selectively delete contents of a .gitnexus directory, preserving config files.
+ * Preserves: meta.json, config.json, .gitnexusignore
+ */
+const selectiveClean = async (storagePath) => {
+    const PRESERVE = new Set(['meta.json', 'config.json', '.gitnexusignore']);
+    let entries;
+    try {
+        entries = await fs.readdir(storagePath);
+    }
+    catch {
+        // Directory doesn't exist, nothing to clean
+        return;
+    }
+    for (const entry of entries) {
+        if (PRESERVE.has(entry))
+            continue;
+        await fs.rm(path.join(storagePath, entry), { recursive: true, force: true });
+    }
+};
 export const cleanCommand = async (options) => {
     // --all flag: clean all indexed repos
     if (options?.all) {
@@ -25,7 +46,7 @@ export const cleanCommand = async (options) => {
         const entries = await listRegisteredRepos();
         for (const entry of entries) {
             try {
-                await fs.rm(entry.storagePath, { recursive: true, force: true });
+                await selectiveClean(entry.storagePath);
                 await unregisterRepo(entry.path);
                 console.log(`Cleaned: ${entry.name} (${entry.storagePath})`);
             }
@@ -50,7 +71,7 @@ export const cleanCommand = async (options) => {
         return;
     }
     try {
-        await fs.rm(repo.storagePath, { recursive: true, force: true });
+        await selectiveClean(repo.storagePath);
         await unregisterRepo(repo.repoPath);
         console.log(`Cleaned: ${repo.storagePath}`);
     }

package/dist/cli/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 // Heap re-spawn removed — only analyze.ts needs the 8GB heap (via its own ensureHeap()).
 // Removing it from here improves MCP server startup time significantly.
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { createRequire } from 'node:module';
 import { createLazyAction } from './lazy-action.js';
-import { attachRuleLabCommands } from './rule-lab.js';
 const _require = createRequire(import.meta.url);
 const pkg = _require('../../package.json');
 const program = new Command();
@@ -25,6 +24,8 @@ program
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
     .option('--no-reuse-options', 'Do not reuse stored analyze options from previous index')
+    .addOption(new Option('--ai-context', 'Write AGENTS.md/CLAUDE.md and install repo-local GitNexus skills').hideHelp())
+    .option('--no-ai-context', 'Skip writing AGENTS.md/CLAUDE.md and installing repo-local GitNexus skills')
     .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')
@@ -58,7 +59,6 @@ program
     .option('-f, --force', 'Skip confirmation prompt')
     .option('--all', 'Clean all indexed repos')
     .action(createLazyAction(() => import('./clean.js'), 'cleanCommand'));
-attachRuleLabCommands(program, (handlerName) => createLazyAction(() => import('./rule-lab.js'), handlerName));
 program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')

package/dist/cli/repo-manager-alias.test.js

@@ -51,6 +51,7 @@ test('saveMeta/loadMeta persists analyzeOptions for future re-index reuse', asyn
             scopeRules: ['Assets/NEON/Code'],
             repoAlias: 'neonspark-v1-subset',
             embeddings: true,
+            aiContext: false,
         },
         stats: { files: 1, nodes: 2, edges: 3 },
     });
@@ -60,6 +61,7 @@ test('saveMeta/loadMeta persists analyzeOptions for future re-index reuse', asyn
         scopeRules: ['Assets/NEON/Code'],
         repoAlias: 'neonspark-v1-subset',
         embeddings: true,
+        aiContext: false,
     });
     assert.equal(meta?.repoId, 'neonspark-v1-subset');
 });

package/dist/core/ingestion/pipeline.js

@@ -9,11 +9,9 @@ import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
 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';
@@ -341,7 +339,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         let communityResult;
         let processResult;
         let unityResult;
-        let unityRuleBindingResult;
         if (!options?.skipGraphPhases) {
             // ── Phase 4.5: Method Resolution Order ──────────────────────────────
             onProgress({
@@ -422,45 +419,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             if (isDev && isUnityProject) {
                 console.log(`[UnityLifecycle] auto-detected hosts=${unityLifecycleSyntheticResult.hostCount} syntheticEdges=${unityLifecycleSyntheticResult.syntheticEdgeCount} rejectedHosts=${unityLifecycleSyntheticResult.rejectedHostCount}`);
             }
-            // Phase 5.7: rule-driven binding injection (Phase 3)
-            try {
-                const analyzeRules = await loadAnalyzeRules(repoPath);
-                const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
-                unityRuleBindingResult = bindingResult;
-                if (isDev && bindingResult.edgesInjected > 0) {
-                    console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
-                }
-            }
-            catch (err) {
-                // rule catalog missing or invalid — skip silently
-                console.warn(`[UnityRuleBinding] failed to load or apply analyze rules: ${err instanceof Error ? err.message : String(err)}`);
-                const reason = err instanceof Error ? err.message : String(err);
-                unityRuleBindingResult = {
-                    edgesInjected: 0,
-                    ruleResults: [],
-                    diagnostics: {
-                        rulesEvaluated: 0,
-                        bindingsEvaluated: 0,
-                        bindingsByKind: {},
-                        methodLookupCalls: 0,
-                        methodLookupCacheHits: 0,
-                        sceneRuntimeTraversalCalls: 0,
-                        sceneRuntimeTraversalCacheHits: 0,
-                        sceneRuntimeResourcesVisited: 0,
-                        anomalies: [`failed to load/apply analyze rules: ${reason}`],
-                        shouldAgentReport: true,
-                        agentReportReason: 'failed to load/apply analyze rules',
-                        summary: [
-                            'rule_binding.summary: rules=0, bindings=0, edges=0',
-                            'rule_binding.bindings_by_kind: none',
-                            'rule_binding.lookup: method_calls=0, cache_hits=0',
-                            'rule_binding.scene_closure: traversals=0, cache_hits=0, visited_resources=0',
-                            'rule_binding.agent_report: should_report=true reason="failed to load/apply analyze rules"',
-                            `rule_binding.anomaly: failed to load/apply analyze rules: ${reason}`,
-                        ],
-                    },
-                };
-            }
             // ── Phase 6: Processes ─────────────────────────────────────────────
             onProgress({
                 phase: 'processes',
@@ -545,7 +503,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             communityResult,
             processResult,
             unityResult,
-            unityRuleBindingResult,
             scopeDiagnostics: scopeSelection.diagnostics,
             csharpPreprocDiagnostics,
         };