@petepetrash/circuit 0.1.0

package/dist/schemas/history.d.ts

@@ -0,0 +1,1735 @@
+import { z } from 'zod';
+export declare const HISTORY_AUTHORITY_NOTICE = "History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.";
+export declare const HistoryWarningCodeV1: z.ZodEnum<{
+    run_skipped: "run_skipped";
+    report_skipped: "report_skipped";
+    trace_skipped: "trace_skipped";
+    source_unreadable: "source_unreadable";
+    source_invalid: "source_invalid";
+    source_pruned: "source_pruned";
+    envelope_missing: "envelope_missing";
+    recall_report_missing: "recall_report_missing";
+    memory_input_unmatched: "memory_input_unmatched";
+    content_id_unhashed_source: "content_id_unhashed_source";
+    effect_report_unavailable: "effect_report_unavailable";
+    pull_log_unavailable: "pull_log_unavailable";
+}>;
+export type HistoryWarningCodeV1 = z.infer<typeof HistoryWarningCodeV1>;
+export declare const HistoryWarningV1: z.ZodObject<{
+    code: z.ZodEnum<{
+        run_skipped: "run_skipped";
+        report_skipped: "report_skipped";
+        trace_skipped: "trace_skipped";
+        source_unreadable: "source_unreadable";
+        source_invalid: "source_invalid";
+        source_pruned: "source_pruned";
+        envelope_missing: "envelope_missing";
+        recall_report_missing: "recall_report_missing";
+        memory_input_unmatched: "memory_input_unmatched";
+        content_id_unhashed_source: "content_id_unhashed_source";
+        effect_report_unavailable: "effect_report_unavailable";
+        pull_log_unavailable: "pull_log_unavailable";
+    }>;
+    message: z.ZodString;
+    run_folder: z.ZodOptional<z.ZodString>;
+    source_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type HistoryWarningV1 = z.infer<typeof HistoryWarningV1>;
+export declare const HistoryManifestV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-index-v1">;
+    schema_version: z.ZodLiteral<1>;
+    created_at: z.ZodISODateTime;
+    repo_root: z.ZodString;
+    runs_base: z.ZodString;
+    index_dir: z.ZodString;
+    documents_path: z.ZodLiteral<"documents.v1.jsonl">;
+    run_count: z.ZodNumber;
+    document_count: z.ZodNumber;
+    source_fingerprint: z.ZodObject<{
+        run_folder_names_sha256: z.ZodString;
+        latest_source_mtime_ms: z.ZodNumber;
+    }, z.core.$strict>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryManifestV1 = z.infer<typeof HistoryManifestV1>;
+export declare const HistoryDocumentKindV1: z.ZodEnum<{
+    report: "report";
+    trace: "trace";
+    checkpoint: "checkpoint";
+    run: "run";
+}>;
+export type HistoryDocumentKindV1 = z.infer<typeof HistoryDocumentKindV1>;
+export declare const HistoryDocumentV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-document-v1">;
+    schema_version: z.ZodLiteral<1>;
+    doc_id: z.ZodString;
+    doc_kind: z.ZodEnum<{
+        report: "report";
+        trace: "trace";
+        checkpoint: "checkpoint";
+        run: "run";
+    }>;
+    run_id: z.ZodString;
+    flow_id: z.ZodOptional<z.ZodString>;
+    run_folder: z.ZodString;
+    source_path: z.ZodString;
+    source_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>;
+    source_sha256: z.ZodOptional<z.ZodString>;
+    source_mtime_ms: z.ZodOptional<z.ZodNumber>;
+    report_schema: z.ZodOptional<z.ZodString>;
+    step_id: z.ZodOptional<z.ZodString>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    recorded_at: z.ZodOptional<z.ZodISODateTime>;
+    outcome: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    text: z.ZodString;
+    extracted_from: z.ZodArray<z.ZodObject<{
+        json_pointer: z.ZodOptional<z.ZodString>;
+        field_role: z.ZodString;
+    }, z.core.$strict>>;
+    facets: z.ZodArray<z.ZodString>;
+    memory_safe: z.ZodBoolean;
+}, z.core.$strict>;
+export type HistoryDocumentV1 = z.infer<typeof HistoryDocumentV1>;
+export declare const HistoryStalenessV1: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    reason_codes: z.ZodArray<z.ZodString>;
+    checked_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type HistoryStalenessV1 = z.infer<typeof HistoryStalenessV1>;
+export declare const HistoryQueryHitV1: z.ZodObject<{
+    rank: z.ZodNumber;
+    score: z.ZodNumber;
+    doc: z.ZodObject<{
+        api_version: z.ZodLiteral<"history-document-v1">;
+        schema_version: z.ZodLiteral<1>;
+        doc_id: z.ZodString;
+        doc_kind: z.ZodEnum<{
+            report: "report";
+            trace: "trace";
+            checkpoint: "checkpoint";
+            run: "run";
+        }>;
+        run_id: z.ZodString;
+        flow_id: z.ZodOptional<z.ZodString>;
+        run_folder: z.ZodString;
+        source_path: z.ZodString;
+        source_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>;
+        source_sha256: z.ZodOptional<z.ZodString>;
+        source_mtime_ms: z.ZodOptional<z.ZodNumber>;
+        report_schema: z.ZodOptional<z.ZodString>;
+        step_id: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+        recorded_at: z.ZodOptional<z.ZodISODateTime>;
+        outcome: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        text: z.ZodString;
+        extracted_from: z.ZodArray<z.ZodObject<{
+            json_pointer: z.ZodOptional<z.ZodString>;
+            field_role: z.ZodString;
+        }, z.core.$strict>>;
+        facets: z.ZodArray<z.ZodString>;
+        memory_safe: z.ZodBoolean;
+    }, z.core.$strict>;
+    snippet: z.ZodString;
+    matched_terms: z.ZodArray<z.ZodString>;
+    ranking_reasons: z.ZodArray<z.ZodString>;
+    staleness: z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        reason_codes: z.ZodArray<z.ZodString>;
+        checked_at: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HistoryQueryHitV1 = z.infer<typeof HistoryQueryHitV1>;
+export declare const HistoryQueryResultV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-query-result-v1">;
+    schema_version: z.ZodLiteral<1>;
+    query: z.ZodString;
+    format: z.ZodLiteral<"json">;
+    index_state: z.ZodEnum<{
+        fresh: "fresh";
+        possibly_stale: "possibly_stale";
+    }>;
+    rebuilt: z.ZodBoolean;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    results: z.ZodArray<z.ZodObject<{
+        rank: z.ZodNumber;
+        score: z.ZodNumber;
+        doc: z.ZodObject<{
+            api_version: z.ZodLiteral<"history-document-v1">;
+            schema_version: z.ZodLiteral<1>;
+            doc_id: z.ZodString;
+            doc_kind: z.ZodEnum<{
+                report: "report";
+                trace: "trace";
+                checkpoint: "checkpoint";
+                run: "run";
+            }>;
+            run_id: z.ZodString;
+            flow_id: z.ZodOptional<z.ZodString>;
+            run_folder: z.ZodString;
+            source_path: z.ZodString;
+            source_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>;
+            source_sha256: z.ZodOptional<z.ZodString>;
+            source_mtime_ms: z.ZodOptional<z.ZodNumber>;
+            report_schema: z.ZodOptional<z.ZodString>;
+            step_id: z.ZodOptional<z.ZodString>;
+            attempt: z.ZodOptional<z.ZodNumber>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+            recorded_at: z.ZodOptional<z.ZodISODateTime>;
+            outcome: z.ZodOptional<z.ZodString>;
+            title: z.ZodString;
+            summary: z.ZodString;
+            text: z.ZodString;
+            extracted_from: z.ZodArray<z.ZodObject<{
+                json_pointer: z.ZodOptional<z.ZodString>;
+                field_role: z.ZodString;
+            }, z.core.$strict>>;
+            facets: z.ZodArray<z.ZodString>;
+            memory_safe: z.ZodBoolean;
+        }, z.core.$strict>;
+        snippet: z.ZodString;
+        matched_terms: z.ZodArray<z.ZodString>;
+        ranking_reasons: z.ZodArray<z.ZodString>;
+        staleness: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            reason_codes: z.ZodArray<z.ZodString>;
+            checked_at: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryQueryResultV1 = z.infer<typeof HistoryQueryResultV1>;
+export declare const HistoryMemoryInputMatchV1: z.ZodObject<{
+    memory_id: z.ZodString;
+    rank: z.ZodNumber;
+    score: z.ZodNumber;
+    source_doc_id: z.ZodString;
+    source_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>;
+    snippet: z.ZodString;
+}, z.core.$strict>;
+export type HistoryMemoryInputMatchV1 = z.infer<typeof HistoryMemoryInputMatchV1>;
+export declare const HistoryMemoryInputPreviewV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-memory-input-preview-v1">;
+    schema_version: z.ZodLiteral<1>;
+    query: z.ZodString;
+    format: z.ZodLiteral<"memory-input">;
+    index_state: z.ZodEnum<{
+        fresh: "fresh";
+        possibly_stale: "possibly_stale";
+    }>;
+    rebuilt: z.ZodBoolean;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    memory_inputs: z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        memory_id: z.ZodString;
+        kind: z.ZodEnum<{
+            project: "project";
+            repo: "repo";
+            user: "user";
+            prior_run: "prior_run";
+            continuity: "continuity";
+            handoff_brief: "handoff_brief";
+        }>;
+        source: z.ZodObject<{
+            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>;
+            captured_at: z.ZodISODateTime;
+            source_updated_at: z.ZodOptional<z.ZodISODateTime>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        summary: z.ZodString;
+        hints: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            applies_to: z.ZodEnum<{
+                verification: "verification";
+                preference: "preference";
+                context: "context";
+                prior_failure: "prior_failure";
+                repo_convention: "repo_convention";
+                operator_note: "operator_note";
+            }>;
+        }, z.core.$strict>>;
+        staleness: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            checked_at: z.ZodISODateTime;
+            reason_codes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        authority: z.ZodLiteral<"hint_only">;
+    }, z.core.$strict>>;
+    matches: z.ZodArray<z.ZodObject<{
+        memory_id: z.ZodString;
+        rank: z.ZodNumber;
+        score: z.ZodNumber;
+        source_doc_id: z.ZodString;
+        source_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>;
+        snippet: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryMemoryInputPreviewV1 = z.infer<typeof HistoryMemoryInputPreviewV1>;
+export declare const HistoryRecallStatusV1: z.ZodEnum<{
+    unavailable: "unavailable";
+    used: "used";
+    empty: "empty";
+}>;
+export type HistoryRecallStatusV1 = z.infer<typeof HistoryRecallStatusV1>;
+export declare const HistoryRecallReportV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-recall-report-v1">;
+    schema_version: z.ZodLiteral<1>;
+    status: z.ZodEnum<{
+        unavailable: "unavailable";
+        used: "used";
+        empty: "empty";
+    }>;
+    query: z.ZodString;
+    index_state: z.ZodOptional<z.ZodEnum<{
+        fresh: "fresh";
+        possibly_stale: "possibly_stale";
+    }>>;
+    rebuilt: z.ZodBoolean;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    memory_input_count: z.ZodNumber;
+    memory_inputs: z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        memory_id: z.ZodString;
+        kind: z.ZodEnum<{
+            project: "project";
+            repo: "repo";
+            user: "user";
+            prior_run: "prior_run";
+            continuity: "continuity";
+            handoff_brief: "handoff_brief";
+        }>;
+        source: z.ZodObject<{
+            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>;
+            captured_at: z.ZodISODateTime;
+            source_updated_at: z.ZodOptional<z.ZodISODateTime>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        summary: z.ZodString;
+        hints: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            applies_to: z.ZodEnum<{
+                verification: "verification";
+                preference: "preference";
+                context: "context";
+                prior_failure: "prior_failure";
+                repo_convention: "repo_convention";
+                operator_note: "operator_note";
+            }>;
+        }, z.core.$strict>>;
+        staleness: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            checked_at: z.ZodISODateTime;
+            reason_codes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        authority: z.ZodLiteral<"hint_only">;
+    }, z.core.$strict>>;
+    matches: z.ZodArray<z.ZodObject<{
+        memory_id: z.ZodString;
+        rank: z.ZodNumber;
+        score: z.ZodNumber;
+        source_doc_id: z.ZodString;
+        source_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>;
+        snippet: z.ZodString;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryRecallReportV1 = z.infer<typeof HistoryRecallReportV1>;
+export declare const HistoryStatusV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-status-v1">;
+    schema_version: z.ZodLiteral<1>;
+    index_exists: z.ZodBoolean;
+    index_state: z.ZodEnum<{
+        missing: "missing";
+        fresh: "fresh";
+        possibly_stale: "possibly_stale";
+        corrupt: "corrupt";
+        unsupported: "unsupported";
+    }>;
+    runs_base: z.ZodString;
+    index_dir: z.ZodString;
+    manifest: z.ZodOptional<z.ZodObject<{
+        api_version: z.ZodLiteral<"history-index-v1">;
+        schema_version: z.ZodLiteral<1>;
+        created_at: z.ZodISODateTime;
+        repo_root: z.ZodString;
+        runs_base: z.ZodString;
+        index_dir: z.ZodString;
+        documents_path: z.ZodLiteral<"documents.v1.jsonl">;
+        run_count: z.ZodNumber;
+        document_count: z.ZodNumber;
+        source_fingerprint: z.ZodObject<{
+            run_folder_names_sha256: z.ZodString;
+            latest_source_mtime_ms: z.ZodNumber;
+        }, z.core.$strict>;
+        warnings: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                run_skipped: "run_skipped";
+                report_skipped: "report_skipped";
+                trace_skipped: "trace_skipped";
+                source_unreadable: "source_unreadable";
+                source_invalid: "source_invalid";
+                source_pruned: "source_pruned";
+                envelope_missing: "envelope_missing";
+                recall_report_missing: "recall_report_missing";
+                memory_input_unmatched: "memory_input_unmatched";
+                content_id_unhashed_source: "content_id_unhashed_source";
+                effect_report_unavailable: "effect_report_unavailable";
+                pull_log_unavailable: "pull_log_unavailable";
+            }>;
+            message: z.ZodString;
+            run_folder: z.ZodOptional<z.ZodString>;
+            source_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryStatusV1 = z.infer<typeof HistoryStatusV1>;
+export declare const HistoryErrorCodeV1: z.ZodEnum<{
+    invalid_invocation: "invalid_invocation";
+    internal_error: "internal_error";
+    source_unreadable: "source_unreadable";
+    runs_base_not_found: "runs_base_not_found";
+    runs_base_unreadable: "runs_base_unreadable";
+    index_missing: "index_missing";
+    index_unsupported: "index_unsupported";
+    index_corrupt: "index_corrupt";
+}>;
+export type HistoryErrorCodeV1 = z.infer<typeof HistoryErrorCodeV1>;
+export declare const HistoryErrorV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-error-v1">;
+    schema_version: z.ZodLiteral<1>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            invalid_invocation: "invalid_invocation";
+            internal_error: "internal_error";
+            source_unreadable: "source_unreadable";
+            runs_base_not_found: "runs_base_not_found";
+            runs_base_unreadable: "runs_base_unreadable";
+            index_missing: "index_missing";
+            index_unsupported: "index_unsupported";
+            index_corrupt: "index_corrupt";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    runs_base: z.ZodOptional<z.ZodString>;
+    index_dir: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type HistoryErrorV1 = z.infer<typeof HistoryErrorV1>;
+export declare const MemoryMergeEffectStatusV1: z.ZodEnum<{
+    not_enough_data: "not_enough_data";
+    correlated_positive: "correlated_positive";
+    correlated_negative: "correlated_negative";
+    unresolved: "unresolved";
+}>;
+export type MemoryMergeEffectStatusV1 = z.infer<typeof MemoryMergeEffectStatusV1>;
+export declare const MemoryMergeInputV1: z.ZodObject<{
+    memory_input_id: z.ZodString;
+    content_id: z.ZodNullable<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        repo: "repo";
+        user: "user";
+        prior_run: "prior_run";
+        continuity: "continuity";
+        handoff_brief: "handoff_brief";
+    }>>;
+    source_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>>;
+    staleness: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale: "stale";
+    }>>;
+    resolved_from_recall: z.ZodBoolean;
+}, z.core.$strict>;
+export type MemoryMergeInputV1 = z.infer<typeof MemoryMergeInputV1>;
+export declare const MemoryMergeRunLinkageV1: z.ZodObject<{
+    run_id: z.ZodString;
+    flow_id: z.ZodOptional<z.ZodString>;
+    operator_intent: z.ZodString;
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        blocked: "blocked";
+        needs_attention: "needs_attention";
+    }>;
+    abort_reason: z.ZodOptional<z.ZodString>;
+    memory_used: z.ZodBoolean;
+    memory_inputs: z.ZodArray<z.ZodObject<{
+        memory_input_id: z.ZodString;
+        content_id: z.ZodNullable<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            project: "project";
+            repo: "repo";
+            user: "user";
+            prior_run: "prior_run";
+            continuity: "continuity";
+            handoff_brief: "handoff_brief";
+        }>>;
+        source_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>>;
+        staleness: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>>;
+        resolved_from_recall: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MemoryMergeRunLinkageV1 = z.infer<typeof MemoryMergeRunLinkageV1>;
+export declare const MemoryMergeOutcomeCountV1: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        complete: "complete";
+        handoff: "handoff";
+        failed: "failed";
+        blocked: "blocked";
+        needs_attention: "needs_attention";
+    }>;
+    count: z.ZodNumber;
+}, z.core.$strict>;
+export type MemoryMergeOutcomeCountV1 = z.infer<typeof MemoryMergeOutcomeCountV1>;
+export declare const MemoryMergeItemV1: z.ZodObject<{
+    group_key: z.ZodString;
+    content_id: z.ZodNullable<z.ZodString>;
+    memory_input_ids: z.ZodArray<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        repo: "repo";
+        user: "user";
+        prior_run: "prior_run";
+        continuity: "continuity";
+        handoff_brief: "handoff_brief";
+    }>>;
+    source_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>>;
+    used_by_run_ids: z.ZodArray<z.ZodString>;
+    outcome_counts: z.ZodArray<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+        }>;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    effect_status: z.ZodEnum<{
+        not_enough_data: "not_enough_data";
+        correlated_positive: "correlated_positive";
+        correlated_negative: "correlated_negative";
+        unresolved: "unresolved";
+    }>;
+    effect_note: z.ZodString;
+}, z.core.$strict>;
+export type MemoryMergeItemV1 = z.infer<typeof MemoryMergeItemV1>;
+export declare const HistoryMemoryMergeV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-memory-merge-v1">;
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodISODateTime;
+    runs_base: z.ZodString;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    run_count: z.ZodNumber;
+    envelope_count: z.ZodNumber;
+    memory_run_count: z.ZodNumber;
+    linkages: z.ZodArray<z.ZodObject<{
+        run_id: z.ZodString;
+        flow_id: z.ZodOptional<z.ZodString>;
+        operator_intent: z.ZodString;
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+        }>;
+        abort_reason: z.ZodOptional<z.ZodString>;
+        memory_used: z.ZodBoolean;
+        memory_inputs: z.ZodArray<z.ZodObject<{
+            memory_input_id: z.ZodString;
+            content_id: z.ZodNullable<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                project: "project";
+                repo: "repo";
+                user: "user";
+                prior_run: "prior_run";
+                continuity: "continuity";
+                handoff_brief: "handoff_brief";
+            }>>;
+            source_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>>;
+            staleness: z.ZodOptional<z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>>;
+            resolved_from_recall: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    memory_items: z.ZodArray<z.ZodObject<{
+        group_key: z.ZodString;
+        content_id: z.ZodNullable<z.ZodString>;
+        memory_input_ids: z.ZodArray<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            project: "project";
+            repo: "repo";
+            user: "user";
+            prior_run: "prior_run";
+            continuity: "continuity";
+            handoff_brief: "handoff_brief";
+        }>>;
+        source_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>>;
+        used_by_run_ids: z.ZodArray<z.ZodString>;
+        outcome_counts: z.ZodArray<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                complete: "complete";
+                handoff: "handoff";
+                failed: "failed";
+                blocked: "blocked";
+                needs_attention: "needs_attention";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+        effect_status: z.ZodEnum<{
+            not_enough_data: "not_enough_data";
+            correlated_positive: "correlated_positive";
+            correlated_negative: "correlated_negative";
+            unresolved: "unresolved";
+        }>;
+        effect_note: z.ZodString;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryMemoryMergeV1 = z.infer<typeof HistoryMemoryMergeV1>;
+export declare const MemoryEffectArmV1: z.ZodObject<{
+    run_ids: z.ZodArray<z.ZodString>;
+    size: z.ZodNumber;
+    complete_count: z.ZodNumber;
+    adverse_count: z.ZodNumber;
+    neutral_count: z.ZodNumber;
+    outcome_counts: z.ZodArray<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            complete: "complete";
+            handoff: "handoff";
+            failed: "failed";
+            blocked: "blocked";
+            needs_attention: "needs_attention";
+        }>;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    complete_rate: z.ZodNumber;
+    adverse_rate: z.ZodNumber;
+}, z.core.$strict>;
+export type MemoryEffectArmV1 = z.infer<typeof MemoryEffectArmV1>;
+export declare const MemoryEffectComparisonV1: z.ZodObject<{
+    used_arm: z.ZodObject<{
+        run_ids: z.ZodArray<z.ZodString>;
+        size: z.ZodNumber;
+        complete_count: z.ZodNumber;
+        adverse_count: z.ZodNumber;
+        neutral_count: z.ZodNumber;
+        outcome_counts: z.ZodArray<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                complete: "complete";
+                handoff: "handoff";
+                failed: "failed";
+                blocked: "blocked";
+                needs_attention: "needs_attention";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+        complete_rate: z.ZodNumber;
+        adverse_rate: z.ZodNumber;
+    }, z.core.$strict>;
+    comparable_arm: z.ZodObject<{
+        run_ids: z.ZodArray<z.ZodString>;
+        size: z.ZodNumber;
+        complete_count: z.ZodNumber;
+        adverse_count: z.ZodNumber;
+        neutral_count: z.ZodNumber;
+        outcome_counts: z.ZodArray<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                complete: "complete";
+                handoff: "handoff";
+                failed: "failed";
+                blocked: "blocked";
+                needs_attention: "needs_attention";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+        complete_rate: z.ZodNumber;
+        adverse_rate: z.ZodNumber;
+    }, z.core.$strict>;
+    complete_rate_delta: z.ZodNumber;
+    adverse_rate_delta: z.ZodNumber;
+    effect_status: z.ZodEnum<{
+        not_enough_data: "not_enough_data";
+        correlated_positive: "correlated_positive";
+        correlated_negative: "correlated_negative";
+        unresolved: "unresolved";
+    }>;
+    effect_note: z.ZodString;
+}, z.core.$strict>;
+export type MemoryEffectComparisonV1 = z.infer<typeof MemoryEffectComparisonV1>;
+export declare const MemoryEffectItemV1: z.ZodObject<{
+    content_id: z.ZodNullable<z.ZodString>;
+    group_key: z.ZodString;
+    flow_id: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        repo: "repo";
+        user: "user";
+        prior_run: "prior_run";
+        continuity: "continuity";
+        handoff_brief: "handoff_brief";
+    }>>;
+    source_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>>;
+    comparison: z.ZodObject<{
+        used_arm: z.ZodObject<{
+            run_ids: z.ZodArray<z.ZodString>;
+            size: z.ZodNumber;
+            complete_count: z.ZodNumber;
+            adverse_count: z.ZodNumber;
+            neutral_count: z.ZodNumber;
+            outcome_counts: z.ZodArray<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    complete: "complete";
+                    handoff: "handoff";
+                    failed: "failed";
+                    blocked: "blocked";
+                    needs_attention: "needs_attention";
+                }>;
+                count: z.ZodNumber;
+            }, z.core.$strict>>;
+            complete_rate: z.ZodNumber;
+            adverse_rate: z.ZodNumber;
+        }, z.core.$strict>;
+        comparable_arm: z.ZodObject<{
+            run_ids: z.ZodArray<z.ZodString>;
+            size: z.ZodNumber;
+            complete_count: z.ZodNumber;
+            adverse_count: z.ZodNumber;
+            neutral_count: z.ZodNumber;
+            outcome_counts: z.ZodArray<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    complete: "complete";
+                    handoff: "handoff";
+                    failed: "failed";
+                    blocked: "blocked";
+                    needs_attention: "needs_attention";
+                }>;
+                count: z.ZodNumber;
+            }, z.core.$strict>>;
+            complete_rate: z.ZodNumber;
+            adverse_rate: z.ZodNumber;
+        }, z.core.$strict>;
+        complete_rate_delta: z.ZodNumber;
+        adverse_rate_delta: z.ZodNumber;
+        effect_status: z.ZodEnum<{
+            not_enough_data: "not_enough_data";
+            correlated_positive: "correlated_positive";
+            correlated_negative: "correlated_negative";
+            unresolved: "unresolved";
+        }>;
+        effect_note: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type MemoryEffectItemV1 = z.infer<typeof MemoryEffectItemV1>;
+export declare const MemoryFlowContrastV1: z.ZodObject<{
+    flow_id: z.ZodString;
+    comparison: z.ZodObject<{
+        used_arm: z.ZodObject<{
+            run_ids: z.ZodArray<z.ZodString>;
+            size: z.ZodNumber;
+            complete_count: z.ZodNumber;
+            adverse_count: z.ZodNumber;
+            neutral_count: z.ZodNumber;
+            outcome_counts: z.ZodArray<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    complete: "complete";
+                    handoff: "handoff";
+                    failed: "failed";
+                    blocked: "blocked";
+                    needs_attention: "needs_attention";
+                }>;
+                count: z.ZodNumber;
+            }, z.core.$strict>>;
+            complete_rate: z.ZodNumber;
+            adverse_rate: z.ZodNumber;
+        }, z.core.$strict>;
+        comparable_arm: z.ZodObject<{
+            run_ids: z.ZodArray<z.ZodString>;
+            size: z.ZodNumber;
+            complete_count: z.ZodNumber;
+            adverse_count: z.ZodNumber;
+            neutral_count: z.ZodNumber;
+            outcome_counts: z.ZodArray<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    complete: "complete";
+                    handoff: "handoff";
+                    failed: "failed";
+                    blocked: "blocked";
+                    needs_attention: "needs_attention";
+                }>;
+                count: z.ZodNumber;
+            }, z.core.$strict>>;
+            complete_rate: z.ZodNumber;
+            adverse_rate: z.ZodNumber;
+        }, z.core.$strict>;
+        complete_rate_delta: z.ZodNumber;
+        adverse_rate_delta: z.ZodNumber;
+        effect_status: z.ZodEnum<{
+            not_enough_data: "not_enough_data";
+            correlated_positive: "correlated_positive";
+            correlated_negative: "correlated_negative";
+            unresolved: "unresolved";
+        }>;
+        effect_note: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type MemoryFlowContrastV1 = z.infer<typeof MemoryFlowContrastV1>;
+export declare const MemoryEffectSummaryV1: z.ZodObject<{
+    items_total: z.ZodNumber;
+    items_not_enough_data: z.ZodNumber;
+    items_unresolved: z.ZodNumber;
+    items_correlated_positive: z.ZodNumber;
+    items_correlated_negative: z.ZodNumber;
+    flow_contrasts_total: z.ZodNumber;
+    flow_contrasts_not_enough_data: z.ZodNumber;
+    flow_contrasts_unresolved: z.ZodNumber;
+    flow_contrasts_correlated_positive: z.ZodNumber;
+    flow_contrasts_correlated_negative: z.ZodNumber;
+}, z.core.$strict>;
+export type MemoryEffectSummaryV1 = z.infer<typeof MemoryEffectSummaryV1>;
+export declare const HistoryMemoryEffectV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-memory-effect-v1">;
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodISODateTime;
+    runs_base: z.ZodString;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    min_arm_size: z.ZodNumber;
+    margin: z.ZodNumber;
+    source_run_count: z.ZodNumber;
+    source_envelope_count: z.ZodNumber;
+    source_memory_run_count: z.ZodNumber;
+    item_effects: z.ZodArray<z.ZodObject<{
+        content_id: z.ZodNullable<z.ZodString>;
+        group_key: z.ZodString;
+        flow_id: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            project: "project";
+            repo: "repo";
+            user: "user";
+            prior_run: "prior_run";
+            continuity: "continuity";
+            handoff_brief: "handoff_brief";
+        }>>;
+        source_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>>;
+        comparison: z.ZodObject<{
+            used_arm: z.ZodObject<{
+                run_ids: z.ZodArray<z.ZodString>;
+                size: z.ZodNumber;
+                complete_count: z.ZodNumber;
+                adverse_count: z.ZodNumber;
+                neutral_count: z.ZodNumber;
+                outcome_counts: z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        complete: "complete";
+                        handoff: "handoff";
+                        failed: "failed";
+                        blocked: "blocked";
+                        needs_attention: "needs_attention";
+                    }>;
+                    count: z.ZodNumber;
+                }, z.core.$strict>>;
+                complete_rate: z.ZodNumber;
+                adverse_rate: z.ZodNumber;
+            }, z.core.$strict>;
+            comparable_arm: z.ZodObject<{
+                run_ids: z.ZodArray<z.ZodString>;
+                size: z.ZodNumber;
+                complete_count: z.ZodNumber;
+                adverse_count: z.ZodNumber;
+                neutral_count: z.ZodNumber;
+                outcome_counts: z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        complete: "complete";
+                        handoff: "handoff";
+                        failed: "failed";
+                        blocked: "blocked";
+                        needs_attention: "needs_attention";
+                    }>;
+                    count: z.ZodNumber;
+                }, z.core.$strict>>;
+                complete_rate: z.ZodNumber;
+                adverse_rate: z.ZodNumber;
+            }, z.core.$strict>;
+            complete_rate_delta: z.ZodNumber;
+            adverse_rate_delta: z.ZodNumber;
+            effect_status: z.ZodEnum<{
+                not_enough_data: "not_enough_data";
+                correlated_positive: "correlated_positive";
+                correlated_negative: "correlated_negative";
+                unresolved: "unresolved";
+            }>;
+            effect_note: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    flow_contrasts: z.ZodArray<z.ZodObject<{
+        flow_id: z.ZodString;
+        comparison: z.ZodObject<{
+            used_arm: z.ZodObject<{
+                run_ids: z.ZodArray<z.ZodString>;
+                size: z.ZodNumber;
+                complete_count: z.ZodNumber;
+                adverse_count: z.ZodNumber;
+                neutral_count: z.ZodNumber;
+                outcome_counts: z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        complete: "complete";
+                        handoff: "handoff";
+                        failed: "failed";
+                        blocked: "blocked";
+                        needs_attention: "needs_attention";
+                    }>;
+                    count: z.ZodNumber;
+                }, z.core.$strict>>;
+                complete_rate: z.ZodNumber;
+                adverse_rate: z.ZodNumber;
+            }, z.core.$strict>;
+            comparable_arm: z.ZodObject<{
+                run_ids: z.ZodArray<z.ZodString>;
+                size: z.ZodNumber;
+                complete_count: z.ZodNumber;
+                adverse_count: z.ZodNumber;
+                neutral_count: z.ZodNumber;
+                outcome_counts: z.ZodArray<z.ZodObject<{
+                    outcome: z.ZodEnum<{
+                        complete: "complete";
+                        handoff: "handoff";
+                        failed: "failed";
+                        blocked: "blocked";
+                        needs_attention: "needs_attention";
+                    }>;
+                    count: z.ZodNumber;
+                }, z.core.$strict>>;
+                complete_rate: z.ZodNumber;
+                adverse_rate: z.ZodNumber;
+            }, z.core.$strict>;
+            complete_rate_delta: z.ZodNumber;
+            adverse_rate_delta: z.ZodNumber;
+            effect_status: z.ZodEnum<{
+                not_enough_data: "not_enough_data";
+                correlated_positive: "correlated_positive";
+                correlated_negative: "correlated_negative";
+                unresolved: "unresolved";
+            }>;
+            effect_note: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    summary: z.ZodObject<{
+        items_total: z.ZodNumber;
+        items_not_enough_data: z.ZodNumber;
+        items_unresolved: z.ZodNumber;
+        items_correlated_positive: z.ZodNumber;
+        items_correlated_negative: z.ZodNumber;
+        flow_contrasts_total: z.ZodNumber;
+        flow_contrasts_not_enough_data: z.ZodNumber;
+        flow_contrasts_unresolved: z.ZodNumber;
+        flow_contrasts_correlated_positive: z.ZodNumber;
+        flow_contrasts_correlated_negative: z.ZodNumber;
+    }, z.core.$strict>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryMemoryEffectV1 = z.infer<typeof HistoryMemoryEffectV1>;
+export declare const RecallPrecisionTierV1: z.ZodEnum<{
+    stale: "stale";
+    suppressed: "suppressed";
+    positive_fresh: "positive_fresh";
+    neutral_fresh: "neutral_fresh";
+}>;
+export type RecallPrecisionTierV1 = z.infer<typeof RecallPrecisionTierV1>;
+export declare const RecallPrecisionConsultedStatusV1: z.ZodUnion<readonly [z.ZodEnum<{
+    not_enough_data: "not_enough_data";
+    correlated_positive: "correlated_positive";
+    correlated_negative: "correlated_negative";
+    unresolved: "unresolved";
+}>, z.ZodLiteral<"no_verdict">]>;
+export type RecallPrecisionConsultedStatusV1 = z.infer<typeof RecallPrecisionConsultedStatusV1>;
+export declare const RecallPrecisionDecisionV1: z.ZodObject<{
+    memory_input_id: z.ZodString;
+    content_id: z.ZodNullable<z.ZodString>;
+    staleness: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    consulted_effect_status: z.ZodUnion<readonly [z.ZodEnum<{
+        not_enough_data: "not_enough_data";
+        correlated_positive: "correlated_positive";
+        correlated_negative: "correlated_negative";
+        unresolved: "unresolved";
+    }>, z.ZodLiteral<"no_verdict">]>;
+    tier: z.ZodEnum<{
+        stale: "stale";
+        suppressed: "suppressed";
+        positive_fresh: "positive_fresh";
+        neutral_fresh: "neutral_fresh";
+    }>;
+    injected: z.ZodBoolean;
+}, z.core.$strict>;
+export type RecallPrecisionDecisionV1 = z.infer<typeof RecallPrecisionDecisionV1>;
+export declare const HistoryRecallPrecisionV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-recall-precision-v1">;
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodISODateTime;
+    flow_id: z.ZodOptional<z.ZodString>;
+    effect_report_available: z.ZodBoolean;
+    effect_report_generated_at: z.ZodOptional<z.ZodISODateTime>;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    budget: z.ZodNumber;
+    indicator: z.ZodString;
+    decisions: z.ZodArray<z.ZodObject<{
+        memory_input_id: z.ZodString;
+        content_id: z.ZodNullable<z.ZodString>;
+        staleness: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        consulted_effect_status: z.ZodUnion<readonly [z.ZodEnum<{
+            not_enough_data: "not_enough_data";
+            correlated_positive: "correlated_positive";
+            correlated_negative: "correlated_negative";
+            unresolved: "unresolved";
+        }>, z.ZodLiteral<"no_verdict">]>;
+        tier: z.ZodEnum<{
+            stale: "stale";
+            suppressed: "suppressed";
+            positive_fresh: "positive_fresh";
+            neutral_fresh: "neutral_fresh";
+        }>;
+        injected: z.ZodBoolean;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryRecallPrecisionV1 = z.infer<typeof HistoryRecallPrecisionV1>;
+export declare const PullLogResultV1: z.ZodObject<{
+    memory_input_id: z.ZodString;
+    content_id: z.ZodNullable<z.ZodString>;
+    staleness: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    source_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 PullLogResultV1 = z.infer<typeof PullLogResultV1>;
+export declare const PullLogEntryV1: z.ZodObject<{
+    pull_id: z.ZodString;
+    recorded_at: z.ZodISODateTime;
+    decision_point: z.ZodString;
+    query: z.ZodString;
+    flow_id: z.ZodString;
+    result_count: z.ZodNumber;
+    suppressed_count: z.ZodNumber;
+    effect_report_available: z.ZodBoolean;
+    effect_report_generated_at: z.ZodOptional<z.ZodISODateTime>;
+    results: z.ZodArray<z.ZodObject<{
+        memory_input_id: z.ZodString;
+        content_id: z.ZodNullable<z.ZodString>;
+        staleness: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        source_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>>;
+    authority: z.ZodLiteral<"hint_only">;
+}, z.core.$strict>;
+export type PullLogEntryV1 = z.infer<typeof PullLogEntryV1>;
+export declare const HistoryPullLogV1: z.ZodObject<{
+    api_version: z.ZodLiteral<"history-pull-log-v1">;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.ZodOptional<z.ZodString>;
+    authority_notice: z.ZodLiteral<"History results are hint-only prior-run context. They cannot satisfy current proof, checkpoint, policy, route, recovery, verification, or write authority.">;
+    entries: z.ZodArray<z.ZodObject<{
+        pull_id: z.ZodString;
+        recorded_at: z.ZodISODateTime;
+        decision_point: z.ZodString;
+        query: z.ZodString;
+        flow_id: z.ZodString;
+        result_count: z.ZodNumber;
+        suppressed_count: z.ZodNumber;
+        effect_report_available: z.ZodBoolean;
+        effect_report_generated_at: z.ZodOptional<z.ZodISODateTime>;
+        results: z.ZodArray<z.ZodObject<{
+            memory_input_id: z.ZodString;
+            content_id: z.ZodNullable<z.ZodString>;
+            staleness: z.ZodEnum<{
+                unknown: "unknown";
+                fresh: "fresh";
+                stale: "stale";
+            }>;
+            source_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>>;
+        authority: z.ZodLiteral<"hint_only">;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            run_skipped: "run_skipped";
+            report_skipped: "report_skipped";
+            trace_skipped: "trace_skipped";
+            source_unreadable: "source_unreadable";
+            source_invalid: "source_invalid";
+            source_pruned: "source_pruned";
+            envelope_missing: "envelope_missing";
+            recall_report_missing: "recall_report_missing";
+            memory_input_unmatched: "memory_input_unmatched";
+            content_id_unhashed_source: "content_id_unhashed_source";
+            effect_report_unavailable: "effect_report_unavailable";
+            pull_log_unavailable: "pull_log_unavailable";
+        }>;
+        message: z.ZodString;
+        run_folder: z.ZodOptional<z.ZodString>;
+        source_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HistoryPullLogV1 = z.infer<typeof HistoryPullLogV1>;
+//# sourceMappingURL=history.d.ts.map