@veewo/gitnexus 1.5.7 → 1.5.9

package/dist/mcp/local/runtime-claim-rule-registry.js

@@ -1,6 +1,3 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { loadCompiledRuleBundle } from '../../rule-lab/compiled-bundles.js';
 export class RuleRegistryLoadError extends Error {
     code;
     details;
@@ -139,59 +136,6 @@ export function parseRuleYaml(raw, filePath) {
     const legacyGuarantees = readList(raw, 'guarantees');
     const legacyNonGuarantees = readList(raw, 'non_guarantees');
     const legacyNextAction = readScalar(raw, 'next_action');
-    // Parse resource_bindings
-    const rbLines = readSectionLines(raw, 'resource_bindings');
-    let resource_bindings;
-    if (rbLines.length > 0) {
-        resource_bindings = [];
-        const joined = rbLines.map((l) => l.replace(/^\s{2}/, '')).join('\n');
-        const entries = joined.split(/(?=^\s*- kind:)/m).filter((s) => s.trim());
-        for (const entry of entries) {
-            const kindMatch = entry.match(/- kind:\s*(.+)/);
-            if (!kindMatch)
-                continue;
-            const binding = { kind: decodeYamlScalar(kindMatch[1]) };
-            const scalar = (k) => {
-                const m = entry.match(new RegExp(`^\\s+${k}:\\s*(.+)$`, 'm'));
-                return m ? decodeYamlScalar(m[1]) : undefined;
-            };
-            const list = (k) => {
-                const lines = entry.split('\n');
-                const idx = lines.findIndex((l) => new RegExp(`^\\s+${k}:\\s*$`).test(l));
-                if (idx < 0)
-                    return undefined;
-                const out = [];
-                for (let i = idx + 1; i < lines.length; i++) {
-                    if (!/^\s+-\s+/.test(lines[i]))
-                        break;
-                    out.push(decodeYamlScalar(lines[i].replace(/^\s+-\s+/, '')));
-                }
-                return out.length > 0 ? out : undefined;
-            };
-            binding.ref_field_pattern = scalar('ref_field_pattern');
-            binding.target_entry_points = list('target_entry_points');
-            binding.host_class_pattern = scalar('host_class_pattern');
-            binding.field_name = scalar('field_name');
-            binding.loader_methods = list('loader_methods');
-            binding.scene_name = scalar('scene_name');
-            binding.source_class_pattern = scalar('source_class_pattern');
-            binding.source_method = scalar('source_method');
-            binding.target_class_pattern = scalar('target_class_pattern');
-            binding.target_method = scalar('target_method');
-            resource_bindings.push(binding);
-        }
-        if (resource_bindings.length === 0)
-            resource_bindings = undefined;
-    }
-    // Parse lifecycle_overrides
-    const loEntryPoints = readNestedList(raw, 'lifecycle_overrides', 'additional_entry_points');
-    const loScope = readNestedScalar(raw, 'lifecycle_overrides', 'scope');
-    const lifecycle_overrides = loEntryPoints.length > 0 || loScope
-        ? {
-            ...(loEntryPoints.length > 0 ? { additional_entry_points: loEntryPoints } : {}),
-            ...(loScope ? { scope: loScope } : {}),
-        }
-        : undefined;
     return {
         id,
         version,
@@ -209,109 +153,6 @@ export function parseRuleYaml(raw, filePath) {
         guarantees: claimGuarantees.length > 0 ? claimGuarantees : legacyGuarantees,
         non_guarantees: claimNonGuarantees.length > 0 ? claimNonGuarantees : legacyNonGuarantees,
         next_action: claimNextAction || legacyNextAction,
-        family: readScalar(raw, 'family') || 'verification_rules',
-        resource_bindings,
-        lifecycle_overrides,
         file_path: filePath,
     };
 }
-/**
- * Runtime claim rule registry remains the source for analyze-time synthetic-edge production
- * and offline governance/report workflows. Query-time runtime closure verification is graph-only.
- */
-export async function loadRuleRegistry(repoPath, rulesRoot) {
-    const normalizedRepoPath = path.resolve(repoPath);
-    const root = rulesRoot
-        ? path.resolve(rulesRoot)
-        : path.join(normalizedRepoPath, '.gitnexus', 'rules');
-    const compiledVerificationBundle = await loadCompiledRuleBundle(normalizedRepoPath, 'verification_rules', root);
-    if (compiledVerificationBundle && compiledVerificationBundle.rules.length > 0) {
-        return {
-            repoPath: normalizedRepoPath,
-            rulesRoot: root,
-            catalogPath: path.join(root, 'compiled', 'verification_rules.v2.json'),
-            activeRules: compiledVerificationBundle.rules.map((rule) => ({
-                id: rule.id,
-                version: rule.version,
-                trigger_family: rule.trigger_family,
-                resource_types: rule.resource_types,
-                host_base_type: rule.host_base_type,
-                match: rule.match,
-                required_hops: rule.required_hops,
-                guarantees: rule.guarantees,
-                non_guarantees: rule.non_guarantees,
-                next_action: rule.next_action,
-                file_path: rule.file_path,
-                topology: rule.topology,
-                closure: rule.closure,
-                claims: rule.claims,
-            })),
-        };
-    }
-    const catalogPath = path.join(root, 'catalog.json');
-    let catalogRaw;
-    try {
-        catalogRaw = await fs.readFile(catalogPath, 'utf-8');
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT') {
-            throw new RuleRegistryLoadError('rule_catalog_missing', `Runtime claim rule catalog not found: ${catalogPath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath });
-        }
-        throw error;
-    }
-    let catalog;
-    try {
-        catalog = JSON.parse(catalogRaw);
-    }
-    catch {
-        throw new RuleRegistryLoadError('rule_catalog_invalid', `Runtime claim rule catalog is invalid JSON: ${catalogPath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath });
-    }
-    const catalogRules = Array.isArray(catalog.rules) ? catalog.rules : [];
-    const activeRules = [];
-    for (const entry of catalogRules) {
-        if (entry.enabled === false)
-            continue;
-        const relativeRulePath = String(entry.file || path.join('approved', `${entry.id}.yaml`));
-        const rulePath = path.join(root, relativeRulePath);
-        let raw;
-        try {
-            raw = await fs.readFile(rulePath, 'utf-8');
-        }
-        catch (error) {
-            if (error?.code === 'ENOENT') {
-                throw new RuleRegistryLoadError('rule_file_missing', `Runtime claim rule file not found: ${rulePath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath, rulePath, ruleId: entry.id });
-            }
-            throw error;
-        }
-        const parsed = parseRuleYaml(raw, rulePath);
-        if (parsed.id !== entry.id) {
-            throw new Error(`Rule id mismatch between catalog and yaml: ${entry.id} vs ${parsed.id}`);
-        }
-        activeRules.push({
-            ...parsed,
-            version: entry.version || parsed.version,
-            family: entry.family || parsed.family || 'verification_rules',
-        });
-    }
-    return {
-        repoPath: normalizedRepoPath,
-        rulesRoot: root,
-        catalogPath,
-        activeRules,
-    };
-}
-export async function loadAnalyzeRules(repoPath, rulesRoot) {
-    const normalizedRepoPath = path.resolve(repoPath);
-    const root = rulesRoot
-        ? path.resolve(rulesRoot)
-        : path.join(normalizedRepoPath, '.gitnexus', 'rules');
-    const analyzeBundle = await loadCompiledRuleBundle(normalizedRepoPath, 'analyze_rules', root);
-    if (analyzeBundle && analyzeBundle.rules.length > 0) {
-        return analyzeBundle.rules.map((rule) => ({
-            ...rule,
-            family: 'analyze_rules',
-        }));
-    }
-    const registry = await loadRuleRegistry(repoPath, rulesRoot);
-    return registry.activeRules.filter((r) => r.family === 'analyze_rules');
-}

package/dist/mcp/local/runtime-claim-rule-registry.test.js

@@ -1,24 +1,14 @@
 import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import { test } from 'vitest';
-import { RuleRegistryLoadError, loadRuleRegistry } from './runtime-claim-rule-registry.js';
-test('loads active runtime claim rules from project catalog', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), [
+import { RuleRegistryLoadError, parseRuleYaml } from './runtime-claim-rule-registry.js';
+test('RuleRegistryLoadError has code and context', () => {
+    const err = new RuleRegistryLoadError('rule_catalog_missing', 'Catalog not found', { repoPath: '/tmp/repo' });
+    assert.ok(err instanceof RuleRegistryLoadError);
+    assert.equal(err.code, 'rule_catalog_missing');
+    assert.match(String(err.message || ''), /Catalog not found/);
+});
+test('parseRuleYaml parses basic fields', () => {
+    const yaml = [
         'id: demo.reload.rule.v1',
         'version: 1.2.3',
         'trigger_family: reload',
@@ -33,106 +23,37 @@ test('loads active runtime claim rules from project catalog', async () => {
         'non_guarantees:',
         '  - no_runtime_execution',
         'next_action: gitnexus query "reload"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.reload.rule.v1');
-        assert.equal(registry.activeRules[0].version, '1.2.3');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when target repo has no catalog (no ancestor fallback)', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const workspaceRoot = path.join(tempRoot, 'workspace');
-    const nestedCwd = path.join(workspaceRoot, 'packages', 'app');
-    const rulesRoot = path.join(workspaceRoot, '.gitnexus', 'rules');
-    const catalogPath = path.join(rulesRoot, 'catalog.json');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.mkdir(nestedCwd, { recursive: true });
-    await fs.writeFile(catalogPath, JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), ['id: demo.reload.rule.v1', 'version: 1.2.3', 'trigger_family: reload'].join('\n'), 'utf-8');
-    const originalCwd = process.cwd();
-    process.chdir(nestedCwd);
-    try {
-        await assert.rejects(() => loadRuleRegistry(path.join(tempRoot, 'does-not-exist')), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            assert.match(String(error.message || ''), /catalog not found/i);
-            return true;
-        });
-    }
-    finally {
-        process.chdir(originalCwd);
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when rulesRoot exists but catalog.json is missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_file_missing when catalog entry points to missing yaml file', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.0.0',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_file_missing');
-            assert.match(String(error.message || ''), /rule file not found/i);
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        '    - reload_chain_closed',
+        '  non_guarantees:',
+        '    - no_runtime_execution',
+        '  next_action: gitnexus query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'test.yaml');
+    assert.equal(rule.id, 'demo.reload.rule.v1');
+    assert.equal(rule.version, '1.2.3');
+    assert.equal(rule.trigger_family, 'reload');
+    assert.deepEqual(rule.resource_types, ['asset']);
+    assert.deepEqual(rule.host_base_type, ['ReloadBase']);
+    assert.equal(rule.file_path, 'test.yaml');
 });
-test('parses scalar/list values with spaces, quotes, and escapes without truncation', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.scalar-parser.v1',
-                version: '1.0.0',
-                file: 'approved/demo.scalar-parser.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.scalar-parser.v1.yaml'), [
+test('parseRuleYaml parses scalar/list values with spaces, quotes, and escapes', () => {
+    const yaml = [
         'id: demo.scalar-parser.v1',
         'version: 1.0.0',
         'trigger_family: reload',
@@ -149,100 +70,32 @@ test('parses scalar/list values with spaces, quotes, and escapes without truncat
         '  - "double-quote \\"inside\\""',
         "  - 'single-quote ''inside'''",
         'next_action: node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        const rule = registry.activeRules[0];
-        assert.equal(rule.id, 'demo.scalar-parser.v1');
-        assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
-        assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
-        assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
-        assert.equal(rule.next_action, 'node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('rejects rule yaml when topology/closure/claims are missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v2',
-                version: '2.0.0',
-                file: 'approved/demo.reload.rule.v2.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v2.yaml'), [
-        'id: demo.reload.rule.v2',
-        'version: 2.0.0',
-        'trigger_family: reload',
-        'resource_types:',
-        '  - asset',
-        'host_base_type:',
-        '  - ReloadBase',
-        'required_hops:',
-        '  - resource',
-        'guarantees:',
-        '  - reload_chain_closed',
-        'non_guarantees:',
-        '  - no_runtime_execution_guarantee',
-    ].join('\n'), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), /topology|closure|claims/i);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('loads v2 verification bundle from explicit compiled path without catalog fallback', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const compiledRoot = path.join(repoPath, '.gitnexus', 'rules', 'compiled');
-    await fs.mkdir(compiledRoot, { recursive: true });
-    await fs.writeFile(path.join(compiledRoot, 'verification_rules.v2.json'), JSON.stringify({
-        bundle_version: '2.0.0',
-        family: 'verification_rules',
-        generated_at: new Date().toISOString(),
-        rules: [
-            {
-                id: 'demo.bundle.rule.v2',
-                version: '2.0.0',
-                trigger_family: 'reload',
-                resource_types: ['asset'],
-                host_base_type: ['ReloadBase'],
-                required_hops: ['resource', 'code_runtime'],
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-                next_action: 'gitnexus query "reload"',
-                file_path: '.gitnexus/rules/compiled/verification_rules.v2.json',
-                match: { trigger_tokens: ['reload'] },
-                topology: [
-                    { hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } },
-                ],
-                closure: {
-                    required_hops: ['resource', 'code_runtime'],
-                    failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
-                },
-                claims: {
-                    guarantees: ['reload_chain_closed'],
-                    non_guarantees: ['no_runtime_execution'],
-                    next_action: 'gitnexus query "reload"',
-                },
-            },
-        ],
-    }, null, 2), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.bundle.rule.v2');
-        assert.equal(registry.activeRules[0].version, '2.0.0');
-        assert.deepEqual(registry.activeRules[0].required_hops, ['resource', 'code_runtime']);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        "    - 'guarantee with spaces'",
+        '  non_guarantees:',
+        '    - "double-quote \\"inside\\""',
+        "    - 'single-quote ''inside'''",
+        '  next_action: query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'scalar.yaml');
+    assert.equal(rule.id, 'demo.scalar-parser.v1');
+    assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
+    assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
+    assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
+    assert.equal(rule.next_action, 'query "reload"');
 });

package/dist/mcp/tools.js

@@ -383,76 +383,6 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             required: ['target', 'goal'],
         },
     },
-    {
-        name: 'rule_lab_analyze',
-        description: `Analyze one Rule Lab slice and emit anchor-backed candidates.jsonl.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_review_pack',
-        description: `Pack analyzed candidates into review cards with token budget enforcement.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                max_tokens: { type: 'number', description: 'Token budget cap (default: 6000)', default: 6000 },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_curate',
-        description: `Validate human-curated semantic closure input and persist curated artifacts for promotion.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                input_path: { type: 'string', description: 'Absolute or repo-relative path to curation input JSON' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id', 'input_path'],
-        },
-    },
-    {
-        name: 'rule_lab_promote',
-        description: `Promote curated candidates into approved YAML rules and upsert catalog.json entries.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                version: { type: 'string', description: 'Promoted rule version (default: 1.0.0)', default: '1.0.0' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_regress',
-        description: `Evaluate Rule Lab precision/coverage gates and optionally persist a regression report.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                precision: { type: 'number', description: 'Observed precision metric' },
-                coverage: { type: 'number', description: 'Observed coverage metric' },
-                probes_path: { type: 'string', description: 'Optional path to a JSON array of regression probes with bucket metadata' },
-                run_id: { type: 'string', description: 'Optional run id for report naming' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['precision', 'coverage'],
-        },
-    },
     {
         name: 'impact',
         description: `Analyze the blast radius of changing a code symbol.

package/dist/storage/repo-manager.d.ts

@@ -16,6 +16,7 @@ export interface RepoMeta {
         repoAlias?: string;
         embeddings?: boolean;
         csharpDefineCsproj?: string;
+        aiContext?: boolean;
     };
     stats?: {
         files?: number;

package/dist/types/pipeline.d.ts

@@ -2,7 +2,6 @@ import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/type
 import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
 import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
 import type { UnityResourceProcessingResult } from '../core/ingestion/unity-resource-processor.js';
-import type { UnityRuntimeBindingResult } from '../core/ingestion/unity-runtime-binding-rules.js';
 import type { ScopeSelectionDiagnostics } from '../core/ingestion/scope-filter.js';
 export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
 export interface PipelineProgress {
@@ -40,7 +39,6 @@ export interface PipelineResult {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
@@ -49,7 +47,6 @@ export interface PipelineRuntimeSummary {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -71,6 +71,7 @@
   },
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",
+    "@ladybugdb/core": "0.15.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "cli-progress": "^3.12.0",
     "commander": "^12.0.0",
@@ -80,7 +81,6 @@
     "graphology": "^0.25.4",
     "graphology-indices": "^0.17.0",
     "graphology-utils": "^2.3.0",
-    "@ladybugdb/core": "0.15.1",
     "ignore": "^7.0.5",
     "lru-cache": "^11.0.0",
     "mnemonist": "^0.39.0",
@@ -100,9 +100,9 @@
     "uuid": "^13.0.0"
   },
   "optionalDependencies": {
+    "tree-sitter-gdscript": "^6.1.0",
     "tree-sitter-kotlin": "^0.3.8",
-    "tree-sitter-swift": "^0.6.0",
-    "tree-sitter-gdscript": "^6.1.0"
+    "tree-sitter-swift": "^0.6.0"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",

package/skills/gitnexus-cli.md

@@ -58,7 +58,7 @@ fi
 $GN analyze
 ```
 
-Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files.
+Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files unless `--no-ai-context` is set.
 
 Analyze options are resolved with two-layer priority: **CLI arguments** > **stored options** in `meta.json.analyzeOptions`. On first run, pass CLI flags; they are persisted automatically for subsequent runs.
 
@@ -66,6 +66,7 @@ Analyze options are resolved with two-layer priority: **CLI arguments** > **stor
 |------|--------|
 | `--force` | Force full re-index even if up to date |
 | `--no-reuse-options` | Do not reuse stored analyze options from previous index |
+| `--no-ai-context` | Skip writing `AGENTS.md` / `CLAUDE.md` and installing repo-local GitNexus skills |
 | `--embeddings` | Enable embedding generation (off by default) |
 | `--extensions <list>` | Comma-separated file extensions (e.g. `.cs,.ts`) |
 | `--scope <rules>` | Comma-separated scope path-prefix rules (e.g. `Assets/,Packages/com.veewo.*`) |
@@ -74,7 +75,9 @@ Analyze options are resolved with two-layer priority: **CLI arguments** > **stor
 | `--skills` | Generate repo-specific skill files from detected communities |
 | `-v, --verbose` | Enable verbose ingestion warnings |
 
-**Option persistence:** `--extensions`, `--scope`, `--repo-alias`, `--embeddings`, and `--csharp-define-csproj` are automatically saved to `meta.json.analyzeOptions` after a successful run. On subsequent runs, these stored values are reused unless you pass new CLI flags or use `--no-reuse-options`.
+**Option persistence:** `--extensions`, `--scope`, `--repo-alias`, `--embeddings`, `--csharp-define-csproj`, and the effective AI-context setting are automatically saved to `meta.json.analyzeOptions` after a successful run. On subsequent runs, these stored values are reused unless you pass new CLI flags or use `--no-reuse-options`.
+
+When `--no-ai-context` is saved, later `analyze` runs continue skipping AGENTS/CLAUDE generation until you explicitly re-enable AI context (for example by passing `--ai-context` through a direct CLI invocation or clearing the stored setting with `--no-reuse-options`).
 
 #### Scope rules