@veewo/gitnexus 1.5.0 → 1.5.1

package/dist/rule-lab/promote.js

@@ -24,6 +24,10 @@ function isForbiddenPlaceholder(value) {
     const token = toComparableToken(value);
     return token === 'unknown' || token === 'todo' || token === 'tbd' || /<[^>]+>/.test(token);
 }
+function hasPlaceholderText(value) {
+    const raw = String(value || '').trim();
+    return !raw || /TODO|TBD|placeholder|<[^>]+>/i.test(raw);
+}
 function assertNoPlaceholderScope(values, field) {
     if (values.length === 0) {
         throw new Error(`promote lint failed: ${field} must be non-empty`);
@@ -32,6 +36,48 @@ function assertNoPlaceholderScope(values, field) {
         throw new Error(`promote lint failed: unknown scope placeholder is forbidden (${field})`);
     }
 }
+function assertResolvedBindings(resourceBindings, ruleId) {
+    if (!Array.isArray(resourceBindings) || resourceBindings.length === 0)
+        return;
+    const raw = JSON.stringify(resourceBindings);
+    if (/UnknownClass|UnknownMethod|UnknownSource|UnknownTarget|TODO|TBD|placeholder|<[^>]+>/i.test(raw)) {
+        throw new Error(`binding_unresolved: placeholder binding values are forbidden for rule ${ruleId}`);
+    }
+}
+function requireEvidenceGuard(item, ruleId) {
+    const steps = Array.isArray(item.confirmed_chain?.steps) ? item.confirmed_chain.steps : [];
+    if (steps.length === 0) {
+        throw new Error(`evidence_guard_failed: confirmed_chain.steps must be non-empty for rule ${ruleId}`);
+    }
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index];
+        if (hasPlaceholderText(step.anchor)) {
+            throw new Error(`evidence_guard_failed: confirmed_chain.steps[${index}].anchor invalid for rule ${ruleId}`);
+        }
+        if (hasPlaceholderText(step.snippet)) {
+            throw new Error(`evidence_guard_failed: confirmed_chain.steps[${index}].snippet invalid for rule ${ruleId}`);
+        }
+    }
+}
+function isExactPairEventDelegateItem(item) {
+    const triggerTokens = Array.isArray(item.match?.trigger_tokens)
+        ? item.match?.trigger_tokens || []
+        : [];
+    const hasEventDelegateTrigger = triggerTokens.some((token) => toComparableToken(token) === 'event_delegate');
+    if (!hasEventDelegateTrigger)
+        return false;
+    const hasCodeRuntimeTopology = Array.isArray(item.topology)
+        && item.topology.some((hop) => toComparableToken(hop.hop) === 'code_runtime');
+    const hasEvidence = Array.isArray(item.confirmed_chain?.steps) && item.confirmed_chain.steps.length > 0;
+    return hasCodeRuntimeTopology && hasEvidence;
+}
+function requireBindingGuard(item, ruleId) {
+    const bindings = item.resource_bindings;
+    if (isExactPairEventDelegateItem(item) && (!Array.isArray(bindings) || bindings.length === 0)) {
+        throw new Error(`binding_unresolved: exact_pair_binding_missing for rule ${ruleId}`);
+    }
+    assertResolvedBindings(bindings, ruleId);
+}
 function toDraftFromCurated(item) {
     const triggerTokens = unique(item.match?.trigger_tokens || [inferTriggerFamily(item)]);
     const topology = Array.isArray(item.topology) && item.topology.length > 0
@@ -69,6 +115,9 @@ function toDraftFromCurated(item) {
             non_guarantees: nonGuarantees,
             next_action: nextAction,
         },
+        ...(Array.isArray(item.resource_bindings)
+            ? { resource_bindings: item.resource_bindings }
+            : {}),
     };
 }
 function compileRule(ruleId, version, draft) {
@@ -87,6 +136,7 @@ function compileRule(ruleId, version, draft) {
     const nextAction = String(draft.claims.next_action || '').trim() || 'gitnexus query "runtime"';
     assertNoPlaceholderScope(resourceTypes, 'resource_types');
     assertNoPlaceholderScope(hostBaseType, 'host_base_type');
+    assertResolvedBindings(draft.resource_bindings, ruleId);
     return {
         id: ruleId,
         version,
@@ -204,6 +254,16 @@ function buildRuleYaml(rule) {
                 lines.push(`    field_name: ${quoteYaml(binding.field_name)}`);
             if (binding.loader_methods?.length)
                 pushList(lines, 'loader_methods', binding.loader_methods, '    ');
+            if (binding.scene_name)
+                lines.push(`    scene_name: ${quoteYaml(binding.scene_name)}`);
+            if (binding.source_class_pattern)
+                lines.push(`    source_class_pattern: ${quoteYaml(binding.source_class_pattern)}`);
+            if (binding.source_method)
+                lines.push(`    source_method: ${quoteYaml(binding.source_method)}`);
+            if (binding.target_class_pattern)
+                lines.push(`    target_class_pattern: ${quoteYaml(binding.target_class_pattern)}`);
+            if (binding.target_method)
+                lines.push(`    target_method: ${quoteYaml(binding.target_method)}`);
         }
     }
     if (rule.lifecycle_overrides) {
@@ -233,6 +293,17 @@ async function readCatalog(catalogPath) {
         throw error;
     }
 }
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
 export async function promoteCuratedRules(input) {
     const normalizedRepoPath = path.resolve(input.repoPath);
     const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
@@ -262,8 +333,16 @@ export async function promoteCuratedRules(input) {
         if (!ruleId) {
             throw new Error('curated item missing rule id');
         }
+        requireEvidenceGuard(item, ruleId);
+        requireBindingGuard(item, ruleId);
+        if (catalog.rules.some((entry) => entry.id === ruleId)) {
+            throw new Error(`duplicate_rule_id: ${ruleId} already exists in catalog`);
+        }
         const relativeFile = path.join('approved', `${ruleId}.yaml`).split(path.sep).join('/');
         const absoluteFile = path.join(paths.rulesRoot, relativeFile);
+        if (await fileExists(absoluteFile)) {
+            throw new Error(`duplicate_rule_id: ${ruleId} already exists at ${relativeFile}`);
+        }
         const draft = dslDraftFromCurate && curatedItems.length === 1
             ? { ...dslDraftFromCurate, id: ruleId, version }
             : { ...toDraftFromCurated(item), id: ruleId, version };
@@ -279,13 +358,7 @@ export async function promoteCuratedRules(input) {
             file: relativeFile,
             ...(compiledRule.family ? { family: compiledRule.family } : {}),
         };
-        const existingIndex = catalog.rules.findIndex((entry) => entry.id === ruleId);
-        if (existingIndex >= 0) {
-            catalog.rules[existingIndex] = nextEntry;
-        }
-        else {
-            catalog.rules.push(nextEntry);
-        }
+        catalog.rules.push(nextEntry);
     }
     await fs.mkdir(path.dirname(catalogPath), { recursive: true });
     await fs.writeFile(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`, 'utf-8');

package/dist/rule-lab/promote.test.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { promoteCuratedRules } from './promote.js';
+import { loadRuleRegistry } from '../mcp/local/runtime-claim-rule-registry.js';
 describe('rule-lab promote', () => {
     it('promotes curated candidate into approved yaml and catalog entry', async () => {
         const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-promote-'));
@@ -161,4 +162,153 @@ describe('rule-lab promote', () => {
         await expect(promoteCuratedRules({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a' })).rejects.toThrow(/unknown/i);
         await fs.rm(repoRoot, { recursive: true, force: true });
     });
+    it('promotes every curated item when dsl-drafts includes multiple candidates', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-promote-multi-'));
+        const rulesRoot = path.join(repoRoot, '.gitnexus', 'rules');
+        const sliceDir = path.join(rulesRoot, 'lab', 'runs', 'run-x', 'slices', 'slice-a');
+        await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
+        await fs.mkdir(sliceDir, { recursive: true });
+        await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({ version: 1, rules: [] }, null, 2), 'utf-8');
+        const curated = {
+            run_id: 'run-x',
+            slice_id: 'slice-a',
+            curated: [
+                {
+                    id: 'candidate-1',
+                    rule_id: 'demo.multi.first.v1',
+                    title: 'demo first',
+                    match: { trigger_tokens: ['reload'], resource_types: ['syncvar_hook'], host_base_type: ['network_behaviour'] },
+                    topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
+                    closure: { required_hops: ['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"' },
+                    confirmed_chain: { steps: [{ hop_type: 'code_runtime', anchor: 'Assets/A.cs:1', snippet: 'A' }] },
+                    guarantees: ['reload_chain_closed'],
+                    non_guarantees: ['no_runtime_execution'],
+                },
+                {
+                    id: 'candidate-2',
+                    rule_id: 'demo.multi.second.v1',
+                    title: 'demo second',
+                    match: { trigger_tokens: ['reload'], resource_types: ['syncvar_hook'], host_base_type: ['network_behaviour'] },
+                    topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
+                    closure: { required_hops: ['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"' },
+                    confirmed_chain: { steps: [{ hop_type: 'code_runtime', anchor: 'Assets/B.cs:2', snippet: 'B' }] },
+                    guarantees: ['reload_chain_closed'],
+                    non_guarantees: ['no_runtime_execution'],
+                },
+            ],
+        };
+        await fs.writeFile(path.join(sliceDir, 'curated.json'), JSON.stringify(curated, null, 2), 'utf-8');
+        await fs.writeFile(path.join(sliceDir, 'dsl-drafts.json'), JSON.stringify({
+            drafts: [
+                {
+                    id: 'demo.multi.first.v1',
+                    version: '2.0.0',
+                    match: curated.curated[0].match,
+                    topology: curated.curated[0].topology,
+                    closure: curated.curated[0].closure,
+                    claims: curated.curated[0].claims,
+                },
+                {
+                    id: 'demo.multi.second.v1',
+                    version: '2.0.0',
+                    match: curated.curated[1].match,
+                    topology: curated.curated[1].topology,
+                    closure: curated.curated[1].closure,
+                    claims: curated.curated[1].claims,
+                },
+            ],
+        }, null, 2), 'utf-8');
+        await fs.writeFile(path.join(sliceDir, 'dsl-draft.json'), JSON.stringify({
+            compatibility_warning: 'multi-draft compatibility alias',
+            primary_draft_id: 'demo.multi.first.v1',
+        }, null, 2), 'utf-8');
+        const out = await promoteCuratedRules({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a' });
+        expect(out.promotedFiles).toHaveLength(2);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('writes all binding fields into yaml and keeps them parseable via loadRuleRegistry', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-promote-bindings-roundtrip-'));
+        const rulesRoot = path.join(repoRoot, '.gitnexus', 'rules');
+        const sliceDir = path.join(rulesRoot, 'lab', 'runs', 'run-x', 'slices', 'slice-a');
+        await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
+        await fs.mkdir(sliceDir, { recursive: true });
+        await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({ version: 1, rules: [] }, null, 2), 'utf-8');
+        await fs.writeFile(path.join(sliceDir, 'curated.json'), JSON.stringify({
+            run_id: 'run-x',
+            slice_id: 'slice-a',
+            curated: [
+                {
+                    id: 'candidate-1',
+                    rule_id: 'demo.bindings.roundtrip.v1',
+                    title: 'demo bindings',
+                    match: {
+                        trigger_tokens: ['reload'],
+                        resource_types: ['syncvar_hook'],
+                        host_base_type: ['network_behaviour'],
+                    },
+                    topology: [
+                        { hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } },
+                    ],
+                    closure: {
+                        required_hops: ['code_runtime'],
+                        failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
+                    },
+                    claims: {
+                        guarantees: ['binding_fields_roundtrip'],
+                        non_guarantees: ['no_runtime_execution'],
+                        next_action: 'gitnexus query "reload"',
+                    },
+                    confirmed_chain: {
+                        steps: [{ hop_type: 'code_runtime', anchor: 'Assets/Demo.cs:12', snippet: 'Demo.Trigger' }],
+                    },
+                    guarantees: ['binding_fields_roundtrip'],
+                    non_guarantees: ['no_runtime_execution'],
+                    resource_bindings: [
+                        {
+                            kind: 'method_triggers_scene_load',
+                            host_class_pattern: 'BattleController',
+                            loader_methods: ['EnterBattle'],
+                            scene_name: 'BattleScene',
+                        },
+                        {
+                            kind: 'method_triggers_method',
+                            source_class_pattern: 'SourceClass',
+                            source_method: 'Emit',
+                            target_class_pattern: 'TargetClass',
+                            target_method: 'Handle',
+                        },
+                    ],
+                },
+            ],
+        }, null, 2), 'utf-8');
+        const out = await promoteCuratedRules({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a', version: '1.0.0' });
+        const yaml = await fs.readFile(out.promotedFiles[0], 'utf-8');
+        expect(yaml).toContain('scene_name: BattleScene');
+        expect(yaml).toContain('host_class_pattern: BattleController');
+        expect(yaml).toContain('loader_methods:');
+        expect(yaml).toContain('- EnterBattle');
+        expect(yaml).toContain('target_class_pattern: TargetClass');
+        expect(yaml).toContain('target_method: Handle');
+        await fs.rm(path.join(rulesRoot, 'compiled'), { recursive: true, force: true });
+        const registry = await loadRuleRegistry(repoRoot);
+        const rule = registry.activeRules.find((item) => item.id === 'demo.bindings.roundtrip.v1');
+        expect(rule).toBeTruthy();
+        expect(rule?.resource_bindings).toBeDefined();
+        expect(rule?.resource_bindings?.[0].kind).toBe('method_triggers_scene_load');
+        expect(rule?.resource_bindings?.[0].host_class_pattern).toBe('BattleController');
+        expect(rule?.resource_bindings?.[0].loader_methods).toEqual(['EnterBattle']);
+        expect(rule?.resource_bindings?.[0].scene_name).toBe('BattleScene');
+        expect(rule?.resource_bindings?.[0].source_class_pattern).toBeUndefined();
+        expect(rule?.resource_bindings?.[0].source_method).toBeUndefined();
+        expect(rule?.resource_bindings?.[0].target_class_pattern).toBeUndefined();
+        expect(rule?.resource_bindings?.[0].target_method).toBeUndefined();
+        expect(rule?.resource_bindings?.[1].kind).toBe('method_triggers_method');
+        expect(rule?.resource_bindings?.[1].source_class_pattern).toBe('SourceClass');
+        expect(rule?.resource_bindings?.[1].source_method).toBe('Emit');
+        expect(rule?.resource_bindings?.[1].target_class_pattern).toBe('TargetClass');
+        expect(rule?.resource_bindings?.[1].target_method).toBe('Handle');
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
 });

package/dist/rule-lab/review-pack.d.ts

@@ -14,6 +14,9 @@ export interface ReviewPackCard {
         failure_map: Record<string, string>;
         guarantees: string[];
         non_guarantees: string[];
+        draft_rule_ids: string[];
+        aggregation_modes: string[];
+        binding_kinds: string[];
     };
 }
 export interface ReviewPackMeta {

package/dist/rule-lab/review-pack.js

@@ -49,6 +49,15 @@ function collectClaims(candidates) {
         non_guarantees: nonGuarantees,
     };
 }
+function collectDraftRuleIds(candidates) {
+    return unique(candidates.map((candidate) => String(candidate.draft_rule_id || '').trim()).filter(Boolean));
+}
+function collectAggregationModes(candidates) {
+    return unique(candidates.map((candidate) => String(candidate.aggregation_mode || '').trim()).filter(Boolean));
+}
+function collectBindingKinds(candidates) {
+    return unique(candidates.map((candidate) => String(candidate.binding_kind || '').trim()).filter(Boolean));
+}
 function buildCards(candidates) {
     const cards = [];
     const chunkSize = 4;
@@ -64,6 +73,9 @@ function buildCards(candidates) {
                 failure_map: mergeFailureMaps(chunk),
                 guarantees: claims.guarantees,
                 non_guarantees: claims.non_guarantees,
+                draft_rule_ids: collectDraftRuleIds(chunk),
+                aggregation_modes: collectAggregationModes(chunk),
+                binding_kinds: collectBindingKinds(chunk),
             },
         });
     }
@@ -87,15 +99,43 @@ function renderReviewPack(meta, cards) {
         lines.push(`- required_hops: ${card.decision_inputs.required_hops.join(', ')}`);
         lines.push(`- guarantees: ${card.decision_inputs.guarantees.join(', ')}`);
         lines.push(`- non_guarantees: ${card.decision_inputs.non_guarantees.join(', ')}`);
+        lines.push(`- draft_rule_ids: ${card.decision_inputs.draft_rule_ids.join(', ')}`);
+        lines.push(`- aggregation_modes: ${card.decision_inputs.aggregation_modes.join(', ')}`);
+        lines.push(`- binding_kinds: ${card.decision_inputs.binding_kinds.join(', ')}`);
         lines.push(`- failure_map: ${JSON.stringify(card.decision_inputs.failure_map)}`);
         lines.push('');
     }
     return `${lines.join('\n')}\n`;
 }
+function isENOENT(error) {
+    return typeof error === 'object' && error !== null && error.code === 'ENOENT';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readCandidatesFileWithRetry(candidatesPath, analyzeCommandHint, timeoutMs = 3000, intervalMs = 100) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            return await fs.readFile(candidatesPath, 'utf-8');
+        }
+        catch (error) {
+            if (!isENOENT(error))
+                throw error;
+            if (Date.now() >= deadline) {
+                throw new Error(`Missing candidates file for review-pack: ${candidatesPath}\n` +
+                    `Run analyze first and wait for completion, then retry review-pack.\n` +
+                    `Suggested command: ${analyzeCommandHint}`);
+            }
+            await sleep(intervalMs);
+        }
+    }
+}
 export async function buildReviewPack(input) {
     const normalizedRepoPath = path.resolve(input.repoPath);
     const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
-    const raw = await fs.readFile(paths.candidatesPath, 'utf-8');
+    const analyzeCommandHint = `gitnexus rule-lab analyze --repo-path "${normalizedRepoPath}" --run-id "${input.runId}" --slice-id "${input.sliceId}"`;
+    const raw = await readCandidatesFileWithRetry(paths.candidatesPath, analyzeCommandHint);
     const candidates = parseCandidates(raw);
     const included = [];
     let tokenEstimate = 0;

package/dist/rule-lab/review-pack.test.js

@@ -46,4 +46,71 @@ describe('rule-lab review-pack', () => {
         expect(persisted).toContain('token_budget_estimate');
         await fs.rm(repoRoot, { recursive: true, force: true });
     });
+    it('shows actionable guidance when candidates are missing', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-missing-'));
+        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-y', 'slices', 'slice-b');
+        await fs.mkdir(sliceDir, { recursive: true });
+        const err = await buildReviewPack({ repoPath: repoRoot, runId: 'run-y', sliceId: 'slice-b', maxTokens: 6000 })
+            .then(() => null)
+            .catch((error) => error);
+        expect(err).toBeTruthy();
+        expect(String(err?.message || '')).toMatch(/Missing candidates file for review-pack/);
+        expect(String(err?.message || '')).toMatch(/rule-lab analyze --repo-path/);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('waits briefly for candidates to avoid analyze/review-pack races', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-race-'));
+        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-z', 'slices', 'slice-c');
+        await fs.mkdir(sliceDir, { recursive: true });
+        const candidatesPath = path.join(sliceDir, 'candidates.jsonl');
+        const line = JSON.stringify({
+            id: 'cand-race',
+            title: 'race candidate',
+            topology: [{ hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } }],
+            evidence: { hops: [{ hop_type: 'resource', anchor: 'Assets/Test.prefab:1', snippet: 'Race' }] },
+        });
+        const delayedWrite = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                fs.writeFile(candidatesPath, `${line}\n`, 'utf-8').then(() => resolve()).catch(reject);
+            }, 150);
+        });
+        const out = await buildReviewPack({ repoPath: repoRoot, runId: 'run-z', sliceId: 'slice-c', maxTokens: 6000 });
+        await delayedWrite;
+        expect(out.meta.total_candidates).toBe(1);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('renders decision inputs without lineage-only fields', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-direct-'));
+        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-h', 'slices', 'slice-h');
+        await fs.mkdir(sliceDir, { recursive: true });
+        const rows = [
+            {
+                id: 'proposal-1',
+                title: 'event_delegate proposal accepted-a',
+                proposal_kind: 'per_anchor_rule',
+                aggregation_mode: 'per_anchor_rules',
+                draft_rule_id: 'unity.event.netplayer-gameover-syncvar-hook-ondeadchange.v1',
+                binding_kind: 'method_triggers_method',
+                topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
+                evidence: { hops: [{ hop_type: 'code_runtime', anchor: 'Assets/A.cs:1', snippet: 'A' }] },
+            },
+            {
+                id: 'proposal-2',
+                title: 'event_delegate proposal accepted-b',
+                proposal_kind: 'per_anchor_rule',
+                aggregation_mode: 'per_anchor_rules',
+                draft_rule_id: 'unity.event.mirrorbattlemgr-createnetplayer-syncvar-hook-changeroomgrid.v1',
+                binding_kind: 'method_triggers_method',
+                topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
+                evidence: { hops: [{ hop_type: 'code_runtime', anchor: 'Assets/B.cs:2', snippet: 'B' }] },
+            },
+        ];
+        await fs.writeFile(path.join(sliceDir, 'candidates.jsonl'), `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf-8');
+        const out = await buildReviewPack({ repoPath: repoRoot, runId: 'run-h', sliceId: 'slice-h', maxTokens: 6000 });
+        const persisted = await fs.readFile(out.paths.reviewCardsPath, 'utf-8');
+        expect(persisted).not.toContain('Handoff Summary');
+        expect(persisted).not.toContain('source_gap_candidate_ids');
+        expect(persisted).toContain('draft_rule_ids: unity.event.netplayer-gameover-syncvar-hook-ondeadchange.v1, unity.event.mirrorbattlemgr-createnetplayer-syncvar-hook-changeroomgrid.v1');
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
 });

package/dist/rule-lab/types.d.ts

@@ -6,6 +6,7 @@ export interface RuleLabSlice {
     resource_types: string[];
     host_base_type: string[];
     required_hops?: string[];
+    exact_pairs?: RuleLabExactPair[];
 }
 export interface RuleLabManifest {
     run_id: string;
@@ -25,6 +26,11 @@ export interface RuleLabCandidate {
     id: string;
     title: string;
     rule_hint?: string;
+    proposal_kind?: 'per_anchor_rule' | 'aggregate_rule';
+    source_slice_id?: string;
+    aggregation_mode?: 'per_anchor_rules' | 'aggregate_single_rule';
+    binding_kind?: string;
+    draft_rule_id?: string;
     topology?: Array<{
         hop: string;
         from: Record<string, unknown>;
@@ -46,10 +52,33 @@ export interface RuleLabCandidate {
         missing_hop?: string;
         evidence_anchor?: string;
     }>;
+    closure?: {
+        required_hops: string[];
+        failure_map: Record<string, RuntimeClaimFailureReason | string>;
+    };
+    claims?: {
+        guarantees: string[];
+        non_guarantees: string[];
+        next_action: string;
+    };
+    proposal_evidence_keys?: string[];
+    exact_pair?: RuleLabExactPair;
     evidence: {
         hops: RuleLabCandidateHop[];
     };
 }
+export interface RuleLabExactPairAnchor {
+    file: string;
+    line?: number;
+    symbol?: string;
+}
+export interface RuleLabExactPair {
+    id?: string;
+    binding_kind?: UnityResourceBinding['kind'];
+    draft_rule_id?: string;
+    source_anchor: RuleLabExactPairAnchor;
+    target_anchor: RuleLabExactPairAnchor;
+}
 export interface RuleDslMatch {
     trigger_tokens: string[];
     symbol_kind?: string[];

package/dist/types/pipeline.d.ts

@@ -2,6 +2,7 @@ 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 {
@@ -39,6 +40,7 @@ export interface PipelineResult {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
+    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
@@ -47,6 +49,7 @@ 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.0",
+  "version": "1.5.1",
   "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",
@@ -41,7 +41,8 @@
     "dev": "tsx watch src/cli/index.ts",
     "test": "vitest run test/unit",
     "test:integration": "vitest run test/integration",
-    "test:all": "vitest run",
+    "test:src:node": "npm run build && node scripts/run-node-tests.mjs",
+    "test:all": "vitest run && npm run test:src:node",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "prepare": "npm run build",

package/scripts/run-node-tests.mjs

@@ -0,0 +1,61 @@
+import { spawnSync } from 'node:child_process';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..');
+const srcRoot = path.join(repoRoot, 'src');
+const distRoot = path.join(repoRoot, 'dist');
+
+function walk(dir, out) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(full, out);
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith('.test.ts')) {
+      out.push(full);
+    }
+  }
+}
+
+const sourceTests = [];
+walk(srcRoot, sourceTests);
+
+const nodeTests = sourceTests
+  .filter((filePath) => {
+    const content = readFileSync(filePath, 'utf8');
+    return content.includes("from 'node:test'") || content.includes('from "node:test"');
+  })
+  .map((filePath) => {
+    const rel = path.relative(srcRoot, filePath).replace(/\.ts$/, '.js');
+    return path.join(distRoot, rel);
+  })
+  .sort();
+
+if (nodeTests.length === 0) {
+  console.error('No node:test suites detected under src/**/*.test.ts');
+  process.exit(1);
+}
+
+const missing = nodeTests.filter((filePath) => !existsSync(filePath));
+if (missing.length > 0) {
+  console.error('Missing compiled node:test files in dist/. Run build first.');
+  for (const filePath of missing.slice(0, 20)) {
+    console.error(`- ${filePath}`);
+  }
+  if (missing.length > 20) {
+    console.error(`... and ${missing.length - 20} more`);
+  }
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, ['--test', ...nodeTests], {
+  stdio: 'inherit',
+  cwd: repoRoot,
+});
+
+process.exit(result.status ?? 1);