@veewo/gitnexus 1.5.6 → 1.5.8

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

@@ -3,16 +3,13 @@
  *
  * 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;
+    scope?: string;
     repoAlias?: string;
     csharpDefineCsproj?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
-    syncManifestPolicy?: SyncManifestPolicy;
     reuseOptions?: boolean;
     skills?: boolean;
     verbose?: boolean;
@@ -21,6 +18,7 @@ export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptio
 export declare function buildPipelineRunOptionsForAnalyze(resolvedOptions: {
     includeExtensions: string[];
     scopeRules: string[];
+    csharpDefineCsproj?: string;
 }, options?: AnalyzeOptions): {
     includeExtensions: string[];
     scopeRules: string[];

package/dist/cli/analyze.js

@@ -18,11 +18,10 @@ import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
 import { generateSkillFiles } from './skill-gen.js';
 import fs from 'fs/promises';
-import { resolveEffectiveAnalyzeOptions } from './analyze-options.js';
-import { formatCSharpPreprocDiagnosticsSummary, formatFallbackSummary, formatUnityDiagnosticsSummary, formatUnityRuleBindingSummary, resolveFallbackStats, } from './analyze-summary.js';
+import { resolveEffectiveAnalyzeOptions, validateStoredOptions } from './analyze-options.js';
+import { formatCSharpPreprocDiagnosticsSummary, formatFallbackSummary, formatUnityDiagnosticsSummary, resolveFallbackStats, } from './analyze-summary.js';
 import { resolveChildProcessExit } from './exit-code.js';
 import { toPipelineRuntimeSummary } from './analyze-runtime-summary.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. */
@@ -111,31 +110,22 @@ export const analyzeCommand = async (inputPath, options) => {
     let scopeRules = [];
     let repoAlias;
     let embeddingsEnabled = false;
+    let csharpDefineCsproj;
     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 validatedStored = await validateStoredOptions(options?.reuseOptions !== false ? existingMeta?.analyzeOptions : undefined, repoPath);
         const effectiveOptions = await resolveEffectiveAnalyzeOptions({
             extensions: options?.extensions,
-            scopeManifest,
-            scopePrefix: options?.scopePrefix,
+            scope: options?.scope,
             repoAlias: options?.repoAlias,
             embeddings: options?.embeddings,
             reuseOptions: options?.reuseOptions,
-        }, existingMeta?.analyzeOptions);
+            csharpDefineCsproj: options?.csharpDefineCsproj,
+        }, validatedStored);
         includeExtensions = effectiveOptions.includeExtensions;
         scopeRules = effectiveOptions.scopeRules;
         repoAlias = effectiveOptions.repoAlias;
         embeddingsEnabled = effectiveOptions.embeddings;
