@veewo/gitnexus 1.5.0 → 1.5.2

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

@@ -2,27 +2,245 @@ import { describe, expect, it } from 'vitest';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { analyzeRuleLabSlice } from './analyze.js';
-describe('rule-lab analyze', () => {
-    it('analyze emits multiple topology candidates with coverage/conflict stats', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-'));
-        const runRoot = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-x');
-        const sliceDir = path.join(runRoot, 'slices', 'slice-a');
-        await fs.mkdir(sliceDir, { recursive: true });
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const fixturePath = path.join(here, '__fixtures__', 'rule-lab-slice-input.json');
-        const fixtureRaw = await fs.readFile(fixturePath, 'utf-8');
-        await fs.writeFile(path.join(sliceDir, 'slice.json'), fixtureRaw, 'utf-8');
-        const result = await analyzeRuleLabSlice({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a' });
-        expect(result.candidates.length).toBeGreaterThan(1);
-        expect(result.candidates[0]).toHaveProperty('topology');
-        expect(result.candidates[0]).toHaveProperty('stats.coverage_rate');
-        expect(result.candidates[0]).toHaveProperty('stats.conflict_rate');
-        expect(result.candidates[0]).toHaveProperty('counter_examples');
-        expect(result.candidates[0].evidence.hops[0].anchor).toMatch(/:\d+$/);
-        const persisted = await fs.readFile(result.paths.candidatesPath, 'utf-8');
-        expect(persisted.trim().length).toBeGreaterThan(0);
+import { curateRuleLabSlice } from './curate.js';
+import { promoteCuratedRules } from './promote.js';
+async function writeJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+describe('rule-lab analyze (exact pair flow)', () => {
+    it('builds proposal candidates and curation input directly from exact_pairs', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-a',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
+                },
+                {
+                    id: 'pair-b',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceB.cs', line: 15, symbol: 'SourceB.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetB.cs', line: 36, symbol: 'TargetB.OnTrigger' },
+                },
+            ],
+        });
+        const out = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
+        expect(out.candidates).toHaveLength(2);
+        expect(out.candidates.every((candidate) => candidate.proposal_kind === 'per_anchor_rule')).toBe(true);
+        expect(out.candidates.every((candidate) => candidate.exact_pair)).toBe(true);
+        const curationPath = path.join(path.dirname(out.paths.candidatesPath), 'curation-input.json');
+        const curation = JSON.parse(await fs.readFile(curationPath, 'utf-8'));
+        expect(curation.curated).toHaveLength(2);
+        expect(curation.curated.every((item) => item.confirmed_chain.steps.length > 0)).toBe(true);
+        expect(curation.curated.every((item) => Array.isArray(item.resource_bindings) && item.resource_bindings.length > 0)).toBe(true);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('fails when exact_pairs are missing', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-missing-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+        });
+        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/exact_pairs/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('fails fast when exact_pairs contain duplicate non-empty ids', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-dup-id-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-dup',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
+                },
+                {
+                    id: 'pair-dup',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceB.cs', line: 15, symbol: 'SourceB.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetB.cs', line: 36, symbol: 'TargetB.OnTrigger' },
+                },
+            ],
+        });
+        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/duplicate_exact_pair_id/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('supports exact-pair analyze -> curate -> promote flow', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-e2e-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId);
+        const rulesRoot = path.join(repoRoot, '.gitnexus', 'rules');
+        const slicePath = path.join(sliceDir, 'slice.json');
+        await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
+        await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({ version: 1, rules: [] }, null, 2), 'utf-8');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-a',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
+                },
+            ],
+        });
+        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
+        const inputPath = path.join(path.dirname(analyzed.paths.candidatesPath), 'curation-input.json');
+        await curateRuleLabSlice({ repoPath: repoRoot, runId, sliceId, inputPath });
+        const promoted = await promoteCuratedRules({ repoPath: repoRoot, runId, sliceId, version: '1.0.0' });
+        expect(promoted.promotedFiles).toHaveLength(1);
+        await expect(fs.access(promoted.promotedFiles[0])).resolves.toBeUndefined();
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('fails closed when exact-pair symbols cannot resolve Class.Method', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-unresolved-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-a',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'TriggerOnly' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
+                },
+            ],
+        });
+        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/binding_unresolved/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('builds scene_load binding with host_class_pattern + loader_methods + scene_name', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-scene-load-shape-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['scene'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-scene',
+                    binding_kind: 'method_triggers_scene_load',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: 'Assets/Scenes/BattleScene.unity', line: 1, symbol: 'BattleScene' },
+                },
+            ],
+        });
+        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
+        const curationPath = path.join(path.dirname(analyzed.paths.candidatesPath), 'curation-input.json');
+        const curation = JSON.parse(await fs.readFile(curationPath, 'utf-8'));
+        const binding = curation.curated[0].resource_bindings[0];
+        expect(binding.kind).toBe('method_triggers_scene_load');
+        expect(binding.host_class_pattern).toBe('SourceA');
+        expect(binding.loader_methods).toEqual(['Trigger']);
+        expect(binding.scene_name).toBe('BattleScene');
+        expect(binding.source_class_pattern).toBeUndefined();
+        expect(binding.source_method).toBeUndefined();
+        expect(binding.target_class_pattern).toBeUndefined();
+        expect(binding.target_method).toBeUndefined();
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('fails closed for scene_load when target scene token is missing', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-scene-load-missing-scene-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['scene'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-scene',
+                    binding_kind: 'method_triggers_scene_load',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: '', line: 1, symbol: '' },
+                },
+            ],
+        });
+        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId })).rejects.toThrow(/binding_unresolved/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('ignores legacy parity/coverage fields when exact_pairs are valid', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-legacy-'));
+        const runId = 'run-x';
+        const sliceId = 'slice-a';
+        const slicePath = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'slice.json');
+        await writeJson(slicePath, {
+            id: sliceId,
+            trigger_family: 'event_delegate',
+            resource_types: ['syncvar_hook'],
+            host_base_type: ['network_behaviour'],
+            required_hops: ['code_runtime'],
+            exact_pairs: [
+                {
+                    id: 'pair-a',
+                    binding_kind: 'method_triggers_method',
+                    source_anchor: { file: 'Assets/Gameplay/SourceA.cs', line: 12, symbol: 'SourceA.Trigger' },
+                    target_anchor: { file: 'Assets/Gameplay/TargetA.cs', line: 32, symbol: 'TargetA.OnTrigger' },
+                },
+            ],
+            coverage_gate: {
+                status: 'blocked',
+                reason: 'coverage_incomplete',
+                processed_user_matches: 0,
+                user_raw_matches: 9,
+            },
+            parity_status: {
+                status: 'blocked',
+                reason: 'parity_missing_rules_slice',
+            },
+        });
+        const analyzed = await analyzeRuleLabSlice({ repoPath: repoRoot, runId, sliceId });
+        expect(analyzed.candidates).toHaveLength(1);
+        expect(analyzed.candidates[0].exact_pair?.id).toBe('pair-a');
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+    it('rejects placeholder run/slice ids', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-analyze-exact-placeholder-'));
+        await expect(analyzeRuleLabSlice({ repoPath: repoRoot, runId: '<run_id>', sliceId: '<slice_id>' })).rejects.toThrow(/placeholder/i);
         await fs.rm(repoRoot, { recursive: true, force: true });
     });
 });

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

