@veewo/gitnexus 1.4.11-rc → 1.5.0-rc

package/dist/mcp/tools.js

@@ -37,15 +37,15 @@ Returns results grouped by process (execution flow):
 - processes[].evidence_mode: direct_step | method_projected | resource_heuristic
 - processes[].confidence: high | medium | low
 - processes[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
-- processes[].runtime_chain_confidence: high | medium | low (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- processes[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- processes[].verification_hint: { action, target, next_command } (required when confidence=low and confidence fields flag is on)
+- 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_confidence: high | medium | low
 - process_symbols[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
-- process_symbols[].runtime_chain_confidence: high | medium | low (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- process_symbols[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- process_symbols[].verification_hint: { action, target, next_command } (when confidence fields flag is on)
+- 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 }
 
 Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.
 Supports optional scope controls for noisy codebases:
@@ -55,7 +55,8 @@ Supports optional scope controls for noisy codebases:
 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.`,
+- Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.
+- Returns next_hops[] with ranked follow-up actions when Unity evidence is available.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -79,9 +80,43 @@ Includes optional Unity retrieval contract:
                 unity_hydration_mode: {
                     type: 'string',
                     enum: ['parity', 'compact'],
-                    description: 'Unity hydration mode when unity_resources is enabled (default: compact)',
+                    description: 'Execution-mode input for Unity hydration (default: compact). Can be overridden by hydration_policy; inspect hydrationMeta.requestedMode/effectiveMode/reason.',
                     default: 'compact',
                 },
+                unity_evidence_mode: {
+                    type: 'string',
+                    enum: ['summary', 'focused', 'full'],
+                    description: 'Unity evidence payload mode (default: summary)',
+                    default: 'summary',
+                },
+                hydration_policy: {
+                    type: 'string',
+                    enum: ['fast', 'balanced', 'strict'],
+                    description: 'Hydration strategy policy (high-priority). strict->parity, fast->compact, balanced->uses unity_hydration_mode and may escalate to parity on missing evidence.',
+                    default: 'balanced',
+                },
+                resource_path_prefix: {
+                    type: 'string',
+                    description: 'Optional resource-path prefix filter applied to Unity evidence bindings',
+                },
+                binding_kind: {
+                    type: 'string',
+                    description: 'Optional Unity binding kind filter (for example: direct, component, scriptable_object)',
+                },
+                max_bindings: {
+                    type: 'number',
+                    description: 'Optional cap for number of returned evidence bindings',
+                },
+                max_reference_fields: {
+                    type: 'number',
+                    description: 'Optional cap for number of reference fields returned per binding',
+                },
+                resource_seed_mode: {
+                    type: 'string',
+                    enum: ['strict', 'balanced'],
+                    description: 'Resource-seed policy for Unity retrieval hints. strict prioritizes user-provided asset path and deterministic mapped assets.',
+                    default: 'balanced',
+                },
                 runtime_chain_verify: {
                     type: 'string',
                     enum: ['off', 'on-demand'],
@@ -156,14 +191,15 @@ Process participation metadata:
 - processes[].evidence_mode: direct_step | method_projected | resource_heuristic
 - processes[].confidence: high | medium | low
 - processes[].process_subtype: unity_lifecycle | static_calls (when persisted metadata exists)
-- processes[].runtime_chain_confidence: high | medium | low (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- processes[].runtime_chain_evidence_level: none | clue | verified_segment | verified_chain (when GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on)
-- processes[].verification_hint: { action, target, next_command } (required when confidence=low and confidence fields flag is on)
+- 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)
 
 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.`,
+- Check response hydrationMeta: when needsParityRetry=true, rerun with unity_hydration_mode=parity for completeness.
+- Returns next_hops[] with ranked follow-up actions when Unity evidence is available.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -180,9 +216,43 @@ Unity retrieval contract:
                 unity_hydration_mode: {
                     type: 'string',
                     enum: ['parity', 'compact'],
-                    description: 'Unity hydration mode when unity_resources is enabled (default: compact)',
+                    description: 'Execution-mode input for Unity hydration (default: compact). Can be overridden by hydration_policy; inspect hydrationMeta.requestedMode/effectiveMode/reason.',
                     default: 'compact',
                 },
+                unity_evidence_mode: {
+                    type: 'string',
+                    enum: ['summary', 'focused', 'full'],
+                    description: 'Unity evidence payload mode (default: summary)',
+                    default: 'summary',
+                },
+                hydration_policy: {
+                    type: 'string',
+                    enum: ['fast', 'balanced', 'strict'],
+                    description: 'Hydration strategy policy (high-priority). strict->parity, fast->compact, balanced->uses unity_hydration_mode and may escalate to parity on missing evidence.',
+                    default: 'balanced',
+                },
+                resource_path_prefix: {
+                    type: 'string',
+                    description: 'Optional resource-path prefix filter applied to Unity evidence bindings',
+                },
+                binding_kind: {
+                    type: 'string',
+                    description: 'Optional Unity binding kind filter (for example: direct, component, scriptable_object)',
+                },
+                max_bindings: {
+                    type: 'number',
+                    description: 'Optional cap for number of returned evidence bindings',
+                },
+                max_reference_fields: {
+                    type: 'number',
+                    description: 'Optional cap for number of reference fields returned per binding',
+                },
+                resource_seed_mode: {
+                    type: 'string',
+                    enum: ['strict', 'balanced'],
+                    description: 'Resource-seed policy for Unity retrieval hints. strict prioritizes user-provided asset path and deterministic mapped assets.',
+                    default: 'balanced',
+                },
                 runtime_chain_verify: {
                     type: 'string',
                     enum: ['off', 'on-demand'],
@@ -270,6 +340,89 @@ 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.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                run_id: { type: 'string', description: 'Rule Lab run id' },
+                slice_id: { type: 'string', description: 'Slice id from discover manifest' },
+                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: 'Slice id from discover manifest' },
+                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: 'Slice id from discover manifest' },
+                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: 'Slice id from discover manifest' },
+                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/rule-lab/analyze.d.ts

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

package/dist/rule-lab/analyze.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { getRuleLabPaths } from './paths.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 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]
+        : ['resource', 'code_runtime'];
+    const primaryTopology = 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];
+}
+export async function analyzeRuleLabSlice(input) {
+    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);
+    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');
+    return {
+        paths,
+        candidates,
+    };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+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);
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    });
+});

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

