@petepetrash/circuit 0.1.0

package/dist/schemas/step.d.ts

@@ -0,0 +1,2455 @@
+import { z } from 'zod';
+import { JsonObject } from './json.js';
+export declare const RelayRole: z.ZodEnum<{
+    researcher: "researcher";
+    implementer: "implementer";
+    reviewer: "reviewer";
+}>;
+export type RelayRole = z.infer<typeof RelayRole>;
+export declare const RelayConnectorName: z.ZodString;
+export declare const ReportRef: z.ZodObject<{
+    path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    schema: z.ZodString;
+}, z.core.$strip>;
+export type ReportRef = z.infer<typeof ReportRef>;
+export declare const RouteFromReport: z.ZodObject<{
+    path: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type RouteFromReport = z.infer<typeof RouteFromReport>;
+declare const StepBase: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StepBudgets = NonNullable<z.infer<typeof StepBase>['budgets']>;
+export declare const ComposeStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"compose">;
+    writes: z.ZodObject<{
+        report: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"schema_sections">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            ref: z.ZodLiteral<"report">;
+        }, z.core.$strict>;
+        required: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ComposeStep = z.infer<typeof ComposeStep>;
+export declare const VerificationStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"verification">;
+    writes: z.ZodObject<{
+        report: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"schema_sections">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            ref: z.ZodLiteral<"report">;
+        }, z.core.$strict>;
+        required: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VerificationStep = z.infer<typeof VerificationStep>;
+export declare const AutoResolutionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    policy: z.ZodLiteral<"highest-score">;
+    source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    branches_path: z.ZodDefault<z.ZodString>;
+    id_path: z.ZodDefault<z.ZodString>;
+    rubric_result_path: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>], "policy">;
+export type AutoResolutionPolicy = z.infer<typeof AutoResolutionPolicy>;
+export declare const CheckpointPolicy: z.ZodObject<{
+    prompt: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    choices_from: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"report_items">;
+        source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        items_path: z.ZodString;
+        filter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"path_equals">;
+            path: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>], "kind">>;
+        required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"axis">;
+            axis: z.ZodLiteral<"tournament_n">;
+        }, z.core.$strict>], "kind">>;
+        id_path: z.ZodString;
+        label_path: z.ZodOptional<z.ZodString>;
+        description_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    safe_default_choice: z.ZodOptional<z.ZodString>;
+    auto_resolution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        policy: z.ZodLiteral<"highest-score">;
+        source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        branches_path: z.ZodDefault<z.ZodString>;
+        id_path: z.ZodDefault<z.ZodString>;
+        rubric_result_path: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>], "policy">>;
+    auto_continuable_when_nested: z.ZodOptional<z.ZodBoolean>;
+    report_template: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+}, z.core.$strict>;
+export type CheckpointPolicy = z.infer<typeof CheckpointPolicy>;
+export declare const CheckpointStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"checkpoint">;
+    policy: z.ZodObject<{
+        prompt: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        choices_from: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"report_items">;
+            source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            items_path: z.ZodString;
+            filter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"path_equals">;
+                path: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strict>], "kind">>;
+            required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"constant">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"axis">;
+                axis: z.ZodLiteral<"tournament_n">;
+            }, z.core.$strict>], "kind">>;
+            id_path: z.ZodString;
+            label_path: z.ZodOptional<z.ZodString>;
+            description_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        safe_default_choice: z.ZodOptional<z.ZodString>;
+        auto_resolution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            policy: z.ZodLiteral<"highest-score">;
+            source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            branches_path: z.ZodDefault<z.ZodString>;
+            id_path: z.ZodDefault<z.ZodString>;
+            rubric_result_path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>], "policy">>;
+        auto_continuable_when_nested: z.ZodOptional<z.ZodBoolean>;
+        report_template: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>;
+    writes: z.ZodObject<{
+        request: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        response: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"checkpoint_selection">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"checkpoint_response">;
+            ref: z.ZodLiteral<"response">;
+        }, z.core.$strict>;
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allow_from: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"policy_choices">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CheckpointStep = z.infer<typeof CheckpointStep>;
+export declare const RelayStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"worker">;
+    kind: z.ZodLiteral<"relay">;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    connector: z.ZodOptional<z.ZodString>;
+    acceptance_criteria: z.ZodOptional<z.ZodObject<{
+        checks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"command">;
+            id: z.ZodString;
+            command: z.ZodObject<{
+                id: z.ZodString;
+                cwd: z.ZodString;
+                argv: z.ZodArray<z.ZodString>;
+                timeout_ms: z.ZodNumber;
+                max_output_bytes: z.ZodNumber;
+                env: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            expected_status: z.ZodLiteral<"passed">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"report_field">;
+            id: z.ZodString;
+            path: z.ZodArray<z.ZodString>;
+            predicate: z.ZodEnum<{
+                present: "present";
+                non_empty: "non_empty";
+                changed_on_disk: "changed_on_disk";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        on_failure: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"hard-fail">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"retry-with-feedback">;
+        }, z.core.$strict>], "mode">>;
+    }, z.core.$strict>>;
+    writes: z.ZodObject<{
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+        request: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        receipt: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        result: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"result_verdict">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relay_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"sub_run_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>], "kind">;
+        pass: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RelayStep = z.infer<typeof RelayStep>;
+export declare const CompiledFlowRef: z.ZodObject<{
+    flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    entry_mode: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CompiledFlowRef = z.infer<typeof CompiledFlowRef>;
+export declare const SubRunStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"sub-run">;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    writes: z.ZodObject<{
+        result: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"result_verdict">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relay_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"sub_run_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>], "kind">;
+        pass: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SubRunStep = z.infer<typeof SubRunStep>;
+export declare const FanoutSubRunBranch: z.ZodObject<{
+    branch_id: z.ZodString;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FanoutSubRunBranch = z.infer<typeof FanoutSubRunBranch>;
+export declare const FanoutRelayBranchExecution: z.ZodObject<{
+    kind: z.ZodLiteral<"relay">;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    goal: z.ZodString;
+    report_schema: z.ZodString;
+    provenance_field: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FanoutRelayBranchExecution = z.infer<typeof FanoutRelayBranchExecution>;
+export declare const FanoutRelayBranch: z.ZodObject<{
+    branch_id: z.ZodString;
+    execution: z.ZodObject<{
+        kind: z.ZodLiteral<"relay">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        goal: z.ZodString;
+        report_schema: z.ZodString;
+        provenance_field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    connector: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FanoutRelayBranch = z.infer<typeof FanoutRelayBranch>;
+export declare const FanoutBranch: z.ZodUnion<readonly [z.ZodObject<{
+    branch_id: z.ZodString;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    branch_id: z.ZodString;
+    execution: z.ZodObject<{
+        kind: z.ZodLiteral<"relay">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        goal: z.ZodString;
+        report_schema: z.ZodString;
+        provenance_field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    connector: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type FanoutBranch = z.infer<typeof FanoutBranch>;
+export declare const FanoutSubRunBranchTemplate: z.ZodObject<{
+    branch_id: z.ZodString;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    selection: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type FanoutSubRunBranchTemplate = z.infer<typeof FanoutSubRunBranchTemplate>;
+export declare const FanoutRelayBranchTemplate: z.ZodObject<{
+    branch_id: z.ZodString;
+    execution: z.ZodObject<{
+        kind: z.ZodLiteral<"relay">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        goal: z.ZodString;
+        report_schema: z.ZodString;
+        provenance_field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    connector: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type FanoutRelayBranchTemplate = z.infer<typeof FanoutRelayBranchTemplate>;
+export declare const FanoutBranchTemplate: z.ZodUnion<readonly [z.ZodObject<{
+    branch_id: z.ZodString;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    selection: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    branch_id: z.ZodString;
+    execution: z.ZodObject<{
+        kind: z.ZodLiteral<"relay">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        goal: z.ZodString;
+        report_schema: z.ZodString;
+        provenance_field: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    connector: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>]>;
+export type FanoutBranchTemplate = z.infer<typeof FanoutBranchTemplate>;
+export declare const FanoutBranchesStatic: z.ZodObject<{
+    kind: z.ZodLiteral<"static">;
+    branches: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        branch_id: z.ZodString;
+        flow_ref: z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            entry_mode: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        goal: z.ZodString;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        selection: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"inherit">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"replace">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"append">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"remove">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>], "mode">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        branch_id: z.ZodString;
+        execution: z.ZodObject<{
+            kind: z.ZodLiteral<"relay">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            goal: z.ZodString;
+            report_schema: z.ZodString;
+            provenance_field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        connector: z.ZodOptional<z.ZodString>;
+        selection: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"inherit">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"replace">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"append">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"remove">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>], "mode">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type FanoutBranchesStatic = z.infer<typeof FanoutBranchesStatic>;
+export declare const FanoutBranchesDynamic: z.ZodObject<{
+    kind: z.ZodLiteral<"dynamic">;
+    source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    items_path: z.ZodString;
+    template: z.ZodUnion<readonly [z.ZodObject<{
+        branch_id: z.ZodString;
+        flow_ref: z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            entry_mode: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        goal: z.ZodString;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        selection: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        branch_id: z.ZodString;
+        execution: z.ZodObject<{
+            kind: z.ZodLiteral<"relay">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            goal: z.ZodString;
+            report_schema: z.ZodString;
+            provenance_field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        connector: z.ZodOptional<z.ZodString>;
+        selection: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>]>;
+    max_branches: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"constant">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"axis">;
+        axis: z.ZodLiteral<"tournament_n">;
+    }, z.core.$strict>], "kind">]>>;
+    required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"constant">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"axis">;
+        axis: z.ZodLiteral<"tournament_n">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type FanoutBranchesDynamic = z.infer<typeof FanoutBranchesDynamic>;
+export declare const FanoutBranches: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"static">;
+    branches: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        branch_id: z.ZodString;
+        flow_ref: z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            entry_mode: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        goal: z.ZodString;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        selection: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"inherit">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"replace">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"append">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"remove">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>], "mode">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        branch_id: z.ZodString;
+        execution: z.ZodObject<{
+            kind: z.ZodLiteral<"relay">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            goal: z.ZodString;
+            report_schema: z.ZodString;
+            provenance_field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        connector: z.ZodOptional<z.ZodString>;
+        selection: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"inherit">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"replace">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"append">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"remove">;
+                skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            }, z.core.$strict>], "mode">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"dynamic">;
+    source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    items_path: z.ZodString;
+    template: z.ZodUnion<readonly [z.ZodObject<{
+        branch_id: z.ZodString;
+        flow_ref: z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            entry_mode: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        goal: z.ZodString;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        selection: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        branch_id: z.ZodString;
+        execution: z.ZodObject<{
+            kind: z.ZodLiteral<"relay">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            goal: z.ZodString;
+            report_schema: z.ZodString;
+            provenance_field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        connector: z.ZodOptional<z.ZodString>;
+        selection: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>]>;
+    max_branches: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"constant">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"axis">;
+        axis: z.ZodLiteral<"tournament_n">;
+    }, z.core.$strict>], "kind">]>>;
+    required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"constant">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"axis">;
+        axis: z.ZodLiteral<"tournament_n">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>], "kind">;
+export type FanoutBranches = z.infer<typeof FanoutBranches>;
+export declare const FanoutConcurrency: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"unbounded">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"bounded">;
+    max: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export type FanoutConcurrency = z.infer<typeof FanoutConcurrency>;
+export declare const FanoutFailurePolicy: z.ZodEnum<{
+    "abort-all": "abort-all";
+    "continue-others": "continue-others";
+}>;
+export type FanoutFailurePolicy = z.infer<typeof FanoutFailurePolicy>;
+export declare const FanoutRubricRuntimeSignalSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"constant">;
+    signal: z.ZodEnum<{
+        met: "met";
+        missing: "missing";
+        "n/a": "n/a";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"non_empty_array">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"non_empty_string">;
+    path: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type FanoutRubricRuntimeSignalSource = z.infer<typeof FanoutRubricRuntimeSignalSource>;
+export declare const FanoutRubric: z.ZodObject<{
+    model_judgments_path: z.ZodString;
+    ordered_dims: z.ZodArray<z.ZodString>;
+    runtime_signals: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"constant">;
+        signal: z.ZodEnum<{
+            met: "met";
+            missing: "missing";
+            "n/a": "n/a";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"non_empty_array">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"non_empty_string">;
+        path: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type FanoutRubric = z.infer<typeof FanoutRubric>;
+export declare const FanoutStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"fanout">;
+    branches: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"static">;
+        branches: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            branch_id: z.ZodString;
+            flow_ref: z.ZodObject<{
+                flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+                entry_mode: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            goal: z.ZodString;
+            depth: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>;
+            selection: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        custom: "custom";
+                        openai: "openai";
+                        anthropic: "anthropic";
+                        gemini: "gemini";
+                    }>;
+                    model: z.ZodString;
+                }, z.core.$strict>>;
+                effort: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    none: "none";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                    max: "max";
+                }>>;
+                skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"inherit">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"replace">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"append">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"remove">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>], "mode">>;
+                depth: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    tournament: "tournament";
+                    autonomous: "autonomous";
+                }>>;
+                invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            branch_id: z.ZodString;
+            execution: z.ZodObject<{
+                kind: z.ZodLiteral<"relay">;
+                role: z.ZodEnum<{
+                    researcher: "researcher";
+                    implementer: "implementer";
+                    reviewer: "reviewer";
+                }>;
+                goal: z.ZodString;
+                report_schema: z.ZodString;
+                provenance_field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            connector: z.ZodOptional<z.ZodString>;
+            selection: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        custom: "custom";
+                        openai: "openai";
+                        anthropic: "anthropic";
+                        gemini: "gemini";
+                    }>;
+                    model: z.ZodString;
+                }, z.core.$strict>>;
+                effort: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    none: "none";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                    max: "max";
+                }>>;
+                skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"inherit">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"replace">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"append">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"remove">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>], "mode">>;
+                depth: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    tournament: "tournament";
+                    autonomous: "autonomous";
+                }>>;
+                invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dynamic">;
+        source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        items_path: z.ZodString;
+        template: z.ZodUnion<readonly [z.ZodObject<{
+            branch_id: z.ZodString;
+            flow_ref: z.ZodObject<{
+                flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+                entry_mode: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            goal: z.ZodString;
+            depth: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>;
+            selection: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            branch_id: z.ZodString;
+            execution: z.ZodObject<{
+                kind: z.ZodLiteral<"relay">;
+                role: z.ZodEnum<{
+                    researcher: "researcher";
+                    implementer: "implementer";
+                    reviewer: "reviewer";
+                }>;
+                goal: z.ZodString;
+                report_schema: z.ZodString;
+                provenance_field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            connector: z.ZodOptional<z.ZodString>;
+            selection: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>]>;
+        max_branches: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"axis">;
+            axis: z.ZodLiteral<"tournament_n">;
+        }, z.core.$strict>], "kind">]>>;
+        required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"axis">;
+            axis: z.ZodLiteral<"tournament_n">;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>], "kind">;
+    concurrency: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unbounded">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        max: z.ZodNumber;
+    }, z.core.$strict>], "kind">>;
+    on_child_failure: z.ZodDefault<z.ZodEnum<{
+        "abort-all": "abort-all";
+        "continue-others": "continue-others";
+    }>>;
+    rubric: z.ZodOptional<z.ZodObject<{
+        model_judgments_path: z.ZodString;
+        ordered_dims: z.ZodArray<z.ZodString>;
+        runtime_signals: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            signal: z.ZodEnum<{
+                met: "met";
+                missing: "missing";
+                "n/a": "n/a";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_empty_array">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_empty_string">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    writes: z.ZodObject<{
+        branches_dir: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        aggregate: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"fanout_aggregate">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"fanout_results">;
+            ref: z.ZodLiteral<"aggregate">;
+        }, z.core.$strict>;
+        join: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            policy: z.ZodLiteral<"pick-winner">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"disjoint-merge">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"aggregate-only">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"aggregate-survivors">;
+        }, z.core.$strict>], "policy">;
+        verdicts: z.ZodObject<{
+            admit: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FanoutStep = z.infer<typeof FanoutStep>;
+export declare const Step: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"compose">;
+    writes: z.ZodObject<{
+        report: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"schema_sections">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            ref: z.ZodLiteral<"report">;
+        }, z.core.$strict>;
+        required: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"verification">;
+    writes: z.ZodObject<{
+        report: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"schema_sections">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            ref: z.ZodLiteral<"report">;
+        }, z.core.$strict>;
+        required: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"checkpoint">;
+    policy: z.ZodObject<{
+        prompt: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        choices_from: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"report_items">;
+            source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            items_path: z.ZodString;
+            filter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"path_equals">;
+                path: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strict>], "kind">>;
+            required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"constant">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"axis">;
+                axis: z.ZodLiteral<"tournament_n">;
+            }, z.core.$strict>], "kind">>;
+            id_path: z.ZodString;
+            label_path: z.ZodOptional<z.ZodString>;
+            description_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        safe_default_choice: z.ZodOptional<z.ZodString>;
+        auto_resolution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            policy: z.ZodLiteral<"highest-score">;
+            source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            branches_path: z.ZodDefault<z.ZodString>;
+            id_path: z.ZodDefault<z.ZodString>;
+            rubric_result_path: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>], "policy">>;
+        auto_continuable_when_nested: z.ZodOptional<z.ZodBoolean>;
+        report_template: z.ZodOptional<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>;
+    writes: z.ZodObject<{
+        request: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        response: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"checkpoint_selection">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"checkpoint_response">;
+            ref: z.ZodLiteral<"response">;
+        }, z.core.$strict>;
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allow_from: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"policy_choices">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"worker">;
+    kind: z.ZodLiteral<"relay">;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    connector: z.ZodOptional<z.ZodString>;
+    acceptance_criteria: z.ZodOptional<z.ZodObject<{
+        checks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"command">;
+            id: z.ZodString;
+            command: z.ZodObject<{
+                id: z.ZodString;
+                cwd: z.ZodString;
+                argv: z.ZodArray<z.ZodString>;
+                timeout_ms: z.ZodNumber;
+                max_output_bytes: z.ZodNumber;
+                env: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            expected_status: z.ZodLiteral<"passed">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"report_field">;
+            id: z.ZodString;
+            path: z.ZodArray<z.ZodString>;
+            predicate: z.ZodEnum<{
+                present: "present";
+                non_empty: "non_empty";
+                changed_on_disk: "changed_on_disk";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        on_failure: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"hard-fail">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"retry-with-feedback">;
+        }, z.core.$strict>], "mode">>;
+    }, z.core.$strict>>;
+    writes: z.ZodObject<{
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+        request: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        receipt: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        result: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"result_verdict">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relay_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"sub_run_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>], "kind">;
+        pass: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"sub-run">;
+    flow_ref: z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        entry_mode: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    goal: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    writes: z.ZodObject<{
+        result: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        report: z.ZodOptional<z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"result_verdict">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"relay_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"sub_run_result">;
+            ref: z.ZodLiteral<"result">;
+        }, z.core.$strict>], "kind">;
+        pass: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    title: z.ZodString;
+    protocol: z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">;
+    reads: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"inherit">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"replace">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"append">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"remove">;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        }, z.core.$strict>], "mode">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    equipment_scope: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+            allow: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>>;
+    }, z.core.$strict>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    budgets: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        wall_clock_ms: z.ZodOptional<z.ZodNumber>;
+        inactivity_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executor: z.ZodLiteral<"orchestrator">;
+    kind: z.ZodLiteral<"fanout">;
+    branches: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"static">;
+        branches: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            branch_id: z.ZodString;
+            flow_ref: z.ZodObject<{
+                flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+                entry_mode: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            goal: z.ZodString;
+            depth: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>;
+            selection: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        custom: "custom";
+                        openai: "openai";
+                        anthropic: "anthropic";
+                        gemini: "gemini";
+                    }>;
+                    model: z.ZodString;
+                }, z.core.$strict>>;
+                effort: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    none: "none";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                    max: "max";
+                }>>;
+                skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"inherit">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"replace">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"append">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"remove">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>], "mode">>;
+                depth: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    tournament: "tournament";
+                    autonomous: "autonomous";
+                }>>;
+                invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            branch_id: z.ZodString;
+            execution: z.ZodObject<{
+                kind: z.ZodLiteral<"relay">;
+                role: z.ZodEnum<{
+                    researcher: "researcher";
+                    implementer: "implementer";
+                    reviewer: "reviewer";
+                }>;
+                goal: z.ZodString;
+                report_schema: z.ZodString;
+                provenance_field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            connector: z.ZodOptional<z.ZodString>;
+            selection: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodEnum<{
+                        custom: "custom";
+                        openai: "openai";
+                        anthropic: "anthropic";
+                        gemini: "gemini";
+                    }>;
+                    model: z.ZodString;
+                }, z.core.$strict>>;
+                effort: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    none: "none";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                    max: "max";
+                }>>;
+                skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"inherit">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"replace">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"append">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"remove">;
+                    skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+                }, z.core.$strict>], "mode">>;
+                depth: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    tournament: "tournament";
+                    autonomous: "autonomous";
+                }>>;
+                invocation_options: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dynamic">;
+        source_report: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        items_path: z.ZodString;
+        template: z.ZodUnion<readonly [z.ZodObject<{
+            branch_id: z.ZodString;
+            flow_ref: z.ZodObject<{
+                flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+                entry_mode: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            goal: z.ZodString;
+            depth: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>;
+            selection: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            branch_id: z.ZodString;
+            execution: z.ZodObject<{
+                kind: z.ZodLiteral<"relay">;
+                role: z.ZodEnum<{
+                    researcher: "researcher";
+                    implementer: "implementer";
+                    reviewer: "reviewer";
+                }>;
+                goal: z.ZodString;
+                report_schema: z.ZodString;
+                provenance_field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            connector: z.ZodOptional<z.ZodString>;
+            selection: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>]>;
+        max_branches: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"axis">;
+            axis: z.ZodLiteral<"tournament_n">;
+        }, z.core.$strict>], "kind">]>>;
+        required_count: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"axis">;
+            axis: z.ZodLiteral<"tournament_n">;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>], "kind">;
+    concurrency: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unbounded">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        max: z.ZodNumber;
+    }, z.core.$strict>], "kind">>;
+    on_child_failure: z.ZodDefault<z.ZodEnum<{
+        "abort-all": "abort-all";
+        "continue-others": "continue-others";
+    }>>;
+    rubric: z.ZodOptional<z.ZodObject<{
+        model_judgments_path: z.ZodString;
+        ordered_dims: z.ZodArray<z.ZodString>;
+        runtime_signals: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"constant">;
+            signal: z.ZodEnum<{
+                met: "met";
+                missing: "missing";
+                "n/a": "n/a";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_empty_array">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_empty_string">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    writes: z.ZodObject<{
+        branches_dir: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+        aggregate: z.ZodObject<{
+            path: z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">;
+            schema: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>;
+    check: z.ZodObject<{
+        kind: z.ZodLiteral<"fanout_aggregate">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"fanout_results">;
+            ref: z.ZodLiteral<"aggregate">;
+        }, z.core.$strict>;
+        join: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            policy: z.ZodLiteral<"pick-winner">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"disjoint-merge">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"aggregate-only">;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"aggregate-survivors">;
+        }, z.core.$strict>], "policy">;
+        verdicts: z.ZodObject<{
+            admit: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type Step = z.infer<typeof Step>;
+export declare const RouteMap: z.ZodRecord<z.ZodString, z.ZodString>;
+export type RouteMap = z.infer<typeof RouteMap>;
+export {};
+//# sourceMappingURL=step.d.ts.map