@veewo/gitnexus 1.5.0 → 1.5.2

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

@@ -5,10 +5,43 @@ 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 repoPath = path.resolve('.');
-    const registry = await loadRuleRegistry(repoPath);
-    assert.equal(registry.activeRules[0].id, 'unity.gungraph.reload.output-getvalue.v1');
-    assert.equal(registry.activeRules[0].version, '1.0.0');
+    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'), [
+        'id: demo.reload.rule.v1',
+        'version: 1.2.3',
+        'trigger_family: reload',
+        'resource_types:',
+        '  - asset',
+        'host_base_type:',
+        '  - ReloadBase',
+        'required_hops:',
+        '  - resource',
+        'guarantees:',
+        '  - reload_chain_closed',
+        '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-'));

package/dist/mcp/local/runtime-claim.d.ts

@@ -16,9 +16,19 @@ export interface RuntimeClaim {
     non_guarantees: string[];
     hops: RuntimeChainHop[];
     gaps: RuntimeChainGap[];
+    verification_core_status?: 'verified_full' | 'failed';
+    verification_core_evidence_level?: RuntimeChainEvidenceLevel;
+    policy_adjusted?: boolean;
+    policy_adjust_reason?: string;
     reason?: RuntimeClaimReason;
     next_action?: string;
 }
