synorch 0.2.0 → 0.4.0-beta.0

package/dist/harness/contracts/jsonl.d.ts

@@ -0,0 +1,3386 @@
+import { z } from "zod";
+/**
+ * Machine mode (`--mode jsonl`, alias `--json` on runtime commands). stdout carries only these
+ * frames, one per line, separated by a single LF; everything human goes to stderr. The first frame
+ * is `hello`, the last is exactly one `result` or `error`. Frames are one-way: approvals and steering
+ * over stdin belong to a separate RPC mode that is out of scope for v1.
+ */
+export declare const JSONL_PROTOCOL: "synorch.jsonl";
+export declare const JSONL_SCHEMA_VERSION: 1;
+export declare const jsonlFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    data: z.ZodObject<{
+        protocol: z.ZodLiteral<"synorch.jsonl">;
+        harness_version: z.ZodString;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        policy_mode: z.ZodEnum<{
+            autonomous: "autonomous";
+            ask: "ask";
+        }>;
+        stream_deltas: z.ZodBoolean;
+    }, z.core.$strict>;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    seq: z.ZodInt;
+    timestamp: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"event">;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"session/opened">;
+        data: z.ZodObject<{
+            writer: z.ZodObject<{
+                name: z.ZodLiteral<"synorch">;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            project_id: z.core.$ZodBranded<z.ZodString, "ProjectId", "out">;
+            workspace_root: z.ZodString;
+            cwd: z.ZodString;
+            platform: z.ZodEnum<{
+                darwin: "darwin";
+                linux: "linux";
+                win32: "win32";
+                other: "other";
+            }>;
+            git: z.ZodNullable<z.ZodObject<{
+                branch: z.ZodOptional<z.ZodString>;
+                head: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            policy_mode: z.ZodEnum<{
+                autonomous: "autonomous";
+                ask: "ask";
+            }>;
+            parent: z.ZodOptional<z.ZodObject<{
+                session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+                up_to_seq: z.ZodInt;
+            }, z.core.$strict>>;
+            config_ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                layer: z.ZodEnum<{
+                    workspace: "workspace";
+                    project: "project";
+                }>;
+                path: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"session/resumed">;
+        data: z.ZodObject<{
+            previous_last_seq: z.ZodInt;
+            recovered: z.ZodArray<z.ZodObject<{
+                machine: z.ZodEnum<{
+                    run: "run";
+                    task: "task";
+                    step: "step";
+                    attempt: "attempt";
+                    toolCall: "toolCall";
+                    approval: "approval";
+                }>;
+                id: z.ZodString;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>>;
+            torn_tail: z.ZodOptional<z.ZodObject<{
+                segment: z.ZodInt;
+                bytes: z.ZodInt;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"session/closed">;
+        data: z.ZodObject<{
+            reason: z.ZodEnum<{
+                error: "error";
+                completed: "completed";
+                user: "user";
+                signal: "signal";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"run/created">;
+        data: z.ZodObject<{
+            goal: z.ZodString;
+            policy_mode: z.ZodEnum<{
+                autonomous: "autonomous";
+                ask: "ask";
+            }>;
+            headless: z.ZodBoolean;
+            budget: z.ZodObject<{
+                max_wall_time_seconds: z.ZodOptional<z.ZodInt>;
+                max_cost_usd: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"run/state_changed">;
+        data: z.ZodObject<{
+            from: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                created: "created";
+                cancelled: "cancelled";
+                running: "running";
+                waiting_for_approval: "waiting_for_approval";
+                interrupted: "interrupted";
+            }>;
+            to: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                created: "created";
+                cancelled: "cancelled";
+                running: "running";
+                waiting_for_approval: "waiting_for_approval";
+                interrupted: "interrupted";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"policy/snapshot">;
+        data: z.ZodObject<{
+            policy: z.ZodObject<{
+                schema_version: z.ZodLiteral<1>;
+                policy_version: z.ZodInt;
+                mode: z.ZodEnum<{
+                    autonomous: "autonomous";
+                    ask: "ask";
+                }>;
+                role: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    explorer: "explorer";
+                    implementer: "implementer";
+                    debugger: "debugger";
+                    reviewer: "reviewer";
+                    session: "session";
+                }>;
+                run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+                task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+                workspace_root: z.ZodString;
+                write_scope: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                read_scope: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                forbidden: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                effects: z.ZodObject<{
+                    "network-read": z.ZodDefault<z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>>;
+                    read: z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    "workspace-write": z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    exec: z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    "external-write": z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    control: z.ZodEnum<{
+                        ask: "ask";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                }, z.core.$strict>;
+                external_write_allowlist: z.ZodArray<z.ZodString>;
+                network: z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        allowlist: "allowlist";
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    hosts: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                sandbox: z.ZodObject<{
+                    backend: z.ZodString;
+                    enforcement: z.ZodEnum<{
+                        partial: "partial";
+                        full: "full";
+                        unavailable: "unavailable";
+                    }>;
+                }, z.core.$strict>;
+                require_full_sandbox: z.ZodBoolean;
+                exec_confinement: z.ZodOptional<z.ZodEnum<{
+                    ask: "ask";
+                    "full-sandbox": "full-sandbox";
+                    allowlist: "allowlist";
+                }>>;
+                verification_commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                workspace_trusted: z.ZodOptional<z.ZodBoolean>;
+                dependency_links: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                command_grants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                permission_mode: z.ZodOptional<z.ZodEnum<{
+                    plan: "plan";
+                    ask: "ask";
+                    auto: "auto";
+                    full: "full";
+                }>>;
+                layers: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodEnum<{
+                        workspace: "workspace";
+                        role: "role";
+                        task: "task";
+                        approval: "approval";
+                        user: "user";
+                        platform: "platform";
+                        sandbox: "sandbox";
+                    }>;
+                    source: z.ZodString;
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"route/decided">;
+        data: z.ZodObject<{
+            decision: z.ZodObject<{
+                tier: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    complex_worker: "complex_worker";
+                    fast_worker: "fast_worker";
+                    session: "session";
+                }>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    explorer: "explorer";
+                    implementer: "implementer";
+                    debugger: "debugger";
+                    reviewer: "reviewer";
+                    session: "session";
+                }>>;
+                route: z.ZodObject<{
+                    provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+                    model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+                    adapter_id: z.ZodString;
+                    adapter_kind: z.ZodEnum<{
+                        model: "model";
+                        "agent-backend": "agent-backend";
+                    }>;
+                    auth_method: z.ZodEnum<{
+                        "oauth-subscription": "oauth-subscription";
+                        "cli-bridge": "cli-bridge";
+                        "api-key": "api-key";
+                    }>;
+                    profile: z.ZodString;
+                    tier: z.ZodOptional<z.ZodEnum<{
+                        orchestrator: "orchestrator";
+                        complex_worker: "complex_worker";
+                        fast_worker: "fast_worker";
+                        session: "session";
+                    }>>;
+                }, z.core.$strict>;
+                source: z.ZodEnum<{
+                    workspace: "workspace";
+                    project: "project";
+                    session: "session";
+                    user: "user";
+                    "provider-default": "provider-default";
+                }>;
+                reason: z.ZodString;
+                capabilities_probed_at: z.ZodOptional<z.ZodISODateTime>;
+                fallback: z.ZodObject<{
+                    used: z.ZodBoolean;
+                    from: z.ZodOptional<z.ZodObject<{
+                        provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+                        model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+                        adapter_id: z.ZodString;
+                        adapter_kind: z.ZodEnum<{
+                            model: "model";
+                            "agent-backend": "agent-backend";
+                        }>;
+                        auth_method: z.ZodEnum<{
+                            "oauth-subscription": "oauth-subscription";
+                            "cli-bridge": "cli-bridge";
+                            "api-key": "api-key";
+                        }>;
+                        profile: z.ZodString;
+                        tier: z.ZodOptional<z.ZodEnum<{
+                            orchestrator: "orchestrator";
+                            complex_worker: "complex_worker";
+                            fast_worker: "fast_worker";
+                            session: "session";
+                        }>>;
+                    }, z.core.$strict>>;
+                    approval_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"plan/proposed">;
+        data: z.ZodObject<{
+            plan: z.ZodObject<{
+                created_at: z.ZodISODateTime;
+                goal: z.ZodString;
+                risk: z.ZodEnum<{
+                    trivial: "trivial";
+                    standard: "standard";
+                    "high-risk": "high-risk";
+                }>;
+                scope: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                tasks: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    role: z.ZodEnum<{
+                        explorer: "explorer";
+                        implementer: "implementer";
+                        debugger: "debugger";
+                        reviewer: "reviewer";
+                    }>;
+                    objective: z.ZodString;
+                    depends_on: z.ZodArray<z.ZodString>;
+                    owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    read_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    risk: z.ZodEnum<{
+                        trivial: "trivial";
+                        standard: "standard";
+                        "high-risk": "high-risk";
+                    }>;
+                    model_tier: z.ZodEnum<{
+                        orchestrator: "orchestrator";
+                        complex_worker: "complex_worker";
+                        fast_worker: "fast_worker";
+                    }>;
+                    effort: z.ZodOptional<z.ZodEnum<{
+                        low: "low";
+                        medium: "medium";
+                        high: "high";
+                        xhigh: "xhigh";
+                        max: "max";
+                        ultra: "ultra";
+                    }>>;
+                    agent: z.ZodOptional<z.ZodString>;
+                    acceptance_criteria: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        statement: z.ZodString;
+                    }, z.core.$strict>>;
+                    verification: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                expected_external_effects: z.ZodArray<z.ZodString>;
+                verification: z.ZodArray<z.ZodString>;
+                budget: z.ZodObject<{
+                    max_wall_time_seconds: z.ZodInt;
+                    max_steps: z.ZodInt;
+                    max_cost_usd: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                assumptions: z.ZodArray<z.ZodString>;
+                schema_version: z.ZodLiteral<1>;
+                plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+                run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+                version: z.ZodInt;
+            }, z.core.$strict>;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"plan/state_changed">;
+        data: z.ZodObject<{
+            approval_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">>;
+            from: z.ZodEnum<{
+                proposed: "proposed";
+                rejected: "rejected";
+                superseded: "superseded";
+                invalidated: "invalidated";
+                draft: "draft";
+                approved: "approved";
+            }>;
+            to: z.ZodEnum<{
+                proposed: "proposed";
+                rejected: "rejected";
+                superseded: "superseded";
+                invalidated: "invalidated";
+                draft: "draft";
+                approved: "approved";
+            }>;
+            reason: z.ZodString;
+            plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"approval/requested">;
+        data: z.ZodObject<{
+            request: z.ZodObject<{
+                approval_id: z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">;
+                run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+                task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+                subject_kind: z.ZodEnum<{
+                    plan: "plan";
+                    memory: "memory";
+                    budget: "budget";
+                    action: "action";
+                    "scope-expansion": "scope-expansion";
+                    "provider-change": "provider-change";
+                    "workspace-trust": "workspace-trust";
+                }>;
+                subject_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                summary: z.ZodString;
+                effect: z.ZodOptional<z.ZodEnum<{
+                    read: "read";
+                    "workspace-write": "workspace-write";
+                    exec: "exec";
+                    "external-write": "external-write";
+                    control: "control";
+                    "network-read": "network-read";
+                }>>;
+                scope: z.ZodEnum<{
+                    plan: "plan";
+                    session: "session";
+                    once: "once";
+                }>;
+                command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                details: z.ZodOptional<z.ZodObject<{
+                    why: z.ZodString;
+                    consequence: z.ZodString;
+                }, z.core.$strict>>;
+                requested_at: z.ZodISODateTime;
+                expires_at: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"approval/decided">;
+        data: z.ZodObject<{
+            decision: z.ZodObject<{
+                approval_id: z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">;
+                subject_kind: z.ZodEnum<{
+                    plan: "plan";
+                    memory: "memory";
+                    budget: "budget";
+                    action: "action";
+                    "scope-expansion": "scope-expansion";
+                    "provider-change": "provider-change";
+                    "workspace-trust": "workspace-trust";
+                }>;
+                subject_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                outcome: z.ZodEnum<{
+                    expired: "expired";
+                    cancelled: "cancelled";
+                    unavailable: "unavailable";
+                    "allowed-once": "allowed-once";
+                    "allowed-for-scope": "allowed-for-scope";
+                    rejected: "rejected";
+                }>;
+                decided_by: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    session: "session";
+                    user: "user";
+                    config: "config";
+                    broker: "broker";
+                }>;
+                mode: z.ZodEnum<{
+                    autonomous: "autonomous";
+                    ask: "ask";
+                }>;
+                decided_at: z.ZodISODateTime;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"approval/invalidated">;
+        data: z.ZodObject<{
+            approval_id: z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">;
+            reason: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/created">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            plan_id: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+            key: z.ZodString;
+            role: z.ZodEnum<{
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+            }>;
+            depends_on: z.ZodArray<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+            owned_paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            risk: z.ZodEnum<{
+                trivial: "trivial";
+                standard: "standard";
+                "high-risk": "high-risk";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/state_changed">;
+        data: z.ZodObject<{
+            from: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                cancelled: "cancelled";
+                running: "running";
+                interrupted: "interrupted";
+                draft: "draft";
+                awaiting_approval: "awaiting_approval";
+                ready: "ready";
+                retry_pending: "retry_pending";
+                verifying: "verifying";
+                reviewing: "reviewing";
+                changes_requested: "changes_requested";
+            }>;
+            to: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                cancelled: "cancelled";
+                running: "running";
+                interrupted: "interrupted";
+                draft: "draft";
+                awaiting_approval: "awaiting_approval";
+                ready: "ready";
+                retry_pending: "retry_pending";
+                verifying: "verifying";
+                reviewing: "reviewing";
+                changes_requested: "changes_requested";
+            }>;
+            reason: z.ZodString;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/delegated">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            key: z.ZodString;
+            role: z.ZodEnum<{
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+            }>;
+            provider_id: z.ZodString;
+            model_id: z.ZodString;
+            objective: z.ZodString;
+            attempt: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/user_message">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            text: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/user_control">;
+        data: z.ZodObject<{
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            action: z.ZodEnum<{
+                pause: "pause";
+                resume: "resume";
+                cancel: "cancel";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/packet_issued">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            kind: z.ZodEnum<{
+                full: "full";
+                delta: "delta";
+            }>;
+            packet_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            blob: z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/started">;
+        data: z.ZodObject<{
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            role: z.ZodEnum<{
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+            }>;
+            route: z.ZodObject<{
+                provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+                model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+                adapter_id: z.ZodString;
+                adapter_kind: z.ZodEnum<{
+                    model: "model";
+                    "agent-backend": "agent-backend";
+                }>;
+                auth_method: z.ZodEnum<{
+                    "oauth-subscription": "oauth-subscription";
+                    "cli-bridge": "cli-bridge";
+                    "api-key": "api-key";
+                }>;
+                profile: z.ZodString;
+                tier: z.ZodOptional<z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    complex_worker: "complex_worker";
+                    fast_worker: "fast_worker";
+                    session: "session";
+                }>>;
+            }, z.core.$strict>;
+            packet_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            isolation: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    worktree: "worktree";
+                    "scoped-dir": "scoped-dir";
+                    "shared-read-only": "shared-read-only";
+                }>;
+                path: z.ZodOptional<z.ZodString>;
+                base_commit: z.ZodOptional<z.ZodString>;
+                reused: z.ZodOptional<z.ZodBoolean>;
+                fallback: z.ZodOptional<z.ZodObject<{
+                    from: z.ZodLiteral<"worktree">;
+                    reason: z.ZodEnum<{
+                        "worktree-create-failed": "worktree-create-failed";
+                        "path-too-long": "path-too-long";
+                        "git-unavailable": "git-unavailable";
+                    }>;
+                    detail: z.ZodString;
+                }, z.core.$strict>>;
+                overlaid: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                dependency_links: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                submodules: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            }, z.core.$strict>;
+            session_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SessionId", "out">>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/state_changed">;
+        data: z.ZodObject<{
+            from: z.ZodEnum<{
+                failed: "failed";
+                cancelled: "cancelled";
+                running: "running";
+                waiting_for_approval: "waiting_for_approval";
+                interrupted: "interrupted";
+                queued: "queued";
+                succeeded: "succeeded";
+            }>;
+            to: z.ZodEnum<{
+                failed: "failed";
+                cancelled: "cancelled";
+                running: "running";
+                waiting_for_approval: "waiting_for_approval";
+                interrupted: "interrupted";
+                queued: "queued";
+                succeeded: "succeeded";
+            }>;
+            reason: z.ZodString;
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/completion_recorded">;
+        data: z.ZodObject<{
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            status: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                partial: "partial";
+            }>;
+            completion_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            blob: z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/verification_ran">;
+        data: z.ZodObject<{
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            ordinal: z.ZodInt;
+            command: z.ZodString;
+            argv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            command_class: z.ZodOptional<z.ZodEnum<{
+                other: "other";
+                "build-test": "build-test";
+                "read-only": "read-only";
+            }>>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                "not-run": "not-run";
+            }>;
+            termination: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                timeout: "timeout";
+                exited: "exited";
+                "spawn-failed": "spawn-failed";
+            }>>;
+            exit_code: z.ZodNullable<z.ZodInt>;
+            duration_ms: z.ZodInt;
+            output_excerpt: z.ZodString;
+            output_blob: z.ZodOptional<z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>>;
+            artifact_digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"attempt/repair_requested">;
+        data: z.ZodObject<{
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            kind: z.ZodEnum<{
+                "evidence-repair": "evidence-repair";
+                "verification-repair": "verification-repair";
+            }>;
+            round: z.ZodInt;
+            budget: z.ZodInt;
+            problems: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"task/integrated">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            artifact_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            paths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"review/recorded">;
+        data: z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            reviewer_attempt_id: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+            review_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            decision: z.ZodEnum<{
+                accept: "accept";
+                revise: "revise";
+                block: "block";
+            }>;
+            blob: z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"turn/started">;
+        data: z.ZodObject<{
+            turn_id: z.core.$ZodBranded<z.ZodString, "TurnId", "out">;
+            trigger: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                user: "user";
+                steer: "steer";
+                "follow-up": "follow-up";
+                dispatch: "dispatch";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"turn/ended">;
+        data: z.ZodObject<{
+            turn_id: z.core.$ZodBranded<z.ZodString, "TurnId", "out">;
+            outcome: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                budget_exceeded: "budget_exceeded";
+                max_steps: "max_steps";
+                awaiting_approval: "awaiting_approval";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"step/started">;
+        data: z.ZodObject<{
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            turn_id: z.core.$ZodBranded<z.ZodString, "TurnId", "out">;
+            request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"step/ended">;
+        data: z.ZodObject<{
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            state: z.ZodEnum<{
+                settled: "settled";
+                aborted: "aborted";
+                errored: "errored";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"message/recorded">;
+        data: z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                tool: "tool";
+            }>;
+            request_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
+            message: z.ZodOptional<z.ZodObject<{
+                role: z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                    tool: "tool";
+                }>;
+                content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"thinking">;
+                    text: z.ZodString;
+                    opaque: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_call">;
+                    provider_call_id: z.ZodString;
+                    tool_call_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">>;
+                    name: z.ZodString;
+                    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"tool_result">;
+                    tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+                    provider_call_id: z.ZodString;
+                    is_error: z.ZodBoolean;
+                    text: z.ZodString;
+                    blob: z.ZodOptional<z.ZodObject<{
+                        digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                        size_bytes: z.ZodInt;
+                        media_type: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"blob">;
+                    blob: z.ZodObject<{
+                        digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                        size_bytes: z.ZodInt;
+                        media_type: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    blob: z.ZodObject<{
+                        digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                        media_type: z.ZodEnum<{
+                            "image/png": "image/png";
+                            "image/jpeg": "image/jpeg";
+                            "image/gif": "image/gif";
+                            "image/webp": "image/webp";
+                        }>;
+                        size_bytes: z.ZodInt;
+                    }, z.core.$strict>;
+                    data: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>], "type">>;
+            }, z.core.$strict>>;
+            blob: z.ZodOptional<z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"model/request_prepared">;
+        data: z.ZodObject<{
+            request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+            step_id: z.core.$ZodBranded<z.ZodString, "StepId", "out">;
+            route: z.ZodObject<{
+                provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+                model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+                adapter_id: z.ZodString;
+                adapter_kind: z.ZodEnum<{
+                    model: "model";
+                    "agent-backend": "agent-backend";
+                }>;
+                auth_method: z.ZodEnum<{
+                    "oauth-subscription": "oauth-subscription";
+                    "cli-bridge": "cli-bridge";
+                    "api-key": "api-key";
+                }>;
+                profile: z.ZodString;
+                tier: z.ZodOptional<z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    complex_worker: "complex_worker";
+                    fast_worker: "fast_worker";
+                    session: "session";
+                }>>;
+            }, z.core.$strict>;
+            envelope_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            envelope_blob: z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>;
+            tool_set_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+                ultra: "ultra";
+            }>>;
+            context: z.ZodArray<z.ZodObject<{
+                block_id: z.ZodString;
+                source: z.ZodEnum<{
+                    skill: "skill";
+                    role: "role";
+                    constitution: "constitution";
+                    protocol: "protocol";
+                    harness: "harness";
+                    memory: "memory";
+                    "skill-catalog": "skill-catalog";
+                    packet: "packet";
+                    compaction: "compaction";
+                    history: "history";
+                    "tool-result": "tool-result";
+                }>;
+                trust: z.ZodEnum<{
+                    project: "project";
+                    harness: "harness";
+                    untrusted: "untrusted";
+                }>;
+                tokens_estimate: z.ZodInt;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"model/response_settled">;
+        data: z.ZodObject<{
+            request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+            stop_reason: z.ZodEnum<{
+                length: "length";
+                stop: "stop";
+                tool_use: "tool_use";
+            }>;
+            usage: z.ZodOptional<z.ZodObject<{
+                input_tokens: z.ZodOptional<z.ZodInt>;
+                output_tokens: z.ZodOptional<z.ZodInt>;
+                cache_read_tokens: z.ZodOptional<z.ZodInt>;
+                cache_write_tokens: z.ZodOptional<z.ZodInt>;
+                reasoning_tokens: z.ZodOptional<z.ZodInt>;
+                cost_usd_estimate: z.ZodOptional<z.ZodNumber>;
+                source: z.ZodEnum<{
+                    unknown: "unknown";
+                    "provider-reported": "provider-reported";
+                    "adapter-estimated": "adapter-estimated";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"model/response_failed">;
+        data: z.ZodObject<{
+            request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+            error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    auth_expired: "auth_expired";
+                    forbidden: "forbidden";
+                    unauthenticated: "unauthenticated";
+                    entitlement_missing: "entitlement_missing";
+                    model_unavailable: "model_unavailable";
+                    rate_limited: "rate_limited";
+                    quota_exhausted: "quota_exhausted";
+                    context_overflow: "context_overflow";
+                    invalid_request: "invalid_request";
+                    timeout: "timeout";
+                    stream_interrupted: "stream_interrupted";
+                    provider_internal: "provider_internal";
+                    protocol_mismatch: "protocol_mismatch";
+                    bridge_unavailable: "bridge_unavailable";
+                }>;
+                message: z.ZodString;
+                retryable: z.ZodBoolean;
+                retry_after_ms: z.ZodOptional<z.ZodInt>;
+                http_status: z.ZodOptional<z.ZodInt>;
+                provider_code: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            partial_blob: z.ZodOptional<z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"provider/usage">;
+        data: z.ZodObject<{
+            request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+            usage: z.ZodObject<{
+                input_tokens: z.ZodOptional<z.ZodInt>;
+                output_tokens: z.ZodOptional<z.ZodInt>;
+                cache_read_tokens: z.ZodOptional<z.ZodInt>;
+                cache_write_tokens: z.ZodOptional<z.ZodInt>;
+                reasoning_tokens: z.ZodOptional<z.ZodInt>;
+                cost_usd_estimate: z.ZodOptional<z.ZodNumber>;
+                source: z.ZodEnum<{
+                    unknown: "unknown";
+                    "provider-reported": "provider-reported";
+                    "adapter-estimated": "adapter-estimated";
+                }>;
+            }, z.core.$strict>;
+            quota: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    none: "none";
+                    headers: "headers";
+                    api: "api";
+                }>;
+                plan_label: z.ZodOptional<z.ZodString>;
+                windows: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    used_percent: z.ZodNumber;
+                    resets_at: z.ZodOptional<z.ZodISODateTime>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            provider_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ProviderId", "out">>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"tool/call_proposed">;
+        data: z.ZodObject<{
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            request_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
+            provider_call_id: z.ZodString;
+            tool_name: z.ZodString;
+            args_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            args_blob: z.ZodOptional<z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>>;
+            ref: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"tool/policy_decided">;
+        data: z.ZodObject<{
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            action: z.ZodObject<{
+                tool_name: z.ZodString;
+                tool_version: z.ZodString;
+                effect: z.ZodEnum<{
+                    read: "read";
+                    "workspace-write": "workspace-write";
+                    exec: "exec";
+                    "external-write": "external-write";
+                    control: "control";
+                    "network-read": "network-read";
+                }>;
+                role: z.ZodEnum<{
+                    orchestrator: "orchestrator";
+                    explorer: "explorer";
+                    implementer: "implementer";
+                    debugger: "debugger";
+                    reviewer: "reviewer";
+                    session: "session";
+                }>;
+                task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+                args_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                paths: z.ZodArray<z.ZodObject<{
+                    path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                    access: z.ZodEnum<{
+                        read: "read";
+                        write: "write";
+                    }>;
+                }, z.core.$strict>>;
+                escapes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    requested: z.ZodString;
+                    access: z.ZodEnum<{
+                        read: "read";
+                        write: "write";
+                    }>;
+                    reason: z.ZodEnum<{
+                        "invalid-path": "invalid-path";
+                        "unc-or-device": "unc-or-device";
+                        "outside-workspace": "outside-workspace";
+                        "link-escape": "link-escape";
+                        "dangling-link": "dangling-link";
+                        "hard-link": "hard-link";
+                        "changed-after-decision": "changed-after-decision";
+                    }>;
+                }, z.core.$strict>>>;
+                command: z.ZodOptional<z.ZodObject<{
+                    argv: z.ZodArray<z.ZodString>;
+                    cwd: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                }, z.core.$strict>>;
+                network_hosts: z.ZodArray<z.ZodString>;
+                destructive: z.ZodBoolean;
+                network_purpose: z.ZodOptional<z.ZodEnum<{
+                    search: "search";
+                    fetch: "fetch";
+                }>>;
+                egress_findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+            decision: z.ZodObject<{
+                decision: z.ZodEnum<{
+                    ask: "ask";
+                    allow: "allow";
+                    deny: "deny";
+                }>;
+                action_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                policy_digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                reasons: z.ZodArray<z.ZodObject<{
+                    code: z.ZodString;
+                    layer: z.ZodEnum<{
+                        workspace: "workspace";
+                        role: "role";
+                        task: "task";
+                        approval: "approval";
+                        user: "user";
+                        platform: "platform";
+                        sandbox: "sandbox";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+                rail: z.ZodOptional<z.ZodEnum<{
+                    "write-outside-scope": "write-outside-scope";
+                    "reserved-path-write": "reserved-path-write";
+                    "destructive-command": "destructive-command";
+                    "credential-access": "credential-access";
+                    "secret-egress": "secret-egress";
+                    "policy-self-modification": "policy-self-modification";
+                    "foreign-credential-store": "foreign-credential-store";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"tool/execution_started">;
+        data: z.ZodObject<{
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            sandbox_enforcement: z.ZodEnum<{
+                partial: "partial";
+                full: "full";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"tool/result_recorded">;
+        data: z.ZodObject<{
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            state: z.ZodEnum<{
+                failed: "failed";
+                cancelled: "cancelled";
+                succeeded: "succeeded";
+                denied: "denied";
+            }>;
+            result: z.ZodObject<{
+                status: z.ZodEnum<{
+                    error: "error";
+                    ok: "ok";
+                }>;
+                text: z.ZodString;
+                blob: z.ZodOptional<z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>>;
+                truncated: z.ZodBoolean;
+                exit_code: z.ZodOptional<z.ZodInt>;
+                changed_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                digest: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+                redactions: z.ZodInt;
+                error: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodEnum<{
+                        cancelled: "cancelled";
+                        policy_denied: "policy_denied";
+                        sandbox_insufficient: "sandbox_insufficient";
+                        approval_rejected: "approval_rejected";
+                        approval_unavailable: "approval_unavailable";
+                        timeout: "timeout";
+                        unknown_tool: "unknown_tool";
+                        invalid_arguments: "invalid_arguments";
+                        path_outside_scope: "path_outside_scope";
+                        stale_precondition: "stale_precondition";
+                        execution_failed: "execution_failed";
+                        outcome_unknown: "outcome_unknown";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            duration_ms: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"tool/interrupted">;
+        data: z.ZodObject<{
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            outcome: z.ZodLiteral<"unknown">;
+            idempotent: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"backend/tool_observed">;
+        data: z.ZodObject<{
+            source: z.ZodLiteral<"claude-code-native">;
+            phase: z.ZodEnum<{
+                started: "started";
+                finished: "finished";
+            }>;
+            tool_use_id: z.ZodString;
+            tool_name: z.ZodString;
+            input_summary: z.ZodString;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+            result_summary: z.ZodOptional<z.ZodString>;
+            lines_added: z.ZodOptional<z.ZodInt>;
+            lines_removed: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"context/compacted">;
+        data: z.ZodObject<{
+            from_seq: z.ZodInt;
+            to_seq: z.ZodInt;
+            first_kept_seq: z.ZodInt;
+            method: z.ZodLiteral<"summary-v1">;
+            model_id: z.ZodOptional<z.ZodString>;
+            tokens_before: z.ZodInt;
+            tokens_after: z.ZodInt;
+            summary_blob: z.ZodObject<{
+                digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                size_bytes: z.ZodInt;
+                media_type: z.ZodString;
+            }, z.core.$strict>;
+            trigger: z.ZodEnum<{
+                manual: "manual";
+                threshold: "threshold";
+                overflow: "overflow";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"context/source_changed">;
+        data: z.ZodObject<{
+            task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+            path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            expected: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+            actual: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"memory/persisted">;
+        data: z.ZodObject<{
+            memory_id: z.core.$ZodBranded<z.ZodString, "MemoryId", "out">;
+            kind: z.ZodEnum<{
+                evidence: "evidence";
+                project: "project";
+                question: "question";
+                decision: "decision";
+                assumption: "assumption";
+                concept: "concept";
+                preference: "preference";
+            }>;
+            path: z.ZodString;
+            digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"memory/proposed">;
+        data: z.ZodObject<{
+            proposal_id: z.core.$ZodBranded<z.ZodString, "ProposalId", "out">;
+            kind: z.ZodEnum<{
+                note: "note";
+                relation: "relation";
+                contradiction: "contradiction";
+                "status-change": "status-change";
+            }>;
+            target: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "MemoryId", "out">>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"memory/proposal_decided">;
+        data: z.ZodObject<{
+            proposal_id: z.core.$ZodBranded<z.ZodString, "ProposalId", "out">;
+            state: z.ZodEnum<{
+                rejected: "rejected";
+                accepted: "accepted";
+                deferred: "deferred";
+            }>;
+            decided_by: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                user: "user";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"budget/exceeded">;
+        data: z.ZodObject<{
+            scope: z.ZodEnum<{
+                run: "run";
+                task: "task";
+            }>;
+            metric: z.ZodEnum<{
+                tool_calls: "tool_calls";
+                cost_usd: "cost_usd";
+                wall_time_seconds: "wall_time_seconds";
+                steps: "steps";
+            }>;
+            limit: z.ZodNumber;
+            used: z.ZodNumber;
+            action: z.ZodEnum<{
+                "stop-new-requests": "stop-new-requests";
+                "cancel-active": "cancel-active";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"steer/queued">;
+        data: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"trust/granted">;
+        data: z.ZodObject<{
+            workspace_root: z.ZodString;
+            repo_identity: z.ZodString;
+            source: z.ZodEnum<{
+                command: "command";
+                prompt: "prompt";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"trust/revoked">;
+        data: z.ZodObject<{
+            workspace_root: z.ZodString;
+            repo_identity: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"trust/used">;
+        data: z.ZodObject<{
+            workspace_root: z.ZodString;
+            repo_identity: z.ZodString;
+            source: z.ZodEnum<{
+                session: "session";
+                store: "store";
+                flag: "flag";
+            }>;
+            sandbox_enforcement: z.ZodEnum<{
+                partial: "partial";
+                full: "full";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"checkpoint/recorded">;
+        data: z.ZodObject<{
+            turn_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TurnId", "out">>;
+            tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                before: z.ZodNullable<z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>>;
+                after: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Digest", "out">>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"checkpoint/restored">;
+        data: z.ZodObject<{
+            checkpoint_seq: z.ZodInt;
+            restored: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            skipped: z.ZodArray<z.ZodObject<{
+                path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"command/allowed">;
+        data: z.ZodObject<{
+            workspace_root: z.ZodString;
+            prefix: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"network/host_allowed">;
+        data: z.ZodObject<{
+            host: z.ZodString;
+            scope: z.ZodEnum<{
+                global: "global";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        event_id: z.core.$ZodBranded<z.ZodString, "EventId", "out">;
+        session_id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+        seq: z.ZodInt;
+        event_version: z.ZodInt;
+        timestamp: z.ZodISODateTime;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                orchestrator: "orchestrator";
+                provider: "provider";
+                agent: "agent";
+                user: "user";
+                worker: "worker";
+                system: "system";
+                policy: "policy";
+            }>;
+            role: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                explorer: "explorer";
+                implementer: "implementer";
+                debugger: "debugger";
+                reviewer: "reviewer";
+                session: "session";
+            }>>;
+            attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        }, z.core.$strict>;
+        run_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RunId", "out">>;
+        task_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+        attempt_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+        causation_seq: z.ZodOptional<z.ZodInt>;
+        type: z.ZodLiteral<"web/searched">;
+        data: z.ZodObject<{
+            provider: z.ZodString;
+            query: z.ZodString;
+            sources: z.ZodInt;
+            request_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    seq: z.ZodInt;
+    timestamp: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"delta">;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"start">;
+        request_id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+        route: z.ZodObject<{
+            provider_id: z.core.$ZodBranded<z.ZodString, "ProviderId", "out">;
+            model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+            adapter_id: z.ZodString;
+            adapter_kind: z.ZodEnum<{
+                model: "model";
+                "agent-backend": "agent-backend";
+            }>;
+            auth_method: z.ZodEnum<{
+                "oauth-subscription": "oauth-subscription";
+                "cli-bridge": "cli-bridge";
+                "api-key": "api-key";
+            }>;
+            profile: z.ZodString;
+            tier: z.ZodOptional<z.ZodEnum<{
+                orchestrator: "orchestrator";
+                complex_worker: "complex_worker";
+                fast_worker: "fast_worker";
+                session: "session";
+            }>>;
+        }, z.core.$strict>;
+        provider_request_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"backend_init">;
+        backend_session_id: z.ZodString;
+        model_id: z.core.$ZodBranded<z.ZodString, "ModelId", "out">;
+        auth_source: z.ZodEnum<{
+            unknown: "unknown";
+            "api-key": "api-key";
+            subscription: "subscription";
+        }>;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"text_delta">;
+        index: z.ZodInt;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking_delta">;
+        index: z.ZodInt;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_call_start">;
+        index: z.ZodInt;
+        provider_call_id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_call_delta">;
+        index: z.ZodInt;
+        provider_call_id: z.ZodString;
+        arguments_fragment: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_call_end">;
+        index: z.ZodInt;
+        provider_call_id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"usage">;
+        usage: z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodInt>;
+            output_tokens: z.ZodOptional<z.ZodInt>;
+            cache_read_tokens: z.ZodOptional<z.ZodInt>;
+            cache_write_tokens: z.ZodOptional<z.ZodInt>;
+            reasoning_tokens: z.ZodOptional<z.ZodInt>;
+            cost_usd_estimate: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodEnum<{
+                unknown: "unknown";
+                "provider-reported": "provider-reported";
+                "adapter-estimated": "adapter-estimated";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"quota">;
+        quota: z.ZodObject<{
+            source: z.ZodEnum<{
+                none: "none";
+                headers: "headers";
+                api: "api";
+            }>;
+            plan_label: z.ZodOptional<z.ZodString>;
+            windows: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                used_percent: z.ZodNumber;
+                resets_at: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"done">;
+        stop_reason: z.ZodEnum<{
+            length: "length";
+            stop: "stop";
+            tool_use: "tool_use";
+        }>;
+        message: z.ZodObject<{
+            content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"thinking">;
+                text: z.ZodString;
+                opaque: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_call">;
+                provider_call_id: z.ZodString;
+                tool_call_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">>;
+                name: z.ZodString;
+                arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_result">;
+                tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+                provider_call_id: z.ZodString;
+                is_error: z.ZodBoolean;
+                text: z.ZodString;
+                blob: z.ZodOptional<z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"blob">;
+                blob: z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                blob: z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    media_type: z.ZodEnum<{
+                        "image/png": "image/png";
+                        "image/jpeg": "image/jpeg";
+                        "image/gif": "image/gif";
+                        "image/webp": "image/webp";
+                    }>;
+                    size_bytes: z.ZodInt;
+                }, z.core.$strict>;
+                data: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "type">>;
+            role: z.ZodLiteral<"assistant">;
+        }, z.core.$strict>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodInt>;
+            output_tokens: z.ZodOptional<z.ZodInt>;
+            cache_read_tokens: z.ZodOptional<z.ZodInt>;
+            cache_write_tokens: z.ZodOptional<z.ZodInt>;
+            reasoning_tokens: z.ZodOptional<z.ZodInt>;
+            cost_usd_estimate: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodEnum<{
+                unknown: "unknown";
+                "provider-reported": "provider-reported";
+                "adapter-estimated": "adapter-estimated";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        error: z.ZodObject<{
+            code: z.ZodEnum<{
+                cancelled: "cancelled";
+                auth_expired: "auth_expired";
+                forbidden: "forbidden";
+                unauthenticated: "unauthenticated";
+                entitlement_missing: "entitlement_missing";
+                model_unavailable: "model_unavailable";
+                rate_limited: "rate_limited";
+                quota_exhausted: "quota_exhausted";
+                context_overflow: "context_overflow";
+                invalid_request: "invalid_request";
+                timeout: "timeout";
+                stream_interrupted: "stream_interrupted";
+                provider_internal: "provider_internal";
+                protocol_mismatch: "protocol_mismatch";
+                bridge_unavailable: "bridge_unavailable";
+            }>;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+            retry_after_ms: z.ZodOptional<z.ZodInt>;
+            http_status: z.ZodOptional<z.ZodInt>;
+            provider_code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        partial: z.ZodOptional<z.ZodObject<{
+            content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"thinking">;
+                text: z.ZodString;
+                opaque: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_call">;
+                provider_call_id: z.ZodString;
+                tool_call_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">>;
+                name: z.ZodString;
+                arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"tool_result">;
+                tool_call_id: z.core.$ZodBranded<z.ZodString, "ToolCallId", "out">;
+                provider_call_id: z.ZodString;
+                is_error: z.ZodBoolean;
+                text: z.ZodString;
+                blob: z.ZodOptional<z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"blob">;
+                blob: z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    size_bytes: z.ZodInt;
+                    media_type: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                blob: z.ZodObject<{
+                    digest: z.core.$ZodBranded<z.ZodString, "Digest", "out">;
+                    media_type: z.ZodEnum<{
+                        "image/png": "image/png";
+                        "image/jpeg": "image/jpeg";
+                        "image/gif": "image/gif";
+                        "image/webp": "image/webp";
+                    }>;
+                    size_bytes: z.ZodInt;
+                }, z.core.$strict>;
+                data: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "type">>;
+            role: z.ZodLiteral<"assistant">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "type">;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    seq: z.ZodInt;
+    timestamp: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    data: z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            cancelled: "cancelled";
+            rejected: "rejected";
+            succeeded: "succeeded";
+        }>;
+        exit_code: z.ZodInt;
+        summary: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            task_id: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+            state: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                cancelled: "cancelled";
+                running: "running";
+                interrupted: "interrupted";
+                draft: "draft";
+                awaiting_approval: "awaiting_approval";
+                ready: "ready";
+                retry_pending: "retry_pending";
+                verifying: "verifying";
+                reviewing: "reviewing";
+                changes_requested: "changes_requested";
+            }>;
+        }, z.core.$strict>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodInt>;
+            output_tokens: z.ZodOptional<z.ZodInt>;
+            cache_read_tokens: z.ZodOptional<z.ZodInt>;
+            cache_write_tokens: z.ZodOptional<z.ZodInt>;
+            reasoning_tokens: z.ZodOptional<z.ZodInt>;
+            cost_usd_estimate: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodEnum<{
+                unknown: "unknown";
+                "provider-reported": "provider-reported";
+                "adapter-estimated": "adapter-estimated";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    seq: z.ZodInt;
+    timestamp: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    data: z.ZodObject<{
+        code: z.ZodEnum<{
+            internal: "internal";
+            session_locked: "session_locked";
+            cancelled: "cancelled";
+            usage_invalid: "usage_invalid";
+            config_invalid: "config_invalid";
+            auth_required: "auth_required";
+            auth_expired: "auth_expired";
+            provider_failed: "provider_failed";
+            tool_failed: "tool_failed";
+            policy_denied: "policy_denied";
+            sandbox_insufficient: "sandbox_insufficient";
+            approval_rejected: "approval_rejected";
+            approval_unavailable: "approval_unavailable";
+            verification_failed: "verification_failed";
+            review_blocked: "review_blocked";
+            budget_exceeded: "budget_exceeded";
+            session_corrupt: "session_corrupt";
+            store_write_failed: "store_write_failed";
+            stale_packet: "stale_packet";
+        }>;
+        message: z.ZodString;
+        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        workspace_effect: z.ZodEnum<{
+            unknown: "unknown";
+            none: "none";
+            partial: "partial";
+        }>;
+        retry_safe: z.ZodBoolean;
+        next_command: z.ZodOptional<z.ZodString>;
+        exit_code: z.ZodInt;
+    }, z.core.$strict>;
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    seq: z.ZodInt;
+    timestamp: z.ZodISODateTime;
+}, z.core.$strict>], "type">;
+export type JsonlFrame = z.infer<typeof jsonlFrameSchema>;
+export declare function encodeJsonlFrame(frame: JsonlFrame): string;
+/**
+ * Splits a stream on LF only. `readline` is unsuitable because it also breaks on U+2028/U+2029,
+ * which JSON strings may contain unescaped. A trailing CR is tolerated for Windows pipes.
+ */
+export declare function splitJsonlLines(chunk: string): {
+    readonly lines: readonly string[];
+    readonly rest: string;
+};
+/** Checks the stream-level invariants: hello first, dense seq, exactly one terminal frame, last. */
+export declare function validateFrameSequence(frames: readonly JsonlFrame[]): readonly string[];
+//# sourceMappingURL=jsonl.d.ts.map