@@ -1,5 +1,5 @@
 import { getRuleLabPaths } from './paths.js';
-import type { RuleDslMatch, RuleDslTopologyHop, RuleDslClosure, RuleDslClaims } from './types.js';
+import type { RuleDslMatch, RuleDslTopologyHop, RuleDslClosure, RuleDslClaims, UnityResourceBinding } from './types.js';
 export interface CurateInput {
     repoPath: string;
     runId: string;
@@ -19,6 +19,7 @@ export interface CuratedItem {
     topology?: RuleDslTopologyHop[];
     closure?: RuleDslClosure;
     claims?: RuleDslClaims;
+    resource_bindings?: UnityResourceBinding[];
     confirmed_chain: {
         steps: CuratedStep[];
     };

package/dist/rule-lab/curate.js

@@ -76,6 +76,12 @@ function validateCuratedItem(item) {
     if (hasPlaceholderText(JSON.stringify(item))) {
         throw new Error('curated item contains placeholder text');
     }
+    if (Array.isArray(item.resource_bindings)) {
+        const rawBindings = JSON.stringify(item.resource_bindings);
+        if (/UnknownClass|UnknownMethod|UnknownSource|UnknownTarget/i.test(rawBindings)) {
+            throw new Error('binding unresolved: unknown placeholder binding values are forbidden');
+        }
+    }
     const guaranteeSet = normalizeForSet(item.guarantees);
     const nonGuaranteeSet = normalizeForSet(item.non_guarantees);
     const overlap = [...guaranteeSet].filter((entry) => nonGuaranteeSet.has(entry));
@@ -92,6 +98,9 @@ function toDslDraft(item) {
         topology: item.topology,
         closure: item.closure,
         claims: item.claims,
+        ...(Array.isArray(item.resource_bindings) && item.resource_bindings.length > 0
+            ? { resource_bindings: item.resource_bindings }
+            : {}),
     };
 }
 function validateDslDraft(draft) {
@@ -122,11 +131,23 @@ export async function curateRuleLabSlice(input) {
         throw new Error('curated must contain at least one candidate');
     }
     curated.forEach(validateCuratedItem);
-    const firstDraft = toDslDraft(curated[0]);
-    validateDslDraft(firstDraft);
+    const drafts = curated.map((item) => toDslDraft(item));
+    drafts.forEach(validateDslDraft);
+    const firstDraft = drafts[0];
+    const sliceDir = path.dirname(paths.curatedPath);
     await fs.mkdir(path.dirname(paths.curatedPath), { recursive: true });
     await fs.writeFile(paths.curatedPath, `${JSON.stringify({ run_id: input.runId, slice_id: input.sliceId, curated }, null, 2)}\n`, 'utf-8');
-    await fs.writeFile(path.join(path.dirname(paths.curatedPath), 'dsl-draft.json'), `${JSON.stringify(firstDraft, null, 2)}\n`, 'utf-8');
+    await fs.writeFile(path.join(sliceDir, 'dsl-drafts.json'), `${JSON.stringify({ run_id: input.runId, slice_id: input.sliceId, drafts }, null, 2)}\n`, 'utf-8');
+    if (drafts.length === 1) {
+        await fs.writeFile(path.join(sliceDir, 'dsl-draft.json'), `${JSON.stringify(firstDraft, null, 2)}\n`, 'utf-8');
+    }
+    else {
+        await fs.writeFile(path.join(sliceDir, 'dsl-draft.json'), `${JSON.stringify({
+            compatibility_warning: 'multi-draft mode active; use dsl-drafts.json for complete draft set',
+            primary_draft_id: firstDraft.id,
+            primary_draft: firstDraft,
+        }, null, 2)}\n`, 'utf-8');
+    }
     return {
         paths,
         curated,

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

@@ -69,4 +69,69 @@ describe('rule-lab curate', () => {
         await expect(curateRuleLabSlice({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a', inputPath })).rejects.toThrow(/failure_map/i);
         await fs.rm(repoRoot, { recursive: true, force: true });
     });
+    it('preserves multi-candidate curation and writes dsl-drafts with compatibility warning', async () => {
+        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-curate-'));
+        const inputPath = path.join(repoRoot, 'curation-input.json');
+        const curated = [
+            {
+                id: 'candidate-1',
+                rule_id: 'demo.rule.first.v1',
+                title: 'first rule',
+                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.rule.second.v1',
+                title: 'second rule',
+                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(inputPath, JSON.stringify({ run_id: 'run-x', slice_id: 'slice-a', curated }, null, 2), 'utf-8');
+        const out = await curateRuleLabSlice({
+            repoPath: repoRoot,
+            runId: 'run-x',
+            sliceId: 'slice-a',
+            inputPath,
+        });
+        const baseDir = path.dirname(out.paths.curatedPath);
+        const curatedOut = JSON.parse(await fs.readFile(out.paths.curatedPath, 'utf-8'));
+        const drafts = JSON.parse(await fs.readFile(path.join(baseDir, 'dsl-drafts.json'), 'utf-8'));
+        const legacy = JSON.parse(await fs.readFile(path.join(baseDir, 'dsl-draft.json'), 'utf-8'));
+        expect(curatedOut.curated).toHaveLength(2);
+        expect(drafts.drafts).toHaveLength(2);
+        expect(legacy.compatibility_warning).toMatch(/multi-draft/i);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
 });

package/dist/rule-lab/curation-input-builder.d.ts

@@ -0,0 +1,45 @@
+import type { RuleLabCandidate, RuleLabSlice, UnityResourceBinding } from './types.js';
+interface CurationInputItem {
+    id: string;
+    rule_id: string;
+    title: string;
+    match: {
+        trigger_tokens: string[];
+        symbol_kind: string[];
+        module_scope: string[];
+        resource_types: string[];
+        host_base_type: string[];
+    };
+    topology: NonNullable<RuleLabCandidate['topology']>;
+    closure: {
+        required_hops: string[];
+        failure_map: Record<string, string>;
+    };
+    claims: {
+        guarantees: string[];
+        non_guarantees: string[];
+        next_action: string;
+    };
+    confirmed_chain: {
+        steps: Array<{
+            hop_type?: string;
+            anchor: string;
+            snippet: string;
+        }>;
+    };
+    guarantees: string[];
+    non_guarantees: string[];
+    resource_bindings: UnityResourceBinding[];
+}
+export interface CurationInputDocument {
+    run_id: string;
+    slice_id: string;
+    curated: CurationInputItem[];
+}
+export declare function buildCurationInput(input: {
+    runId: string;
+    sliceId: string;
+    slice: RuleLabSlice;
+    candidates: RuleLabCandidate[];
+}): CurationInputDocument;
+export {};

package/dist/rule-lab/curation-input-builder.js

@@ -0,0 +1,133 @@
+function unique(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+function splitSymbol(symbol) {
+    const raw = String(symbol || '').trim();
+    const parts = raw.split('.');
+    if (parts.length < 2) {
+        return { className: '', methodName: '' };
+    }
+    const className = String(parts[parts.length - 2] || '').trim();
+    const methodName = String(parts[parts.length - 1] || '').trim();
+    return { className, methodName };
+}
+function assertResolvedBindingParts(parts, side, candidateId) {
+    const className = String(parts.className || '').trim();
+    const methodName = String(parts.methodName || '').trim();
+    if (!className || !methodName) {
+        throw new Error(`binding_unresolved: ${side} symbol unresolved for candidate ${candidateId}`);
+    }
+    if (/^unknown/i.test(className) || /^unknown/i.test(methodName)) {
+        throw new Error(`binding_unresolved: ${side} symbol contains unknown placeholder for candidate ${candidateId}`);
+    }
+}
+function assertResolvedSceneToken(value, candidateId) {
+    const token = String(value || '').trim();
+    if (!token) {
+        throw new Error(`binding_unresolved: scene token unresolved for candidate ${candidateId}`);
+    }
+    if (/^unknown/i.test(token)) {
+        throw new Error(`binding_unresolved: scene token contains unknown placeholder for candidate ${candidateId}`);
+    }
+    return token;
+}
+function buildBinding(candidate, pair) {
+    const source = splitSymbol(pair.source_anchor.symbol);
+    assertResolvedBindingParts(source, 'source', candidate.id);
+    const kind = candidate.binding_kind === 'method_triggers_scene_load'
+        ? 'method_triggers_scene_load'
+        : 'method_triggers_method';
+    if (kind === 'method_triggers_scene_load') {
+        const sceneName = assertResolvedSceneToken(String(pair.target_anchor.symbol || pair.target_anchor.file || ''), candidate.id);
+        return [{
+                kind,
+                host_class_pattern: source.className,
+                loader_methods: [source.methodName],
+                scene_name: sceneName,
+                description: `Derived from exact pair ${String(pair.id || candidate.id)}`,
+            }];
+    }
+    const target = splitSymbol(pair.target_anchor.symbol);
+    assertResolvedBindingParts(target, 'target', candidate.id);
+    return [{
+            kind,
+            source_class_pattern: source.className,
+            source_method: source.methodName,
+            target_class_pattern: target.className,
+            target_method: target.methodName,
+            description: `Derived from exact pair ${String(pair.id || candidate.id)}`,
+        }];
+}
+function buildConfirmedChain(candidate, pair) {
+    const hops = (candidate.evidence?.hops || []).filter((hop) => String(hop.anchor || '').trim() && String(hop.snippet || '').trim());
+    if (hops.length > 0)
+        return hops;
+    const sourceAnchor = String(pair.source_anchor.file || '').trim();
+    const targetAnchor = String(pair.target_anchor.file || '').trim();
+    const sourceSnippet = String(pair.source_anchor.symbol || '').trim();
+    const targetSnippet = String(pair.target_anchor.symbol || '').trim();
+    const fallback = [
+        sourceAnchor ? {
+            hop_type: 'code_runtime',
+            anchor: `${sourceAnchor}:${Number(pair.source_anchor.line || 1)}`,
+            snippet: sourceSnippet || 'source',
+        } : undefined,
+        targetAnchor ? {
+            hop_type: 'code_runtime',
+            anchor: `${targetAnchor}:${Number(pair.target_anchor.line || 1)}`,
+            snippet: targetSnippet || 'target',
+        } : undefined,
+    ].filter((item) => Boolean(item));
+    if (fallback.length === 0) {
+        throw new Error(`confirmed_chain_empty: no evidence or anchor fallback for candidate ${candidate.id}`);
+    }
+    return fallback;
+}
+export function buildCurationInput(input) {
+    const curated = input.candidates.map((candidate) => {
+        const pair = candidate.exact_pair;
+        if (!pair) {
+            throw new Error(`binding_unresolved: exact_pair missing for candidate ${candidate.id}`);
+        }
+        const requiredHops = unique((candidate.topology || []).map((hop) => hop.hop));
+        const guaranteed = unique(candidate.claims?.guarantees || [`exact pair candidate: ${candidate.id}`]);
+        const nonGuaranteed = unique(candidate.claims?.non_guarantees || ['sparse gap path only']);
+        const bindings = buildBinding(candidate, pair);
+        const confirmedChain = buildConfirmedChain(candidate, pair);
+        return {
+            id: candidate.id,
+            rule_id: String(candidate.draft_rule_id || candidate.id),
+            title: String(candidate.title || ''),
+            match: {
+                trigger_tokens: [input.slice.trigger_family],
+                symbol_kind: ['method'],
+                module_scope: [input.slice.id],
+                resource_types: [...input.slice.resource_types],
+                host_base_type: [...input.slice.host_base_type],
+            },
+            topology: candidate.topology || [],
+            closure: {
+                required_hops: requiredHops.length > 0 ? requiredHops : ['code_runtime'],
+                failure_map: {
+                    missing_evidence: 'rule_matched_but_evidence_missing',
+                },
+            },
+            claims: {
+                guarantees: guaranteed,
+                non_guarantees: nonGuaranteed,
+                next_action: String(candidate.claims?.next_action || `gitnexus query "${input.slice.trigger_family}"`),
+            },
+            confirmed_chain: {
+                steps: confirmedChain,
+            },
+            guarantees: guaranteed,
+            non_guarantees: nonGuaranteed,
+            resource_bindings: bindings,
+        };
+    });
+    return {
+        run_id: input.runId,
+        slice_id: input.sliceId,
+        curated,
+    };
+}