@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/models/wire/journal.d.ts

@@ -0,0 +1,2772 @@
+import { z } from 'zod';
+import { type ContentPartInput } from '../../llm/index.js';
+import type { DeepReadonly } from '../../util/json.js';
+declare const seq: z.ZodNumber;
+/** Monotonic position in the journal. Assigned by `append`, never by a caller. */
+export type Seq = z.infer<typeof seq>;
+/** Opaque to the engine. The named plugin owns payload validation and version upgrades. */
+export declare const ExtensionRecordSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    instance_id: z.ZodDefault<z.ZodString>;
+    kind: z.ZodString;
+    version: z.ZodNumber;
+    data: z.ZodJSONSchema;
+}, z.core.$strip>;
+export type ExtensionRecord = z.infer<typeof ExtensionRecordSchema>;
+/**
+ * One preset installation as a thread records it: its id, the preset's id, and the configuration
+ * the preset's schema produced, which is what `setup` receives on every activation.
+ */
+export declare const InstallationSchema: z.ZodObject<{
+    installation_id: z.ZodString;
+    preset_id: z.ZodString;
+    config: z.ZodJSONSchema;
+}, z.core.$strict>;
+export type Installation = z.infer<typeof InstallationSchema>;
+/**
+ * How long an installation a thread is created with lasts: `defining`, for as long as the thread,
+ * never removed; `configurable`, until a configuration change removes it, as one applied later.
+ */
+export declare const InstallationLifetimeSchema: z.ZodEnum<{
+    defining: "defining";
+    configurable: "configurable";
+}>;
+export type InstallationLifetime = z.infer<typeof InstallationLifetimeSchema>;
+/** An installation a thread is created with, recorded in its spawn row with its lifetime. */
+export declare const InitialInstallationSchema: z.ZodObject<{
+    installation_id: z.ZodString;
+    preset_id: z.ZodString;
+    config: z.ZodJSONSchema;
+    lifetime: z.ZodEnum<{
+        defining: "defining";
+        configurable: "configurable";
+    }>;
+}, z.core.$strict>;
+export type InitialInstallation = z.infer<typeof InitialInstallationSchema>;
+/** One stop check's refusal of an answer, and the plugin that gave it. */
+export declare const TurnRejectionSchema: z.ZodObject<{
+    reason: z.ZodString;
+    source: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TurnRejection = z.infer<typeof TurnRejectionSchema>;
+/**
+ * Why a turn was interrupted. `abandoned`: the process died inside it, and recovery closed it the
+ * next time the thread ran. `activation-changed`: the activation's plugins changed under it; it
+ * takes precedence when the judgment was also invalidated. `judgment-invalidated`: the registrations
+ * its stop checks were fenced on, or the facts they declared they observed, no longer match.
+ */
+export declare const InterruptionCauseSchema: z.ZodEnum<{
+    abandoned: "abandoned";
+    "activation-changed": "activation-changed";
+    "judgment-invalidated": "judgment-invalidated";
+}>;
+export type InterruptionCause = z.infer<typeof InterruptionCauseSchema>;
+export declare const TurnEndReasonSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"completed">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"blocked">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"max-steps">;
+    limit: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"interrupted">;
+    cause: z.ZodEnum<{
+        abandoned: "abandoned";
+        "activation-changed": "activation-changed";
+        "judgment-invalidated": "judgment-invalidated";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"aborted">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"error">;
+    error_text: z.ZodString;
+    failure_kind: z.ZodEnum<{
+        length: "length";
+        other: "other";
+        transport: "transport";
+        empty: "empty";
+        invalid: "invalid";
+        rate_limit: "rate_limit";
+        overloaded: "overloaded";
+        timeout: "timeout";
+        auth: "auth";
+        quota: "quota";
+        overflow: "overflow";
+    }>;
+    retry_after_ms: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    rejections: z.ZodArray<z.ZodObject<{
+        reason: z.ZodString;
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export type TurnEndReason = z.infer<typeof TurnEndReasonSchema>;
+/**
+ * What a re-dispatch may do with a call whose attempt was interrupted — the process stopped between
+ * the attempt's authorization and its result, so the tool may have begun and its outcome is unknown.
+ * `rerun`: the tool is read-only, or idempotent under its effect identity (the thread and the
+ * `tool/call` row), and runs again. `report`: the call is answered with an error saying it was
+ * interrupted and its outcome is unknown, and the model decides what to check before repeating it.
+ */
+export declare const InterruptionPolicySchema: z.ZodEnum<{
+    rerun: "rerun";
+    report: "report";
+}>;
+export type InterruptionPolicy = z.infer<typeof InterruptionPolicySchema>;
+/** Where queued input waits: `next-turn` opens a turn, `next-step` joins the one in flight. */
+export declare const InboxTargetSchema: z.ZodEnum<{
+    "next-turn": "next-turn";
+    "next-step": "next-step";
+}>;
+export type InboxTarget = z.infer<typeof InboxTargetSchema>;
+/**
+ * Roles an application or a plugin may put into a thread's input.
+ *
+ * Deliberately not `assistant` or `tool`: those are the model's and the loop's to write, and a
+ * queued one would invent a tool call or answer one. Not `system` either — the prompt travels
+ * beside the conversation, recorded once on `thread/prompt`.
+ */
+export declare const INPUT_ROLES: readonly ["user", "developer"];
+export type InputRole = (typeof INPUT_ROLES)[number];
+/** Input as it waits in the inbox: a message the model has not seen yet, and the id that claims it. */
+export declare const QueuedInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodDefault<z.ZodEnum<{
+        developer: "developer";
+        user: "user";
+    }>>;
+    content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        detail: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            low: "low";
+            high: "high";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>], "type">>>, unknown>;
+    source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type QueuedInput = z.infer<typeof QueuedInputSchema>;
+/** What a caller may queue: text, or a message with a role and content parts. */
+export type ThreadInput = string | {
+    role?: InputRole;
+    content: string | readonly ContentPartInput[];
+};
+/** Normalizes what a caller wrote into the queued form. Empty input is a caller bug, not a no-op. */
+export declare function queuedInput(input: ThreadInput, id: string, source?: ExtensionRecord | null): QueuedInput;
+/**
+ * A message a plugin adds to a model step that is already due. It is recorded as an `input/message`
+ * carrying `source`, so the plugin — and a frontend — can tell it from what the person typed.
+ */
+export declare const StepContributionSchema: z.ZodObject<{
+    role: z.ZodDefault<z.ZodEnum<{
+        developer: "developer";
+        user: "user";
+    }>>;
+    content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        detail: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            low: "low";
+            high: "high";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>], "type">>>, unknown>;
+    source: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>;
+    source_seqs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type StepContribution = z.infer<typeof StepContributionSchema>;
+export type StepContributionInput = z.input<typeof StepContributionSchema>;
+export declare function stepContribution(input: StepContributionInput): StepContribution;
+/**
+ * What made a strategy replace part of a surface: a model step it measured (`pressure`), a request
+ * the provider refused as too long (`overflow`), or someone asking (`request`).
+ */
+export declare const ReplacementTriggerSchema: z.ZodEnum<{
+    overflow: "overflow";
+    pressure: "pressure";
+    request: "request";
+}>;
+export type ReplacementTrigger = z.infer<typeof ReplacementTriggerSchema>;
+/**
+ * A replacement of part of what the model sees; the rows it replaces, cited in `source_seqs` in
+ * surface order, stay in the journal.
+ *
+ * The stand-in is stored as only what a replacement may change, and the fold builds the message: a
+ * `span`'s role and content, a `rewrite`'s content, which keeps the role and tool call id of the
+ * message it rewrites. So no stand-in can carry provider state, reasoning, provider calls, tool calls
+ * or usage — the Responses adapters replay a message's provider state in place of its content, and
+ * a stand-in that could carry one could replay the answer it stands for. The stand-ins are strict
+ * objects so a caller handing over a whole message is refused, not silently trimmed.
+ *
+ * A `span` stand-in speaks as `user` or `assistant`, never as the harness: it is a plugin's text
+ * standing for what the model and its tools said. The rules a replacement must meet against the
+ * surface it lands on are the surface's, in `loop/`, judged where the row is written.
+ */
+declare const SurfaceReplacedSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>;
+    trigger: z.ZodEnum<{
+        overflow: "overflow";
+        pressure: "pressure";
+        request: "request";
+    }>;
+    auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+    turn: z.ZodNullable<z.ZodNumber>;
+    step: z.ZodNullable<z.ZodNumber>;
+    kind: z.ZodLiteral<"span">;
+    stand_in: z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>;
+    trigger: z.ZodEnum<{
+        overflow: "overflow";
+        pressure: "pressure";
+        request: "request";
+    }>;
+    auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+    turn: z.ZodNullable<z.ZodNumber>;
+    step: z.ZodNullable<z.ZodNumber>;
+    kind: z.ZodLiteral<"rewrite">;
+    stand_in: z.ZodObject<{
+        content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>;
+    }, z.core.$strict>;
+}, z.core.$strip>], "kind">;
+export type ReplacementKind = z.infer<typeof SurfaceReplacedSchema>['kind'];
+/**
+ * What on the caller made a thread or a task: a `call`, the caller's `tool/call` row; or an
+ * `assignment` a registered owner made. An assignment's `key` is the owner's own record of it, which
+ * only the owner's codec reads; core never interprets it.
+ */
+export declare const OriginCauseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"call">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"assignment">;
+    owner: z.ZodString;
+    key: z.ZodJSONSchema;
+}, z.core.$strip>], "kind">;
+export type OriginCause = DeepReadonly<z.infer<typeof OriginCauseSchema>>;
+/**
+ * Where a thread came from: the caller thread it sits under, the one link every walk of a tree
+ * follows whatever the cause, the caller's row that caused it, and the cause. `source_seq` is the
+ * caller's `tool/call` row for a `call`, and the row that granted an assignment for an
+ * `assignment`, so stop ordering and descendant authority read it without decoding the owner's key.
+ * Immutable once recorded; the journal checks that the row is on the caller's lineage, and a `call`'s
+ * is a `tool/call` (`origins.validate`).
+ */
+export declare const ThreadOriginSchema: z.ZodObject<{
+    caller_thread_id: z.ZodString;
+    source_seq: z.ZodNumber;
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"call">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"assignment">;
+        owner: z.ZodString;
+        key: z.ZodJSONSchema;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type ThreadOrigin = DeepReadonly<z.infer<typeof ThreadOriginSchema>>;
+/**
+ * Where a forked thread continues from: the source thread and the row it was cut at. The child's
+ * thread-scoped state starts as the source's state at that row — the conversation, the prompt, the
+ * route, plugin state — without any of it being copied.
+ */
+export declare const ThreadForkSchema: z.ZodObject<{
+    thread_id: z.ZodString;
+    seq: z.ZodNumber;
+}, z.core.$strip>;
+export type ThreadFork = z.infer<typeof ThreadForkSchema>;
+/** Where a thread's work happens. Engine-read and typed, unlike `metadata`. */
+export declare const ThreadEnvironmentSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    read_roots: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ThreadEnvironment = z.infer<typeof ThreadEnvironmentSchema>;
+/**
+ * How a turn a cause opens counts toward the bound on unattended work: a `person` asked for it,
+ * `fresh` authority from an assignment or a schedule gave it, or it is a `reactive` reply to work
+ * the thread itself set going.
+ */
+export declare const RunChainSchema: z.ZodEnum<{
+    person: "person";
+    fresh: "fresh";
+    reactive: "reactive";
+}>;
+export type RunChain = z.infer<typeof RunChainSchema>;
+/** How a run request ended. */
+export declare const RunOutcomeKindSchema: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    superseded: "superseded";
+}>;
+export type RunOutcomeKind = z.infer<typeof RunOutcomeKindSchema>;
+/**
+ * Why a run request settled as it did: `answered`, its last turn completed with nothing left;
+ * `nothing`, it found nothing to do; `turn`, a turn ended in a failure; `setup`, it failed before
+ * any turn opened; `cancel`, a cancel captured it; `obsolete`, a constraint said its authority is
+ * gone for good.
+ */
+export declare const RunSettledReasonSchema: z.ZodEnum<{
+    turn: "turn";
+    answered: "answered";
+    nothing: "nothing";
+    setup: "setup";
+    cancel: "cancel";
+    obsolete: "obsolete";
+}>;
+export type RunSettledReason = z.infer<typeof RunSettledReasonSchema>;
+/** Who cancelled: a person (`user`), which holds the thread, or a feature's `cleanup`, which does not. */
+export declare const CancelIntentSchema: z.ZodEnum<{
+    user: "user";
+    cleanup: "cleanup";
+}>;
+export type CancelIntent = z.infer<typeof CancelIntentSchema>;
+export declare const JOURNAL_EVENT_DATA: {
+    /** Plugin state; never automatically part of the conversation or a frontend update. */
+    readonly ext: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip>;
+    readonly 'turn/start': z.ZodObject<{
+        turn: z.ZodNumber;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        run_id: z.ZodString;
+        attempt_cutoff: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly 'turn/end': z.ZodObject<{
+        turn: z.ZodNumber;
+        reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"blocked">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"max-steps">;
+            limit: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"interrupted">;
+            cause: z.ZodEnum<{
+                abandoned: "abandoned";
+                "activation-changed": "activation-changed";
+                "judgment-invalidated": "judgment-invalidated";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"aborted">;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"error">;
+            error_text: z.ZodString;
+            failure_kind: z.ZodEnum<{
+                length: "length";
+                other: "other";
+                transport: "transport";
+                empty: "empty";
+                invalid: "invalid";
+                rate_limit: "rate_limit";
+                overloaded: "overloaded";
+                timeout: "timeout";
+                auth: "auth";
+                quota: "quota";
+                overflow: "overflow";
+            }>;
+            retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"rejected">;
+            rejections: z.ZodArray<z.ZodObject<{
+                reason: z.ZodString;
+                source: z.ZodObject<{
+                    plugin: z.ZodString;
+                    instance_id: z.ZodDefault<z.ZodString>;
+                    kind: z.ZodString;
+                    version: z.ZodNumber;
+                    data: z.ZodJSONSchema;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    readonly 'step/start': z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly 'step/end': z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /** Input claimed by a step, in the role it speaks as — the user, or the harness around them. */
+    readonly 'input/message': z.ZodObject<{
+        turn: z.ZodNumber;
+        role: z.ZodDefault<z.ZodEnum<{
+            developer: "developer";
+            user: "user";
+        }>>;
+        content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>;
+        input_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    /**
+     * A request as it was actually sent — appended after `lagent/llm/request` listeners have had
+     * their say, not before. The prompt and the tools it sent are recorded on the thread
+     * (`thread/prompt`, `thread/tools`), as they stood at this row; what a request measures, sizes and
+     * digests, is the `diagnostics` plugin's, not the row's.
+     */
+    readonly 'llm/request': z.ZodObject<{
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodDefault<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly 'assistant/message': z.ZodObject<{
+        llm_call_id: z.ZodString;
+        response: z.ZodObject<{
+            message: z.ZodObject<{
+                role: z.ZodEnum<{
+                    system: "system";
+                    developer: "developer";
+                    user: "user";
+                    assistant: "assistant";
+                    tool: "tool";
+                }>;
+                content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    detail: z.ZodDefault<z.ZodEnum<{
+                        auto: "auto";
+                        low: "low";
+                        high: "high";
+                    }>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"file">;
+                    file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>], "type">>>, unknown>;
+                reasoning_content: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>, z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodNull;
+                    malformed: z.ZodObject<{
+                        raw: z.ZodString;
+                        error: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$loose>]>>>;
+                provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    status: z.ZodDefault<z.ZodEnum<{
+                        in_progress: "in_progress";
+                        completed: "completed";
+                        failed: "failed";
+                    }>>;
+                    summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$loose>>>;
+                tool_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    input_tokens: z.ZodDefault<z.ZodNumber>;
+                    output_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                provider_state: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    provider: z.ZodString;
+                    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            finish: z.ZodEnum<{
+                length: "length";
+                completed: "completed";
+                other: "other";
+            }>;
+            provider_metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        interrupted: z.ZodDefault<z.ZodBoolean>;
+        attempts: z.ZodNumber;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * A model call that failed: never on the surface. `failure_kind` says how; an `overflow` is the
+     * record a strategy reads an overflow from, after a crash or on a later run, and nothing more: no
+     * provider states a count it can be trusted with, so none is recorded.
+     */
+    readonly 'assistant/attempt': z.ZodObject<{
+        llm_call_id: z.ZodString;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+        attempts: z.ZodNumber;
+        retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * An auxiliary model call about to be sent: one a plugin makes beside the conversation, through
+     * the same request middleware and terminal as a step, whose reply is never the thread's and never
+     * on the surface. Recorded before the request is sent, so a crash mid-call leaves a request with
+     * no result. What `llm/request` records, plus what makes the canonical request reproducible from
+     * this row alone: it is the surface as it stood at this row (`stateAt`), cut after
+     * `surface_message_count` messages, followed by `instructions`, each a `user` message.
+     */
+    readonly 'auxiliary/request': z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodNumber;
+        surface_message_count: z.ZodNumber;
+        instructions: z.ZodArray<z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>>;
+    }, z.core.$strip>;
+    /**
+     * How an auxiliary call ended: its text and finish, or the error that ended it. Cites its
+     * `auxiliary/request` row. Never an assistant message, so no fold that reads the conversation
+     * sees it.
+     */
+    readonly 'auxiliary/result': z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        text: z.ZodNullable<z.ZodString>;
+        finish: z.ZodNullable<z.ZodEnum<{
+            length: "length";
+            completed: "completed";
+            other: "other";
+        }>>;
+        tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>, z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodNull;
+            malformed: z.ZodObject<{
+                raw: z.ZodString;
+                error: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$loose>]>>>;
+        provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            status: z.ZodDefault<z.ZodEnum<{
+                in_progress: "in_progress";
+                completed: "completed";
+                failed: "failed";
+            }>>;
+            summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        error_text: z.ZodNullable<z.ZodString>;
+        error_kind: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>, z.ZodLiteral<"aborted">]>>;
+        attempts: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * A call was dispatched. The arguments are on the assistant message that asked for it; repeating
+     * them here would be a second copy that a crash could leave disagreeing with the first. Its one
+     * source seq is that message, on a fork's source when the fork inherited it.
+     */
+    readonly 'tool/call': z.ZodObject<{
+        call_id: z.ZodString;
+        name: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * One dispatch attempt of a call: written immediately before the tool is invoked, so an `allow`
+     * with no result after it is the mark that the call may have begun. A call has one per dispatch;
+     * the provider's `call_id` may be reused by a later turn, so `call_seq` names the `tool/call` row
+     * this attempt belongs to.
+     */
+    readonly 'tool/authorization': z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        decision: z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>;
+        confirmed_by: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            policy: "policy";
+        }>>>;
+        policy: z.ZodEnum<{
+            rerun: "rerun";
+            report: "report";
+        }>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly 'tool/result': z.ZodObject<{
+        result: z.ZodObject<{
+            output: z.ZodString;
+            content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>;
+            is_error: z.ZodDefault<z.ZodBoolean>;
+            notes: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            concludes_turn: z.ZodOptional<z.ZodLiteral<true>>;
+            call_id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * A dispatched call suspended: its tool waits on a dependency `owner`, a registered constraint
+     * owner, alone interprets and resolves. The call stays unanswered and is not dispatched again until
+     * a `wait/resolved` records its value; a cancel answers it instead. One per call, keyed by
+     * `call_seq`. Cites the `tool/call` row and the dispatch attempt's `tool/authorization` row.
+     */
+    readonly 'wait/declared': z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        owner: z.ZodString;
+        dependency: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        deadline_at: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * The value a suspended call resolved with, versioned by its wait's owner: what the tool reads
+     * when the call is dispatched again. Cites the declaration, then any evidence the owner names.
+     */
+    readonly 'wait/resolved': z.ZodObject<{
+        call_seq: z.ZodNumber;
+        value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>;
+    readonly 'confirm/requested': z.ZodObject<{
+        request_id: z.ZodString;
+        tool_call: z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly 'confirm/resolved': z.ZodObject<{
+        request_id: z.ZodString;
+        approved: z.ZodBoolean;
+        rejection_message: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    /**
+     * A conversation's identity, lineage and environment. The row where a fork's inherited state
+     * ends: every thread-scoped fold sees it right after the rows the fork inherits, and resets there
+     * whatever described the source's execution rather than its conversation.
+     */
+    readonly 'thread/spawned': z.ZodObject<{
+        agent_name: z.ZodString;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        fork: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            thread_id: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>>>;
+        origin: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            caller_thread_id: z.ZodString;
+            source_seq: z.ZodNumber;
+            cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"call">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"assignment">;
+                owner: z.ZodString;
+                key: z.ZodJSONSchema;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>>>;
+        environment: z.ZodObject<{
+            cwd: z.ZodString;
+            read_roots: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        installations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            installation_id: z.ZodString;
+            preset_id: z.ZodString;
+            config: z.ZodJSONSchema;
+            lifetime: z.ZodEnum<{
+                defining: "defining";
+                configurable: "configurable";
+            }>;
+        }, z.core.$strict>>>;
+        requires: z.ZodArray<z.ZodString>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    /** A preset installed on the thread after its creation; see `Thread.configure`. */
+    readonly 'installation/applied': z.ZodObject<{
+        installation_id: z.ZodString;
+        preset_id: z.ZodString;
+        config: z.ZodJSONSchema;
+    }, z.core.$strict>;
+    /** An installation taken off the thread. Its id stays reserved. */
+    readonly 'installation/removed': z.ZodObject<{
+        installation_id: z.ZodString;
+    }, z.core.$strict>;
+    /** The rendered system prompt this thread sends. The latest row wins; see `rebuildPrompt`. */
+    readonly 'thread/prompt': z.ZodObject<{
+        blocks: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                base: "base";
+                instruction: "instruction";
+                context: "context";
+            }>;
+            tag: z.ZodNullable<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    /**
+     * The tool specifications this thread's requests send from here on, as sent: after request
+     * middleware, independent of live registrations. Written in a request's own group, before its
+     * request row, only when they differ from the latest; so a request sent the latest row at its seq.
+     */
+    readonly 'thread/tools': z.ZodObject<{
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    /**
+     * A run request opened on the thread: from here it is authorized to run until a `run/settled`
+     * names it. Written once per request, in the write of the cause that opened it, or of the
+     * settlement whose residual causes carry over.
+     */
+    readonly 'run/requested': z.ZodObject<{
+        run_id: z.ZodString;
+    }, z.core.$strict>;
+    /**
+     * One reason for the pending request to run, written in the same write as whatever brought it.
+     * Its seq identifies it and its timestamp gives its age. `input_id` is the input it brought, if
+     * any; `releases` says it releases the failure, cancellation and startup holds (a person's or a
+     * host's authority). `route` is the thread's route from this cause on, complete, when the cause
+     * changed it: a route change reauthorizes every unfinished piece of work on the thread on it.
+     */
+    readonly 'run/cause': z.ZodObject<{
+        run_id: z.ZodString;
+        input_id: z.ZodNullable<z.ZodString>;
+        releases: z.ZodBoolean;
+        chain: z.ZodEnum<{
+            person: "person";
+            fresh: "fresh";
+            reactive: "reactive";
+        }>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    /**
+     * A run request ended, once, decided at `through`. `residual` names the causes, by seq, that carry
+     * over to the request a successor `run/requested` in the same write opens. `error_text` says why a
+     * request failed in setup, before any turn: such a failure has no `turn/end` to say it.
+     */
+    readonly 'run/settled': z.ZodObject<{
+        run_id: z.ZodString;
+        outcome: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            superseded: "superseded";
+        }>;
+        reason: z.ZodEnum<{
+            turn: "turn";
+            answered: "answered";
+            nothing: "nothing";
+            setup: "setup";
+            cancel: "cancel";
+            obsolete: "obsolete";
+        }>;
+        error_text: z.ZodNullable<z.ZodString>;
+        through: z.ZodNumber;
+        residual: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    /**
+     * A cancel of the thread, written by every `cancel()` whatever the thread's state, with its inbox
+     * clear and any feature rows. `run_id` is the run of the execution the cancel captured, if any.
+     * A `user` cancel holds the thread until a releasing cause; a `cleanup` one holds nothing.
+     */
+    readonly 'thread/cancel': z.ZodObject<{
+        cancel_id: z.ZodString;
+        intent: z.ZodEnum<{
+            user: "user";
+            cleanup: "cleanup";
+        }>;
+        run_id: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strict>;
+    readonly 'inbox/spliced': z.ZodObject<{
+        target: z.ZodEnum<{
+            "next-turn": "next-turn";
+            "next-step": "next-step";
+        }>;
+        start: z.ZodNumber;
+        removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        inserted: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodDefault<z.ZodEnum<{
+                developer: "developer";
+                user: "user";
+            }>>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+            source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                plugin: z.ZodString;
+                instance_id: z.ZodDefault<z.ZodString>;
+                kind: z.ZodString;
+                version: z.ZodNumber;
+                data: z.ZodJSONSchema;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    /**
+     * Part of the surface replaced: a contiguous `span` by one stand-in, or one message rewritten in
+     * place. Written only by `replaceSurface`, which judges it against the surface it lands on.
+     */
+    readonly 'surface/replaced': z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"span">;
+        stand_in: z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"rewrite">;
+        stand_in: z.ZodObject<{
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>], "kind">;
+    readonly error: z.ZodObject<{
+        turn: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        step: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        llm_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+    }, z.core.$strip>;
+};
+export type JournalEventType = keyof typeof JOURNAL_EVENT_DATA;
+/** A journal event's payload, defaults applied — what a reader sees. */
+export type JournalEventData = {
+    [K in JournalEventType]: z.infer<(typeof JOURNAL_EVENT_DATA)[K]>;
+};
+/** What `append` accepts: the same payload with defaulted fields optional. */
+export type JournalEventInput = {
+    [K in JournalEventType]: DeepReadonly<z.input<(typeof JOURNAL_EVENT_DATA)[K]>>;
+};
+/**
+ * The events that put a message of their own on what the model sees. A `surface/replaced` row
+ * replaces messages there rather than adding one after them, so it is not among them.
+ */
+export declare const SURFACE_EVENT_TYPES: readonly ["input/message", "assistant/message", "tool/result"];
+export type SurfaceEventType = (typeof SURFACE_EVENT_TYPES)[number];
+/**
+ * One journal event: the envelope every row shares, plus the `data` its `type` selects.
+ *
+ * Written by hand rather than inferred from the schema below. Building the zod union by mapping
+ * over `JOURNAL_EVENT_DATA` loses the correlation between `type` and `data`, which is the one thing
+ * every reader of this type relies on; `data` still comes from `JOURNAL_EVENT_DATA`, so it cannot drift.
+ */
+export type JournalEvent<K extends JournalEventType = JournalEventType> = {
+    [T in K]: {
+        readonly seq: Seq;
+        readonly type: T;
+        readonly timestamp: string;
+        /** The thread this belongs to. Every row has one: there are no rows about the journal as a whole. */
+        readonly thread_id: string;
+        readonly data: JournalEventData[T];
+        /** Causally linked earlier events — a `tool/result` cites the `tool/call` it answers. */
+        readonly source_seqs: readonly Seq[];
+    };
+}[K];
+/** Runtime validation for a stored row. Narrow with {@link JournalEvent}, not with `z.infer`. */
+export declare const JournalEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    seq: z.ZodNumber;
+    type: z.ZodLiteral<"error" | "ext" | "turn/start" | "turn/end" | "step/start" | "step/end" | "input/message" | "llm/request" | "assistant/message" | "assistant/attempt" | "auxiliary/request" | "auxiliary/result" | "tool/call" | "tool/authorization" | "tool/result" | "wait/declared" | "wait/resolved" | "confirm/requested" | "confirm/resolved" | "thread/spawned" | "installation/applied" | "installation/removed" | "thread/prompt" | "thread/tools" | "run/requested" | "run/cause" | "run/settled" | "thread/cancel" | "inbox/spliced" | "surface/replaced">;
+    timestamp: z.ZodDefault<z.ZodISODateTime>;
+    thread_id: z.ZodString;
+    data: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip> | z.ZodObject<{
+        installation_id: z.ZodString;
+        preset_id: z.ZodString;
+        config: z.ZodJSONSchema;
+    }, z.core.$strict> | z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"span">;
+        stand_in: z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"rewrite">;
+        stand_in: z.ZodObject<{
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>], "kind"> | z.ZodObject<{
+        turn: z.ZodNumber;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        run_id: z.ZodString;
+        attempt_cutoff: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"blocked">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"max-steps">;
+            limit: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"interrupted">;
+            cause: z.ZodEnum<{
+                abandoned: "abandoned";
+                "activation-changed": "activation-changed";
+                "judgment-invalidated": "judgment-invalidated";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"aborted">;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"error">;
+            error_text: z.ZodString;
+            failure_kind: z.ZodEnum<{
+                length: "length";
+                other: "other";
+                transport: "transport";
+                empty: "empty";
+                invalid: "invalid";
+                rate_limit: "rate_limit";
+                overloaded: "overloaded";
+                timeout: "timeout";
+                auth: "auth";
+                quota: "quota";
+                overflow: "overflow";
+            }>;
+            retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"rejected">;
+            rejections: z.ZodArray<z.ZodObject<{
+                reason: z.ZodString;
+                source: z.ZodObject<{
+                    plugin: z.ZodString;
+                    instance_id: z.ZodDefault<z.ZodString>;
+                    kind: z.ZodString;
+                    version: z.ZodNumber;
+                    data: z.ZodJSONSchema;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        role: z.ZodDefault<z.ZodEnum<{
+            developer: "developer";
+            user: "user";
+        }>>;
+        content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>;
+        input_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodDefault<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        response: z.ZodObject<{
+            message: z.ZodObject<{
+                role: z.ZodEnum<{
+                    system: "system";
+                    developer: "developer";
+                    user: "user";
+                    assistant: "assistant";
+                    tool: "tool";
+                }>;
+                content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    detail: z.ZodDefault<z.ZodEnum<{
+                        auto: "auto";
+                        low: "low";
+                        high: "high";
+                    }>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"file">;
+                    file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>], "type">>>, unknown>;
+                reasoning_content: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>, z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodNull;
+                    malformed: z.ZodObject<{
+                        raw: z.ZodString;
+                        error: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$loose>]>>>;
+                provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    status: z.ZodDefault<z.ZodEnum<{
+                        in_progress: "in_progress";
+                        completed: "completed";
+                        failed: "failed";
+                    }>>;
+                    summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$loose>>>;
+                tool_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    input_tokens: z.ZodDefault<z.ZodNumber>;
+                    output_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                provider_state: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    provider: z.ZodString;
+                    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            finish: z.ZodEnum<{
+                length: "length";
+                completed: "completed";
+                other: "other";
+            }>;
+            provider_metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        interrupted: z.ZodDefault<z.ZodBoolean>;
+        attempts: z.ZodNumber;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+        attempts: z.ZodNumber;
+        retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodNumber;
+        surface_message_count: z.ZodNumber;
+        instructions: z.ZodArray<z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>>;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        text: z.ZodNullable<z.ZodString>;
+        finish: z.ZodNullable<z.ZodEnum<{
+            length: "length";
+            completed: "completed";
+            other: "other";
+        }>>;
+        tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>, z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodNull;
+            malformed: z.ZodObject<{
+                raw: z.ZodString;
+                error: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$loose>]>>>;
+        provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            status: z.ZodDefault<z.ZodEnum<{
+                in_progress: "in_progress";
+                completed: "completed";
+                failed: "failed";
+            }>>;
+            summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        error_text: z.ZodNullable<z.ZodString>;
+        error_kind: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>, z.ZodLiteral<"aborted">]>>;
+        attempts: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        name: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        decision: z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>;
+        confirmed_by: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            policy: "policy";
+        }>>>;
+        policy: z.ZodEnum<{
+            rerun: "rerun";
+            report: "report";
+        }>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        result: z.ZodObject<{
+            output: z.ZodString;
+            content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>;
+            is_error: z.ZodDefault<z.ZodBoolean>;
+            notes: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            concludes_turn: z.ZodOptional<z.ZodLiteral<true>>;
+            call_id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        owner: z.ZodString;
+        dependency: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        deadline_at: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_seq: z.ZodNumber;
+        value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip> | z.ZodObject<{
+        request_id: z.ZodString;
+        tool_call: z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        request_id: z.ZodString;
+        approved: z.ZodBoolean;
+        rejection_message: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip> | z.ZodObject<{
+        agent_name: z.ZodString;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        fork: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            thread_id: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>>>;
+        origin: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            caller_thread_id: z.ZodString;
+            source_seq: z.ZodNumber;
+            cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"call">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"assignment">;
+                owner: z.ZodString;
+                key: z.ZodJSONSchema;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>>>;
+        environment: z.ZodObject<{
+            cwd: z.ZodString;
+            read_roots: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        installations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            installation_id: z.ZodString;
+            preset_id: z.ZodString;
+            config: z.ZodJSONSchema;
+            lifetime: z.ZodEnum<{
+                defining: "defining";
+                configurable: "configurable";
+            }>;
+        }, z.core.$strict>>>;
+        requires: z.ZodArray<z.ZodString>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        installation_id: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        blocks: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                base: "base";
+                instruction: "instruction";
+                context: "context";
+            }>;
+            tag: z.ZodNullable<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        run_id: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        run_id: z.ZodString;
+        input_id: z.ZodNullable<z.ZodString>;
+        releases: z.ZodBoolean;
+        chain: z.ZodEnum<{
+            person: "person";
+            fresh: "fresh";
+            reactive: "reactive";
+        }>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict> | z.ZodObject<{
+        run_id: z.ZodString;
+        outcome: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            superseded: "superseded";
+        }>;
+        reason: z.ZodEnum<{
+            turn: "turn";
+            answered: "answered";
+            nothing: "nothing";
+            setup: "setup";
+            cancel: "cancel";
+            obsolete: "obsolete";
+        }>;
+        error_text: z.ZodNullable<z.ZodString>;
+        through: z.ZodNumber;
+        residual: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict> | z.ZodObject<{
+        cancel_id: z.ZodString;
+        intent: z.ZodEnum<{
+            user: "user";
+            cleanup: "cleanup";
+        }>;
+        run_id: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        target: z.ZodEnum<{
+            "next-turn": "next-turn";
+            "next-step": "next-step";
+        }>;
+        start: z.ZodNumber;
+        removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        inserted: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodDefault<z.ZodEnum<{
+                developer: "developer";
+                user: "user";
+            }>>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+            source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                plugin: z.ZodString;
+                instance_id: z.ZodDefault<z.ZodString>;
+                kind: z.ZodString;
+                version: z.ZodNumber;
+                data: z.ZodJSONSchema;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        step: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        llm_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+    }, z.core.$strip>;
+    source_seqs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>, ...z.ZodObject<{
+    seq: z.ZodNumber;
+    type: z.ZodLiteral<"error" | "ext" | "turn/start" | "turn/end" | "step/start" | "step/end" | "input/message" | "llm/request" | "assistant/message" | "assistant/attempt" | "auxiliary/request" | "auxiliary/result" | "tool/call" | "tool/authorization" | "tool/result" | "wait/declared" | "wait/resolved" | "confirm/requested" | "confirm/resolved" | "thread/spawned" | "installation/applied" | "installation/removed" | "thread/prompt" | "thread/tools" | "run/requested" | "run/cause" | "run/settled" | "thread/cancel" | "inbox/spliced" | "surface/replaced">;
+    timestamp: z.ZodDefault<z.ZodISODateTime>;
+    thread_id: z.ZodString;
+    data: z.ZodObject<{
+        plugin: z.ZodString;
+        instance_id: z.ZodDefault<z.ZodString>;
+        kind: z.ZodString;
+        version: z.ZodNumber;
+        data: z.ZodJSONSchema;
+    }, z.core.$strip> | z.ZodObject<{
+        installation_id: z.ZodString;
+        preset_id: z.ZodString;
+        config: z.ZodJSONSchema;
+    }, z.core.$strict> | z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"span">;
+        stand_in: z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>;
+        trigger: z.ZodEnum<{
+            overflow: "overflow";
+            pressure: "pressure";
+            request: "request";
+        }>;
+        auxiliary_request_seq: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodLiteral<"rewrite">;
+        stand_in: z.ZodObject<{
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+        }, z.core.$strict>;
+    }, z.core.$strip>], "kind"> | z.ZodObject<{
+        turn: z.ZodNumber;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        run_id: z.ZodString;
+        attempt_cutoff: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"blocked">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"max-steps">;
+            limit: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"interrupted">;
+            cause: z.ZodEnum<{
+                abandoned: "abandoned";
+                "activation-changed": "activation-changed";
+                "judgment-invalidated": "judgment-invalidated";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"aborted">;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"error">;
+            error_text: z.ZodString;
+            failure_kind: z.ZodEnum<{
+                length: "length";
+                other: "other";
+                transport: "transport";
+                empty: "empty";
+                invalid: "invalid";
+                rate_limit: "rate_limit";
+                overloaded: "overloaded";
+                timeout: "timeout";
+                auth: "auth";
+                quota: "quota";
+                overflow: "overflow";
+            }>;
+            retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"rejected">;
+            rejections: z.ZodArray<z.ZodObject<{
+                reason: z.ZodString;
+                source: z.ZodObject<{
+                    plugin: z.ZodString;
+                    instance_id: z.ZodDefault<z.ZodString>;
+                    kind: z.ZodString;
+                    version: z.ZodNumber;
+                    data: z.ZodJSONSchema;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNumber;
+        role: z.ZodDefault<z.ZodEnum<{
+            developer: "developer";
+            user: "user";
+        }>>;
+        content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>;
+        input_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            plugin: z.ZodString;
+            instance_id: z.ZodDefault<z.ZodString>;
+            kind: z.ZodString;
+            version: z.ZodNumber;
+            data: z.ZodJSONSchema;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodDefault<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        response: z.ZodObject<{
+            message: z.ZodObject<{
+                role: z.ZodEnum<{
+                    system: "system";
+                    developer: "developer";
+                    user: "user";
+                    assistant: "assistant";
+                    tool: "tool";
+                }>;
+                content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"image">;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    detail: z.ZodDefault<z.ZodEnum<{
+                        auto: "auto";
+                        low: "low";
+                        high: "high";
+                    }>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"file">;
+                    file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>], "type">>>, unknown>;
+                reasoning_content: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>, z.ZodObject<{
+                    call_id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodNull;
+                    malformed: z.ZodObject<{
+                        raw: z.ZodString;
+                        error: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$loose>]>>>;
+                provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    status: z.ZodDefault<z.ZodEnum<{
+                        in_progress: "in_progress";
+                        completed: "completed";
+                        failed: "failed";
+                    }>>;
+                    summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$loose>>>;
+                tool_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    input_tokens: z.ZodDefault<z.ZodNumber>;
+                    output_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+                    reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                provider_state: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    provider: z.ZodString;
+                    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            finish: z.ZodEnum<{
+                length: "length";
+                completed: "completed";
+                other: "other";
+            }>;
+            provider_metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        interrupted: z.ZodDefault<z.ZodBoolean>;
+        attempts: z.ZodNumber;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        llm_call_id: z.ZodString;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+        attempts: z.ZodNumber;
+        retry_after_ms: z.ZodNullable<z.ZodNumber>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        model: z.ZodString;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>;
+        message_count: z.ZodNumber;
+        surface_message_count: z.ZodNumber;
+        instructions: z.ZodArray<z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            detail: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>], "type">>>, unknown>>;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodNullable<z.ZodNumber>;
+        step: z.ZodNullable<z.ZodNumber>;
+        llm_call_id: z.ZodString;
+        usage: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            input_tokens: z.ZodDefault<z.ZodNumber>;
+            output_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodDefault<z.ZodNumber>;
+            cache_write_input_tokens: z.ZodDefault<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        text: z.ZodNullable<z.ZodString>;
+        finish: z.ZodNullable<z.ZodEnum<{
+            length: "length";
+            completed: "completed";
+            other: "other";
+        }>>;
+        tool_calls: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>, z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodNull;
+            malformed: z.ZodObject<{
+                raw: z.ZodString;
+                error: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$loose>]>>>;
+        provider_calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            status: z.ZodDefault<z.ZodEnum<{
+                in_progress: "in_progress";
+                completed: "completed";
+                failed: "failed";
+            }>>;
+            summary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        error_text: z.ZodNullable<z.ZodString>;
+        error_kind: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>, z.ZodLiteral<"aborted">]>>;
+        attempts: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        name: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        decision: z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>;
+        confirmed_by: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            policy: "policy";
+        }>>>;
+        policy: z.ZodEnum<{
+            rerun: "rerun";
+            report: "report";
+        }>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        result: z.ZodObject<{
+            output: z.ZodString;
+            content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>;
+            is_error: z.ZodDefault<z.ZodBoolean>;
+            notes: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            concludes_turn: z.ZodOptional<z.ZodLiteral<true>>;
+            call_id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_id: z.ZodString;
+        call_seq: z.ZodNumber;
+        owner: z.ZodString;
+        dependency: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        deadline_at: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        call_seq: z.ZodNumber;
+        value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip> | z.ZodObject<{
+        request_id: z.ZodString;
+        tool_call: z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>;
+        reason: z.ZodString;
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip> | z.ZodObject<{
+        request_id: z.ZodString;
+        approved: z.ZodBoolean;
+        rejection_message: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip> | z.ZodObject<{
+        agent_name: z.ZodString;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        fork: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            thread_id: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>>>;
+        origin: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            caller_thread_id: z.ZodString;
+            source_seq: z.ZodNumber;
+            cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"call">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"assignment">;
+                owner: z.ZodString;
+                key: z.ZodJSONSchema;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>>>;
+        environment: z.ZodObject<{
+            cwd: z.ZodString;
+            read_roots: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        installations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            installation_id: z.ZodString;
+            preset_id: z.ZodString;
+            config: z.ZodJSONSchema;
+            lifetime: z.ZodEnum<{
+                defining: "defining";
+                configurable: "configurable";
+            }>;
+        }, z.core.$strict>>>;
+        requires: z.ZodArray<z.ZodString>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        installation_id: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        blocks: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                base: "base";
+                instruction: "instruction";
+                context: "context";
+            }>;
+            tag: z.ZodNullable<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip> | z.ZodObject<{
+        run_id: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        run_id: z.ZodString;
+        input_id: z.ZodNullable<z.ZodString>;
+        releases: z.ZodBoolean;
+        chain: z.ZodEnum<{
+            person: "person";
+            fresh: "fresh";
+            reactive: "reactive";
+        }>;
+        route: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            thinking_effort: z.ZodNullable<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                none: "none";
+                medium: "medium";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict> | z.ZodObject<{
+        run_id: z.ZodString;
+        outcome: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            superseded: "superseded";
+        }>;
+        reason: z.ZodEnum<{
+            turn: "turn";
+            answered: "answered";
+            nothing: "nothing";
+            setup: "setup";
+            cancel: "cancel";
+            obsolete: "obsolete";
+        }>;
+        error_text: z.ZodNullable<z.ZodString>;
+        through: z.ZodNumber;
+        residual: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict> | z.ZodObject<{
+        cancel_id: z.ZodString;
+        intent: z.ZodEnum<{
+            user: "user";
+            cleanup: "cleanup";
+        }>;
+        run_id: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        target: z.ZodEnum<{
+            "next-turn": "next-turn";
+            "next-step": "next-step";
+        }>;
+        start: z.ZodNumber;
+        removed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        inserted: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodDefault<z.ZodEnum<{
+                developer: "developer";
+                user: "user";
+            }>>;
+            content: z.ZodPreprocess<z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                detail: z.ZodDefault<z.ZodEnum<{
+                    auto: "auto";
+                    low: "low";
+                    high: "high";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                file_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                data: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                filename: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                media_type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>], "type">>>, unknown>;
+            source: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                plugin: z.ZodString;
+                instance_id: z.ZodDefault<z.ZodString>;
+                kind: z.ZodString;
+                version: z.ZodNumber;
+                data: z.ZodJSONSchema;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip> | z.ZodObject<{
+        turn: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        step: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        llm_call_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+    }, z.core.$strip>;
+    source_seqs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>[]], "type">;
+export declare const parseJournalEvent: (value: unknown) => JournalEvent;
+/** Whether this is a forked thread's spawn row: where a fold resets what a fork does not inherit. */
+export declare const isForkSpawn: (event: JournalEvent) => event is JournalEvent<"thread/spawned">;
+/** Whether an event appends to the model-visible message surface. */
+export declare const isSurfaceEvent: (event: JournalEvent) => event is JournalEvent<SurfaceEventType>;
+/** One confirmation a thread still waits on, as its summary lists it: enough to find it, not to show it. */
+export declare const ConfirmationDescriptorSchema: z.ZodObject<{
+    request_id: z.ZodString;
+    call_seq: z.ZodNullable<z.ZodNumber>;
+    tool_name: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type ConfirmationDescriptor = z.infer<typeof ConfirmationDescriptorSchema>;
+/**
+ * One call a thread has suspended, as its summary lists it: declared and unanswered, `resolved` once
+ * its value is recorded while the call waits to be dispatched again.
+ */
+export declare const WaitDescriptorSchema: z.ZodObject<{
+    call_seq: z.ZodNumber;
+    owner: z.ZodString;
+    deadline_at: z.ZodNullable<z.ZodNumber>;
+    reason: z.ZodString;
+    resolved: z.ZodBoolean;
+}, z.core.$strip>;
+export type WaitDescriptor = z.infer<typeof WaitDescriptorSchema>;
+/**
+ * A thread's catalog entry: what the journal keeps of a thread so that listing it, finding it and
+ * deciding whether a restart should run it need none of its rows in memory. Derived from the
+ * thread's own rows by core, written in the same transaction as the rows that change it, and
+ * rebuildable from them. Core's fields are a hint for finding and a record for listing, never an
+ * authority for acting. `contributions` is what plugins and hosts registered, keyed by contributor:
+ * a listing hint for most, and for a plugin whose contribution is total and fails closed when
+ * unavailable, what it decides from.
+ */
+export declare const ThreadSummarySchema: z.ZodObject<{
+    thread_id: z.ZodString;
+    spawn_seq: z.ZodNumber;
+    through_seq: z.ZodNumber;
+    agent_name: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    fork: z.ZodNullable<z.ZodObject<{
+        thread_id: z.ZodString;
+        seq: z.ZodNumber;
+    }, z.core.$strip>>;
+    origin: z.ZodNullable<z.ZodObject<{
+        caller_thread_id: z.ZodString;
+        source_seq: z.ZodNumber;
+        cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"call">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"assignment">;
+            owner: z.ZodString;
+            key: z.ZodJSONSchema;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>;
+    environment: z.ZodObject<{
+        cwd: z.ZodString;
+        read_roots: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    has_work: z.ZodBoolean;
+    turn_open: z.ZodBoolean;
+    last_reason: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"completed">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"blocked">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"max-steps">;
+        limit: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"interrupted">;
+        cause: z.ZodEnum<{
+            abandoned: "abandoned";
+            "activation-changed": "activation-changed";
+            "judgment-invalidated": "judgment-invalidated";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"aborted">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"error">;
+        error_text: z.ZodString;
+        failure_kind: z.ZodEnum<{
+            length: "length";
+            other: "other";
+            transport: "transport";
+            empty: "empty";
+            invalid: "invalid";
+            rate_limit: "rate_limit";
+            overloaded: "overloaded";
+            timeout: "timeout";
+            auth: "auth";
+            quota: "quota";
+            overflow: "overflow";
+        }>;
+        retry_after_ms: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        rejections: z.ZodArray<z.ZodObject<{
+            reason: z.ZodString;
+            source: z.ZodObject<{
+                plugin: z.ZodString;
+                instance_id: z.ZodDefault<z.ZodString>;
+                kind: z.ZodString;
+                version: z.ZodNumber;
+                data: z.ZodJSONSchema;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">>;
+    route: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        thinking_effort: z.ZodNullable<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            none: "none";
+            medium: "medium";
+            max: "max";
+        }>>;
+    }, z.core.$strip>;
+    queued_input: z.ZodNumber;
+    unanswered_confirmations: z.ZodArray<z.ZodObject<{
+        request_id: z.ZodString;
+        call_seq: z.ZodNullable<z.ZodNumber>;
+        tool_name: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    waits: z.ZodArray<z.ZodObject<{
+        call_seq: z.ZodNumber;
+        owner: z.ZodString;
+        deadline_at: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodString;
+        resolved: z.ZodBoolean;
+    }, z.core.$strip>>;
+    pending_run: z.ZodNullable<z.ZodObject<{
+        run_id: z.ZodString;
+        newest_cause_at: z.ZodNullable<z.ZodString>;
+        releasing: z.ZodBoolean;
+        cancelled: z.ZodBoolean;
+    }, z.core.$strip>>;
+    latest_settlement: z.ZodNullable<z.ZodObject<{
+        run_id: z.ZodString;
+        outcome: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            superseded: "superseded";
+        }>;
+        reason: z.ZodEnum<{
+            turn: "turn";
+            answered: "answered";
+            nothing: "nothing";
+            setup: "setup";
+            cancel: "cancel";
+            obsolete: "obsolete";
+        }>;
+        error_text: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    latest_user_cancel: z.ZodNullable<z.ZodObject<{
+        seq: z.ZodNumber;
+        released: z.ZodBoolean;
+    }, z.core.$strip>>;
+    requires: z.ZodArray<z.ZodString>;
+    answered_at: z.ZodNullable<z.ZodNumber>;
+    contributions: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strip>;
+export type ThreadSummary = DeepReadonly<z.infer<typeof ThreadSummarySchema>>;
+export {};