@petepetrash/circuit 0.1.0

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

@@ -0,0 +1,795 @@
+export declare const goalFlowData: {
+    id: string;
+    visibility: "internal";
+    paths: {
+        schematic: 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<{
+            schema: import("zod").ZodLiteral<"goal.clarified-task@v1">;
+            verdict: import("zod").ZodEnum<{
+                continue: "continue";
+                stop: "stop";
+                ask: "ask";
+            }>;
+            original_request: import("zod").ZodString;
+            target: import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"flow">;
+                id: import("zod").ZodLiteral<"goal">;
+            }, import("zod/v4/core").$strict>;
+            guide_id: import("zod").ZodLiteral<"goal-v1">;
+            clarified_prompt: import("zod").ZodString;
+            objective: import("zod").ZodString;
+            desired_outcome: import("zod").ZodString;
+            proof_needed: import("zod").ZodArray<import("zod").ZodObject<{
+                kind: import("zod").ZodEnum<{
+                    command: "command";
+                    report: "report";
+                    source: "source";
+                    checkpoint: "checkpoint";
+                    review: "review";
+                }>;
+                description: import("zod").ZodString;
+                required: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>>;
+            constraints: import("zod").ZodArray<import("zod").ZodString>;
+            scope: import("zod").ZodObject<{
+                in_bounds: import("zod").ZodArray<import("zod").ZodString>;
+                out_of_bounds: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            assumptions: import("zod").ZodArray<import("zod").ZodString>;
+            missing_information: import("zod").ZodArray<import("zod").ZodObject<{
+                question: import("zod").ZodString;
+                why_it_matters: import("zod").ZodString;
+                safe_default: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            iteration_policy: import("zod").ZodArray<import("zod").ZodString>;
+            stop_conditions: import("zod").ZodArray<import("zod").ZodString>;
+            suggested_parts: import("zod").ZodArray<import("zod").ZodObject<{
+                title: import("zod").ZodString;
+                objective: import("zod").ZodString;
+                proof_needed: import("zod").ZodArray<import("zod").ZodString>;
+                risk_notes: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema: import("zod").ZodLiteral<"goal.contract@v1">;
+            objective: import("zod").ZodString;
+            source_of_truth: import("zod").ZodLiteral<"circuit-run-folder">;
+            scope: import("zod").ZodObject<{
+                in: import("zod").ZodArray<import("zod").ZodString>;
+                out: import("zod").ZodArray<import("zod").ZodString>;
+                assumptions: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            constraints: import("zod").ZodArray<import("zod").ZodString>;
+            done_when: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                claim: import("zod").ZodString;
+                required_evidence: import("zod").ZodArray<import("zod").ZodObject<{
+                    kind: import("zod").ZodEnum<{
+                        command: "command";
+                        report: "report";
+                        source: "source";
+                        checkpoint: "checkpoint";
+                        review: "review";
+                    }>;
+                    description: import("zod").ZodString;
+                    required: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+            allowed_flow_targets: import("zod").ZodArray<import("zod").ZodEnum<{
+                review: "review";
+                pursue: "pursue";
+                fix: "fix";
+                build: "build";
+                explore: "explore";
+            }>>;
+            selected_flow_target: import("zod").ZodEnum<{
+                review: "review";
+                pursue: "pursue";
+                fix: "fix";
+                build: "build";
+                explore: "explore";
+            }>;
+            recovery_policy: import("zod").ZodObject<{
+                max_attempts: import("zod").ZodNumber;
+                routes: import("zod").ZodArray<import("zod").ZodEnum<{
+                    handoff: "handoff";
+                    checkpoint: "checkpoint";
+                    blocked: "blocked";
+                    "run-fix": "run-fix";
+                    "run-review": "run-review";
+                    "run-explore": "run-explore";
+                    "split-to-pursue": "split-to-pursue";
+                    "retry-selected-flow": "retry-selected-flow";
+                }>>;
+            }, import("zod/v4/core").$strict>;
+            check_in_triggers: import("zod").ZodArray<import("zod").ZodString>;
+            stop_conditions: import("zod").ZodArray<import("zod").ZodString>;
+            completion_gate: import("zod").ZodObject<{
+                required_passes: import("zod").ZodLiteral<2>;
+                blocking_severities: import("zod").ZodArray<import("zod").ZodEnum<{
+                    medium: "medium";
+                    high: "high";
+                    critical: "critical";
+                }>>;
+                reset_on_blocking_finding: import("zod").ZodLiteral<true>;
+            }, 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<{
+            schema_version: import("zod").ZodLiteral<1>;
+            run_id: import("zod/v4/core").$ZodBranded<import("zod").ZodGUID, "RunId", "out">;
+            flow_id: import("zod/v4/core").$ZodBranded<import("zod").ZodString, "CompiledFlowId", "out">;
+            goal: import("zod").ZodString;
+            why: import("zod").ZodOptional<import("zod").ZodString>;
+            outcome: import("zod").ZodEnum<{
+                complete: "complete";
+                stopped: "stopped";
+                handoff: "handoff";
+                aborted: "aborted";
+                escalated: "escalated";
+            }>;
+            summary: import("zod").ZodString;
+            closed_at: import("zod").ZodISODateTime;
+            trace_entries_observed: import("zod").ZodNumber;
+            manifest_hash: import("zod").ZodString;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            verdict: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        relayHint?: never;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema: import("zod").ZodLiteral<"goal.attempt@v1">;
+            attempt_id: import("zod").ZodString;
+            flow_target: import("zod").ZodEnum<{
+                review: "review";
+                pursue: "pursue";
+                fix: "fix";
+                build: "build";
+                explore: "explore";
+            }>;
+            child_result_path: import("zod").ZodString;
+            child_report_paths: import("zod").ZodArray<import("zod").ZodString>;
+            outcome: import("zod").ZodEnum<{
+                complete: "complete";
+                handoff: "handoff";
+                failed: "failed";
+                blocked: "blocked";
+                needs_attention: "needs_attention";
+            }>;
+            summary: 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: import("zod").ZodLiteral<"goal.evidence-evaluation@v1">;
+            verdict: import("zod").ZodEnum<{
+                contradicted: "contradicted";
+                blocked: "blocked";
+                "missing-evidence": "missing-evidence";
+                satisfied: "satisfied";
+            }>;
+            claim_results: import("zod").ZodArray<import("zod").ZodObject<{
+                claim_id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    missing: "missing";
+                    contradicted: "contradicted";
+                    blocked: "blocked";
+                    proved: "proved";
+                }>;
+                evidence: import("zod").ZodArray<import("zod").ZodString>;
+                gap: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            next_route: import("zod").ZodEnum<{
+                handoff: "handoff";
+                checkpoint: "checkpoint";
+                blocked: "blocked";
+                "run-fix": "run-fix";
+                "run-review": "run-review";
+                "run-explore": "run-explore";
+                "split-to-pursue": "split-to-pursue";
+                "completion-gate": "completion-gate";
+                "retry-selected-flow": "retry-selected-flow";
+            }>;
+        }, 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: import("zod").ZodLiteral<"goal.recovery@v1">;
+            reason: import("zod").ZodEnum<{
+                "missing-evidence": "missing-evidence";
+                "verification-failed": "verification-failed";
+                "review-blocked": "review-blocked";
+                "scope-drift": "scope-drift";
+                "child-blocked": "child-blocked";
+                "attempt-limit": "attempt-limit";
+            }>;
+            selected_route: import("zod").ZodEnum<{
+                handoff: "handoff";
+                checkpoint: "checkpoint";
+                blocked: "blocked";
+                "run-fix": "run-fix";
+                "run-review": "run-review";
+                "run-explore": "run-explore";
+                "split-to-pursue": "split-to-pursue";
+                "retry-selected-flow": "retry-selected-flow";
+            }>;
+            rationale: import("zod").ZodString;
+            attempt_count: import("zod").ZodNumber;
+            operator_input_required: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            schema: import("zod").ZodLiteral<"goal.gate@v1">;
+            verdict: import("zod").ZodEnum<{
+                blocked: "blocked";
+                "gate-pass": "gate-pass";
+            }>;
+            clean_streak: import("zod").ZodNumber;
+            required_passes: import("zod").ZodLiteral<2>;
+            blocking_findings: import("zod").ZodArray<import("zod").ZodObject<{
+                severity: import("zod").ZodEnum<{
+                    medium: "medium";
+                    high: "high";
+                    critical: "critical";
+                }>;
+                text: import("zod").ZodString;
+                refs: import("zod").ZodArray<import("zod").ZodString>;
+                recovery_route: import("zod").ZodEnum<{
+                    checkpoint: "checkpoint";
+                    blocked: "blocked";
+                    "run-fix": "run-fix";
+                    "run-review": "run-review";
+                    "run-explore": "run-explore";
+                    "split-to-pursue": "split-to-pursue";
+                    "retry-selected-flow": "retry-selected-flow";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+            low_findings: import("zod").ZodArray<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                refs: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            passes: import("zod").ZodArray<import("zod").ZodObject<{
+                pass_id: import("zod").ZodString;
+                attack_lens: import("zod").ZodEnum<{
+                    "contract-and-proof": "contract-and-proof";
+                    "false-done-and-recovery": "false-done-and-recovery";
+                    "scope-and-host-boundary": "scope-and-host-boundary";
+                }>;
+                evidence_checked: import("zod").ZodArray<import("zod").ZodString>;
+                verdict: import("zod").ZodEnum<{
+                    blocked: "blocked";
+                    "gate-pass": "gate-pass";
+                }>;
+            }, import("zod/v4/core").$strict>>;
+            next_route: import("zod").ZodEnum<{
+                close: "close";
+                recover: "recover";
+                "run-next-gate-pass": "run-next-gate-pass";
+            }>;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema: import("zod").ZodLiteral<"goal.result@v1">;
+            outcome: import("zod").ZodEnum<{
+                complete: "complete";
+                handoff: "handoff";
+                failed: "failed";
+                blocked: "blocked";
+                needs_attention: "needs_attention";
+            }>;
+            summary: import("zod").ZodString;
+            proven_claims: import("zod").ZodArray<import("zod").ZodString>;
+            missing_or_weak_claims: import("zod").ZodArray<import("zod").ZodString>;
+            recovery_history: import("zod").ZodArray<import("zod").ZodString>;
+            residual_risks: import("zod").ZodArray<import("zod").ZodString>;
+            rerun_commands: import("zod").ZodArray<import("zod").ZodString>;
+            evidence_links: import("zod").ZodArray<import("zod").ZodObject<{
+                report_id: import("zod").ZodEnum<{
+                    "goal.contract": "goal.contract";
+                    "goal.attempt": "goal.attempt";
+                    "goal.evidence-evaluation": "goal.evidence-evaluation";
+                    "goal.recovery": "goal.recovery";
+                    "goal.gate": "goal.gate";
+                }>;
+                path: import("zod").ZodString;
+                schema: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            gate: import("zod").ZodObject<{
+                clean_streak: import("zod").ZodNumber;
+                required_passes: import("zod").ZodLiteral<2>;
+                final_verdict: import("zod").ZodEnum<{
+                    blocked: "blocked";
+                    "gate-pass": "gate-pass";
+                }>;
+            }, 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: "researcher";
+                relayStartedText: string;
+                relayCompletedText: string;
+            } | {
+                stepId: string;
+                taskTitle: string;
+                activeText: string;
+                relayRole?: never;
+                relayStartedText?: never;
+                relayCompletedText?: never;
+            } | {
+                stepId: string;
+                taskTitle: string;
+                activeText: string;
+                relayRole: "reviewer";
+                relayStartedText: string;
+                relayCompletedText: string;
+            })[];
+        };
+    };
+};
+//# sourceMappingURL=data.d.ts.map