@@ -0,0 +1,5 @@
+import { type RuleBundleFamily } from './compiled-bundles.js';
+export declare function compileRules(options: {
+    repoPath?: string;
+    family?: RuleBundleFamily;
+}): Promise<void>;

package/dist/rule-lab/compile.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseRuleYaml } from '../mcp/local/runtime-claim-rule-registry.js';
+import { writeCompiledRuleBundle } from './compiled-bundles.js';
+export async function compileRules(options) {
+    const repoPath = path.resolve(options.repoPath || process.cwd());
+    const family = options.family || 'analyze_rules';
+    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
+    const catalogPath = path.join(rulesRoot, 'catalog.json');
+    let catalog;
+    try {
+        catalog = JSON.parse(await fs.readFile(catalogPath, 'utf-8'));
+    }
+    catch {
+        console.error(`No catalog.json found at ${catalogPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    const entries = catalog.rules.filter((e) => e.enabled !== false && e.family === family);
+    if (entries.length === 0) {
+        console.log(`No enabled ${family} rules in catalog.`);
+        return;
+    }
+    const compiled = [];
+    for (const entry of entries) {
+        const yamlPath = path.join(rulesRoot, entry.file);
+        const raw = await fs.readFile(yamlPath, 'utf-8');
+        const rule = parseRuleYaml(raw, entry.file);
+        compiled.push({
+            id: rule.id,
+            version: rule.version,
+            trigger_family: rule.trigger_family,
+            trigger_tokens: [...(rule.match?.trigger_tokens || [])],
+            resource_types: [...rule.resource_types],
+            host_base_type: [...rule.host_base_type],
+            required_hops: [...rule.required_hops],
+            guarantees: [...rule.guarantees],
+            non_guarantees: [...rule.non_guarantees],
+            next_action: rule.next_action || '',
+            file_path: entry.file,
+            match: rule.match || { trigger_tokens: [] },
+            topology: [],
+            closure: { required_hops: rule.required_hops, failure_map: {} },
+            claims: { guarantees: rule.guarantees, non_guarantees: rule.non_guarantees, next_action: rule.next_action || '' },
+            ...(rule.resource_bindings ? { resource_bindings: rule.resource_bindings } : {}),
+            ...(rule.lifecycle_overrides ? { lifecycle_overrides: rule.lifecycle_overrides } : {}),
+        });
+    }
+    const outPath = await writeCompiledRuleBundle(rulesRoot, family, compiled);
+    console.log(`Compiled ${compiled.length} ${family} rules → ${outPath}`);
+}

package/dist/rule-lab/compiled-bundles.d.ts

@@ -0,0 +1,30 @@
+import type { RuleDslClaims, RuleDslClosure, RuleDslMatch, RuleDslTopologyHop } from './types.js';
+export type RuleBundleFamily = 'analyze_rules' | 'retrieval_rules' | 'verification_rules';
+export interface StageAwareCompiledRule {
+    id: string;
+    version: string;
+    trigger_family: string;
+    trigger_tokens: string[];
+    resource_types: string[];
+    host_base_type: string[];
+    required_hops: string[];
+    guarantees: string[];
+    non_guarantees: string[];
+    next_action: string;
+    file_path: string;
+    match: RuleDslMatch;
+    topology: RuleDslTopologyHop[];
+    closure: RuleDslClosure;
+    claims: RuleDslClaims;
+    resource_bindings?: import('./types.js').UnityResourceBinding[];
+    lifecycle_overrides?: import('./types.js').LifecycleOverrides;
+}
+export interface CompiledRuleBundle {
+    bundle_version: '2.0.0';
+    family: RuleBundleFamily;
+    generated_at: string;
+    rules: StageAwareCompiledRule[];
+}
+export declare function compiledBundlePath(rulesRoot: string, family: RuleBundleFamily): string;
+export declare function writeCompiledRuleBundle(rulesRoot: string, family: RuleBundleFamily, rules: StageAwareCompiledRule[]): Promise<string>;
+export declare function loadCompiledRuleBundle(repoPath: string, family: RuleBundleFamily, rulesRoot?: string): Promise<CompiledRuleBundle | undefined>;

package/dist/rule-lab/compiled-bundles.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function compiledBundlePath(rulesRoot, family) {
+    return path.join(path.resolve(rulesRoot), 'compiled', `${family}.v2.json`);
+}
+export async function writeCompiledRuleBundle(rulesRoot, family, rules) {
+    const outPath = compiledBundlePath(rulesRoot, family);
+    const bundle = {
+        bundle_version: '2.0.0',
+        family,
+        generated_at: new Date().toISOString(),
+        rules,
+    };
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf-8');
+    return outPath;
+}
+export async function loadCompiledRuleBundle(repoPath, family, rulesRoot) {
+    const root = rulesRoot
+        ? path.resolve(rulesRoot)
+        : path.join(path.resolve(repoPath), '.gitnexus', 'rules');
+    const bundlePath = compiledBundlePath(root, family);
+    try {
+        const raw = await fs.readFile(bundlePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.family !== family || !Array.isArray(parsed.rules)) {
+            throw new Error(`Invalid compiled ${family} bundle: ${bundlePath}`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { getRuleLabPaths } from './paths.js';
+import type { RuleDslMatch, RuleDslTopologyHop, RuleDslClosure, RuleDslClaims } from './types.js';
+export interface CurateInput {
+    repoPath: string;
+    runId: string;
+    sliceId: string;
+    inputPath: string;
+}
+export interface CuratedStep {
+    hop_type?: string;
+    anchor: string;
+    snippet: string;
+}
+export interface CuratedItem {
+    id: string;
+    rule_id?: string;
+    title?: string;
+    match?: RuleDslMatch;
+    topology?: RuleDslTopologyHop[];
+    closure?: RuleDslClosure;
+    claims?: RuleDslClaims;
+    confirmed_chain: {
+        steps: CuratedStep[];
+    };
+    guarantees: string[];
+    non_guarantees: string[];
+}
+export interface CurateOutput {
+    paths: ReturnType<typeof getRuleLabPaths>;
+    curated: CuratedItem[];
+}
+export declare function curateRuleLabSlice(input: CurateInput): Promise<CurateOutput>;

package/dist/rule-lab/curate.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getRuleLabPaths } from './paths.js';
+const PLACEHOLDER_RE = /TODO|TBD|placeholder|<[^>]+>/i;
+function hasPlaceholderText(value) {
+    return PLACEHOLDER_RE.test(String(value || ''));
+}
+function normalizeForSet(values) {
+    return new Set(values.map((value) => value.trim().toLowerCase()));
+}
+function ensureStringArray(values, field) {
+    if (!Array.isArray(values) || values.length === 0) {
+        throw new Error(`${field} must be non-empty`);
+    }
+    if (values.some((value) => !String(value || '').trim())) {
+        throw new Error(`${field} entries must be non-empty strings`);
+    }
+    return values.map((value) => String(value).trim());
+}
+function validateDslFields(item) {
+    if (!item.match || !Array.isArray(item.match.trigger_tokens) || item.match.trigger_tokens.length === 0) {
+        throw new Error('match.trigger_tokens must be non-empty');
+    }
+    ensureStringArray(item.match.trigger_tokens, 'match.trigger_tokens');
+    if (!Array.isArray(item.topology) || item.topology.length === 0) {
+        throw new Error('topology must be non-empty');
+    }
+    item.topology.forEach((hop, index) => {
+        if (!String(hop.hop || '').trim()) {
+            throw new Error(`topology[${index}].hop must be non-empty`);
+        }
+        if (!String(hop.edge?.kind || '').trim()) {
+            throw new Error(`topology[${index}].edge.kind must be non-empty`);
+        }
+    });
+    if (!item.closure || !Array.isArray(item.closure.required_hops) || item.closure.required_hops.length === 0) {
+        throw new Error('closure.required_hops must be non-empty');
+    }
+    if (!item.closure.failure_map || Object.keys(item.closure.failure_map).length === 0) {
+        throw new Error('closure.failure_map must be non-empty');
+    }
+    ensureStringArray(item.closure.required_hops, 'closure.required_hops');
+    if (!item.claims) {
+        throw new Error('claims must be present');
+    }
+    ensureStringArray(item.claims.guarantees, 'claims.guarantees');
+    ensureStringArray(item.claims.non_guarantees, 'claims.non_guarantees');
+    if (!String(item.claims.next_action || '').trim()) {
+        throw new Error('claims.next_action must be non-empty');
+    }
+}
+function validateCuratedItem(item) {
+    if (!Array.isArray(item.confirmed_chain?.steps) || item.confirmed_chain.steps.length === 0) {
+        throw new Error('confirmed_chain.steps must be non-empty for promotion');
+    }
+    item.confirmed_chain.steps.forEach((step, index) => {
+        if (!String(step.anchor || '').trim()) {
+            throw new Error(`confirmed_chain.steps[${index}].anchor must be non-empty`);
+        }
+        if (!String(step.snippet || '').trim()) {
+            throw new Error(`confirmed_chain.steps[${index}].snippet must be non-empty`);
+        }
+        if (hasPlaceholderText(step.anchor) || hasPlaceholderText(step.snippet)) {
+            throw new Error(`confirmed_chain.steps[${index}] contains placeholder text`);
+        }
+    });
+    if (!Array.isArray(item.guarantees) || item.guarantees.length === 0) {
+        throw new Error('guarantees must be non-empty');
+    }
+    if (!Array.isArray(item.non_guarantees) || item.non_guarantees.length === 0) {
+        throw new Error('non_guarantees must be non-empty');
+    }
+    if (item.guarantees.some((entry) => !String(entry || '').trim()) || item.non_guarantees.some((entry) => !String(entry || '').trim())) {
+        throw new Error('guarantees/non_guarantees entries must be non-empty strings');
+    }
+    if (hasPlaceholderText(JSON.stringify(item))) {
+        throw new Error('curated item contains placeholder text');
+    }
+    const guaranteeSet = normalizeForSet(item.guarantees);
+    const nonGuaranteeSet = normalizeForSet(item.non_guarantees);
+    const overlap = [...guaranteeSet].filter((entry) => nonGuaranteeSet.has(entry));
+    if (overlap.length === guaranteeSet.size && overlap.length === nonGuaranteeSet.size) {
+        throw new Error('guarantees and non_guarantees must have semantic distinction');
+    }
+    validateDslFields(item);
+}
+function toDslDraft(item) {
+    return {
+        id: String(item.rule_id || item.id || '').trim(),
+        version: '2.0.0',
+        match: item.match,
+        topology: item.topology,
+        closure: item.closure,
+        claims: item.claims,
+    };
+}
+function validateDslDraft(draft) {
+    if (!String(draft.id || '').trim()) {
+        throw new Error('dsl draft id must be non-empty');
+    }
+    ensureStringArray(draft.match.trigger_tokens, 'match.trigger_tokens');
+    if (!Array.isArray(draft.topology) || draft.topology.length === 0) {
+        throw new Error('topology must be non-empty');
+    }
+    ensureStringArray(draft.closure.required_hops, 'closure.required_hops');
+    if (!draft.closure.failure_map || Object.keys(draft.closure.failure_map).length === 0) {
+        throw new Error('closure.failure_map must be non-empty');
+    }
+    ensureStringArray(draft.claims.guarantees, 'claims.guarantees');
+    ensureStringArray(draft.claims.non_guarantees, 'claims.non_guarantees');
+    if (!String(draft.claims.next_action || '').trim()) {
+        throw new Error('claims.next_action must be non-empty');
+    }
+}
+export async function curateRuleLabSlice(input) {
+    const normalizedRepoPath = path.resolve(input.repoPath);
+    const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
+    const raw = await fs.readFile(path.resolve(input.inputPath), 'utf-8');
+    const parsed = JSON.parse(raw);
+    const curated = Array.isArray(parsed.curated) ? parsed.curated : [];
+    if (curated.length === 0) {
+        throw new Error('curated must contain at least one candidate');
+    }
+    curated.forEach(validateCuratedItem);
+    const firstDraft = toDslDraft(curated[0]);
+    validateDslDraft(firstDraft);
+    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');
+    return {
+        paths,
+        curated,
+    };
+}

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

@@ -0,0 +1 @@
+export {};