@petepetrash/circuit 0.1.0

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

@@ -0,0 +1,1032 @@
+export declare const explainerFlowData: {
+    id: string;
+    visibility: "internal";
+    paths: {
+        schematic: string;
+        contract: string;
+    };
+    schematic: {
+        schema_version: "2";
+        id: string;
+        title: string;
+        purpose: string;
+        status: "active";
+        version: string;
+        starts_at: string;
+        initial_contracts: string[];
+        contract_aliases: {
+            generic: string;
+            actual: string;
+        }[];
+        axes: {
+            allowed_depths: ("low" | "medium" | "high")[];
+            supports_tournament: true;
+            supports_autonomous: true;
+            default: {
+                depth: "medium";
+                tournament: false;
+                tournament_n: number;
+                autonomous: false;
+            };
+            tournament_fan_out_stage: string;
+        };
+        stage_path_policy: {
+            mode: "strict";
+        };
+        stages: ({
+            id: string;
+            canonical: "frame";
+            title: string;
+        } | {
+            id: string;
+            canonical: "analyze";
+            title: string;
+        } | {
+            id: string;
+            canonical: "plan";
+            title: string;
+        } | {
+            id: string;
+            canonical: "act";
+            title: string;
+        } | {
+            id: string;
+            canonical: "verify";
+            title: string;
+        } | {
+            id: string;
+            canonical: "review";
+            title: string;
+        } | {
+            id: string;
+            canonical: "close";
+            title: 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;
+        } | {
+            id: string;
+            title: string;
+            stage: "frame";
+            block: "frame";
+            input: {
+                task: string;
+                route: string;
+                brief?: never;
+                context?: never;
+                diagnosis?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                contract?: never;
+                plan?: never;
+                change?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                continue: string;
+                stop: string;
+                retry?: never;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "analyze";
+            block: "diagnose";
+            input: {
+                brief: string;
+                context: string;
+                task?: never;
+                route?: never;
+                diagnosis?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                contract?: never;
+                plan?: never;
+                change?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                continue: string;
+                stop: string;
+                retry?: never;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "plan";
+            block: "plan";
+            input: {
+                brief: string;
+                diagnosis: string;
+                task?: never;
+                route?: never;
+                context?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                contract?: never;
+                plan?: never;
+                change?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                continue: string;
+                stop: string;
+                retry?: never;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "plan";
+            block: "plan";
+            input: {
+                brief: string;
+                ideas: string;
+                aggregate: string;
+                hardening: string;
+                task?: never;
+                route?: never;
+                context?: never;
+                diagnosis?: never;
+                contract?: never;
+                plan?: never;
+                change?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                continue: string;
+                stop: string;
+                retry?: never;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "act";
+            block: "goal-child-run";
+            input: {
+                contract: string;
+                task?: never;
+                route?: never;
+                brief?: never;
+                context?: never;
+                diagnosis?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                plan?: never;
+                change?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "sub-run";
+                flow_ref: {
+                    flow_id: string;
+                    entry_mode: string;
+                };
+                goal: string;
+                depth: "medium";
+            };
+            protocol: string;
+            writes: {
+                result_path: string;
+                report_path?: never;
+            };
+            check: {
+                pass: ("accept" | "accept-with-fixes" | "accept-with-fold-ins" | "clean" | "needs-followup" | "decided" | "NO_ISSUES_FOUND" | "ISSUES_FOUND")[];
+                required?: never;
+            };
+            routes: {
+                continue: string;
+                stop: string;
+                retry?: never;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "verify";
+            block: "run-verification";
+            input: {
+                plan: string;
+                change: string;
+                task?: never;
+                route?: never;
+                brief?: never;
+                context?: never;
+                diagnosis?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                contract?: never;
+                intake?: never;
+                spec?: never;
+                verification?: never;
+                build?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "verification";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                continue: string;
+                retry: string;
+                stop: string;
+                complete?: never;
+            };
+        } | {
+            id: string;
+            title: string;
+            stage: "close";
+            block: "close-with-evidence";
+            input: {
+                intake: string;
+                spec: string;
+                verification: string;
+                build: string;
+                task?: never;
+                route?: never;
+                brief?: never;
+                context?: never;
+                diagnosis?: never;
+                ideas?: never;
+                aggregate?: never;
+                hardening?: never;
+                contract?: never;
+                plan?: never;
+                change?: never;
+            };
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+                flow_ref?: never;
+                goal?: never;
+                depth?: never;
+            };
+            protocol: string;
+            writes: {
+                report_path: string;
+                result_path?: never;
+            };
+            check: {
+                required: string[];
+                pass?: never;
+            };
+            routes: {
+                complete: string;
+                stop: string;
+                continue?: never;
+                retry?: never;
+            };
+        })[];
+        engine_flags: {
+            binds_terminal_outcome_to_primary_result: true;
+        };
+    };
+    canonicalStagePolicy: {
+        kind: "enforce";
+        canonicals: string[];
+        omits: never[];
+        optional_canonicals: never[];
+        variants: never[];
+        title: string;
+        authority: string;
+    };
+    reports: ({
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            verdict: import("zod").ZodLiteral<"accept">;
+            concept_id: import("zod").ZodString;
+            concept_label: import("zod").ZodString;
+            case_summary: import("zod").ZodString;
+            fidelity_evidence: import("zod").ZodArray<import("zod").ZodString>;
+            risks: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            rubric_model_judgments: import("zod").ZodObject<{
+                fidelity: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+                memetic_potential: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+                entertainment: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+                cross_audience_reach: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+                build_feasibility: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+                novelty: import("zod").ZodEnum<{
+                    pass: "pass";
+                    concern: "concern";
+                    fail: "fail";
+                }>;
+            }, 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<{
+                recommend: "recommend";
+                "no-clear-winner": "no-clear-winner";
+                "needs-operator": "needs-operator";
+            }>;
+            recommended_concept_id: import("zod").ZodNullable<import("zod").ZodString>;
+            teaches_right_driver: import("zod").ZodBoolean;
+            banned_phrase_findings: import("zod").ZodArray<import("zod").ZodObject<{
+                phrase: import("zod").ZodString;
+                present: import("zod").ZodBoolean;
+                note: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            objections: import("zod").ZodArray<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;
+            paper_reference: import("zod").ZodString;
+            house_style_references: import("zod").ZodArray<import("zod").ZodString>;
+            success_condition: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            subject: import("zod").ZodString;
+            lossless_principle: import("zod").ZodString;
+            notation_rows: import("zod").ZodArray<import("zod").ZodObject<{
+                symbol: import("zod").ZodString;
+                name: import("zod").ZodString;
+                definition: import("zod").ZodString;
+                role: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            outline_sections: import("zod").ZodArray<import("zod").ZodObject<{
+                section_id: import("zod").ZodString;
+                title: import("zod").ZodString;
+                load_bearing_points: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            brief_question: import("zod").ZodString;
+            concepts: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodString;
+                summary: import("zod").ZodString;
+                lens: import("zod").ZodString;
+                scoped_prompt: import("zod").ZodString;
+                fidelity_anchor: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+            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">;
+                    concept_id: import("zod").ZodString;
+                    concept_label: import("zod").ZodString;
+                    case_summary: import("zod").ZodString;
+                    fidelity_evidence: import("zod").ZodArray<import("zod").ZodString>;
+                    risks: import("zod").ZodArray<import("zod").ZodString>;
+                    next_action: import("zod").ZodString;
+                    rubric_model_judgments: import("zod").ZodObject<{
+                        fidelity: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        memetic_potential: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        entertainment: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        cross_audience_reach: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        build_feasibility: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                        novelty: import("zod").ZodEnum<{
+                            pass: "pass";
+                            concern: "concern";
+                            fail: "fail";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                }, 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<{
+            concept_id: import("zod").ZodString;
+            concept_label: import("zod").ZodString;
+            visual_system: import("zod").ZodString;
+            motion_architecture: import("zod").ZodString;
+            copy_deck: import("zod").ZodString;
+            fidelity_citations: import("zod").ZodArray<import("zod").ZodString>;
+            build_brief: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+            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<{
+            overall_status: import("zod").ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            commands: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                exit_code: import("zod").ZodNumber;
+                stdout_summary: import("zod").ZodString;
+                stderr_summary: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            verification: import("../registries/verification-writers/types.js").VerificationBuilder[];
+            compose?: never;
+            close?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            outcome: import("zod").ZodEnum<{
+                complete: "complete";
+                stopped: "stopped";
+                blocked: "blocked";
+            }>;
+            summary: import("zod").ZodString;
+            shipped_concept_id: import("zod").ZodNullable<import("zod").ZodString>;
+            evidence_pointers: import("zod").ZodArray<import("zod").ZodString>;
+            residual_risks: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            close: import("../registries/close-writers/types.js").CloseBuilder[];
+            compose?: never;
+            verification?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema_version: import("zod").ZodLiteral<1>;
+            step_id: import("zod").ZodString;
+            selection: import("zod").ZodString;
+            route_id: import("zod").ZodString;
+            resolution_source: import("zod").ZodString;
+            auto_resolution: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strict>;
+        relayHint?: never;
+        writers?: 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: "reviewer";
+                relayStartedText: string;
+                relayCompletedText: string;
+            })[];
+        };
+    };
+};
+//# sourceMappingURL=data.d.ts.map