opencode-plugin-flow 5.0.0 → 5.1.1

package/dist/application/replay/contract.d.ts

@@ -0,0 +1,2007 @@
+import { z } from "zod";
+export declare const REPLAY_SCENARIO_IDS: readonly ["active_final_feature_awaiting_review", "contradictory_feature_final_verdicts", "failed_to_passed_retry", "unsubmitted_review_failure", "malformed_optional_telemetry", "empty_or_malformed_handoff", "stale_validation", "unchanged_finding_retry", "crash_replay_around_mutation"];
+export declare const ReplayScenarioIdSchema: z.ZodEnum<{
+    active_final_feature_awaiting_review: "active_final_feature_awaiting_review";
+    contradictory_feature_final_verdicts: "contradictory_feature_final_verdicts";
+    crash_replay_around_mutation: "crash_replay_around_mutation";
+    empty_or_malformed_handoff: "empty_or_malformed_handoff";
+    failed_to_passed_retry: "failed_to_passed_retry";
+    malformed_optional_telemetry: "malformed_optional_telemetry";
+    stale_validation: "stale_validation";
+    unchanged_finding_retry: "unchanged_finding_retry";
+    unsubmitted_review_failure: "unsubmitted_review_failure";
+}>;
+export type ReplayScenarioId = z.infer<typeof ReplayScenarioIdSchema>;
+export declare const ReplayVariantSchema: z.ZodEnum<{
+    A: "A";
+    B: "B";
+    C: "C";
+    D: "D";
+}>;
+export type ReplayVariant = z.infer<typeof ReplayVariantSchema>;
+export declare const FixtureIdSchema: z.ZodString;
+export declare const SessionIdSchema: z.ZodString;
+export declare const OperationIdSchema: z.ZodString;
+export declare const WorkerIdSchema: z.ZodString;
+export declare const AttemptIdSchema: z.ZodString;
+export declare const LogicalPassIdSchema: z.ZodString;
+export declare const SnapshotIdSchema: z.ZodString;
+export declare const EvidenceRefSchema: z.ZodString;
+export declare const MutationIdSchema: z.ZodString;
+/** Closed, canonical identifier forms; arbitrary slugs and prose are rejected. */
+export declare const OpaqueIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodString, z.ZodString, z.ZodString, z.ZodString, z.ZodString, z.ZodString, z.ZodString]>;
+export type OpaqueId = z.infer<typeof OpaqueIdSchema>;
+export declare const REPLAY_IDENTIFIER_SCHEMAS: {
+    readonly fixture: z.ZodString;
+    readonly session: z.ZodString;
+    readonly operation: z.ZodString;
+    readonly worker: z.ZodString;
+    readonly attempt: z.ZodString;
+    readonly logicalPass: z.ZodString;
+    readonly snapshot: z.ZodString;
+    readonly evidence: z.ZodString;
+    readonly mutation: z.ZodString;
+};
+export declare const Sha256DigestSchema: z.ZodString;
+export type Sha256Digest = z.infer<typeof Sha256DigestSchema>;
+export declare const SourceCategorySchema: z.ZodEnum<{
+    flow_ledger: "flow_ledger";
+    host_metadata: "host_metadata";
+    replay_derived: "replay_derived";
+    supplied_observation: "supplied_observation";
+}>;
+export type SourceCategory = z.infer<typeof SourceCategorySchema>;
+export declare const AvailabilityReasonSchema: z.ZodEnum<{
+    not_applicable: "not_applicable";
+    not_recorded: "not_recorded";
+    privacy_redacted: "privacy_redacted";
+    provider_unavailable: "provider_unavailable";
+    unreconciled: "unreconciled";
+}>;
+export type AvailabilityReason = z.infer<typeof AvailabilityReasonSchema>;
+export declare const UnsignedAvailabilitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    value: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        not_applicable: "not_applicable";
+        not_recorded: "not_recorded";
+        privacy_redacted: "privacy_redacted";
+        provider_unavailable: "provider_unavailable";
+        unreconciled: "unreconciled";
+    }>;
+}, z.core.$strict>], "status">;
+export type UnsignedAvailability = z.infer<typeof UnsignedAvailabilitySchema>;
+export declare const AggregateMetricSchema: z.ZodEnum<{
+    cache_read_token_count: "cache_read_token_count";
+    child_flow_status_call_count: "child_flow_status_call_count";
+    child_flow_status_result_character_count: "child_flow_status_result_character_count";
+    child_session_count: "child_session_count";
+    compaction_count: "compaction_count";
+    completion_schema_failure_count: "completion_schema_failure_count";
+    declared_worker_count: "declared_worker_count";
+    duplicate_finding_count: "duplicate_finding_count";
+    failed_review_attempt_count: "failed_review_attempt_count";
+    flow_tool_call_count: "flow_tool_call_count";
+    flow_tool_result_character_count: "flow_tool_result_character_count";
+    four_invocation_character_count: "four_invocation_character_count";
+    input_token_count: "input_token_count";
+    live_prompt_character_count: "live_prompt_character_count";
+    live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+    message_error_count: "message_error_count";
+    output_token_count: "output_token_count";
+    prompt_character_count: "prompt_character_count";
+    recovery_count: "recovery_count";
+    result_character_count: "result_character_count";
+    review_attempt_count: "review_attempt_count";
+    review_packet_file_count: "review_packet_file_count";
+    review_packet_line_count: "review_packet_line_count";
+    reviewer_child_session_count: "reviewer_child_session_count";
+    reviewer_dispatch_count: "reviewer_dispatch_count";
+    reviewer_execution_count: "reviewer_execution_count";
+    reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+    root_flow_tool_call_count: "root_flow_tool_call_count";
+    root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+    scenario_count: "scenario_count";
+    session_count: "session_count";
+    terminal_decision_count: "terminal_decision_count";
+    tool_error_count: "tool_error_count";
+    tool_latency_p50_ms: "tool_latency_p50_ms";
+    tool_latency_p95_ms: "tool_latency_p95_ms";
+    tool_latency_total_ms: "tool_latency_total_ms";
+    tool_part_count: "tool_part_count";
+    validation_failure_count: "validation_failure_count";
+}>;
+export type AggregateMetric = z.infer<typeof AggregateMetricSchema>;
+export declare const ApprovedAggregateFactSchema: z.ZodObject<{
+    metric: z.ZodEnum<{
+        cache_read_token_count: "cache_read_token_count";
+        child_flow_status_call_count: "child_flow_status_call_count";
+        child_flow_status_result_character_count: "child_flow_status_result_character_count";
+        child_session_count: "child_session_count";
+        compaction_count: "compaction_count";
+        completion_schema_failure_count: "completion_schema_failure_count";
+        declared_worker_count: "declared_worker_count";
+        duplicate_finding_count: "duplicate_finding_count";
+        failed_review_attempt_count: "failed_review_attempt_count";
+        flow_tool_call_count: "flow_tool_call_count";
+        flow_tool_result_character_count: "flow_tool_result_character_count";
+        four_invocation_character_count: "four_invocation_character_count";
+        input_token_count: "input_token_count";
+        live_prompt_character_count: "live_prompt_character_count";
+        live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+        message_error_count: "message_error_count";
+        output_token_count: "output_token_count";
+        prompt_character_count: "prompt_character_count";
+        recovery_count: "recovery_count";
+        result_character_count: "result_character_count";
+        review_attempt_count: "review_attempt_count";
+        review_packet_file_count: "review_packet_file_count";
+        review_packet_line_count: "review_packet_line_count";
+        reviewer_child_session_count: "reviewer_child_session_count";
+        reviewer_dispatch_count: "reviewer_dispatch_count";
+        reviewer_execution_count: "reviewer_execution_count";
+        reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+        root_flow_tool_call_count: "root_flow_tool_call_count";
+        root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+        scenario_count: "scenario_count";
+        session_count: "session_count";
+        terminal_decision_count: "terminal_decision_count";
+        tool_error_count: "tool_error_count";
+        tool_latency_p50_ms: "tool_latency_p50_ms";
+        tool_latency_p95_ms: "tool_latency_p95_ms";
+        tool_latency_total_ms: "tool_latency_total_ms";
+        tool_part_count: "tool_part_count";
+        validation_failure_count: "validation_failure_count";
+    }>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>;
+export type ApprovedAggregateFact = z.infer<typeof ApprovedAggregateFactSchema>;
+export declare const SourceProjectionSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    fingerprint: z.ZodString;
+}, z.core.$strict>;
+export declare const ReplayControlDefectSchema: z.ZodEnum<{
+    active_final_false_block: "active_final_false_block";
+    contradictory_verdict_not_reconciled: "contradictory_verdict_not_reconciled";
+    handoff_not_runtime_validated: "handoff_not_runtime_validated";
+    logical_pass_retry_not_correlated: "logical_pass_retry_not_correlated";
+    malformed_telemetry_masks_review: "malformed_telemetry_masks_review";
+    mutation_recovery_not_idempotent: "mutation_recovery_not_idempotent";
+    stale_validation_not_snapshot_bound: "stale_validation_not_snapshot_bound";
+    unchanged_finding_not_deduplicated: "unchanged_finding_not_deduplicated";
+    unsubmitted_review_failure_not_counted: "unsubmitted_review_failure_not_counted";
+}>;
+export type ReplayControlDefect = z.infer<typeof ReplayControlDefectSchema>;
+export declare const ReplayDecisionSchema: z.ZodEnum<{
+    blocked: "blocked";
+    complete: "complete";
+    failed: "failed";
+    recovered: "recovered";
+    retry: "retry";
+}>;
+export type ReplayDecision = z.infer<typeof ReplayDecisionSchema>;
+export declare const ReplayReasonSchema: z.ZodEnum<{
+    active_final_feature_in_progress: "active_final_feature_in_progress";
+    all_gates_passed: "all_gates_passed";
+    contradictory_review_verdicts: "contradictory_review_verdicts";
+    finding_unchanged: "finding_unchanged";
+    handoff_invalid: "handoff_invalid";
+    mutation_incomplete: "mutation_incomplete";
+    mutation_recovered: "mutation_recovered";
+    optional_telemetry_malformed: "optional_telemetry_malformed";
+    review_failed: "review_failed";
+    review_failure_unsubmitted: "review_failure_unsubmitted";
+    review_retry_passed: "review_retry_passed";
+    schema_invalid: "schema_invalid";
+    validation_stale: "validation_stale";
+}>;
+export type ReplayReason = z.infer<typeof ReplayReasonSchema>;
+export declare const SessionStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    completed: "completed";
+    planning: "planning";
+    ready: "ready";
+    running: "running";
+}>;
+export declare const FeatureStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    completed: "completed";
+    in_progress: "in_progress";
+    pending: "pending";
+}>;
+export declare const ReplayRoleSchema: z.ZodEnum<{
+    feature_reviewer: "feature_reviewer";
+    final_reviewer: "final_reviewer";
+    host: "host";
+    implementation_worker: "implementation_worker";
+    root_manager: "root_manager";
+    verifier: "verifier";
+}>;
+export declare const ReplayModelClassSchema: z.ZodEnum<{
+    manager: "manager";
+    reviewer: "reviewer";
+    unknown: "unknown";
+    verifier: "verifier";
+    worker: "worker";
+}>;
+export declare const ReplayEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"session_state">;
+    sessionId: z.ZodString;
+    revision: z.ZodNumber;
+    sessionStatus: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        planning: "planning";
+        ready: "ready";
+        running: "running";
+    }>;
+    featureStatus: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        in_progress: "in_progress";
+        pending: "pending";
+    }>;
+    stateDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"validation">;
+    operationId: z.ZodString;
+    evidenceRef: z.ZodString;
+    snapshotId: z.ZodString;
+    revision: z.ZodNumber;
+    scope: z.ZodEnum<{
+        broad: "broad";
+        targeted: "targeted";
+    }>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    freshness: z.ZodEnum<{
+        current: "current";
+        stale: "stale";
+        unknown: "unknown";
+    }>;
+    latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    operationId: z.ZodString;
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        feature_reviewer: "feature_reviewer";
+        final_reviewer: "final_reviewer";
+        host: "host";
+        implementation_worker: "implementation_worker";
+        root_manager: "root_manager";
+        verifier: "verifier";
+    }>;
+    modelClass: z.ZodEnum<{
+        manager: "manager";
+        reviewer: "reviewer";
+        unknown: "unknown";
+        verifier: "verifier";
+        worker: "worker";
+    }>;
+    attemptId: z.ZodString;
+    logicalPassId: z.ZodString;
+    snapshotId: z.ZodString;
+    evidenceRef: z.ZodString;
+    verdict: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    submitted: z.ZodBoolean;
+    findingFingerprints: z.ZodArray<z.ZodString>;
+    duplicateFindingCount: z.ZodNumber;
+    kind: z.ZodLiteral<"feature_review_attempt">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    operationId: z.ZodString;
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        feature_reviewer: "feature_reviewer";
+        final_reviewer: "final_reviewer";
+        host: "host";
+        implementation_worker: "implementation_worker";
+        root_manager: "root_manager";
+        verifier: "verifier";
+    }>;
+    modelClass: z.ZodEnum<{
+        manager: "manager";
+        reviewer: "reviewer";
+        unknown: "unknown";
+        verifier: "verifier";
+        worker: "worker";
+    }>;
+    attemptId: z.ZodString;
+    logicalPassId: z.ZodString;
+    snapshotId: z.ZodString;
+    evidenceRef: z.ZodString;
+    verdict: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    submitted: z.ZodBoolean;
+    findingFingerprints: z.ZodArray<z.ZodString>;
+    duplicateFindingCount: z.ZodNumber;
+    kind: z.ZodLiteral<"final_review_attempt">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    operationId: z.ZodString;
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        feature_reviewer: "feature_reviewer";
+        final_reviewer: "final_reviewer";
+        host: "host";
+        implementation_worker: "implementation_worker";
+        root_manager: "root_manager";
+        verifier: "verifier";
+    }>;
+    modelClass: z.ZodEnum<{
+        manager: "manager";
+        reviewer: "reviewer";
+        unknown: "unknown";
+        verifier: "verifier";
+        worker: "worker";
+    }>;
+    kind: z.ZodLiteral<"handoff_validity">;
+    status: z.ZodEnum<{
+        empty: "empty";
+        malformed: "malformed";
+        valid: "valid";
+    }>;
+    evidenceRef: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"telemetry_validity">;
+    operationId: z.ZodString;
+    status: z.ZodEnum<{
+        malformed: "malformed";
+        unavailable: "unavailable";
+        valid: "valid";
+    }>;
+    declaredWorkerCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    operationId: z.ZodString;
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        feature_reviewer: "feature_reviewer";
+        final_reviewer: "final_reviewer";
+        host: "host";
+        implementation_worker: "implementation_worker";
+        root_manager: "root_manager";
+        verifier: "verifier";
+    }>;
+    modelClass: z.ZodEnum<{
+        manager: "manager";
+        reviewer: "reviewer";
+        unknown: "unknown";
+        verifier: "verifier";
+        worker: "worker";
+    }>;
+    kind: z.ZodLiteral<"operation_metrics">;
+    latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    inputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    cacheReadTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    outputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    promptCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    resultCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"retry_finding_delta">;
+    operationId: z.ZodString;
+    logicalPassId: z.ZodString;
+    previousAttemptId: z.ZodString;
+    currentAttemptId: z.ZodString;
+    delta: z.ZodEnum<{
+        changed: "changed";
+        resolved: "resolved";
+        unchanged: "unchanged";
+    }>;
+    previousFindingCount: z.ZodNumber;
+    currentFindingCount: z.ZodNumber;
+    duplicateFindingCount: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"compaction">;
+    operationId: z.ZodString;
+    beforeCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+    afterCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        value: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodEnum<{
+            not_applicable: "not_applicable";
+            not_recorded: "not_recorded";
+            privacy_redacted: "privacy_redacted";
+            provider_unavailable: "provider_unavailable";
+            unreconciled: "unreconciled";
+        }>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"schema_failure">;
+    operationId: z.ZodString;
+    target: z.ZodEnum<{
+        completion: "completion";
+        durable_state: "durable_state";
+        handoff: "handoff";
+        telemetry: "telemetry";
+    }>;
+    failure: z.ZodEnum<{
+        extra_field: "extra_field";
+        invalid_type: "invalid_type";
+        invalid_value: "invalid_value";
+        missing_field: "missing_field";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"mutation_start">;
+    operationId: z.ZodString;
+    mutationId: z.ZodString;
+    baseRevision: z.ZodNumber;
+    inputDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"mutation_commit">;
+    operationId: z.ZodString;
+    mutationId: z.ZodString;
+    revision: z.ZodNumber;
+    stateDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"mutation_crash">;
+    operationId: z.ZodString;
+    mutationId: z.ZodString;
+    phase: z.ZodEnum<{
+        after_commit: "after_commit";
+        after_write_before_commit: "after_write_before_commit";
+        before_write: "before_write";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"mutation_recovery">;
+    operationId: z.ZodString;
+    mutationId: z.ZodString;
+    status: z.ZodEnum<{
+        commit_reused: "commit_reused";
+        reapplied: "reapplied";
+        rolled_back: "rolled_back";
+    }>;
+    revision: z.ZodNumber;
+    stateDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        flow_ledger: "flow_ledger";
+        host_metadata: "host_metadata";
+        replay_derived: "replay_derived";
+        supplied_observation: "supplied_observation";
+    }>;
+    kind: z.ZodLiteral<"terminal_decision">;
+    decision: z.ZodEnum<{
+        blocked: "blocked";
+        complete: "complete";
+        failed: "failed";
+        recovered: "recovered";
+        retry: "retry";
+    }>;
+    reason: z.ZodEnum<{
+        active_final_feature_in_progress: "active_final_feature_in_progress";
+        all_gates_passed: "all_gates_passed";
+        contradictory_review_verdicts: "contradictory_review_verdicts";
+        finding_unchanged: "finding_unchanged";
+        handoff_invalid: "handoff_invalid";
+        mutation_incomplete: "mutation_incomplete";
+        mutation_recovered: "mutation_recovered";
+        optional_telemetry_malformed: "optional_telemetry_malformed";
+        review_failed: "review_failed";
+        review_failure_unsubmitted: "review_failure_unsubmitted";
+        review_retry_passed: "review_retry_passed";
+        schema_invalid: "schema_invalid";
+        validation_stale: "validation_stale";
+    }>;
+    revision: z.ZodNumber;
+    stateDigest: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ReplayEvent = z.infer<typeof ReplayEventSchema>;
+export declare const ReplayScenarioSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        active_final_feature_awaiting_review: "active_final_feature_awaiting_review";
+        contradictory_feature_final_verdicts: "contradictory_feature_final_verdicts";
+        crash_replay_around_mutation: "crash_replay_around_mutation";
+        empty_or_malformed_handoff: "empty_or_malformed_handoff";
+        failed_to_passed_retry: "failed_to_passed_retry";
+        malformed_optional_telemetry: "malformed_optional_telemetry";
+        stale_validation: "stale_validation";
+        unchanged_finding_retry: "unchanged_finding_retry";
+        unsubmitted_review_failure: "unsubmitted_review_failure";
+    }>;
+    sessionId: z.ZodString;
+    initialStateDigest: z.ZodString;
+    controlDefects: z.ZodArray<z.ZodEnum<{
+        active_final_false_block: "active_final_false_block";
+        contradictory_verdict_not_reconciled: "contradictory_verdict_not_reconciled";
+        handoff_not_runtime_validated: "handoff_not_runtime_validated";
+        logical_pass_retry_not_correlated: "logical_pass_retry_not_correlated";
+        malformed_telemetry_masks_review: "malformed_telemetry_masks_review";
+        mutation_recovery_not_idempotent: "mutation_recovery_not_idempotent";
+        stale_validation_not_snapshot_bound: "stale_validation_not_snapshot_bound";
+        unchanged_finding_not_deduplicated: "unchanged_finding_not_deduplicated";
+        unsubmitted_review_failure_not_counted: "unsubmitted_review_failure_not_counted";
+    }>>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"session_state">;
+        sessionId: z.ZodString;
+        revision: z.ZodNumber;
+        sessionStatus: z.ZodEnum<{
+            blocked: "blocked";
+            completed: "completed";
+            planning: "planning";
+            ready: "ready";
+            running: "running";
+        }>;
+        featureStatus: z.ZodEnum<{
+            blocked: "blocked";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
+        }>;
+        stateDigest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"validation">;
+        operationId: z.ZodString;
+        evidenceRef: z.ZodString;
+        snapshotId: z.ZodString;
+        revision: z.ZodNumber;
+        scope: z.ZodEnum<{
+            broad: "broad";
+            targeted: "targeted";
+        }>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+        freshness: z.ZodEnum<{
+            current: "current";
+            stale: "stale";
+            unknown: "unknown";
+        }>;
+        latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        operationId: z.ZodString;
+        workerId: z.ZodString;
+        role: z.ZodEnum<{
+            feature_reviewer: "feature_reviewer";
+            final_reviewer: "final_reviewer";
+            host: "host";
+            implementation_worker: "implementation_worker";
+            root_manager: "root_manager";
+            verifier: "verifier";
+        }>;
+        modelClass: z.ZodEnum<{
+            manager: "manager";
+            reviewer: "reviewer";
+            unknown: "unknown";
+            verifier: "verifier";
+            worker: "worker";
+        }>;
+        attemptId: z.ZodString;
+        logicalPassId: z.ZodString;
+        snapshotId: z.ZodString;
+        evidenceRef: z.ZodString;
+        verdict: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+        submitted: z.ZodBoolean;
+        findingFingerprints: z.ZodArray<z.ZodString>;
+        duplicateFindingCount: z.ZodNumber;
+        kind: z.ZodLiteral<"feature_review_attempt">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        operationId: z.ZodString;
+        workerId: z.ZodString;
+        role: z.ZodEnum<{
+            feature_reviewer: "feature_reviewer";
+            final_reviewer: "final_reviewer";
+            host: "host";
+            implementation_worker: "implementation_worker";
+            root_manager: "root_manager";
+            verifier: "verifier";
+        }>;
+        modelClass: z.ZodEnum<{
+            manager: "manager";
+            reviewer: "reviewer";
+            unknown: "unknown";
+            verifier: "verifier";
+            worker: "worker";
+        }>;
+        attemptId: z.ZodString;
+        logicalPassId: z.ZodString;
+        snapshotId: z.ZodString;
+        evidenceRef: z.ZodString;
+        verdict: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+        submitted: z.ZodBoolean;
+        findingFingerprints: z.ZodArray<z.ZodString>;
+        duplicateFindingCount: z.ZodNumber;
+        kind: z.ZodLiteral<"final_review_attempt">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        operationId: z.ZodString;
+        workerId: z.ZodString;
+        role: z.ZodEnum<{
+            feature_reviewer: "feature_reviewer";
+            final_reviewer: "final_reviewer";
+            host: "host";
+            implementation_worker: "implementation_worker";
+            root_manager: "root_manager";
+            verifier: "verifier";
+        }>;
+        modelClass: z.ZodEnum<{
+            manager: "manager";
+            reviewer: "reviewer";
+            unknown: "unknown";
+            verifier: "verifier";
+            worker: "worker";
+        }>;
+        kind: z.ZodLiteral<"handoff_validity">;
+        status: z.ZodEnum<{
+            empty: "empty";
+            malformed: "malformed";
+            valid: "valid";
+        }>;
+        evidenceRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"telemetry_validity">;
+        operationId: z.ZodString;
+        status: z.ZodEnum<{
+            malformed: "malformed";
+            unavailable: "unavailable";
+            valid: "valid";
+        }>;
+        declaredWorkerCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        operationId: z.ZodString;
+        workerId: z.ZodString;
+        role: z.ZodEnum<{
+            feature_reviewer: "feature_reviewer";
+            final_reviewer: "final_reviewer";
+            host: "host";
+            implementation_worker: "implementation_worker";
+            root_manager: "root_manager";
+            verifier: "verifier";
+        }>;
+        modelClass: z.ZodEnum<{
+            manager: "manager";
+            reviewer: "reviewer";
+            unknown: "unknown";
+            verifier: "verifier";
+            worker: "worker";
+        }>;
+        kind: z.ZodLiteral<"operation_metrics">;
+        latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        inputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        cacheReadTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        outputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        promptCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        resultCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"retry_finding_delta">;
+        operationId: z.ZodString;
+        logicalPassId: z.ZodString;
+        previousAttemptId: z.ZodString;
+        currentAttemptId: z.ZodString;
+        delta: z.ZodEnum<{
+            changed: "changed";
+            resolved: "resolved";
+            unchanged: "unchanged";
+        }>;
+        previousFindingCount: z.ZodNumber;
+        currentFindingCount: z.ZodNumber;
+        duplicateFindingCount: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"compaction">;
+        operationId: z.ZodString;
+        beforeCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+        afterCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"schema_failure">;
+        operationId: z.ZodString;
+        target: z.ZodEnum<{
+            completion: "completion";
+            durable_state: "durable_state";
+            handoff: "handoff";
+            telemetry: "telemetry";
+        }>;
+        failure: z.ZodEnum<{
+            extra_field: "extra_field";
+            invalid_type: "invalid_type";
+            invalid_value: "invalid_value";
+            missing_field: "missing_field";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"mutation_start">;
+        operationId: z.ZodString;
+        mutationId: z.ZodString;
+        baseRevision: z.ZodNumber;
+        inputDigest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"mutation_commit">;
+        operationId: z.ZodString;
+        mutationId: z.ZodString;
+        revision: z.ZodNumber;
+        stateDigest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"mutation_crash">;
+        operationId: z.ZodString;
+        mutationId: z.ZodString;
+        phase: z.ZodEnum<{
+            after_commit: "after_commit";
+            after_write_before_commit: "after_write_before_commit";
+            before_write: "before_write";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"mutation_recovery">;
+        operationId: z.ZodString;
+        mutationId: z.ZodString;
+        status: z.ZodEnum<{
+            commit_reused: "commit_reused";
+            reapplied: "reapplied";
+            rolled_back: "rolled_back";
+        }>;
+        revision: z.ZodNumber;
+        stateDigest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        kind: z.ZodLiteral<"terminal_decision">;
+        decision: z.ZodEnum<{
+            blocked: "blocked";
+            complete: "complete";
+            failed: "failed";
+            recovered: "recovered";
+            retry: "retry";
+        }>;
+        reason: z.ZodEnum<{
+            active_final_feature_in_progress: "active_final_feature_in_progress";
+            all_gates_passed: "all_gates_passed";
+            contradictory_review_verdicts: "contradictory_review_verdicts";
+            finding_unchanged: "finding_unchanged";
+            handoff_invalid: "handoff_invalid";
+            mutation_incomplete: "mutation_incomplete";
+            mutation_recovered: "mutation_recovered";
+            optional_telemetry_malformed: "optional_telemetry_malformed";
+            review_failed: "review_failed";
+            review_failure_unsubmitted: "review_failure_unsubmitted";
+            review_retry_passed: "review_retry_passed";
+            schema_invalid: "schema_invalid";
+            validation_stale: "validation_stale";
+        }>;
+        revision: z.ZodNumber;
+        stateDigest: z.ZodString;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type ReplayScenario = z.infer<typeof ReplayScenarioSchema>;
+export declare const ReplayFixtureSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    fixtureId: z.ZodString;
+    sourceFingerprint: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            flow_ledger: "flow_ledger";
+            host_metadata: "host_metadata";
+            replay_derived: "replay_derived";
+            supplied_observation: "supplied_observation";
+        }>;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>>;
+    hostFacts: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            cache_read_token_count: "cache_read_token_count";
+            child_flow_status_call_count: "child_flow_status_call_count";
+            child_flow_status_result_character_count: "child_flow_status_result_character_count";
+            child_session_count: "child_session_count";
+            compaction_count: "compaction_count";
+            completion_schema_failure_count: "completion_schema_failure_count";
+            declared_worker_count: "declared_worker_count";
+            duplicate_finding_count: "duplicate_finding_count";
+            failed_review_attempt_count: "failed_review_attempt_count";
+            flow_tool_call_count: "flow_tool_call_count";
+            flow_tool_result_character_count: "flow_tool_result_character_count";
+            four_invocation_character_count: "four_invocation_character_count";
+            input_token_count: "input_token_count";
+            live_prompt_character_count: "live_prompt_character_count";
+            live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+            message_error_count: "message_error_count";
+            output_token_count: "output_token_count";
+            prompt_character_count: "prompt_character_count";
+            recovery_count: "recovery_count";
+            result_character_count: "result_character_count";
+            review_attempt_count: "review_attempt_count";
+            review_packet_file_count: "review_packet_file_count";
+            review_packet_line_count: "review_packet_line_count";
+            reviewer_child_session_count: "reviewer_child_session_count";
+            reviewer_dispatch_count: "reviewer_dispatch_count";
+            reviewer_execution_count: "reviewer_execution_count";
+            reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+            root_flow_tool_call_count: "root_flow_tool_call_count";
+            root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+            scenario_count: "scenario_count";
+            session_count: "session_count";
+            terminal_decision_count: "terminal_decision_count";
+            tool_error_count: "tool_error_count";
+            tool_latency_p50_ms: "tool_latency_p50_ms";
+            tool_latency_p95_ms: "tool_latency_p95_ms";
+            tool_latency_total_ms: "tool_latency_total_ms";
+            tool_part_count: "tool_part_count";
+            validation_failure_count: "validation_failure_count";
+        }>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    flowLedgerClaims: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            cache_read_token_count: "cache_read_token_count";
+            child_flow_status_call_count: "child_flow_status_call_count";
+            child_flow_status_result_character_count: "child_flow_status_result_character_count";
+            child_session_count: "child_session_count";
+            compaction_count: "compaction_count";
+            completion_schema_failure_count: "completion_schema_failure_count";
+            declared_worker_count: "declared_worker_count";
+            duplicate_finding_count: "duplicate_finding_count";
+            failed_review_attempt_count: "failed_review_attempt_count";
+            flow_tool_call_count: "flow_tool_call_count";
+            flow_tool_result_character_count: "flow_tool_result_character_count";
+            four_invocation_character_count: "four_invocation_character_count";
+            input_token_count: "input_token_count";
+            live_prompt_character_count: "live_prompt_character_count";
+            live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+            message_error_count: "message_error_count";
+            output_token_count: "output_token_count";
+            prompt_character_count: "prompt_character_count";
+            recovery_count: "recovery_count";
+            result_character_count: "result_character_count";
+            review_attempt_count: "review_attempt_count";
+            review_packet_file_count: "review_packet_file_count";
+            review_packet_line_count: "review_packet_line_count";
+            reviewer_child_session_count: "reviewer_child_session_count";
+            reviewer_dispatch_count: "reviewer_dispatch_count";
+            reviewer_execution_count: "reviewer_execution_count";
+            reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+            root_flow_tool_call_count: "root_flow_tool_call_count";
+            root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+            scenario_count: "scenario_count";
+            session_count: "session_count";
+            terminal_decision_count: "terminal_decision_count";
+            tool_error_count: "tool_error_count";
+            tool_latency_p50_ms: "tool_latency_p50_ms";
+            tool_latency_p95_ms: "tool_latency_p95_ms";
+            tool_latency_total_ms: "tool_latency_total_ms";
+            tool_part_count: "tool_part_count";
+            validation_failure_count: "validation_failure_count";
+        }>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    suppliedObservations: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            cache_read_token_count: "cache_read_token_count";
+            child_flow_status_call_count: "child_flow_status_call_count";
+            child_flow_status_result_character_count: "child_flow_status_result_character_count";
+            child_session_count: "child_session_count";
+            compaction_count: "compaction_count";
+            completion_schema_failure_count: "completion_schema_failure_count";
+            declared_worker_count: "declared_worker_count";
+            duplicate_finding_count: "duplicate_finding_count";
+            failed_review_attempt_count: "failed_review_attempt_count";
+            flow_tool_call_count: "flow_tool_call_count";
+            flow_tool_result_character_count: "flow_tool_result_character_count";
+            four_invocation_character_count: "four_invocation_character_count";
+            input_token_count: "input_token_count";
+            live_prompt_character_count: "live_prompt_character_count";
+            live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+            message_error_count: "message_error_count";
+            output_token_count: "output_token_count";
+            prompt_character_count: "prompt_character_count";
+            recovery_count: "recovery_count";
+            result_character_count: "result_character_count";
+            review_attempt_count: "review_attempt_count";
+            review_packet_file_count: "review_packet_file_count";
+            review_packet_line_count: "review_packet_line_count";
+            reviewer_child_session_count: "reviewer_child_session_count";
+            reviewer_dispatch_count: "reviewer_dispatch_count";
+            reviewer_execution_count: "reviewer_execution_count";
+            reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+            root_flow_tool_call_count: "root_flow_tool_call_count";
+            root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+            scenario_count: "scenario_count";
+            session_count: "session_count";
+            terminal_decision_count: "terminal_decision_count";
+            tool_error_count: "tool_error_count";
+            tool_latency_p50_ms: "tool_latency_p50_ms";
+            tool_latency_p95_ms: "tool_latency_p95_ms";
+            tool_latency_total_ms: "tool_latency_total_ms";
+            tool_part_count: "tool_part_count";
+            validation_failure_count: "validation_failure_count";
+        }>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    replayDerivedFacts: z.ZodArray<z.ZodObject<{
+        metric: z.ZodEnum<{
+            cache_read_token_count: "cache_read_token_count";
+            child_flow_status_call_count: "child_flow_status_call_count";
+            child_flow_status_result_character_count: "child_flow_status_result_character_count";
+            child_session_count: "child_session_count";
+            compaction_count: "compaction_count";
+            completion_schema_failure_count: "completion_schema_failure_count";
+            declared_worker_count: "declared_worker_count";
+            duplicate_finding_count: "duplicate_finding_count";
+            failed_review_attempt_count: "failed_review_attempt_count";
+            flow_tool_call_count: "flow_tool_call_count";
+            flow_tool_result_character_count: "flow_tool_result_character_count";
+            four_invocation_character_count: "four_invocation_character_count";
+            input_token_count: "input_token_count";
+            live_prompt_character_count: "live_prompt_character_count";
+            live_prompt_estimated_token_count: "live_prompt_estimated_token_count";
+            message_error_count: "message_error_count";
+            output_token_count: "output_token_count";
+            prompt_character_count: "prompt_character_count";
+            recovery_count: "recovery_count";
+            result_character_count: "result_character_count";
+            review_attempt_count: "review_attempt_count";
+            review_packet_file_count: "review_packet_file_count";
+            review_packet_line_count: "review_packet_line_count";
+            reviewer_child_session_count: "reviewer_child_session_count";
+            reviewer_dispatch_count: "reviewer_dispatch_count";
+            reviewer_execution_count: "reviewer_execution_count";
+            reviewer_input_share_basis_points: "reviewer_input_share_basis_points";
+            root_flow_tool_call_count: "root_flow_tool_call_count";
+            root_flow_tool_result_character_count: "root_flow_tool_result_character_count";
+            scenario_count: "scenario_count";
+            session_count: "session_count";
+            terminal_decision_count: "terminal_decision_count";
+            tool_error_count: "tool_error_count";
+            tool_latency_p50_ms: "tool_latency_p50_ms";
+            tool_latency_p95_ms: "tool_latency_p95_ms";
+            tool_latency_total_ms: "tool_latency_total_ms";
+            tool_part_count: "tool_part_count";
+            validation_failure_count: "validation_failure_count";
+        }>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            value: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                not_applicable: "not_applicable";
+                not_recorded: "not_recorded";
+                privacy_redacted: "privacy_redacted";
+                provider_unavailable: "provider_unavailable";
+                unreconciled: "unreconciled";
+            }>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            active_final_feature_awaiting_review: "active_final_feature_awaiting_review";
+            contradictory_feature_final_verdicts: "contradictory_feature_final_verdicts";
+            crash_replay_around_mutation: "crash_replay_around_mutation";
+            empty_or_malformed_handoff: "empty_or_malformed_handoff";
+            failed_to_passed_retry: "failed_to_passed_retry";
+            malformed_optional_telemetry: "malformed_optional_telemetry";
+            stale_validation: "stale_validation";
+            unchanged_finding_retry: "unchanged_finding_retry";
+            unsubmitted_review_failure: "unsubmitted_review_failure";
+        }>;
+        sessionId: z.ZodString;
+        initialStateDigest: z.ZodString;
+        controlDefects: z.ZodArray<z.ZodEnum<{
+            active_final_false_block: "active_final_false_block";
+            contradictory_verdict_not_reconciled: "contradictory_verdict_not_reconciled";
+            handoff_not_runtime_validated: "handoff_not_runtime_validated";
+            logical_pass_retry_not_correlated: "logical_pass_retry_not_correlated";
+            malformed_telemetry_masks_review: "malformed_telemetry_masks_review";
+            mutation_recovery_not_idempotent: "mutation_recovery_not_idempotent";
+            stale_validation_not_snapshot_bound: "stale_validation_not_snapshot_bound";
+            unchanged_finding_not_deduplicated: "unchanged_finding_not_deduplicated";
+            unsubmitted_review_failure_not_counted: "unsubmitted_review_failure_not_counted";
+        }>>;
+        events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"session_state">;
+            sessionId: z.ZodString;
+            revision: z.ZodNumber;
+            sessionStatus: z.ZodEnum<{
+                blocked: "blocked";
+                completed: "completed";
+                planning: "planning";
+                ready: "ready";
+                running: "running";
+            }>;
+            featureStatus: z.ZodEnum<{
+                blocked: "blocked";
+                completed: "completed";
+                in_progress: "in_progress";
+                pending: "pending";
+            }>;
+            stateDigest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"validation">;
+            operationId: z.ZodString;
+            evidenceRef: z.ZodString;
+            snapshotId: z.ZodString;
+            revision: z.ZodNumber;
+            scope: z.ZodEnum<{
+                broad: "broad";
+                targeted: "targeted";
+            }>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+            }>;
+            freshness: z.ZodEnum<{
+                current: "current";
+                stale: "stale";
+                unknown: "unknown";
+            }>;
+            latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            operationId: z.ZodString;
+            workerId: z.ZodString;
+            role: z.ZodEnum<{
+                feature_reviewer: "feature_reviewer";
+                final_reviewer: "final_reviewer";
+                host: "host";
+                implementation_worker: "implementation_worker";
+                root_manager: "root_manager";
+                verifier: "verifier";
+            }>;
+            modelClass: z.ZodEnum<{
+                manager: "manager";
+                reviewer: "reviewer";
+                unknown: "unknown";
+                verifier: "verifier";
+                worker: "worker";
+            }>;
+            attemptId: z.ZodString;
+            logicalPassId: z.ZodString;
+            snapshotId: z.ZodString;
+            evidenceRef: z.ZodString;
+            verdict: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+            }>;
+            submitted: z.ZodBoolean;
+            findingFingerprints: z.ZodArray<z.ZodString>;
+            duplicateFindingCount: z.ZodNumber;
+            kind: z.ZodLiteral<"feature_review_attempt">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            operationId: z.ZodString;
+            workerId: z.ZodString;
+            role: z.ZodEnum<{
+                feature_reviewer: "feature_reviewer";
+                final_reviewer: "final_reviewer";
+                host: "host";
+                implementation_worker: "implementation_worker";
+                root_manager: "root_manager";
+                verifier: "verifier";
+            }>;
+            modelClass: z.ZodEnum<{
+                manager: "manager";
+                reviewer: "reviewer";
+                unknown: "unknown";
+                verifier: "verifier";
+                worker: "worker";
+            }>;
+            attemptId: z.ZodString;
+            logicalPassId: z.ZodString;
+            snapshotId: z.ZodString;
+            evidenceRef: z.ZodString;
+            verdict: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+            }>;
+            submitted: z.ZodBoolean;
+            findingFingerprints: z.ZodArray<z.ZodString>;
+            duplicateFindingCount: z.ZodNumber;
+            kind: z.ZodLiteral<"final_review_attempt">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            operationId: z.ZodString;
+            workerId: z.ZodString;
+            role: z.ZodEnum<{
+                feature_reviewer: "feature_reviewer";
+                final_reviewer: "final_reviewer";
+                host: "host";
+                implementation_worker: "implementation_worker";
+                root_manager: "root_manager";
+                verifier: "verifier";
+            }>;
+            modelClass: z.ZodEnum<{
+                manager: "manager";
+                reviewer: "reviewer";
+                unknown: "unknown";
+                verifier: "verifier";
+                worker: "worker";
+            }>;
+            kind: z.ZodLiteral<"handoff_validity">;
+            status: z.ZodEnum<{
+                empty: "empty";
+                malformed: "malformed";
+                valid: "valid";
+            }>;
+            evidenceRef: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"telemetry_validity">;
+            operationId: z.ZodString;
+            status: z.ZodEnum<{
+                malformed: "malformed";
+                unavailable: "unavailable";
+                valid: "valid";
+            }>;
+            declaredWorkerCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            operationId: z.ZodString;
+            workerId: z.ZodString;
+            role: z.ZodEnum<{
+                feature_reviewer: "feature_reviewer";
+                final_reviewer: "final_reviewer";
+                host: "host";
+                implementation_worker: "implementation_worker";
+                root_manager: "root_manager";
+                verifier: "verifier";
+            }>;
+            modelClass: z.ZodEnum<{
+                manager: "manager";
+                reviewer: "reviewer";
+                unknown: "unknown";
+                verifier: "verifier";
+                worker: "worker";
+            }>;
+            kind: z.ZodLiteral<"operation_metrics">;
+            latencyMs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            inputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            cacheReadTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            outputTokenCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            promptCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            resultCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"retry_finding_delta">;
+            operationId: z.ZodString;
+            logicalPassId: z.ZodString;
+            previousAttemptId: z.ZodString;
+            currentAttemptId: z.ZodString;
+            delta: z.ZodEnum<{
+                changed: "changed";
+                resolved: "resolved";
+                unchanged: "unchanged";
+            }>;
+            previousFindingCount: z.ZodNumber;
+            currentFindingCount: z.ZodNumber;
+            duplicateFindingCount: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"compaction">;
+            operationId: z.ZodString;
+            beforeCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+            afterCharacterCount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                value: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    not_applicable: "not_applicable";
+                    not_recorded: "not_recorded";
+                    privacy_redacted: "privacy_redacted";
+                    provider_unavailable: "provider_unavailable";
+                    unreconciled: "unreconciled";
+                }>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"schema_failure">;
+            operationId: z.ZodString;
+            target: z.ZodEnum<{
+                completion: "completion";
+                durable_state: "durable_state";
+                handoff: "handoff";
+                telemetry: "telemetry";
+            }>;
+            failure: z.ZodEnum<{
+                extra_field: "extra_field";
+                invalid_type: "invalid_type";
+                invalid_value: "invalid_value";
+                missing_field: "missing_field";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"mutation_start">;
+            operationId: z.ZodString;
+            mutationId: z.ZodString;
+            baseRevision: z.ZodNumber;
+            inputDigest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"mutation_commit">;
+            operationId: z.ZodString;
+            mutationId: z.ZodString;
+            revision: z.ZodNumber;
+            stateDigest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"mutation_crash">;
+            operationId: z.ZodString;
+            mutationId: z.ZodString;
+            phase: z.ZodEnum<{
+                after_commit: "after_commit";
+                after_write_before_commit: "after_write_before_commit";
+                before_write: "before_write";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"mutation_recovery">;
+            operationId: z.ZodString;
+            mutationId: z.ZodString;
+            status: z.ZodEnum<{
+                commit_reused: "commit_reused";
+                reapplied: "reapplied";
+                rolled_back: "rolled_back";
+            }>;
+            revision: z.ZodNumber;
+            stateDigest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            seq: z.ZodNumber;
+            atMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                flow_ledger: "flow_ledger";
+                host_metadata: "host_metadata";
+                replay_derived: "replay_derived";
+                supplied_observation: "supplied_observation";
+            }>;
+            kind: z.ZodLiteral<"terminal_decision">;
+            decision: z.ZodEnum<{
+                blocked: "blocked";
+                complete: "complete";
+                failed: "failed";
+                recovered: "recovered";
+                retry: "retry";
+            }>;
+            reason: z.ZodEnum<{
+                active_final_feature_in_progress: "active_final_feature_in_progress";
+                all_gates_passed: "all_gates_passed";
+                contradictory_review_verdicts: "contradictory_review_verdicts";
+                finding_unchanged: "finding_unchanged";
+                handoff_invalid: "handoff_invalid";
+                mutation_incomplete: "mutation_incomplete";
+                mutation_recovered: "mutation_recovered";
+                optional_telemetry_malformed: "optional_telemetry_malformed";
+                review_failed: "review_failed";
+                review_failure_unsubmitted: "review_failure_unsubmitted";
+                review_retry_passed: "review_retry_passed";
+                schema_invalid: "schema_invalid";
+                validation_stale: "validation_stale";
+            }>;
+            revision: z.ZodNumber;
+            stateDigest: z.ZodString;
+            evidenceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReplayFixture = z.infer<typeof ReplayFixtureSchema>;