@petepetrash/circuit 0.1.0

package/dist/flows/explore/data.d.ts

@@ -0,0 +1,734 @@
+export declare const exploreFlowData: {
+    id: string;
+    visibility: "public";
+    paths: {
+        schematic: string;
+        contract: string;
+    };
+    schematic: {
+        schema_version: "2";
+        id: string & import("zod").$brand<"CompiledFlowId">;
+        title: string;
+        purpose: string;
+        status: "deprecated" | "candidate" | "active";
+        starts_at: string & import("zod").$brand<"StepId">;
+        initial_contracts: string[];
+        contract_aliases: {
+            generic: string;
+            actual: string;
+        }[];
+        items: {
+            id: string & import("zod").$brand<"StepId">;
+            block: "handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint";
+            title: string;
+            stage: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            input: Record<string, string>;
+            optional_inputs: string[];
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+            } | {
+                kind: "relay";
+                role: "researcher" | "implementer" | "reviewer";
+                connector?: string | undefined;
+            } | {
+                kind: "verification";
+            } | {
+                kind: "checkpoint";
+            } | {
+                kind: "sub-run";
+                flow_ref: {
+                    flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                    entry_mode: string;
+                    version?: string | undefined;
+                };
+                goal: string;
+                depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+            } | {
+                kind: "fanout";
+            };
+            skill_slots: {
+                id: string & import("zod").$brand<"SkillSlotId">;
+                description: string;
+            }[];
+            routes: Record<string, (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">;
+            route_overrides: Record<string, Partial<Record<"low" | "medium" | "high" | "tournament" | "autonomous", (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">>>;
+            selection?: {
+                skills: {
+                    mode: "inherit";
+                } | {
+                    mode: "replace";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "append";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "remove";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                };
+                invocation_options: import("../../index.js").JsonObject;
+                model?: {
+                    provider: "custom" | "openai" | "anthropic" | "gemini";
+                    model: string;
+                } | undefined;
+                effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+            } | undefined;
+            equipment_scope?: {
+                tools: {
+                    allow: string[];
+                } | "full";
+                enforcement: "trusted" | "enforced";
+            } | undefined;
+            route_from_report?: {
+                path: string[];
+            } | undefined;
+            protocol?: (string & import("zod").$brand<"ProtocolId">) | undefined;
+            writes?: {
+                report_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                receipt_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                result_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                branches_dir_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_response_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+            } | undefined;
+            check?: {
+                required?: string[] | undefined;
+                allow?: string[] | undefined;
+                allow_from?: {
+                    kind: "policy_choices";
+                } | undefined;
+                pass?: string[] | undefined;
+            } | undefined;
+            acceptance_criteria?: {
+                checks: ({
+                    kind: "command";
+                    id: string;
+                    command: {
+                        id: string;
+                        cwd: string;
+                        argv: string[];
+                        timeout_ms: number;
+                        max_output_bytes: number;
+                        env: Record<string, string>;
+                    };
+                    expected_status: "passed";
+                } | {
+                    kind: "report_field";
+                    id: string;
+                    path: string[];
+                    predicate: "present" | "non_empty" | "changed_on_disk";
+                })[];
+                on_failure: {
+                    mode: "hard-fail";
+                } | {
+                    mode: "retry-with-feedback";
+                };
+            } | undefined;
+            checkpoint_policy?: {
+                prompt: string;
+                choices?: {
+                    id: string;
+                    label?: string | undefined;
+                    description?: string | undefined;
+                }[] | undefined;
+                choices_from?: {
+                    kind: "report_items";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    id_path: string;
+                    filter?: {
+                        kind: "path_equals";
+                        path: string;
+                        value: string | number | boolean | null;
+                    } | undefined;
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                    label_path?: string | undefined;
+                    description_path?: string | undefined;
+                } | undefined;
+                safe_default_choice?: string | undefined;
+                auto_resolution?: {
+                    policy: "highest-score";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    branches_path: string;
+                    id_path: string;
+                    rubric_result_path: string;
+                } | undefined;
+                auto_continuable_when_nested?: boolean | undefined;
+                report_template?: import("../../index.js").JsonObject | undefined;
+            } | undefined;
+            fanout?: {
+                branches: {
+                    kind: "static";
+                    branches: ({
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    })[];
+                } | {
+                    kind: "dynamic";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    template: {
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: unknown;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: unknown;
+                    };
+                    max_branches: number | {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    };
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                };
+                join: {
+                    policy: "pick-winner";
+                } | {
+                    policy: "disjoint-merge";
+                } | {
+                    policy: "aggregate-only";
+                } | {
+                    policy: "aggregate-survivors";
+                };
+                concurrency?: {
+                    kind: "unbounded";
+                } | {
+                    kind: "bounded";
+                    max: number;
+                } | undefined;
+                on_child_failure?: "abort-all" | "continue-others" | undefined;
+                rubric?: {
+                    model_judgments_path: string;
+                    ordered_dims: string[];
+                    runtime_signals: Record<string, {
+                        kind: "constant";
+                        signal: "met" | "missing" | "n/a";
+                    } | {
+                        kind: "non_empty_array";
+                        path: string;
+                    } | {
+                        kind: "non_empty_string";
+                        path: string;
+                    }>;
+                } | undefined;
+            } | undefined;
+        }[];
+        version?: string | undefined;
+        axes?: {
+            allowed_depths: ("low" | "medium" | "high")[];
+            supports_tournament: boolean;
+            supports_autonomous: boolean;
+            default: {
+                depth: "low" | "medium" | "high";
+                tournament: boolean;
+                tournament_n: number;
+                autonomous: boolean;
+            };
+            tournament_fan_out_stage?: (string & import("zod").$brand<"StageId">) | undefined;
+        } | undefined;
+        stage_path_policy?: {
+            mode: "strict";
+        } | {
+            mode: "partial";
+            omits: ("review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close")[];
+            rationale: string;
+        } | undefined;
+        stages?: {
+            canonical: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            id: string & import("zod").$brand<"StageId">;
+            title: string;
+        }[] | undefined;
+        default_selection?: {
+            skills: {
+                mode: "inherit";
+            } | {
+                mode: "replace";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "append";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "remove";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            };
+            invocation_options: import("../../index.js").JsonObject;
+            model?: {
+                provider: "custom" | "openai" | "anthropic" | "gemini";
+                model: string;
+            } | undefined;
+            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+        } | undefined;
+        engine_flags?: {
+            binds_execution_depth_to_relay_selection?: boolean | undefined;
+            binds_terminal_outcome_to_primary_result?: boolean | undefined;
+            iterates_slice_loop?: {
+                head_step: string;
+                tail_step: string;
+                advance_route: string;
+                slices_from: {
+                    report: string;
+                    items_path: string;
+                };
+                max_slices: number;
+                activate_when_depth_at_least: "high";
+            } | undefined;
+            iterates_until_condition?: {
+                head_step: string;
+                tail_step: string;
+                body_steps: string[];
+                reenter_route: string;
+                max_iterations: number;
+                activate_when_depth_at_least: "autonomous";
+                stop_judge?: {
+                    report: string;
+                    goal_met_path: string;
+                    lesson_path?: string | undefined;
+                    progress_path?: string | undefined;
+                } | undefined;
+                needs_attention_route?: string | undefined;
+                carried_notes?: {
+                    report: string;
+                    max_entries?: number | undefined;
+                } | undefined;
+                cumulative_usd_cap?: number | undefined;
+                cumulative_token_cap?: number | undefined;
+                no_progress_ceiling?: number | undefined;
+                iteration_commit_containment?: {
+                    branch_prefix: string;
+                } | undefined;
+                frozen_paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+        report_file_surfaces?: Record<string, {
+            timing: "before" | "after";
+            extractor: {
+                kind: "string-array-field";
+                field: string;
+            } | {
+                kind: "build-plan-and-slices-anticipated-file-extensions";
+            };
+        }> | undefined;
+        required_config?: {
+            axis: "tournament" | "autonomous";
+            path: string;
+            message: string;
+        }[] | undefined;
+    };
+    canonicalStagePolicy: {
+        kind: "enforce";
+        canonicals: string[];
+        omits: string[];
+        optional_canonicals: never[];
+        variants: never[];
+        title: string;
+        authority: string;
+    };
+    reports: ({
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodString;
+            subject: import("zod").ZodString;
+            recommendation: import("zod").ZodString;
+            success_condition_alignment: import("zod").ZodString;
+            supporting_aspects: import("zod").ZodArray<import("zod").ZodObject<{
+                aspect: import("zod").ZodString;
+                contribution: import("zod").ZodString;
+                evidence_refs: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodEnum<{
+                accept: "accept";
+                reject: "reject";
+                "accept-with-fold-ins": "accept-with-fold-ins";
+            }>;
+            overall_assessment: import("zod").ZodString;
+            objections: import("zod").ZodArray<import("zod").ZodString>;
+            missed_angles: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodLiteral<"accept">;
+            option_id: import("zod").ZodString;
+            option_label: import("zod").ZodString;
+            case_summary: import("zod").ZodString;
+            assumptions: import("zod").ZodArray<import("zod").ZodString>;
+            evidence_refs: import("zod").ZodArray<import("zod").ZodString>;
+            risks: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            rubric_model_judgments: import("zod").ZodRecord<import("zod").ZodEnum<{
+                evidence_rigor: "evidence_rigor";
+                actionability: "actionability";
+                coverage_adequacy: "coverage_adequacy";
+                scope_discipline: "scope_discipline";
+                honest_calibration: "honest_calibration";
+                project_specificity: "project_specificity";
+                insight_density: "insight_density";
+                branch_distinctness: "branch_distinctness";
+            }>, import("zod").ZodEnum<{
+                pass: "pass";
+                concern: "concern";
+                fail: "fail";
+            }>>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodEnum<{
+                recommend: "recommend";
+                "no-clear-winner": "no-clear-winner";
+                "needs-operator": "needs-operator";
+            }>;
+            recommended_option_id: import("zod").ZodString;
+            comparison: import("zod").ZodString;
+            objections: import("zod").ZodArray<import("zod").ZodString>;
+            missing_evidence: import("zod").ZodArray<import("zod").ZodString>;
+            tradeoff_question: import("zod").ZodString;
+            confidence: import("zod").ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            subject: import("zod").ZodString;
+            task: import("zod").ZodString;
+            success_condition: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            subject: import("zod").ZodString;
+            aspects: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                summary: import("zod").ZodString;
+                evidence: import("zod").ZodArray<import("zod").ZodObject<{
+                    source: import("zod").ZodString;
+                    summary: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            decision_question: import("zod").ZodString;
+            options: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodString;
+                summary: import("zod").ZodString;
+                best_case_prompt: import("zod").ZodString;
+                evidence_refs: import("zod").ZodArray<import("zod").ZodString>;
+                tradeoffs: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            recommendation_basis: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema_version: import("zod").ZodLiteral<1>;
+            join_policy: import("zod").ZodLiteral<"aggregate-survivors">;
+            branch_count: import("zod").ZodNumber;
+            branches: import("zod").ZodArray<import("zod").ZodObject<{
+                branch_id: import("zod").ZodString;
+                child_run_id: import("zod").ZodString;
+                child_outcome: import("zod").ZodEnum<{
+                    complete: "complete";
+                    stopped: "stopped";
+                    handoff: "handoff";
+                    aborted: "aborted";
+                    escalated: "escalated";
+                }>;
+                verdict: import("zod").ZodString;
+                admitted: import("zod").ZodBoolean;
+                result_path: import("zod").ZodString;
+                duration_ms: import("zod").ZodNumber;
+                result_body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    verdict: import("zod").ZodLiteral<"accept">;
+                    option_id: import("zod").ZodString;
+                    option_label: import("zod").ZodString;
+                    case_summary: import("zod").ZodString;
+                    assumptions: import("zod").ZodArray<import("zod").ZodString>;
+                    evidence_refs: import("zod").ZodArray<import("zod").ZodString>;
+                    risks: import("zod").ZodArray<import("zod").ZodString>;
+                    next_action: import("zod").ZodString;
+                    rubric_model_judgments: import("zod").ZodRecord<import("zod").ZodEnum<{
+                        evidence_rigor: "evidence_rigor";
+                        actionability: "actionability";
+                        coverage_adequacy: "coverage_adequacy";
+                        scope_discipline: "scope_discipline";
+                        honest_calibration: "honest_calibration";
+                        project_specificity: "project_specificity";
+                        insight_density: "insight_density";
+                        branch_distinctness: "branch_distinctness";
+                    }>, import("zod").ZodEnum<{
+                        pass: "pass";
+                        concern: "concern";
+                        fail: "fail";
+                    }>>;
+                }, import("zod/v4/core").$strict>>;
+                rubric_result: import("zod").ZodOptional<import("zod").ZodObject<{
+                    dims: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                        runtime_signal: import("zod").ZodEnum<{
+                            met: "met";
+                            missing: "missing";
+                            "n/a": "n/a";
+                        }>;
+                        model_judgment: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        final_score: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        dim_score: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1>, import("zod").ZodLiteral<0.5>, import("zod").ZodLiteral<0>]>;
+                        runtime_vetoed: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strict>>;
+                    aggregate_score: import("zod").ZodNumber;
+                    runtime_veto_count: import("zod").ZodNumber;
+                    tie_break: import("zod").ZodObject<{
+                        ordered_dims: import("zod").ZodArray<import("zod").ZodString>;
+                        final_reason: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        relayHint?: never;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodLiteral<"decided">;
+            decision_question: import("zod").ZodString;
+            selected_option_id: import("zod").ZodString;
+            selected_option_label: import("zod").ZodString;
+            decision: import("zod").ZodString;
+            rationale: import("zod").ZodString;
+            rejected_options: import("zod").ZodArray<import("zod").ZodObject<{
+                option_id: import("zod").ZodString;
+                reason: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            evidence_links: import("zod").ZodArray<import("zod").ZodString>;
+            assumptions: import("zod").ZodArray<import("zod").ZodString>;
+            residual_risks: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            follow_up_workflow: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            summary: import("zod").ZodString;
+            verdict_snapshot: import("zod").ZodObject<{
+                compose_verdict: import("zod").ZodString;
+                review_verdict: import("zod").ZodEnum<{
+                    accept: "accept";
+                    reject: "reject";
+                    "accept-with-fold-ins": "accept-with-fold-ins";
+                }>;
+                objection_count: import("zod").ZodNumber;
+                missed_angle_count: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>;
+            review_fold_ins: import("zod").ZodOptional<import("zod").ZodObject<{
+                overall_assessment: import("zod").ZodString;
+                objections: import("zod").ZodArray<import("zod").ZodString>;
+                missed_angles: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            evidence_links: import("zod").ZodArray<import("zod").ZodObject<{
+                report_id: import("zod").ZodType<"explore.brief" | "explore.analysis" | "explore.compose" | "explore.review-verdict" | "explore.decision-options" | "explore.tournament-aggregate" | "explore.tournament-review" | "explore.decision", unknown, import("zod/v4/core").$ZodTypeInternals<"explore.brief" | "explore.analysis" | "explore.compose" | "explore.review-verdict" | "explore.decision-options" | "explore.tournament-aggregate" | "explore.tournament-review" | "explore.decision", unknown>>;
+                path: import("zod").ZodString;
+                schema: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            summary: import("zod").ZodString;
+            verdict_snapshot: import("zod").ZodObject<{
+                decision_verdict: import("zod").ZodLiteral<"decided">;
+                tournament_review_verdict: import("zod").ZodEnum<{
+                    recommend: "recommend";
+                    "no-clear-winner": "no-clear-winner";
+                    "needs-operator": "needs-operator";
+                }>;
+                selected_option_id: import("zod").ZodString;
+                objection_count: import("zod").ZodNumber;
+                missing_evidence_count: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>;
+            evidence_links: import("zod").ZodArray<import("zod").ZodObject<{
+                report_id: import("zod").ZodType<"explore.brief" | "explore.analysis" | "explore.compose" | "explore.review-verdict" | "explore.decision-options" | "explore.tournament-aggregate" | "explore.tournament-review" | "explore.decision", unknown, import("zod/v4/core").$ZodTypeInternals<"explore.brief" | "explore.analysis" | "explore.compose" | "explore.review-verdict" | "explore.decision-options" | "explore.tournament-aggregate" | "explore.tournament-review" | "explore.decision", unknown>>;
+                path: import("zod").ZodString;
+                schema: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>]>;
+        writers: {
+            close: import("../registries/close-writers/types.js").CloseBuilder[];
+            compose?: never;
+        };
+        relayHint?: never;
+    })[];
+    runtimeSurface: {
+        primaryResult: {
+            schemaName: string;
+            path: string;
+            label: string;
+        };
+        progress: {
+            steps: ({
+                stepId: string;
+                taskTitle: string;
+                activeText: string;
+                relayRole?: never;
+                relayStartedText?: never;
+                relayCompletedText?: never;
+            } | {
+                stepId: string;
+                taskTitle: string;
+                activeText: string;
+                relayRole: "implementer";
+                relayStartedText: string;
+                relayCompletedText: string;
+            } | {
+                stepId: string;
+                taskTitle: string;
+                activeText: string;
+                relayRole: "reviewer";
+                relayStartedText: string;
+                relayCompletedText: string;
+            })[];
+        };
+    };
+};
+//# sourceMappingURL=data.d.ts.map