@petepetrash/circuit 0.1.0

package/dist/schemas/run.d.ts

@@ -0,0 +1,2866 @@
+import { z } from 'zod';
+import { type SnapshotStatus } from './snapshot.js';
+import { type RunClosedOutcome } from './trace-entry.js';
+export declare const RunTrace: z.ZodPipe<z.ZodCustom<unknown[], unknown[]>, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.bootstrapped">;
+    flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    invocation_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InvocationId", "out">>;
+    depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+    goal: z.ZodString;
+    change_kind: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"ratchet-advance">;
+    }, z.core.$strict>, z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"equivalence-refactor">;
+    }, z.core.$strict>, z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"discovery">;
+    }, z.core.$strict>, z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"disposable">;
+    }, z.core.$strict>, z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"migration-escrow">;
+        expires_at: z.ZodISODateTime;
+        restoration_plan: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        failure_mode: z.ZodString;
+        acceptance_evidence: z.ZodString;
+        alternate_framing: z.ZodString;
+        change_kind: z.ZodLiteral<"break-glass">;
+        post_hoc_adr_deadline_at: z.ZodISODateTime;
+    }, z.core.$strict>], "change_kind">;
+    manifest_hash: z.ZodString;
+    reduced_bindings: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        edit_file_surfaces: "edit_file_surfaces";
+        depth_binding: "depth_binding";
+        slice_loop: "slice_loop";
+        terminal_outcome_binding: "terminal_outcome_binding";
+        primary_result_surface: "primary_result_surface";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"step.entered">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    slice_index: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"step.report_written">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    report_path: z.ZodString;
+    report_schema: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"step.report_skipped">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    report_path: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"check.evaluated">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    check_kind: z.ZodEnum<{
+        schema_sections: "schema_sections";
+        checkpoint_selection: "checkpoint_selection";
+        result_verdict: "result_verdict";
+        fanout_aggregate: "fanout_aggregate";
+        acceptance_criteria: "acceptance_criteria";
+    }>;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    criterion_id: z.ZodOptional<z.ZodString>;
+    criterion_kind: z.ZodOptional<z.ZodEnum<{
+        command: "command";
+        report_field: "report_field";
+    }>>;
+    exit_code: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    stdout_summary: z.ZodOptional<z.ZodString>;
+    stderr_summary: z.ZodOptional<z.ZodString>;
+    missing_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    reason: z.ZodOptional<z.ZodString>;
+    slice_index: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"verification.command_evaluated">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    command_id: z.ZodString;
+    cwd: z.ZodString;
+    argv: z.ZodArray<z.ZodString>;
+    exit_code: z.ZodNumber;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    duration_ms: z.ZodNumber;
+    stdout_summary: z.ZodString;
+    stderr_summary: z.ZodString;
+    timed_out: z.ZodDefault<z.ZodBoolean>;
+    slice_index: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"proof.assessed">;
+    assessment_id: z.ZodString;
+    scope: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    proof_policy_decision_id: z.ZodString;
+    assessment_ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    overall_status: z.ZodEnum<{
+        proven: "proven";
+        weak: "weak";
+        contradicted: "contradicted";
+        unproved: "unproved";
+    }>;
+    close_allowed: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"safe_apply.result">;
+    decision_id: z.ZodString;
+    scope: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    change_packet_ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    base_ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    action: z.ZodEnum<{
+        applied: "applied";
+        rejected: "rejected";
+        accepted_for_review: "accepted_for_review";
+    }>;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+    }>;
+    reason_codes: z.ZodArray<z.ZodEnum<{
+        applied: "applied";
+        weak_proof: "weak_proof";
+        rejected: "rejected";
+        guidance_missing: "guidance_missing";
+        packet_invalid: "packet_invalid";
+        base_mismatch: "base_mismatch";
+        dirty_parent: "dirty_parent";
+        patch_hash_mismatch: "patch_hash_mismatch";
+        apply_conflict: "apply_conflict";
+        touched_files_mismatch: "touched_files_mismatch";
+        protected_file_touched: "protected_file_touched";
+        generated_surface_drift: "generated_surface_drift";
+        final_verification_failed: "final_verification_failed";
+        review_required: "review_required";
+    }>>;
+    protected_file_decision: z.ZodOptional<z.ZodEnum<{
+        allowed: "allowed";
+        rejected: "rejected";
+        checkpointed: "checkpointed";
+    }>>;
+    final_verification_ref: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    touched_files_ref: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    result_ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"checkpoint.requested">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    options: z.ZodArray<z.ZodString>;
+    request_path: z.ZodString;
+    request_report_hash: z.ZodString;
+    boundary_ref: z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    boundary_hash: z.ZodString;
+    auto_resolved: z.ZodOptional<z.ZodLiteral<false>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"checkpoint.resolved">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    selection: z.ZodString;
+    route_id: z.ZodString;
+    auto_resolved: z.ZodBoolean;
+    resolution_source: z.ZodEnum<{
+        policy: "policy";
+        operator: "operator";
+        "declared-default": "declared-default";
+    }>;
+    response_path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.started">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    connector: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"builtin">;
+        name: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "cursor-agent": "cursor-agent";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        name: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        prompt_transport: z.ZodEnum<{
+            "prompt-file": "prompt-file";
+        }>;
+        output: z.ZodObject<{
+            kind: z.ZodLiteral<"output-file">;
+        }, z.core.$strict>;
+        capabilities: z.ZodObject<{
+            filesystem: z.ZodEnum<{
+                "read-only": "read-only";
+                "trusted-write": "trusted-write";
+                "isolated-write": "isolated-write";
+            }>;
+            structured_output: z.ZodEnum<{
+                json: "json";
+            }>;
+            tool_scope: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                "allow-list": "allow-list";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    resolved_selection: z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+        power: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        power_escalated: z.ZodOptional<z.ZodBoolean>;
+        power_source: z.ZodOptional<z.ZodLiteral<"auto">>;
+    }, z.core.$strict>;
+    resolved_from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"explicit">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"role">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"flow">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"default">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"auto">;
+    }, z.core.$strict>], "source">;
+    equipment: z.ZodOptional<z.ZodObject<{
+        declared: z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>;
+        effective: z.ZodEnum<{
+            trusted: "trusted";
+            enforced: "enforced";
+        }>;
+        downgraded: z.ZodBoolean;
+        enforced_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"skills.loaded">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+        cause: z.ZodEnum<{
+            selection: "selection";
+            binding: "binding";
+            "skill-hook": "skill-hook";
+        }>;
+        slot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">>;
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.request">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    request_payload_hash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.failed">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    connector: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"builtin">;
+        name: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "cursor-agent": "cursor-agent";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        name: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        prompt_transport: z.ZodEnum<{
+            "prompt-file": "prompt-file";
+        }>;
+        output: z.ZodObject<{
+            kind: z.ZodLiteral<"output-file">;
+        }, z.core.$strict>;
+        capabilities: z.ZodObject<{
+            filesystem: z.ZodEnum<{
+                "read-only": "read-only";
+                "trusted-write": "trusted-write";
+                "isolated-write": "isolated-write";
+            }>;
+            structured_output: z.ZodEnum<{
+                json: "json";
+            }>;
+            tool_scope: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                "allow-list": "allow-list";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    role: z.ZodEnum<{
+        researcher: "researcher";
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    resolved_selection: z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+        depth: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>>;
+        invocation_options: z.ZodDefault<z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+        power: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        power_escalated: z.ZodOptional<z.ZodBoolean>;
+        power_source: z.ZodOptional<z.ZodLiteral<"auto">>;
+    }, z.core.$strict>;
+    resolved_from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"explicit">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"role">;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"flow">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"default">;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"auto">;
+    }, z.core.$strict>], "source">;
+    request_payload_hash: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.receipt">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    cli_version: z.ZodString;
+    receipt_id: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.result">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    result_report_hash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"relay.completed">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    verdict: z.ZodString;
+    duration_ms: z.ZodNumber;
+    result_path: z.ZodString;
+    receipt_path: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_read_tokens: z.ZodNumber;
+        cache_creation_tokens: z.ZodNumber;
+        cache_creation_5m_tokens: z.ZodNumber;
+        cache_creation_1h_tokens: z.ZodNumber;
+        total_cost_usd_reported: z.ZodOptional<z.ZodNumber>;
+        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            model: z.ZodString;
+            input_tokens: z.ZodNumber;
+            output_tokens: z.ZodNumber;
+            cache_read_tokens: z.ZodNumber;
+            cache_creation_tokens: z.ZodNumber;
+            cost_usd_reported: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"sub_run.started">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    child_flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    child_entry_mode: z.ZodString;
+    child_depth: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        tournament: "tournament";
+        autonomous: "autonomous";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"sub_run.completed">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    child_outcome: z.ZodEnum<{
+        complete: "complete";
+        stopped: "stopped";
+        handoff: "handoff";
+        aborted: "aborted";
+        escalated: "escalated";
+    }>;
+    verdict: z.ZodString;
+    duration_ms: z.ZodNumber;
+    result_path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"fanout.started">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    branch_ids: z.ZodArray<z.ZodString>;
+    on_child_failure: z.ZodEnum<{
+        "abort-all": "abort-all";
+        "continue-others": "continue-others";
+    }>;
+    execution_policy: z.ZodOptional<z.ZodObject<{
+        configured_concurrency: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unbounded">]>;
+        effective_concurrency: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unbounded">]>;
+        writable_relay_branches_serialized: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"fanout.branch_started">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    branch_id: z.ZodString;
+    branch_kind: z.ZodEnum<{
+        relay: "relay";
+        "sub-run": "sub-run";
+    }>;
+    child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    worktree_path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"fanout.branch_completed">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    branch_id: z.ZodString;
+    branch_kind: z.ZodEnum<{
+        relay: "relay";
+        "sub-run": "sub-run";
+    }>;
+    child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    child_outcome: z.ZodEnum<{
+        complete: "complete";
+        stopped: "stopped";
+        handoff: "handoff";
+        aborted: "aborted";
+        escalated: "escalated";
+    }>;
+    verdict: z.ZodString;
+    duration_ms: z.ZodNumber;
+    result_path: z.ZodString;
+    reused_from: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"fanout.joined">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    policy: z.ZodEnum<{
+        "pick-winner": "pick-winner";
+        "disjoint-merge": "disjoint-merge";
+        "aggregate-only": "aggregate-only";
+        "aggregate-survivors": "aggregate-survivors";
+    }>;
+    selected_branch_id: z.ZodOptional<z.ZodString>;
+    aggregate_path: z.ZodString;
+    branches_completed: z.ZodNumber;
+    branches_failed: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"step.completed">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    route_taken: z.ZodString;
+    slice_index: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"step.aborted">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    attempt: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.closed">;
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        stopped: "stopped";
+        handoff: "handoff";
+        aborted: "aborted";
+        escalated: "escalated";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.skill-hook">;
+    event: z.ZodObject<{
+        schema: z.ZodLiteral<"run.skill-hook@v0">;
+        event_id: z.ZodString;
+        hook: z.ZodString;
+        detected_from: z.ZodArray<z.ZodString>;
+        cardinality: z.ZodEnum<{
+            "per-run": "per-run";
+            "per-step": "per-step";
+            "per-stage": "per-stage";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"none">;
+            source: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodEnum<{
+                auto: "auto";
+                mute: "mute";
+            }>;
+            source: z.ZodEnum<{
+                "project-policy": "project-policy";
+                "user-global-policy": "user-global-policy";
+                "default-mapping": "default-mapping";
+            }>;
+            strict: z.ZodBoolean;
+            policy_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "source">;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        stage_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StageId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt_id: z.ZodOptional<z.ZodString>;
+        decision_packet_id: z.ZodOptional<z.ZodString>;
+        triggered_skills: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+            state: z.ZodEnum<{
+                planned: "planned";
+                staged: "staged";
+                requested: "requested";
+                observed: "observed";
+                unplanned: "unplanned";
+                unavailable: "unavailable";
+            }>;
+            source: z.ZodEnum<{
+                "project-policy": "project-policy";
+                "user-global-policy": "user-global-policy";
+                "default-mapping": "default-mapping";
+                "host-observed": "host-observed";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        unavailable_skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+            state: z.ZodEnum<{
+                planned: "planned";
+                staged: "staged";
+                requested: "requested";
+                observed: "observed";
+                unplanned: "unplanned";
+                unavailable: "unavailable";
+            }>;
+            source: z.ZodEnum<{
+                "project-policy": "project-policy";
+                "user-global-policy": "user-global-policy";
+                "default-mapping": "default-mapping";
+                "host-observed": "host-observed";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.skill-hook-error">;
+    step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.power-inference">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    recommended: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    rationale: z.ZodString;
+    floor: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    ceiling: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    resolved: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    clamped: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.power-inference-error">;
+    step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.equipment-reshape">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    confirmed: z.ZodBoolean;
+    reshaped: z.ZodBoolean;
+    domain_tags: z.ZodArray<z.ZodString>;
+    equipped_steps: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "StepId", "out">>>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.context-pull">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    from_step: z.ZodString;
+    field_path: z.ZodString;
+    answered: z.ZodBoolean;
+    bytes: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.context-delivery">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    delivered_slices: z.ZodNumber;
+    delivered_bytes: z.ZodNumber;
+    retried: z.ZodBoolean;
+    kept: z.ZodEnum<{
+        retry: "retry";
+        original: "original";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.context-delivery-error">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"run.until-judgment">;
+    step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+    iteration: z.ZodNumber;
+    goal_proposed: z.ZodBoolean;
+    evidence_confirmed: z.ZodBoolean;
+    disposition: z.ZodEnum<{
+        "stop-clean": "stop-clean";
+        reenter: "reenter";
+        "needs-attention": "needs-attention";
+    }>;
+    no_progress_count: z.ZodNumber;
+    open_latch_count: z.ZodNumber;
+    lesson: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    recorded_at: z.ZodISODateTime;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    kind: z.ZodLiteral<"guidance.decision">;
+    decision_id: z.ZodString;
+    subject: z.ZodEnum<{
+        safe_apply: "safe_apply";
+        recovery_route: "recovery_route";
+        flow_selection: "flow_selection";
+        relay_execution: "relay_execution";
+        checkpoint_resolution: "checkpoint_resolution";
+        proof_policy: "proof_policy";
+    }>;
+    scope: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        branch_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    source: z.ZodEnum<{
+        deterministic: "deterministic";
+        heuristic: "heuristic";
+        model_recommended: "model_recommended";
+        host_recommended: "host_recommended";
+        operator_override: "operator_override";
+    }>;
+    selected: z.ZodUnion<readonly [z.ZodObject<{
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        work_contract_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        host_recommendation: z.ZodOptional<z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            accepted: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        connector: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"builtin">;
+            name: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                "cursor-agent": "cursor-agent";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            name: z.ZodString;
+            command: z.ZodArray<z.ZodString>;
+            prompt_transport: z.ZodEnum<{
+                "prompt-file": "prompt-file";
+            }>;
+            output: z.ZodObject<{
+                kind: z.ZodLiteral<"output-file">;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                filesystem: z.ZodEnum<{
+                    "read-only": "read-only";
+                    "trusted-write": "trusted-write";
+                    "isolated-write": "isolated-write";
+                }>;
+                structured_output: z.ZodEnum<{
+                    json: "json";
+                }>;
+                tool_scope: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    "allow-list": "allow-list";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                custom: "custom";
+                openai: "openai";
+                anthropic: "anthropic";
+                gemini: "gemini";
+            }>;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            none: "none";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+            slot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">>;
+        }, z.core.$strict>>;
+        context_packet_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        request_payload_hash: z.ZodString;
+    }, z.core.$strict>, z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>]>;
+    input_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    constraint_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    contract_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    policy_refs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    evidence_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    memory_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            policy: "policy";
+            work_contract: "work_contract";
+            trace: "trace";
+            evidence: "evidence";
+            request: "request";
+            context_packet: "context_packet";
+            diff: "diff";
+            patch: "patch";
+            change_packet: "change_packet";
+            safe_apply: "safe_apply";
+            worktree: "worktree";
+            generated_surface: "generated_surface";
+            memory: "memory";
+            operator_input: "operator_input";
+        }>;
+        ref: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    reason_codes: z.ZodArray<z.ZodString>;
+    rejected_options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        option: z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>;
+        reason_code: z.ZodString;
+        blocked_by: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>], "kind">>>;
+export type RunTrace = z.infer<typeof RunTrace>;
+type ClosedSnapshotStatus = Exclude<SnapshotStatus, 'in_progress'>;
+type IsExact<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type OutcomeStatusEquality = IsExact<ClosedSnapshotStatus, RunClosedOutcome> extends true ? true : never;
+export declare const _compileTimeOutcomeStatusParity: OutcomeStatusEquality;
+export declare const RunProjection: z.ZodObject<{
+    log: z.ZodPipe<z.ZodCustom<unknown[], unknown[]>, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.bootstrapped">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        invocation_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InvocationId", "out">>;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        goal: z.ZodString;
+        change_kind: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"ratchet-advance">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"equivalence-refactor">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"discovery">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"disposable">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"migration-escrow">;
+            expires_at: z.ZodISODateTime;
+            restoration_plan: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"break-glass">;
+            post_hoc_adr_deadline_at: z.ZodISODateTime;
+        }, z.core.$strict>], "change_kind">;
+        manifest_hash: z.ZodString;
+        reduced_bindings: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            edit_file_surfaces: "edit_file_surfaces";
+            depth_binding: "depth_binding";
+            slice_loop: "slice_loop";
+            terminal_outcome_binding: "terminal_outcome_binding";
+            primary_result_surface: "primary_result_surface";
+        }>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"step.entered">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        slice_index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"step.report_written">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        report_path: z.ZodString;
+        report_schema: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"step.report_skipped">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        report_path: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"check.evaluated">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        check_kind: z.ZodEnum<{
+            schema_sections: "schema_sections";
+            checkpoint_selection: "checkpoint_selection";
+            result_verdict: "result_verdict";
+            fanout_aggregate: "fanout_aggregate";
+            acceptance_criteria: "acceptance_criteria";
+        }>;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        criterion_id: z.ZodOptional<z.ZodString>;
+        criterion_kind: z.ZodOptional<z.ZodEnum<{
+            command: "command";
+            report_field: "report_field";
+        }>>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        stdout_summary: z.ZodOptional<z.ZodString>;
+        stderr_summary: z.ZodOptional<z.ZodString>;
+        missing_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        reason: z.ZodOptional<z.ZodString>;
+        slice_index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"verification.command_evaluated">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        command_id: z.ZodString;
+        cwd: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        exit_code: z.ZodNumber;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        duration_ms: z.ZodNumber;
+        stdout_summary: z.ZodString;
+        stderr_summary: z.ZodString;
+        timed_out: z.ZodDefault<z.ZodBoolean>;
+        slice_index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"proof.assessed">;
+        assessment_id: z.ZodString;
+        scope: z.ZodObject<{
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        proof_policy_decision_id: z.ZodString;
+        assessment_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        overall_status: z.ZodEnum<{
+            proven: "proven";
+            weak: "weak";
+            contradicted: "contradicted";
+            unproved: "unproved";
+        }>;
+        close_allowed: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"safe_apply.result">;
+        decision_id: z.ZodString;
+        scope: z.ZodObject<{
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        change_packet_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        base_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        action: z.ZodEnum<{
+            applied: "applied";
+            rejected: "rejected";
+            accepted_for_review: "accepted_for_review";
+        }>;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        reason_codes: z.ZodArray<z.ZodEnum<{
+            applied: "applied";
+            weak_proof: "weak_proof";
+            rejected: "rejected";
+            guidance_missing: "guidance_missing";
+            packet_invalid: "packet_invalid";
+            base_mismatch: "base_mismatch";
+            dirty_parent: "dirty_parent";
+            patch_hash_mismatch: "patch_hash_mismatch";
+            apply_conflict: "apply_conflict";
+            touched_files_mismatch: "touched_files_mismatch";
+            protected_file_touched: "protected_file_touched";
+            generated_surface_drift: "generated_surface_drift";
+            final_verification_failed: "final_verification_failed";
+            review_required: "review_required";
+        }>>;
+        protected_file_decision: z.ZodOptional<z.ZodEnum<{
+            allowed: "allowed";
+            rejected: "rejected";
+            checkpointed: "checkpointed";
+        }>>;
+        final_verification_ref: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        touched_files_ref: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        result_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"checkpoint.requested">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        options: z.ZodArray<z.ZodString>;
+        request_path: z.ZodString;
+        request_report_hash: z.ZodString;
+        boundary_ref: z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        boundary_hash: z.ZodString;
+        auto_resolved: z.ZodOptional<z.ZodLiteral<false>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"checkpoint.resolved">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        selection: z.ZodString;
+        route_id: z.ZodString;
+        auto_resolved: z.ZodBoolean;
+        resolution_source: z.ZodEnum<{
+            policy: "policy";
+            operator: "operator";
+            "declared-default": "declared-default";
+        }>;
+        response_path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.started">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        connector: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"builtin">;
+            name: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                "cursor-agent": "cursor-agent";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            name: z.ZodString;
+            command: z.ZodArray<z.ZodString>;
+            prompt_transport: z.ZodEnum<{
+                "prompt-file": "prompt-file";
+            }>;
+            output: z.ZodObject<{
+                kind: z.ZodLiteral<"output-file">;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                filesystem: z.ZodEnum<{
+                    "read-only": "read-only";
+                    "trusted-write": "trusted-write";
+                    "isolated-write": "isolated-write";
+                }>;
+                structured_output: z.ZodEnum<{
+                    json: "json";
+                }>;
+                tool_scope: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    "allow-list": "allow-list";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        resolved_selection: z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+            power: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            power_escalated: z.ZodOptional<z.ZodBoolean>;
+            power_source: z.ZodOptional<z.ZodLiteral<"auto">>;
+        }, z.core.$strict>;
+        resolved_from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"explicit">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"role">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"flow">;
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"default">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"auto">;
+        }, z.core.$strict>], "source">;
+        equipment: z.ZodOptional<z.ZodObject<{
+            declared: z.ZodEnum<{
+                trusted: "trusted";
+                enforced: "enforced";
+            }>;
+            effective: z.ZodEnum<{
+                trusted: "trusted";
+                enforced: "enforced";
+            }>;
+            downgraded: z.ZodBoolean;
+            enforced_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"skills.loaded">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+            cause: z.ZodEnum<{
+                selection: "selection";
+                binding: "binding";
+                "skill-hook": "skill-hook";
+            }>;
+            slot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">>;
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.request">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        request_payload_hash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.failed">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        connector: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"builtin">;
+            name: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                "cursor-agent": "cursor-agent";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            name: z.ZodString;
+            command: z.ZodArray<z.ZodString>;
+            prompt_transport: z.ZodEnum<{
+                "prompt-file": "prompt-file";
+            }>;
+            output: z.ZodObject<{
+                kind: z.ZodLiteral<"output-file">;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                filesystem: z.ZodEnum<{
+                    "read-only": "read-only";
+                    "trusted-write": "trusted-write";
+                    "isolated-write": "isolated-write";
+                }>;
+                structured_output: z.ZodEnum<{
+                    json: "json";
+                }>;
+                tool_scope: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    "allow-list": "allow-list";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        role: z.ZodEnum<{
+            researcher: "researcher";
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        resolved_selection: z.ZodObject<{
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodArray<z.core.$ZodBranded<z.ZodString, "SkillId", "out">>;
+            depth: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                tournament: "tournament";
+                autonomous: "autonomous";
+            }>>;
+            invocation_options: z.ZodDefault<z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>>;
+            power: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            power_escalated: z.ZodOptional<z.ZodBoolean>;
+            power_source: z.ZodOptional<z.ZodLiteral<"auto">>;
+        }, z.core.$strict>;
+        resolved_from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"explicit">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"role">;
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"flow">;
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"default">;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"auto">;
+        }, z.core.$strict>], "source">;
+        request_payload_hash: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.receipt">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        cli_version: z.ZodString;
+        receipt_id: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.result">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        result_report_hash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"relay.completed">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        verdict: z.ZodString;
+        duration_ms: z.ZodNumber;
+        result_path: z.ZodString;
+        receipt_path: z.ZodString;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodNumber;
+            output_tokens: z.ZodNumber;
+            cache_read_tokens: z.ZodNumber;
+            cache_creation_tokens: z.ZodNumber;
+            cache_creation_5m_tokens: z.ZodNumber;
+            cache_creation_1h_tokens: z.ZodNumber;
+            total_cost_usd_reported: z.ZodOptional<z.ZodNumber>;
+            models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                model: z.ZodString;
+                input_tokens: z.ZodNumber;
+                output_tokens: z.ZodNumber;
+                cache_read_tokens: z.ZodNumber;
+                cache_creation_tokens: z.ZodNumber;
+                cost_usd_reported: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"sub_run.started">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        child_flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        child_entry_mode: z.ZodString;
+        child_depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"sub_run.completed">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        child_outcome: z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>;
+        verdict: z.ZodString;
+        duration_ms: z.ZodNumber;
+        result_path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"fanout.started">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        branch_ids: z.ZodArray<z.ZodString>;
+        on_child_failure: z.ZodEnum<{
+            "abort-all": "abort-all";
+            "continue-others": "continue-others";
+        }>;
+        execution_policy: z.ZodOptional<z.ZodObject<{
+            configured_concurrency: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unbounded">]>;
+            effective_concurrency: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unbounded">]>;
+            writable_relay_branches_serialized: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"fanout.branch_started">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        branch_id: z.ZodString;
+        branch_kind: z.ZodEnum<{
+            relay: "relay";
+            "sub-run": "sub-run";
+        }>;
+        child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        worktree_path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"fanout.branch_completed">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        branch_id: z.ZodString;
+        branch_kind: z.ZodEnum<{
+            relay: "relay";
+            "sub-run": "sub-run";
+        }>;
+        child_run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        child_outcome: z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>;
+        verdict: z.ZodString;
+        duration_ms: z.ZodNumber;
+        result_path: z.ZodString;
+        reused_from: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"fanout.joined">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        policy: z.ZodEnum<{
+            "pick-winner": "pick-winner";
+            "disjoint-merge": "disjoint-merge";
+            "aggregate-only": "aggregate-only";
+            "aggregate-survivors": "aggregate-survivors";
+        }>;
+        selected_branch_id: z.ZodOptional<z.ZodString>;
+        aggregate_path: z.ZodString;
+        branches_completed: z.ZodNumber;
+        branches_failed: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"step.completed">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        route_taken: z.ZodString;
+        slice_index: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"step.aborted">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        attempt: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.closed">;
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.skill-hook">;
+        event: z.ZodObject<{
+            schema: z.ZodLiteral<"run.skill-hook@v0">;
+            event_id: z.ZodString;
+            hook: z.ZodString;
+            detected_from: z.ZodArray<z.ZodString>;
+            cardinality: z.ZodEnum<{
+                "per-run": "per-run";
+                "per-step": "per-step";
+                "per-stage": "per-stage";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"none">;
+                source: z.ZodLiteral<"none">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodEnum<{
+                    auto: "auto";
+                    mute: "mute";
+                }>;
+                source: z.ZodEnum<{
+                    "project-policy": "project-policy";
+                    "user-global-policy": "user-global-policy";
+                    "default-mapping": "default-mapping";
+                }>;
+                strict: z.ZodBoolean;
+                policy_ref: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "source">;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            stage_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StageId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt_id: z.ZodOptional<z.ZodString>;
+            decision_packet_id: z.ZodOptional<z.ZodString>;
+            triggered_skills: z.ZodArray<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+                state: z.ZodEnum<{
+                    planned: "planned";
+                    staged: "staged";
+                    requested: "requested";
+                    observed: "observed";
+                    unplanned: "unplanned";
+                    unavailable: "unavailable";
+                }>;
+                source: z.ZodEnum<{
+                    "project-policy": "project-policy";
+                    "user-global-policy": "user-global-policy";
+                    "default-mapping": "default-mapping";
+                    "host-observed": "host-observed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            unavailable_skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+                state: z.ZodEnum<{
+                    planned: "planned";
+                    staged: "staged";
+                    requested: "requested";
+                    observed: "observed";
+                    unplanned: "unplanned";
+                    unavailable: "unavailable";
+                }>;
+                source: z.ZodEnum<{
+                    "project-policy": "project-policy";
+                    "user-global-policy": "user-global-policy";
+                    "default-mapping": "default-mapping";
+                    "host-observed": "host-observed";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.skill-hook-error">;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.power-inference">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        recommended: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        rationale: z.ZodString;
+        floor: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        ceiling: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        resolved: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        clamped: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.power-inference-error">;
+        step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.equipment-reshape">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        confirmed: z.ZodBoolean;
+        reshaped: z.ZodBoolean;
+        domain_tags: z.ZodArray<z.ZodString>;
+        equipped_steps: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "StepId", "out">>>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.context-pull">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        from_step: z.ZodString;
+        field_path: z.ZodString;
+        answered: z.ZodBoolean;
+        bytes: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.context-delivery">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        delivered_slices: z.ZodNumber;
+        delivered_bytes: z.ZodNumber;
+        retried: z.ZodBoolean;
+        kept: z.ZodEnum<{
+            retry: "retry";
+            original: "original";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.context-delivery-error">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"run.until-judgment">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        iteration: z.ZodNumber;
+        goal_proposed: z.ZodBoolean;
+        evidence_confirmed: z.ZodBoolean;
+        disposition: z.ZodEnum<{
+            "stop-clean": "stop-clean";
+            reenter: "reenter";
+            "needs-attention": "needs-attention";
+        }>;
+        no_progress_count: z.ZodNumber;
+        open_latch_count: z.ZodNumber;
+        lesson: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        sequence: z.ZodNumber;
+        recorded_at: z.ZodISODateTime;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        kind: z.ZodLiteral<"guidance.decision">;
+        decision_id: z.ZodString;
+        subject: z.ZodEnum<{
+            safe_apply: "safe_apply";
+            recovery_route: "recovery_route";
+            flow_selection: "flow_selection";
+            relay_execution: "relay_execution";
+            checkpoint_resolution: "checkpoint_resolution";
+            proof_policy: "proof_policy";
+        }>;
+        scope: z.ZodObject<{
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            branch_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        source: z.ZodEnum<{
+            deterministic: "deterministic";
+            heuristic: "heuristic";
+            model_recommended: "model_recommended";
+            host_recommended: "host_recommended";
+            operator_override: "operator_override";
+        }>;
+        selected: z.ZodUnion<readonly [z.ZodObject<{
+            flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            work_contract_ref: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    command: "command";
+                    report: "report";
+                    policy: "policy";
+                    work_contract: "work_contract";
+                    trace: "trace";
+                    evidence: "evidence";
+                    request: "request";
+                    context_packet: "context_packet";
+                    diff: "diff";
+                    patch: "patch";
+                    change_packet: "change_packet";
+                    safe_apply: "safe_apply";
+                    worktree: "worktree";
+                    generated_surface: "generated_surface";
+                    memory: "memory";
+                    operator_input: "operator_input";
+                }>;
+                ref: z.ZodString;
+                sha256: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+                flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+                step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+                attempt: z.ZodOptional<z.ZodNumber>;
+                sequence: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            host_recommendation: z.ZodOptional<z.ZodObject<{
+                flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+                accepted: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodEnum<{
+                researcher: "researcher";
+                implementer: "implementer";
+                reviewer: "reviewer";
+            }>;
+            connector: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"builtin">;
+                name: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    "cursor-agent": "cursor-agent";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom">;
+                name: z.ZodString;
+                command: z.ZodArray<z.ZodString>;
+                prompt_transport: z.ZodEnum<{
+                    "prompt-file": "prompt-file";
+                }>;
+                output: z.ZodObject<{
+                    kind: z.ZodLiteral<"output-file">;
+                }, z.core.$strict>;
+                capabilities: z.ZodObject<{
+                    filesystem: z.ZodEnum<{
+                        "read-only": "read-only";
+                        "trusted-write": "trusted-write";
+                        "isolated-write": "isolated-write";
+                    }>;
+                    structured_output: z.ZodEnum<{
+                        json: "json";
+                    }>;
+                    tool_scope: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        "allow-list": "allow-list";
+                    }>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            model: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    custom: "custom";
+                    openai: "openai";
+                    anthropic: "anthropic";
+                    gemini: "gemini";
+                }>;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            skills: z.ZodArray<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "SkillId", "out">;
+                slot: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SkillSlotId", "out">>;
+            }, z.core.$strict>>;
+            context_packet_ref: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    command: "command";
+                    report: "report";
+                    policy: "policy";
+                    work_contract: "work_contract";
+                    trace: "trace";
+                    evidence: "evidence";
+                    request: "request";
+                    context_packet: "context_packet";
+                    diff: "diff";
+                    patch: "patch";
+                    change_packet: "change_packet";
+                    safe_apply: "safe_apply";
+                    worktree: "worktree";
+                    generated_surface: "generated_surface";
+                    memory: "memory";
+                    operator_input: "operator_input";
+                }>;
+                ref: z.ZodString;
+                sha256: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+                flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+                step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+                attempt: z.ZodOptional<z.ZodNumber>;
+                sequence: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            request_payload_hash: z.ZodString;
+        }, z.core.$strict>, z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>]>;
+        input_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        constraint_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        contract_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        policy_refs: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        evidence_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        memory_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                policy: "policy";
+                work_contract: "work_contract";
+                trace: "trace";
+                evidence: "evidence";
+                request: "request";
+                context_packet: "context_packet";
+                diff: "diff";
+                patch: "patch";
+                change_packet: "change_packet";
+                safe_apply: "safe_apply";
+                worktree: "worktree";
+                generated_surface: "generated_surface";
+                memory: "memory";
+                operator_input: "operator_input";
+            }>;
+            ref: z.ZodString;
+            sha256: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+            flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+            step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        reason_codes: z.ZodArray<z.ZodString>;
+        rejected_options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            option: z.ZodType<import("./json.js").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.js").JsonObject, unknown>>;
+            reason_code: z.ZodString;
+            blocked_by: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    command: "command";
+                    report: "report";
+                    policy: "policy";
+                    work_contract: "work_contract";
+                    trace: "trace";
+                    evidence: "evidence";
+                    request: "request";
+                    context_packet: "context_packet";
+                    diff: "diff";
+                    patch: "patch";
+                    change_packet: "change_packet";
+                    safe_apply: "safe_apply";
+                    worktree: "worktree";
+                    generated_surface: "generated_surface";
+                    memory: "memory";
+                    operator_input: "operator_input";
+                }>;
+                ref: z.ZodString;
+                sha256: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodGUID, "RunId", "out">>;
+                flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+                step_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+                attempt: z.ZodOptional<z.ZodNumber>;
+                sequence: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    snapshot: z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        invocation_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InvocationId", "out">>;
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            tournament: "tournament";
+            autonomous: "autonomous";
+        }>;
+        change_kind: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"ratchet-advance">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"equivalence-refactor">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"discovery">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"disposable">;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"migration-escrow">;
+            expires_at: z.ZodISODateTime;
+            restoration_plan: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            failure_mode: z.ZodString;
+            acceptance_evidence: z.ZodString;
+            alternate_framing: z.ZodString;
+            change_kind: z.ZodLiteral<"break-glass">;
+            post_hoc_adr_deadline_at: z.ZodISODateTime;
+        }, z.core.$strict>], "change_kind">;
+        current_step: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "StepId", "out">>;
+        status: z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            in_progress: "in_progress";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            status: z.ZodEnum<{
+                complete: "complete";
+                pending: "pending";
+                in_progress: "in_progress";
+                check_failed: "check_failed";
+                aborted: "aborted";
+            }>;
+            attempts: z.ZodNumber;
+            last_report_path: z.ZodOptional<z.ZodString>;
+            last_checkpoint_selection: z.ZodOptional<z.ZodString>;
+            last_route_taken: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        trace_entries_consumed: z.ZodNumber;
+        manifest_hash: z.ZodString;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RunProjection = z.infer<typeof RunProjection>;
+export {};
+//# sourceMappingURL=run.d.ts.map