+        csharpDefineCsproj = effectiveOptions.csharpDefineCsproj;
     }
     catch (error) {
         console.log(`  ${error?.message || String(error)}\n`);
@@ -146,13 +136,10 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log('  Existing metadata found, but LadybugDB index file is missing — rebuilding index...\n');
     }
     if (existingMeta && hasLbugIndex && !options?.force && existingMeta.lastCommit === currentCommit && !options?.skills) {
-        const hasScopePrefixInput = Array.isArray(options?.scopePrefix)
-            ? options.scopePrefix.length > 0
-            : Boolean(options?.scopePrefix);
         const hasCliOverrides = options?.extensions !== undefined ||
-            Boolean(options?.scopeManifest) ||
-            hasScopePrefixInput ||
+            options?.scope !== undefined ||
             options?.repoAlias !== undefined ||
+            options?.csharpDefineCsproj !== undefined ||
             options?.embeddings !== undefined ||
             options?.reuseOptions === false;
         if (!hasCliOverrides) {
@@ -253,7 +240,7 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Phase 1: Full Pipeline (0–60%) ─────────────────────────────────
     let pipelineResult;
     try {
-        const pipelineRunOptions = buildPipelineRunOptionsForAnalyze({ includeExtensions, scopeRules }, options);
+        const pipelineRunOptions = buildPipelineRunOptionsForAnalyze({ includeExtensions, scopeRules, csharpDefineCsproj });
         pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
             const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
             const scaled = Math.round(progress.percent * 0.6);
@@ -363,6 +350,7 @@ export const analyzeCommand = async (inputPath, options) => {
             scopeRules,
             repoAlias,
             embeddings: embeddingsEnabled,
+            ...(csharpDefineCsproj ? { csharpDefineCsproj } : {}),
         },
         stats: {
             files: pipelineRuntime.totalFileCount,
@@ -444,10 +432,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}`);
@@ -484,8 +468,8 @@ export function buildPipelineRunOptionsForAnalyze(resolvedOptions, options) {
     return {
         includeExtensions: resolvedOptions.includeExtensions,
         scopeRules: resolvedOptions.scopeRules,
-        ...(options?.csharpDefineCsproj
-            ? { csharpDefineCsproj: options.csharpDefineCsproj }
+        ...(resolvedOptions.csharpDefineCsproj
+            ? { csharpDefineCsproj: resolvedOptions.csharpDefineCsproj }
             : {}),
     };
 }

package/dist/cli/analyze.test.js

@@ -1,25 +1,19 @@
 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' });
+    const out = buildPipelineRunOptionsForAnalyze({ includeExtensions: ['.cs'], scopeRules: ['Assets/**'], csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj' });
     assert.deepEqual(out, {
         includeExtensions: ['.cs'],
         scopeRules: ['Assets/**'],
         csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj',
     });
 });
+test('buildPipelineRunOptionsForAnalyze omits csharpDefineCsproj when not provided', () => {
+    const out = buildPipelineRunOptionsForAnalyze({ includeExtensions: ['.cs'], scopeRules: ['Assets/**'] });
+    assert.deepEqual(out, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/**'],
+    });
+    assert.equal(Object.keys(out).includes('csharpDefineCsproj'), false);
+});

package/dist/cli/benchmark-agent-context.d.ts

@@ -17,8 +17,6 @@ export declare function benchmarkAgentContextCommand(dataset: string, options: {
     targetPath?: string;
     reportDir?: string;
     extensions?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
     skipAnalyze?: boolean;
 }, deps?: {
     loadDataset?: (root: string) => Promise<AgentContextDataset>;

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

@@ -29,8 +29,6 @@ export async function benchmarkAgentContextCommand(dataset, options, deps) {
         const analyzeOptions = {
             extensions: options.extensions,
             repoAlias: options.repoAlias,
-            scopeManifest: options.scopeManifest,
-            scopePrefix: options.scopePrefix,
         };
         try {
             await analyze(analyzePath, analyzeOptions);

package/dist/cli/benchmark-agent-safe-query-context.d.ts

@@ -8,8 +8,6 @@ export declare function benchmarkAgentSafeQueryContextCommand(dataset: string, o
     reportDir?: string;
     subagentRunsDir?: string;
     extensions?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
     skipAnalyze?: boolean;
 }, deps?: {
     loadSuite?: (root: string) => Promise<AgentSafeBenchmarkSuite>;

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

@@ -16,8 +16,6 @@ export async function benchmarkAgentSafeQueryContextCommand(dataset, options, de
         await analyze(path.resolve(options.targetPath), {
             extensions: options.extensions,
             repoAlias: options.repoAlias,
-            scopeManifest: options.scopeManifest,
-            scopePrefix: options.scopePrefix,
         });
     }
     const suite = await loadSuite(path.resolve(dataset));

package/dist/cli/benchmark-unity.d.ts

@@ -9,7 +9,5 @@ export declare function benchmarkUnityCommand(dataset: string, options: {
     targetPath?: string;
     reportDir?: string;
     extensions?: string;
-    scopeManifest?: string;
-    scopePrefix?: string[];
     skipAnalyze?: boolean;
 }): Promise<void>;

package/dist/cli/benchmark-unity.js

@@ -19,8 +19,6 @@ export async function benchmarkUnityCommand(dataset, options) {
         profile: profileConfig,
         reportDir: options.reportDir,
         extensions: options.extensions,
-        scopeManifest: options.scopeManifest,
-        scopePrefix: options.scopePrefix,
         skipAnalyze: options.skipAnalyze ?? false,
     });
     process.stderr.write(`${result.pass ? 'PASS' : 'FAIL'}\n`);

package/dist/cli/clean.d.ts

@@ -1,9 +1,8 @@
 /**
  * Clean Command
  *
- * Removes the GitNexus index from the current repository while preserving
- * configuration files (e.g. sync-manifest.txt). Also unregisters the repo
- * from the global registry.
+ * Removes the GitNexus index from the current repository.
+ * Also unregisters the repo from the global registry.
  */
 export declare const cleanCommand: (options?: {
     force?: boolean;

package/dist/cli/clean.js

@@ -1,32 +1,11 @@
 /**
  * Clean Command
  *
- * Removes the GitNexus index from the current repository while preserving
- * configuration files (e.g. sync-manifest.txt). Also unregisters the repo
- * from the global registry.
+ * Removes the GitNexus index from the current repository.
+ * 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';
-/** Files under .gitnexus/ that are configuration, not index data. */
-const PRESERVE_FILES = new Set(['sync-manifest.txt']);
-async function cleanStoragePath(storagePath) {
-    let entries;
-    try {
-        entries = await fs.readdir(storagePath);
-    }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return;
-        throw err;
-    }
-    for (const entry of entries) {
-        if (PRESERVE_FILES.has(entry))
-            continue;
-        const fullPath = path.join(storagePath, entry);
-        await fs.rm(fullPath, { recursive: true, force: true });
-    }
-}
 export const cleanCommand = async (options) => {
     // --all flag: clean all indexed repos
     if (options?.all) {
@@ -46,7 +25,7 @@ export const cleanCommand = async (options) => {
         const entries = await listRegisteredRepos();
         for (const entry of entries) {
             try {
-                await cleanStoragePath(entry.storagePath);
+                await fs.rm(entry.storagePath, { recursive: true, force: true });
                 await unregisterRepo(entry.path);
                 console.log(`Cleaned: ${entry.name} (${entry.storagePath})`);
             }
@@ -71,7 +50,7 @@ export const cleanCommand = async (options) => {
         return;
     }
     try {
-        await cleanStoragePath(repo.storagePath);
+        await fs.rm(repo.storagePath, { recursive: true, force: true });
         await unregisterRepo(repo.repoPath);
         console.log(`Cleaned: ${repo.storagePath}`);
     }

package/dist/cli/index.js

@@ -4,11 +4,9 @@
 import { Command } 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();
-const collectValues = (value, previous) => [...previous, value];
 program
     .name('gitnexus')
     .description('GitNexus local CLI and MCP server')
@@ -29,12 +27,10 @@ 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('--scope <rules>', 'Comma-separated scope path-prefix rules (e.g. Assets/,Packages/com.veewo.*)')
     .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)')
-    .option('--scope-prefix <pathPrefix>', 'Add a scope path prefix rule (repeatable)', collectValues, [])
     .addHelpText('after', '\nEnvironment variables:\n  GITNEXUS_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .gitnexusignore)')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
 program
@@ -61,7 +57,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')
@@ -155,8 +150,6 @@ program
     .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 (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')
     .action(createLazyAction(() => import('./benchmark-unity.js'), 'benchmarkUnityCommand'));
 program
@@ -168,8 +161,6 @@ program
     .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 (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')
     .action(createLazyAction(() => import('./benchmark-agent-context.js'), 'benchmarkAgentContextCommand'));
 program
@@ -181,8 +172,6 @@ program
     .option('--subagent-runs-dir <path>', 'Directory containing session-generated subagent run artifacts')
     .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark-agent-safe-query-context')
     .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')
     .action(createLazyAction(() => import('./benchmark-agent-safe-query-context.js'), 'benchmarkAgentSafeQueryContextCommand'));
 program

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';
@@ -79,7 +77,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         const scopeSelection = selectEntriesByScopeRules(scannedFiles, options?.scopeRules || []);
         const scopedFiles = scopeSelection.selected;
         if (scopeSelection.diagnostics.appliedRuleCount > 0 && scopedFiles.length === 0) {
-            throw new Error('Scope filters matched zero files. Check --scope-manifest/--scope-prefix.');
+            throw new Error('Scope filters matched zero files. Check your scope rules and extensions.');
         }
         const includeExtensions = new Set((options?.includeExtensions || [])
             .map(ext => ext.trim().toLowerCase())
@@ -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,
         };

package/dist/mcp/local/agent-safe-response.js

@@ -416,7 +416,7 @@ function buildResourceChains(resourceChains) {
             }
             : undefined,
     }))
-        .filter((chain) => Boolean(chain.sourceResourcePath && chain.intermediateResourcePath && chain.targetSymbol));
+        .filter((chain) => Boolean(chain.sourceResourcePath && chain.targetSymbol));
 }
 function buildUpgradeHints(input) {
     const repoArg = input.repoName ? ` --repo "${input.repoName}"` : '';

package/dist/mcp/local/local-backend.d.ts

@@ -46,11 +46,6 @@ interface NextHopPayload {
     why: string;
     next_command: string;
 }
-interface RetrievalRuleHint {
-    id: string;
-    next_action: string;
-    host_base_type?: string[];
-}
 export declare function pickVerificationTarget(input: {
     seedMode: ResourceSeedMode;
     seedPath?: string;
@@ -71,23 +66,10 @@ export declare function buildNextHops(input: {
     mappedSeedTargets: string[];
     resourceBindings: ResolvedUnityBinding[];
     verificationHint?: VerificationHint;
-    retrievalRule?: RetrievalRuleHint;
     repoName?: string;
     symbolName: string;
     queryForSymbol: string;
 }): NextHopPayload[];
-export declare function pickRetrievalRuleHintFromBundle(input: {
-    queryText?: string;
-    symbolName?: string;
-    seedPath?: string;
-    rules: Array<{
-        id: string;
-        trigger_tokens?: string[];
-        host_base_type?: string[];
-        resource_types?: string[];
-        next_action: string;
-    }>;
-}): RetrievalRuleHint | undefined;
 export declare function resolveSeedTargetsFromResourceFile(repoPath: string, seedPath: string): Promise<string[]>;
 export declare function filterBm25ResultsByScopePreset<T extends {
     filePath?: string;
@@ -178,11 +160,6 @@ export declare class LocalBackend {
     }>>;
     callTool(method: string, params: any): Promise<any>;
     private unityUiTrace;
-    private ruleLabAnalyze;
-    private ruleLabReviewPack;
-    private ruleLabCurate;
-    private ruleLabPromote;
-    private ruleLabRegress;
     /**
      * Query tool — process-grouped search.
      *