@petepetrash/circuit 0.1.0

package/dist/schemas/flow-schematic.d.ts

@@ -0,0 +1,1407 @@
+import { z } from 'zod';
+import { type FlowBlockCatalog as FlowBlockCatalogValue } from './flow-blocks.js';
+export declare const FlowSchematicStatus: z.ZodEnum<{
+    deprecated: "deprecated";
+    candidate: "candidate";
+    active: "active";
+}>;
+export type FlowSchematicStatus = z.infer<typeof FlowSchematicStatus>;
+export declare const StepRouteTerminalTarget: z.ZodEnum<{
+    "@complete": "@complete";
+    "@stop": "@stop";
+    "@handoff": "@handoff";
+    "@escalate": "@escalate";
+}>;
+export type StepRouteTerminalTarget = z.infer<typeof StepRouteTerminalTarget>;
+export declare const StepRouteTarget: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+    "@complete": "@complete";
+    "@stop": "@stop";
+    "@handoff": "@handoff";
+    "@escalate": "@escalate";
+}>]>;
+export type StepRouteTarget = z.infer<typeof StepRouteTarget>;
+export declare const SchematicRouteModeOverrides: z.ZodRecord<z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    tournament: "tournament";
+    autonomous: "autonomous";
+}> & z.core.$partial, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+    "@complete": "@complete";
+    "@stop": "@stop";
+    "@handoff": "@handoff";
+    "@escalate": "@escalate";
+}>]>>;
+export type SchematicRouteModeOverrides = z.infer<typeof SchematicRouteModeOverrides>;
+export declare const SchematicContractAlias: z.ZodObject<{
+    generic: z.ZodString;
+    actual: z.ZodString;
+}, z.core.$strict>;
+export type SchematicContractAlias = z.infer<typeof SchematicContractAlias>;
+export declare const SchematicEvidenceRequirement: z.ZodString;
+export type SchematicEvidenceRequirement = z.infer<typeof SchematicEvidenceRequirement>;
+export declare const SchematicEvidenceRequirements: z.ZodArray<z.ZodString>;
+export type SchematicEvidenceRequirements = z.infer<typeof SchematicEvidenceRequirements>;
+export declare const StepExecutionKind: z.ZodEnum<{
+    compose: "compose";
+    verification: "verification";
+    checkpoint: "checkpoint";
+    relay: "relay";
+    "sub-run": "sub-run";
+    fanout: "fanout";
+}>;
+export type StepExecutionKind = z.infer<typeof StepExecutionKind>;
+export declare const StepExecution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"compose">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"relay">;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    connector: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"verification">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"checkpoint">;
+}, z.core.$strict>, z.ZodObject<{
+    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";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fanout">;
+}, z.core.$strict>], "kind">;
+export type StepExecution = z.infer<typeof StepExecution>;
+export declare const StepWrites: z.ZodObject<{
+    report_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    receipt_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    result_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    branches_dir_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    checkpoint_request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    checkpoint_response_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+}, z.core.$strict>;
+export type StepWrites = z.infer<typeof StepWrites>;
+export declare const SchematicFanout: z.ZodObject<{
+    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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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.ZodOptional<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.ZodOptional<z.ZodEnum<{
+        "abort-all": "abort-all";
+        "continue-others": "continue-others";
+    }>>;
+    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">;
+    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>>;
+}, z.core.$strict>;
+export type SchematicFanout = z.infer<typeof SchematicFanout>;
+export declare const StepCheck: z.ZodObject<{
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allow_from: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"policy_choices">;
+    }, z.core.$strict>>;
+    pass: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type StepCheck = z.infer<typeof StepCheck>;
+export declare const SchematicStep: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    block: z.ZodEnum<{
+        handoff: "handoff";
+        goal: "goal";
+        route: "route";
+        review: "review";
+        frame: "frame";
+        plan: "plan";
+        act: "act";
+        intake: "intake";
+        clarify: "clarify";
+        "human-decision": "human-decision";
+        "gather-context": "gather-context";
+        diagnose: "diagnose";
+        "run-verification": "run-verification";
+        "goal-child-run": "goal-child-run";
+        "goal-attempt": "goal-attempt";
+        "goal-evaluate": "goal-evaluate";
+        "goal-recover": "goal-recover";
+        "goal-checkpoint": "goal-checkpoint";
+        "goal-gate-review": "goal-gate-review";
+        "goal-close": "goal-close";
+        pursue: "pursue";
+        "coordinate-pursuits": "coordinate-pursuits";
+        queue: "queue";
+        batch: "batch";
+        "risk-rollback-check": "risk-rollback-check";
+        "close-with-evidence": "close-with-evidence";
+        "review-intake": "review-intake";
+        "prototype-variant-evidence": "prototype-variant-evidence";
+        "prototype-checkpoint": "prototype-checkpoint";
+    }>;
+    title: z.ZodString;
+    stage: z.ZodEnum<{
+        review: "review";
+        frame: "frame";
+        analyze: "analyze";
+        plan: "plan";
+        act: "act";
+        verify: "verify";
+        close: "close";
+    }>;
+    input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    optional_inputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    output: z.ZodString;
+    evidence_requirements: z.ZodArray<z.ZodString>;
+    execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"compose">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"relay">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        connector: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"checkpoint">;
+    }, z.core.$strict>, z.ZodObject<{
+        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";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fanout">;
+    }, z.core.$strict>], "kind">;
+    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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    skill_slots: z.ZodDefault<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>>;
+    routes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+        "@complete": "@complete";
+        "@stop": "@stop";
+        "@handoff": "@handoff";
+        "@escalate": "@escalate";
+    }>]>>;
+    route_overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }> & z.core.$partial, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+        "@complete": "@complete";
+        "@stop": "@stop";
+        "@handoff": "@handoff";
+        "@escalate": "@escalate";
+    }>]>>>>;
+    route_from_report: z.ZodOptional<z.ZodObject<{
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    protocol: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">>;
+    writes: z.ZodOptional<z.ZodObject<{
+        report_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        receipt_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        result_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        branches_dir_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        checkpoint_request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        checkpoint_response_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+    }, z.core.$strict>>;
+    check: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allow_from: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"policy_choices">;
+        }, z.core.$strict>>;
+        pass: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    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>>;
+    checkpoint_policy: z.ZodOptional<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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    fanout: z.ZodOptional<z.ZodObject<{
+        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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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.ZodOptional<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.ZodOptional<z.ZodEnum<{
+            "abort-all": "abort-all";
+            "continue-others": "continue-others";
+        }>>;
+        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">;
+        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>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SchematicStep = z.infer<typeof SchematicStep>;
+export declare const FlowAxisSelection: z.ZodObject<{
+    name: z.ZodString;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    description: z.ZodString;
+    default_change_kind: z.ZodOptional<z.ZodEnum<{
+        "ratchet-advance": "ratchet-advance";
+        "equivalence-refactor": "equivalence-refactor";
+        "migration-escrow": "migration-escrow";
+        discovery: "discovery";
+        disposable: "disposable";
+        "break-glass": "break-glass";
+    }>>;
+}, z.core.$strict>;
+export type FlowAxisSelection = z.infer<typeof FlowAxisSelection>;
+export declare const SchematicStage: z.ZodObject<{
+    canonical: z.ZodEnum<{
+        review: "review";
+        frame: "frame";
+        analyze: "analyze";
+        plan: "plan";
+        act: "act";
+        verify: "verify";
+        close: "close";
+    }>;
+    id: z.core.$ZodBranded<z.ZodString, "StageId", "out">;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type SchematicStage = z.infer<typeof SchematicStage>;
+export declare const FlowSchematic: z.ZodObject<{
+    schema_version: z.ZodLiteral<"2">;
+    id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    title: z.ZodString;
+    purpose: z.ZodString;
+    status: z.ZodEnum<{
+        deprecated: "deprecated";
+        candidate: "candidate";
+        active: "active";
+    }>;
+    starts_at: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    initial_contracts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    contract_aliases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        generic: z.ZodString;
+        actual: z.ZodString;
+    }, z.core.$strict>>>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        block: z.ZodEnum<{
+            handoff: "handoff";
+            goal: "goal";
+            route: "route";
+            review: "review";
+            frame: "frame";
+            plan: "plan";
+            act: "act";
+            intake: "intake";
+            clarify: "clarify";
+            "human-decision": "human-decision";
+            "gather-context": "gather-context";
+            diagnose: "diagnose";
+            "run-verification": "run-verification";
+            "goal-child-run": "goal-child-run";
+            "goal-attempt": "goal-attempt";
+            "goal-evaluate": "goal-evaluate";
+            "goal-recover": "goal-recover";
+            "goal-checkpoint": "goal-checkpoint";
+            "goal-gate-review": "goal-gate-review";
+            "goal-close": "goal-close";
+            pursue: "pursue";
+            "coordinate-pursuits": "coordinate-pursuits";
+            queue: "queue";
+            batch: "batch";
+            "risk-rollback-check": "risk-rollback-check";
+            "close-with-evidence": "close-with-evidence";
+            "review-intake": "review-intake";
+            "prototype-variant-evidence": "prototype-variant-evidence";
+            "prototype-checkpoint": "prototype-checkpoint";
+        }>;
+        title: z.ZodString;
+        stage: z.ZodEnum<{
+            review: "review";
+            frame: "frame";
+            analyze: "analyze";
+            plan: "plan";
+            act: "act";
+            verify: "verify";
+            close: "close";
+        }>;
+        input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        optional_inputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        output: z.ZodString;
+        evidence_requirements: z.ZodArray<z.ZodString>;
+        execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"compose">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relay">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            connector: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"verification">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"checkpoint">;
+        }, z.core.$strict>, z.ZodObject<{
+            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";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fanout">;
+        }, z.core.$strict>], "kind">;
+        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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+        skill_slots: z.ZodDefault<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>>;
+        routes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+            "@complete": "@complete";
+            "@stop": "@stop";
+            "@handoff": "@handoff";
+            "@escalate": "@escalate";
+        }>]>>;
+        route_overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }> & z.core.$partial, z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "StepId", "out">, z.ZodEnum<{
+            "@complete": "@complete";
+            "@stop": "@stop";
+            "@handoff": "@handoff";
+            "@escalate": "@escalate";
+        }>]>>>>;
+        route_from_report: z.ZodOptional<z.ZodObject<{
+            path: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        protocol: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ProtocolId", "out">>;
+        writes: z.ZodOptional<z.ZodObject<{
+            report_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            receipt_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            result_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            branches_dir_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            checkpoint_request_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+            checkpoint_response_path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunRelativePath", "out">>;
+        }, z.core.$strict>>;
+        check: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allow_from: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"policy_choices">;
+            }, z.core.$strict>>;
+            pass: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        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>>;
+        checkpoint_policy: z.ZodOptional<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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+        }, z.core.$strict>>;
+        fanout: z.ZodOptional<z.ZodObject<{
+            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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").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.ZodOptional<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.ZodOptional<z.ZodEnum<{
+                "abort-all": "abort-all";
+                "continue-others": "continue-others";
+            }>>;
+            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">;
+            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>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    version: z.ZodOptional<z.ZodString>;
+    axes: z.ZodOptional<z.ZodObject<{
+        allowed_depths: z.ZodArray<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        supports_tournament: z.ZodDefault<z.ZodBoolean>;
+        supports_autonomous: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodDefault<z.ZodObject<{
+            depth: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            tournament: z.ZodDefault<z.ZodBoolean>;
+            tournament_n: z.ZodDefault<z.ZodNumber>;
+            autonomous: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        tournament_fan_out_stage: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StageId", "out">>;
+    }, z.core.$strict>>;
+    stage_path_policy: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"strict">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"partial">;
+        omits: z.ZodArray<z.ZodEnum<{
+            review: "review";
+            frame: "frame";
+            analyze: "analyze";
+            plan: "plan";
+            act: "act";
+            verify: "verify";
+            close: "close";
+        }>>;
+        rationale: z.ZodString;
+    }, z.core.$strict>], "mode">>;
+    stages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        canonical: z.ZodEnum<{
+            review: "review";
+            frame: "frame";
+            analyze: "analyze";
+            plan: "plan";
+            act: "act";
+            verify: "verify";
+            close: "close";
+        }>;
+        id: z.core.$ZodBranded<z.ZodString, "StageId", "out">;
+        title: z.ZodString;
+    }, z.core.$strict>>>;
+    default_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<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+    }, z.core.$strict>>;
+    engine_flags: z.ZodOptional<z.ZodObject<{
+        binds_execution_depth_to_relay_selection: z.ZodOptional<z.ZodBoolean>;
+        binds_terminal_outcome_to_primary_result: z.ZodOptional<z.ZodBoolean>;
+        iterates_slice_loop: z.ZodOptional<z.ZodObject<{
+            head_step: z.ZodString;
+            tail_step: z.ZodString;
+            advance_route: z.ZodString;
+            slices_from: z.ZodObject<{
+                report: z.ZodString;
+                items_path: z.ZodString;
+            }, z.core.$strict>;
+            max_slices: z.ZodNumber;
+            activate_when_depth_at_least: z.ZodLiteral<"high">;
+        }, z.core.$strict>>;
+        iterates_until_condition: z.ZodOptional<z.ZodObject<{
+            head_step: z.ZodString;
+            tail_step: z.ZodString;
+            body_steps: z.ZodArray<z.ZodString>;
+            reenter_route: z.ZodString;
+            max_iterations: z.ZodNumber;
+            stop_judge: z.ZodOptional<z.ZodObject<{
+                report: z.ZodString;
+                goal_met_path: z.ZodString;
+                lesson_path: z.ZodOptional<z.ZodString>;
+                progress_path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            needs_attention_route: z.ZodOptional<z.ZodString>;
+            carried_notes: z.ZodOptional<z.ZodObject<{
+                report: z.ZodString;
+                max_entries: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            cumulative_usd_cap: z.ZodOptional<z.ZodNumber>;
+            cumulative_token_cap: z.ZodOptional<z.ZodNumber>;
+            no_progress_ceiling: z.ZodOptional<z.ZodNumber>;
+            iteration_commit_containment: z.ZodOptional<z.ZodObject<{
+                branch_prefix: z.ZodString;
+            }, z.core.$strict>>;
+            frozen_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            activate_when_depth_at_least: z.ZodLiteral<"autonomous">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    report_file_surfaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        timing: z.ZodEnum<{
+            before: "before";
+            after: "after";
+        }>;
+        extractor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"string-array-field">;
+            field: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"build-plan-and-slices-anticipated-file-extensions">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>>;
+    required_config: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        axis: z.ZodEnum<{
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type FlowSchematic = z.infer<typeof FlowSchematic>;
+export type FlowSchematicCatalogCompatibilityIssue = {
+    item_id?: string;
+    message: string;
+};
+export type RouteRecognizer = (input: {
+    readonly routeId: string;
+    readonly routeTarget: string;
+    readonly stepId: string;
+}) => boolean;
+export interface FlowSchematicCatalogCompatibilityOptions {
+    readonly recognizeRoute?: RouteRecognizer;
+}
+export declare function validateFlowSchematicCatalogCompatibility(schematic: FlowSchematic, catalog: FlowBlockCatalogValue, options?: FlowSchematicCatalogCompatibilityOptions): FlowSchematicCatalogCompatibilityIssue[];
+//# sourceMappingURL=flow-schematic.d.ts.map