@petepetrash/circuit 0.1.0

package/dist/schemas/run-envelope.d.ts

@@ -0,0 +1,1333 @@
+import { z } from 'zod';
+export declare const RunEnvelopeOutcome: z.ZodEnum<{
+    complete: "complete";
+    handoff: "handoff";
+    failed: "failed";
+    blocked: "blocked";
+    needs_attention: "needs_attention";
+}>;
+export type RunEnvelopeOutcome = z.infer<typeof RunEnvelopeOutcome>;
+export declare const RunEvidenceSource: z.ZodEnum<{
+    memory: "memory";
+    operator_input: "operator_input";
+    child_result: "child_result";
+    operator_summary: "operator_summary";
+    process_report: "process_report";
+    process_evidence: "process_evidence";
+}>;
+export type RunEvidenceSource = z.infer<typeof RunEvidenceSource>;
+export declare const RunEvidenceRef: z.ZodObject<{
+    source: z.ZodEnum<{
+        memory: "memory";
+        operator_input: "operator_input";
+        child_result: "child_result";
+        operator_summary: "operator_summary";
+        process_report: "process_report";
+        process_evidence: "process_evidence";
+    }>;
+    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>;
+export type RunEvidenceRef = z.infer<typeof RunEvidenceRef>;
+export declare const RunRequiredEvidenceKind: z.ZodEnum<{
+    command: "command";
+    report: "report";
+    source: "source";
+    checkpoint: "checkpoint";
+    review: "review";
+}>;
+export type RunRequiredEvidenceKind = z.infer<typeof RunRequiredEvidenceKind>;
+declare const RunRequiredEvidence: z.ZodObject<{
+    kind: z.ZodEnum<{
+        command: "command";
+        report: "report";
+        source: "source";
+        checkpoint: "checkpoint";
+        review: "review";
+    }>;
+    description: z.ZodString;
+    required: z.ZodBoolean;
+}, z.core.$strict>;
+export type RunRequiredEvidence = z.infer<typeof RunRequiredEvidence>;
+declare const RunDoneClaim: z.ZodObject<{
+    id: z.ZodString;
+    claim: z.ZodString;
+    required_evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            command: "command";
+            report: "report";
+            source: "source";
+            checkpoint: "checkpoint";
+            review: "review";
+        }>;
+        description: z.ZodString;
+        required: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunDoneClaim = z.infer<typeof RunDoneClaim>;
+export declare const RunGoalContract: z.ZodObject<{
+    schema: z.ZodLiteral<"run.goal-contract@v0">;
+    objective: z.ZodString;
+    scope: z.ZodObject<{
+        in: z.ZodArray<z.ZodString>;
+        out: z.ZodArray<z.ZodString>;
+        assumptions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    constraints: z.ZodArray<z.ZodString>;
+    done_when: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claim: z.ZodString;
+        required_evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                report: "report";
+                source: "source";
+                checkpoint: "checkpoint";
+                review: "review";
+            }>;
+            description: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    recovery_policy: z.ZodObject<{
+        max_process_attempts: z.ZodNumber;
+        allowed_routes: z.ZodArray<z.ZodEnum<{
+            handoff: "handoff";
+            checkpoint: "checkpoint";
+            blocked: "blocked";
+            "retry-process": "retry-process";
+            "run-fix": "run-fix";
+            "run-review": "run-review";
+            "run-explore": "run-explore";
+            "split-to-pursue": "split-to-pursue";
+        }>>;
+    }, z.core.$strict>;
+    stop_conditions: z.ZodArray<z.ZodString>;
+    completion_gate: z.ZodObject<{
+        required_passes: z.ZodLiteral<2>;
+        blocking_severities: z.ZodArray<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        reset_on_blocking_finding: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RunGoalContract = z.infer<typeof RunGoalContract>;
+export declare const RunProcessPlan: z.ZodObject<{
+    schema: z.ZodLiteral<"run.process-plan@v0">;
+    selection_source: z.ZodEnum<{
+        recovery: "recovery";
+        explicit_operator_request: "explicit_operator_request";
+        goal_contract: "goal_contract";
+        completion_followup: "completion_followup";
+    }>;
+    rationale: z.ZodString;
+    planned_attempts: z.ZodArray<z.ZodObject<{
+        attempt_id: z.ZodString;
+        process_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        goal: z.ZodString;
+        expected_evidence: z.ZodArray<z.ZodString>;
+        depends_on_attempt_ids: z.ZodArray<z.ZodString>;
+        followup_for: z.ZodOptional<z.ZodObject<{
+            claim_id: z.ZodString;
+            prior_attempt_id: z.ZodString;
+            missing_evidence: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunProcessPlan = z.infer<typeof RunProcessPlan>;
+export declare const RunProcessAttempt: z.ZodObject<{
+    schema: z.ZodLiteral<"run.process-attempt@v0">;
+    attempt_id: z.ZodString;
+    process_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    goal: z.ZodString;
+    started_at: z.ZodISODateTime;
+    completed_at: z.ZodOptional<z.ZodISODateTime>;
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        checkpoint_waiting: "checkpoint_waiting";
+        blocked: "blocked";
+        needs_attention: "needs_attention";
+    }>;
+    child_run: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        run_folder: z.ZodString;
+        result_ref: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                memory: "memory";
+                operator_input: "operator_input";
+                child_result: "child_result";
+                operator_summary: "operator_summary";
+                process_report: "process_report";
+                process_evidence: "process_evidence";
+            }>;
+            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>>;
+        trace_entries_observed: z.ZodNumber;
+        manifest_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    checkpoint: z.ZodOptional<z.ZodObject<{
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        request_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>;
+        allowed_choices: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence_refs: z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            memory: "memory";
+            operator_input: "operator_input";
+            child_result: "child_result";
+            operator_summary: "operator_summary";
+            process_report: "process_report";
+            process_evidence: "process_evidence";
+        }>;
+        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>>;
+    summary: z.ZodString;
+    blocked_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RunProcessAttempt = z.infer<typeof RunProcessAttempt>;
+declare const RunGatePass: z.ZodObject<{
+    pass_id: z.ZodString;
+    attack_lens: z.ZodString;
+    evidence_checked: z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            memory: "memory";
+            operator_input: "operator_input";
+            child_result: "child_result";
+            operator_summary: "operator_summary";
+            process_report: "process_report";
+            process_evidence: "process_evidence";
+        }>;
+        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>>;
+    verdict: z.ZodEnum<{
+        "gate-pass": "gate-pass";
+        "blocking-finding": "blocking-finding";
+    }>;
+}, z.core.$strict>;
+export type RunGatePass = z.infer<typeof RunGatePass>;
+export declare const RunCompletionGate: z.ZodObject<{
+    schema: z.ZodLiteral<"run.completion-gate@v0">;
+    verdict: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        blocked: "blocked";
+        needs_followup: "needs_followup";
+    }>;
+    claim_results: z.ZodArray<z.ZodObject<{
+        claim_id: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            contradicted: "contradicted";
+            blocked: "blocked";
+            proved: "proved";
+        }>;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                memory: "memory";
+                operator_input: "operator_input";
+                child_result: "child_result";
+                operator_summary: "operator_summary";
+                process_report: "process_report";
+                process_evidence: "process_evidence";
+            }>;
+            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>>;
+        gap: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    gate_passes: z.ZodArray<z.ZodObject<{
+        pass_id: z.ZodString;
+        attack_lens: z.ZodString;
+        evidence_checked: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                memory: "memory";
+                operator_input: "operator_input";
+                child_result: "child_result";
+                operator_summary: "operator_summary";
+                process_report: "process_report";
+                process_evidence: "process_evidence";
+            }>;
+            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>>;
+        verdict: z.ZodEnum<{
+            "gate-pass": "gate-pass";
+            "blocking-finding": "blocking-finding";
+        }>;
+    }, z.core.$strict>>;
+    clean_streak: z.ZodNumber;
+    required_passes: z.ZodLiteral<2>;
+    next_action: z.ZodEnum<{
+        handoff: "handoff";
+        failed: "failed";
+        close: "close";
+        blocked: "blocked";
+        "plan-followup-process": "plan-followup-process";
+        "ask-operator": "ask-operator";
+    }>;
+}, z.core.$strict>;
+export type RunCompletionGate = z.infer<typeof RunCompletionGate>;
+export declare const RunDecisionPacket: z.ZodObject<{
+    schema: z.ZodLiteral<"run.decision-packet@v0">;
+    decision_id: z.ZodString;
+    reason: z.ZodEnum<{
+        "process-checkpoint": "process-checkpoint";
+        "missing-evidence": "missing-evidence";
+        "strict-skill-unavailable": "strict-skill-unavailable";
+        "operator-judgment": "operator-judgment";
+    }>;
+    prompt: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        effect: z.ZodString;
+    }, z.core.$strict>>;
+    resume_target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"run-envelope">;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"process-checkpoint">;
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+        request_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>], "kind">;
+    artifact_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>>;
+    html_projection: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"optional">;
+        projector: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunDecisionPacket = z.infer<typeof RunDecisionPacket>;
+export declare const RunMemoryUpdateStaleness: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    checked_at: z.ZodISODateTime;
+    reason_codes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type RunMemoryUpdateStaleness = z.infer<typeof RunMemoryUpdateStaleness>;
+export declare const RunMemoryUpdateEvent: z.ZodObject<{
+    schema: z.ZodLiteral<"run.memory-update-event@v0">;
+    event_id: z.ZodString;
+    scope: z.ZodEnum<{
+        project: "project";
+        flow: "flow";
+    }>;
+    flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+    action: z.ZodEnum<{
+        rejected: "rejected";
+        proposed: "proposed";
+        recorded: "recorded";
+        skipped: "skipped";
+    }>;
+    reason: z.ZodString;
+    summary: z.ZodString;
+    source_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>>;
+    authority: z.ZodLiteral<"hint_only">;
+    operator_indicator: z.ZodOptional<z.ZodString>;
+    staleness: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        checked_at: z.ZodISODateTime;
+        reason_codes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunMemoryUpdateEvent = z.infer<typeof RunMemoryUpdateEvent>;
+export declare const RunSurfaceOutput: z.ZodObject<{
+    schema: z.ZodLiteral<"run.surface-output@v0">;
+    status_text: z.ZodString;
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        blocked: "blocked";
+        needs_attention: "needs_attention";
+    }>;
+    flow_outcome: z.ZodOptional<z.ZodString>;
+    next_action: z.ZodOptional<z.ZodString>;
+    artifact_links: 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_indicator: z.ZodOptional<z.ZodString>;
+    decision_packet_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>>;
+}, z.core.$strict>;
+export type RunSurfaceOutput = z.infer<typeof RunSurfaceOutput>;
+export declare const RunEnvelopeShadowRecord: z.ZodObject<{
+    schema: z.ZodLiteral<"run.envelope-shadow@v0">;
+    mode: z.ZodLiteral<"shadow">;
+    shadow_reason: z.ZodLiteral<"source-owned-run-not-active">;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    operator_intent: z.ZodString;
+    recorded_at: z.ZodISODateTime;
+    selected_process: z.ZodObject<{
+        process_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        routed_by: z.ZodOptional<z.ZodLiteral<"explicit">>;
+        router_reason: z.ZodString;
+        entry_mode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    child_run: z.ZodObject<{
+        run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        run_folder: z.ZodString;
+        flow_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        outcome: z.ZodUnion<readonly [z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>, z.ZodLiteral<"checkpoint_waiting">]>;
+        trace_entries_observed: z.ZodNumber;
+        manifest_hash: z.ZodString;
+        result_ref: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                memory: "memory";
+                operator_input: "operator_input";
+                child_result: "child_result";
+                operator_summary: "operator_summary";
+                process_report: "process_report";
+                process_evidence: "process_evidence";
+            }>;
+            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>>;
+        checkpoint: z.ZodOptional<z.ZodObject<{
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            request_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>;
+            allowed_choices: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    artifact_links: 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>>;
+}, z.core.$strict>;
+export type RunEnvelopeShadowRecord = z.infer<typeof RunEnvelopeShadowRecord>;
+export declare const RunEnvelopeRecord: z.ZodObject<{
+    schema: z.ZodLiteral<"run.envelope@v0">;
+    run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+    operator_intent: z.ZodString;
+    explicit_constraints: z.ZodArray<z.ZodString>;
+    explicit_process_request: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+    memory_context: z.ZodObject<{
+        used: z.ZodBoolean;
+        memory_input_ids: z.ZodArray<z.ZodString>;
+        authority: z.ZodLiteral<"hint_only">;
+    }, z.core.$strict>;
+    goal_contract: z.ZodObject<{
+        schema: z.ZodLiteral<"run.goal-contract@v0">;
+        objective: z.ZodString;
+        scope: z.ZodObject<{
+            in: z.ZodArray<z.ZodString>;
+            out: z.ZodArray<z.ZodString>;
+            assumptions: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        constraints: z.ZodArray<z.ZodString>;
+        done_when: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            claim: z.ZodString;
+            required_evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    command: "command";
+                    report: "report";
+                    source: "source";
+                    checkpoint: "checkpoint";
+                    review: "review";
+                }>;
+                description: z.ZodString;
+                required: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        recovery_policy: z.ZodObject<{
+            max_process_attempts: z.ZodNumber;
+            allowed_routes: z.ZodArray<z.ZodEnum<{
+                handoff: "handoff";
+                checkpoint: "checkpoint";
+                blocked: "blocked";
+                "retry-process": "retry-process";
+                "run-fix": "run-fix";
+                "run-review": "run-review";
+                "run-explore": "run-explore";
+                "split-to-pursue": "split-to-pursue";
+            }>>;
+        }, z.core.$strict>;
+        stop_conditions: z.ZodArray<z.ZodString>;
+        completion_gate: z.ZodObject<{
+            required_passes: z.ZodLiteral<2>;
+            blocking_severities: z.ZodArray<z.ZodEnum<{
+                medium: "medium";
+                high: "high";
+                critical: "critical";
+            }>>;
+            reset_on_blocking_finding: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    process_plan: z.ZodObject<{
+        schema: z.ZodLiteral<"run.process-plan@v0">;
+        selection_source: z.ZodEnum<{
+            recovery: "recovery";
+            explicit_operator_request: "explicit_operator_request";
+            goal_contract: "goal_contract";
+            completion_followup: "completion_followup";
+        }>;
+        rationale: z.ZodString;
+        planned_attempts: z.ZodArray<z.ZodObject<{
+            attempt_id: z.ZodString;
+            process_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+            goal: z.ZodString;
+            expected_evidence: z.ZodArray<z.ZodString>;
+            depends_on_attempt_ids: z.ZodArray<z.ZodString>;
+            followup_for: z.ZodOptional<z.ZodObject<{
+                claim_id: z.ZodString;
+                prior_attempt_id: z.ZodString;
+                missing_evidence: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    process_attempts: z.ZodArray<z.ZodObject<{
+        schema: z.ZodLiteral<"run.process-attempt@v0">;
+        attempt_id: z.ZodString;
+        process_id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+        goal: z.ZodString;
+        started_at: z.ZodISODateTime;
+        completed_at: z.ZodOptional<z.ZodISODateTime>;
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            checkpoint_waiting: "checkpoint_waiting";
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+        }>;
+        child_run: z.ZodObject<{
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+            run_folder: z.ZodString;
+            result_ref: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    memory: "memory";
+                    operator_input: "operator_input";
+                    child_result: "child_result";
+                    operator_summary: "operator_summary";
+                    process_report: "process_report";
+                    process_evidence: "process_evidence";
+                }>;
+                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>>;
+            trace_entries_observed: z.ZodNumber;
+            manifest_hash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        checkpoint: z.ZodOptional<z.ZodObject<{
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            request_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>;
+            allowed_choices: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        evidence_refs: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                memory: "memory";
+                operator_input: "operator_input";
+                child_result: "child_result";
+                operator_summary: "operator_summary";
+                process_report: "process_report";
+                process_evidence: "process_evidence";
+            }>;
+            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>>;
+        summary: z.ZodString;
+        blocked_reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    completion_gate: z.ZodObject<{
+        schema: z.ZodLiteral<"run.completion-gate@v0">;
+        verdict: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            blocked: "blocked";
+            needs_followup: "needs_followup";
+        }>;
+        claim_results: z.ZodArray<z.ZodObject<{
+            claim_id: z.ZodString;
+            status: z.ZodEnum<{
+                missing: "missing";
+                contradicted: "contradicted";
+                blocked: "blocked";
+                proved: "proved";
+            }>;
+            evidence: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    memory: "memory";
+                    operator_input: "operator_input";
+                    child_result: "child_result";
+                    operator_summary: "operator_summary";
+                    process_report: "process_report";
+                    process_evidence: "process_evidence";
+                }>;
+                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>>;
+            gap: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        gate_passes: z.ZodArray<z.ZodObject<{
+            pass_id: z.ZodString;
+            attack_lens: z.ZodString;
+            evidence_checked: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    memory: "memory";
+                    operator_input: "operator_input";
+                    child_result: "child_result";
+                    operator_summary: "operator_summary";
+                    process_report: "process_report";
+                    process_evidence: "process_evidence";
+                }>;
+                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>>;
+            verdict: z.ZodEnum<{
+                "gate-pass": "gate-pass";
+                "blocking-finding": "blocking-finding";
+            }>;
+        }, z.core.$strict>>;
+        clean_streak: z.ZodNumber;
+        required_passes: z.ZodLiteral<2>;
+        next_action: z.ZodEnum<{
+            handoff: "handoff";
+            failed: "failed";
+            close: "close";
+            blocked: "blocked";
+            "plan-followup-process": "plan-followup-process";
+            "ask-operator": "ask-operator";
+        }>;
+    }, z.core.$strict>;
+    decision_packets: z.ZodArray<z.ZodObject<{
+        schema: z.ZodLiteral<"run.decision-packet@v0">;
+        decision_id: z.ZodString;
+        reason: z.ZodEnum<{
+            "process-checkpoint": "process-checkpoint";
+            "missing-evidence": "missing-evidence";
+            "strict-skill-unavailable": "strict-skill-unavailable";
+            "operator-judgment": "operator-judgment";
+        }>;
+        prompt: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            effect: z.ZodString;
+        }, z.core.$strict>>;
+        resume_target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"run-envelope">;
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"process-checkpoint">;
+            run_id: z.core.$ZodBranded<z.ZodGUID, "RunId", "out">;
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            request_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>], "kind">;
+        artifact_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>>;
+        html_projection: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"optional">;
+            projector: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    memory_update_events: z.ZodArray<z.ZodObject<{
+        schema: z.ZodLiteral<"run.memory-update-event@v0">;
+        event_id: z.ZodString;
+        scope: z.ZodEnum<{
+            project: "project";
+            flow: "flow";
+        }>;
+        flow_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">>;
+        action: z.ZodEnum<{
+            rejected: "rejected";
+            proposed: "proposed";
+            recorded: "recorded";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodString;
+        summary: z.ZodString;
+        source_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>>;
+        authority: z.ZodLiteral<"hint_only">;
+        operator_indicator: z.ZodOptional<z.ZodString>;
+        staleness: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            checked_at: z.ZodISODateTime;
+            reason_codes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    surface_output: z.ZodObject<{
+        schema: z.ZodLiteral<"run.surface-output@v0">;
+        status_text: z.ZodString;
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+        }>;
+        flow_outcome: z.ZodOptional<z.ZodString>;
+        next_action: z.ZodOptional<z.ZodString>;
+        artifact_links: 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_indicator: z.ZodOptional<z.ZodString>;
+        decision_packet_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>>;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        blocked: "blocked";
+        needs_attention: "needs_attention";
+    }>;
+}, z.core.$strict>;
+export type RunEnvelopeRecord = z.infer<typeof RunEnvelopeRecord>;
+export {};
+//# sourceMappingURL=run-envelope.d.ts.map