+type HydrationPolicyOption = 'fast' | 'balanced' | 'strict';
+export declare function adjustRuntimeClaimForPolicy(input: {
+    claim: RuntimeClaim;
+    hydrationPolicy: HydrationPolicyOption;
+    fallbackToCompact: boolean;
+}): RuntimeClaim;
 export declare function buildRuntimeClaimFromRule(input: {
     rule: RuntimeClaimRule;
     status: Exclude<RuntimeChainStatus, 'pending'>;
@@ -36,3 +46,4 @@ export declare function buildReloadRuntimeClaim(input: {
     reason?: RuntimeClaimReason;
     next_action?: string;
 }): RuntimeClaim;
+export {};

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

@@ -1,3 +1,31 @@
+export function adjustRuntimeClaimForPolicy(input) {
+    const base = input.claim;
+    const coreStatus = base.status === 'verified_full' ? 'verified_full' : 'failed';
+    const adjusted = {
+        ...base,
+        verification_core_status: coreStatus,
+        verification_core_evidence_level: base.evidence_level,
+        policy_adjusted: false,
+    };
+    if (input.hydrationPolicy === 'strict' && input.fallbackToCompact) {
+        let changed = false;
+        if (adjusted.status === 'verified_full') {
+            adjusted.status = 'verified_partial';
+            changed = true;
+        }
+        if (adjusted.evidence_level === 'verified_chain' || adjusted.status === 'verified_partial') {
+            if (adjusted.evidence_level !== 'verified_segment') {
+                adjusted.evidence_level = 'verified_segment';
+                changed = true;
+            }
+        }
+        if (changed) {
+            adjusted.policy_adjusted = true;
+            adjusted.policy_adjust_reason = 'strict_fallback_to_compact';
+        }
+    }
+    return adjusted;
+}
 function resolveNonGuarantees(rule) {
     if (rule && Array.isArray(rule.non_guarantees) && rule.non_guarantees.length > 0) {
         return [...rule.non_guarantees];

package/dist/mcp/local/unity-evidence-view.d.ts

@@ -10,7 +10,7 @@ export interface UnityEvidenceMeta {
 }
 export interface UnityEvidenceViewResult {
     resourceBindings: ResolvedUnityBinding[];
-    serializedFields: UnitySerializedFields;
+    serializedFields?: UnitySerializedFields;
     evidence_meta: UnityEvidenceMeta;
     filter_diagnostics: string[];
 }

package/dist/mcp/local/unity-evidence-view.js

@@ -89,7 +89,7 @@ export function buildUnityEvidenceView(input) {
     };
     return {
         resourceBindings: filtered,
-        serializedFields: aggregateSerializedFields(filtered),
+        serializedFields: input.mode === 'full' ? aggregateSerializedFields(filtered) : undefined,
         evidence_meta,
         filter_diagnostics: diagnostics,
     };

package/dist/mcp/local/unity-evidence-view.test.js

@@ -36,4 +36,26 @@ test('unity evidence view emits truncation metadata and fetch hint', () => {
     assert.equal(out.evidence_meta.truncated, true);
     assert.ok(out.evidence_meta.omitted_count > 0);
     assert.match(out.evidence_meta.next_fetch_hint || '', /unity_evidence_mode=full/i);
+    assert.equal(out.serializedFields, undefined);
+});
+test('unity evidence view keeps serialized fields in full mode', () => {
+    const out = buildUnityEvidenceView({
+        resourceBindings: [
+            {
+                resourcePath: 'Assets/A.prefab',
+                resourceType: 'prefab',
+                bindingKind: 'direct',
+                componentObjectId: '1',
+                evidence: { line: 1, lineText: 'x' },
+                serializedFields: {
+                    scalarFields: [{ name: 'scalarA', sourceLayer: 'base' }],
+                    referenceFields: [{ name: 'refA', sourceLayer: 'base' }],
+                },
+                resolvedReferences: [],
+            },
+        ],
+        mode: 'full',
+    });
+    assert.equal(out.serializedFields?.scalarFields.length, 1);
+    assert.equal(out.serializedFields?.referenceFields.length, 1);
 });

package/dist/mcp/tools.js

@@ -34,19 +34,32 @@ Returns results grouped by process (execution flow):
 - processes: ranked execution flows with relevance priority
 - process_symbols: all symbols in those flows with file locations and module (functional area)
 - definitions: standalone types/interfaces not in any process
-- processes[].evidence_mode: direct_step | method_projected | resource_heuristic
+- processes[].evidence_mode: direct_step | method_projected
 - processes[].confidence: high | medium | low
 - processes[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
 - processes[].runtime_chain_confidence: high | medium | low
 - processes[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain
 - processes[].verification_hint: { action, target, next_command } (required when confidence=low)
-- process_symbols[].process_evidence_mode: direct_step | method_projected | resource_heuristic
+- process_symbols[].process_evidence_mode: direct_step | method_projected
 - process_symbols[].process_confidence: high | medium | low
 - process_symbols[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
 - process_symbols[].runtime_chain_confidence: high | medium | low
 - process_symbols[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain
 - process_symbols[].verification_hint: { action, target, next_command }
 
+Default response_profile=slim shape:
+- summary, candidates, process_hints, resource_hints, decision, upgrade_hints, runtime_preview
+- facts, closure, clues, tier_envelope
+- missing_proof_targets, suggested_context_targets
+- read order in strict-anchor mode: facts -> closure -> clues
+- suggested_context_targets[]: { name, uid?, filePath?, why } for direct context disambiguation
+- upgrade_hints may include exact \`context --uid\` follow-ups when same-name symbols are ambiguous
+- decision.recommended_follow_up prefers narrowing hints (for example resource_path_prefix/name) before response_profile=full fallback
+- response_profile=slim is the default and sufficient for all normal agent workflows
+- response_profile=full is for debugging and deep evidence inspection only
+- recommended runtime retrieval sequence: discovery -> seed narrowing -> closure verification
+- strong graph hops can coexist with failed closure when verifier-core remains failed
+
 Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.
 Supports optional scope controls for noisy codebases:
 - scope_preset=unity-gameplay to prioritize project gameplay code and suppress plugin-heavy paths.
@@ -56,6 +69,9 @@ Includes optional Unity retrieval contract:
 - Set unity_resources=on|auto to include Unity resource evidence.
 - Default unity_hydration_mode=compact (fast path).
 - Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.
+- Runtime-chain semantics are two-layered:
+  - verifier-core: binary (verified_full | failed)
+  - policy-adjusted: query-visible result; under strict policy fallback (hydrationMeta.fallbackToCompact=true) this may downgrade to partial semantics.
 - Returns next_hops[] with ranked follow-up actions when Unity evidence is available.`,
         inputSchema: {
             type: 'object',
@@ -66,6 +82,12 @@ Includes optional Unity retrieval contract:
                 limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
                 max_symbols: { type: 'number', description: 'Max symbols per process (default: 10)', default: 10 },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
+                response_profile: {
+                    type: 'string',
+                    enum: ['slim', 'full'],
+                    description: 'Response payload profile: slim (default, sufficient for normal workflows) or full (debug-only for deep evidence inspection).',
+                    default: 'slim',
+                },
                 scope_preset: {
                     type: 'string',
                     enum: ['unity-gameplay', 'unity-all'],
@@ -188,17 +210,32 @@ AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/pro
 Handles disambiguation: if multiple symbols share the same name, returns candidates for you to pick from. Use uid param for zero-ambiguity lookup from prior results.
 
 Process participation metadata:
-- processes[].evidence_mode: direct_step | method_projected | resource_heuristic
+- processes[].evidence_mode: direct_step | method_projected
 - processes[].confidence: high | medium | low
 - processes[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
 - processes[].runtime_chain_confidence: high | medium | low
 - processes[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain
 - processes[].verification_hint: { action, target, next_command } (required when confidence=low)
 
+Default response_profile=slim shape:
+- summary, symbol, incoming, outgoing, processes, resource_hints, verification_hint, upgrade_hints, runtime_preview
+- facts, closure, clues, tier_envelope
+- missing_proof_targets, suggested_context_targets
+- read order in strict-anchor mode: facts -> closure -> clues
+- suggested_context_targets[]: { name, uid?, filePath?, why } for direct context disambiguation
+- upgrade_hints may include exact \`context --uid\` follow-ups when same-name symbols are ambiguous
+- response_profile=slim is the default and sufficient for all normal agent workflows
+- response_profile=full is for debugging and deep evidence inspection only
+- recommended runtime retrieval sequence: discovery -> seed narrowing -> closure verification
+- strong graph hops can coexist with failed closure when verifier-core remains failed
+
 Unity retrieval contract:
 - Set unity_resources=on|auto to include Unity resource evidence.
 - Default unity_hydration_mode=compact (fast path).
 - Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.
+- Runtime-chain semantics are two-layered:
+  - verifier-core: binary (verified_full | failed)
+  - policy-adjusted: context-visible result; under strict policy fallback (hydrationMeta.fallbackToCompact=true) this may downgrade to partial semantics.
 - Returns next_hops[] with ranked follow-up actions when Unity evidence is available.`,
         inputSchema: {
             type: 'object',
@@ -207,6 +244,12 @@ Unity retrieval contract:
                 uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
+                response_profile: {
+                    type: 'string',
+                    enum: ['slim', 'full'],
+                    description: 'Response payload profile: slim (default, sufficient for normal workflows) or full (debug-only for deep evidence inspection).',
+                    default: 'slim',
+                },
                 unity_resources: {
                     type: 'string',
                     enum: ['off', 'on', 'auto'],
@@ -340,27 +383,14 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             required: ['target', 'goal'],
         },
     },
-    {
-        name: 'rule_lab_discover',
-        description: `Start a Rule Lab run by discovering deterministic slices and persisting a manifest under .gitnexus/rules/lab/runs.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scope: { type: 'string', enum: ['full', 'diff'], description: 'Discovery scope (default: full)' },
-                seed: { type: 'string', description: 'Optional deterministic seed' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: [],
-        },
-    },
     {
         name: 'rule_lab_analyze',
-        description: `Analyze one discovered Rule Lab slice and emit anchor-backed candidates.jsonl.`,
+        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: 'Slice id from discover manifest' },
+                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'],
@@ -373,7 +403,7 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             type: 'object',
             properties: {
                 run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Slice id from discover manifest' },
+                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.' },
             },
@@ -387,7 +417,7 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             type: 'object',
             properties: {
                 run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Slice id from discover manifest' },
+                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.' },
             },
@@ -401,7 +431,7 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             type: 'object',
             properties: {
                 run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Slice id from discover manifest' },
+                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.' },
             },

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

@@ -1,5 +1,5 @@
 import { getRuleLabPaths } from './paths.js';
-import type { RuleLabCandidate } from './types.js';
+import type { RuleLabCandidate, RuleLabSlice } from './types.js';
 export interface AnalyzeInput {
     repoPath: string;
     runId: string;
@@ -8,5 +8,6 @@ export interface AnalyzeInput {
 export interface AnalyzeOutput {
     paths: ReturnType<typeof getRuleLabPaths>;
     candidates: RuleLabCandidate[];
+    slice: RuleLabSlice;
 }
 export declare function analyzeRuleLabSlice(input: AnalyzeInput): Promise<AnalyzeOutput>;

package/dist/rule-lab/analyze.js

@@ -2,89 +2,124 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { getRuleLabPaths } from './paths.js';
+import { buildCurationInput } from './curation-input-builder.js';
 function buildCandidateId(slice, variant) {
     return createHash('sha1')
         .update(`${slice.id}:${slice.trigger_family}:${slice.resource_types.join('|')}:${slice.host_base_type.join('|')}:${variant}`)
         .digest('hex')
         .slice(0, 12);
 }
-function toRate(numerator, denominator) {
-    return numerator / Math.max(denominator, 1);
+function normalizeToken(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
 }
-function buildTopologyCandidateSet(slice, anchorFile) {
-    const title = `${slice.trigger_family} ${slice.host_base_type.join(', ') || 'runtime'}`.trim();
-    const requiredHops = slice.required_hops && slice.required_hops.length > 0
-        ? [...slice.required_hops]
+function inferRuleStem(slice, pair) {
+    const source = normalizeToken(pair.source_anchor.symbol || pair.source_anchor.file || `${slice.id}-source`);
+    const target = normalizeToken(pair.target_anchor.symbol || pair.target_anchor.file || `${slice.id}-target`);
+    const joined = [source, target].filter(Boolean).join('-');
+    return joined || normalizeToken(slice.id) || 'runtime-rule';
+}
+function buildProposalTopology(slice) {
+    const requiredHops = Array.isArray(slice.required_hops) && slice.required_hops.length > 0
+        ? slice.required_hops
         : ['resource', 'code_runtime'];
-    const primaryTopology = requiredHops.map((hop) => ({
+    return requiredHops.map((hop) => ({
         hop,
         from: { entity: hop === 'resource' ? 'resource' : 'script' },
         to: { entity: hop === 'code_runtime' ? 'runtime' : 'script' },
         edge: { kind: hop === 'resource' ? 'binds_script' : 'calls' },
     }));
-    const fallbackTopology = primaryTopology.slice(0, Math.max(primaryTopology.length - 1, 1));
-    const primaryCovered = primaryTopology.length;
-    const total = requiredHops.length;
-    const fallbackCovered = Math.min(fallbackTopology.length, total);
-    const fallbackMissingHop = requiredHops.find((hop) => !fallbackTopology.some((node) => node.hop === hop));
-    const primary = {
-        id: buildCandidateId(slice, 'primary'),
-        title: `${title} candidate-a`,
-        rule_hint: `${slice.trigger_family}.${slice.id}.primary`,
-        topology: primaryTopology,
-        stats: {
-            covered: primaryCovered,
-            total,
-            conflicts: 0,
-            coverage_rate: toRate(primaryCovered, total),
-            conflict_rate: 0,
-        },
-        counter_examples: [],
-        evidence: {
-            hops: primaryTopology.map((hop, index) => ({
-                hop_type: hop.hop,
-                anchor: `${anchorFile}:${index + 1}`,
-                snippet: `${slice.trigger_family}:${hop.edge.kind}`,
-            })),
-        },
-    };
-    const fallback = {
-        id: buildCandidateId(slice, 'fallback'),
-        title: `${title} candidate-b`,
-        rule_hint: `${slice.trigger_family}.${slice.id}.fallback`,
-        topology: fallbackTopology,
-        stats: {
-            covered: fallbackCovered,
-            total,
-            conflicts: 1,
-            coverage_rate: toRate(fallbackCovered, total),
-            conflict_rate: toRate(1, total),
-        },
-        counter_examples: fallbackMissingHop
-            ? [{ reason: 'required hop missing in topology candidate', missing_hop: fallbackMissingHop, evidence_anchor: `${anchorFile}:1` }]
-            : [],
-        evidence: {
-            hops: fallbackTopology.map((hop, index) => ({
-                hop_type: hop.hop,
-                anchor: `${anchorFile}:${index + 1}`,
-                snippet: `${slice.trigger_family}:${hop.edge.kind}`,
-            })),
-        },
-    };
-    return [primary, fallback];
+}
+function buildExactPairCandidates(slice) {
+    const pairs = Array.isArray(slice.exact_pairs) ? slice.exact_pairs : [];
+    if (pairs.length === 0) {
+        throw new Error('exact_pairs must be non-empty for reduced rule-lab analyze flow');
+    }
+    const seenPairIds = new Set();
+    for (const pair of pairs) {
+        const pairId = String(pair.id || '').trim();
+        if (!pairId)
+            continue;
+        if (seenPairIds.has(pairId)) {
+            throw new Error(`duplicate_exact_pair_id: ${pairId}`);
+        }
+        seenPairIds.add(pairId);
+    }
+    const topology = buildProposalTopology(slice);
+    return pairs.map((pair, index) => {
+        const pairKey = String(pair.id || `${index + 1}`).trim();
+        const sourceAnchor = `${String(pair.source_anchor.file || '').trim()}:${Number(pair.source_anchor.line || 1)}`;
+        const targetAnchor = `${String(pair.target_anchor.file || '').trim()}:${Number(pair.target_anchor.line || 1)}`;
+        const draftRuleId = String(pair.draft_rule_id || '').trim() || `unity.event.${inferRuleStem(slice, pair)}.v1`;
+        const bindingKind = pair.binding_kind || 'method_triggers_method';
+        return {
+            id: buildCandidateId(slice, `exact:${pairKey}`),
+            title: `${slice.trigger_family} exact pair ${pairKey}`,
+            rule_hint: `${slice.trigger_family}.${slice.id}.exact.${pairKey}`,
+            proposal_kind: 'per_anchor_rule',
+            aggregation_mode: 'per_anchor_rules',
+            binding_kind: bindingKind,
+            draft_rule_id: draftRuleId,
+            topology,
+            closure: {
+                required_hops: topology.map((hop) => hop.hop),
+                failure_map: {
+                    missing_evidence: 'rule_matched_but_evidence_missing',
+                },
+            },
+            claims: {
+                guarantees: [`exact pair linked: ${sourceAnchor} -> ${targetAnchor}`],
+                non_guarantees: ['sparse gap path only; no exhaustive discovery semantics'],
+                next_action: `gitnexus query "${slice.trigger_family}"`,
+            },
+            exact_pair: pair,
+            evidence: {
+                hops: [
+                    {
+                        hop_type: 'code_runtime',
+                        anchor: sourceAnchor,
+                        snippet: String(pair.source_anchor.symbol || 'source'),
+                    },
+                    {
+                        hop_type: 'code_runtime',
+                        anchor: targetAnchor,
+                        snippet: String(pair.target_anchor.symbol || 'target'),
+                    },
+                ],
+            },
+        };
+    });
+}
+function assertNoPlaceholderIds(runId, sliceId) {
+    const placeholderRe = /<[^>]+>|placeholder|todo|tbd/i;
+    if (placeholderRe.test(runId) || placeholderRe.test(sliceId)) {
+        throw new Error('placeholder run/slice ids are not allowed');
+    }
 }
 export async function analyzeRuleLabSlice(input) {
+    assertNoPlaceholderIds(input.runId, input.sliceId);
     const normalizedRepoPath = path.resolve(input.repoPath);
     const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
     const slicePath = path.join(paths.slicesRoot, input.sliceId, 'slice.json');
     const raw = await fs.readFile(slicePath, 'utf-8');
     const slice = JSON.parse(raw);
-    const anchorFile = path.relative(normalizedRepoPath, slicePath).split(path.sep).join('/');
-    const candidates = buildTopologyCandidateSet(slice, anchorFile);
+    const candidates = buildExactPairCandidates(slice);
+    const curation = buildCurationInput({
+        runId: input.runId,
+        sliceId: input.sliceId,
+        slice,
+        candidates,
+    });
     await fs.mkdir(path.dirname(paths.candidatesPath), { recursive: true });
     await fs.writeFile(paths.candidatesPath, `${candidates.map((candidate) => JSON.stringify(candidate)).join('\n')}\n`, 'utf-8');
+    await fs.writeFile(slicePath, `${JSON.stringify(slice, null, 2)}\n`, 'utf-8');
+    await fs.writeFile(path.join(path.dirname(paths.candidatesPath), 'curation-input.json'), `${JSON.stringify(curation, null, 2)}\n`, 'utf-8');
     return {
         paths,
         candidates,
+        slice,
     };
 }