@contraagent/api 0.0.0-stage → 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,3718 @@
+export type paths = {
+    "/api/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Info
+         * @description The title, the panel tabs to offer, and the version of this contract.
+         */
+        get: operations["api_info_api_info_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Runs
+         * @description Every run directory, newest activity first.
+         */
+        get: operations["api_runs_api_runs_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/hosts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Hosts
+         * @description The hosts that drive the runs, and each account's utilization over every run.
+         */
+        get: operations["api_hosts_api_hosts_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/trends": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Trends
+         * @description What the runs of a period add up to, day by day.
+         */
+        get: operations["api_trends_api_trends_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/trends/panels/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Trend Panel
+         * @description One trend panel's body: its `fn(runs, period)` over the runs of the period, made on a
+         *     panel thread, and kept for the same period over the same runs (`Monitor.trends_panel`).
+         */
+        get: operations["api_trend_panel_api_trends_panels__name__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/journal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Journal
+         * @description Journal rows after line offset `since`; `total` is the next offset.
+         */
+        get: operations["api_journal_api_runs__run__journal_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/plan": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Plan
+         * @description Every queued task with its dependencies and state, and the groups the UI draws as columns.
+         */
+        get: operations["api_plan_api_runs__run__plan_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/outputs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Outputs
+         * @description Every declared output/input contract: its file, the model it must satisfy, its status.
+         */
+        get: operations["api_outputs_api_runs__run__outputs_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/definitions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Definitions
+         * @description What defined each kind of task in this run.
+         */
+        get: operations["api_definitions_api_runs__run__definitions_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/cursor": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Cursor
+         * @description The resume cursor; `{}` when the run keeps none.
+         */
+        get: operations["api_cursor_api_runs__run__cursor_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/procs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Procs
+         * @description The run's live agent launches, process tree and Python tasks.
+         */
+        get: operations["api_procs_api_runs__run__procs_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/task/{key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Task
+         * @description One task, by its key: journal rows, live launches, definition, input/output, transcript name.
+         */
+        get: operations["api_task_api_runs__run__task__key__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/stream/{key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Stream
+         * @description A page of task `key`'s normalized transcript from line `since`; `since=0` is the tail page.
+         */
+        get: operations["api_stream_api_runs__run__stream__key__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/runs/{run}/panels/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Api Panel
+         * @description One run panel's body: a typed body (tiles, a table, charts), or any JSON object;
+         *     made on a panel thread.
+         */
+        get: operations["api_panel_api_runs__run__panels__name__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Events
+         * @description The run, live: journal rows as they land, then each other view when it changes.
+         */
+        get: operations["events_events_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/events/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Events Stream
+         * @description Task `key`'s transcript, live: the tail page, then the events after it as they are written.
+         */
+        get: operations["events_stream_events_stream_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+};
+export type webhooks = Record<string, never>;
+export type components = {
+    schemas: {
+        /**
+         * AccountQuota
+         * @description One account's subscription utilization over a run. `last` was taken when the
+         *     account's last session started, so it leaves out that session's own use.
+         */
+        AccountQuota: {
+            /** Credential */
+            credential: string;
+            /**
+             * Account
+             * @description the account the readings are of (`QuotaReading.account`); empty when not known
+             * @default
+             */
+            account?: string;
+            first: components["schemas"]["QuotaReading"];
+            last: components["schemas"]["QuotaReading"];
+            /**
+             * Rests
+             * @description its rests now (`/api/hosts`): those a live run began and that have not ended, nor passed their `until`
+             */
+            rests?: components["schemas"]["CredentialRest"][];
+        };
+        /**
+         * AgentProcess
+         * @description One live agent launch: the topmost process of a coding-agent CLI, found by its
+         *     `CONTRAAGENT_*` environment; or, for an agent behind a library-call backend (no
+         *     child process), the run's own process, from its in-flight marker, with empty
+         *     `cmd`, `full_cmd`, `role`, `model` and `plugin`.
+         */
+        AgentProcess: {
+            /** Pid */
+            pid: number;
+            /** Age S */
+            age_s: number;
+            /**
+             * Cmd
+             * @description the first three words of the command line
+             */
+            cmd: string;
+            /** Full Cmd */
+            full_cmd: string;
+            /** Children */
+            children?: components["schemas"]["ProcNode"][];
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /** Unit */
+            unit: string;
+            /**
+             * Role
+             * @description the role it runs as, from the prompt's TELEMETRY line; empty when none
+             */
+            role: string;
+            /** Model */
+            model: string;
+            /** Plugin */
+            plugin: string;
+        };
+        /**
+         * BlocksBody
+         * @description Bodies one under another: a panel of several parts.
+         */
+        BlocksBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default blocks
+             * @constant
+             */
+            type?: "blocks";
+            /** Blocks */
+            blocks: (components["schemas"]["TilesBody"] | components["schemas"]["TableBody"] | components["schemas"]["ColumnsBody"] | components["schemas"]["LinesBody"] | components["schemas"]["HeatmapBody"] | components["schemas"]["HBarsBody"] | components["schemas"]["StatusGridBody"] | components["schemas"]["NoteBody"] | components["schemas"]["BlocksBody"] | {
+                [key: string]: unknown;
+            })[];
+        };
+        /**
+         * Changes
+         * @description The files one attempt changed under its task's `changes` patterns, as paths relative
+         *     to the working directory: those it `created`, `modified` and `deleted`.
+         */
+        Changes: {
+            /**
+             * Created
+             * @default []
+             */
+            created?: string[];
+            /**
+             * Modified
+             * @default []
+             */
+            modified?: string[];
+            /**
+             * Deleted
+             * @default []
+             */
+            deleted?: string[];
+            /**
+             * Removed
+             * @default []
+             */
+            removed?: string[];
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ChartSeries
+         * @description One series: a value per label of the chart's `x`; null where it has none.
+         */
+        ChartSeries: {
+            /** Name */
+            name: string;
+            /** Values */
+            values: (number | null)[];
+        };
+        /**
+         * ColumnsBody
+         * @description Vertical bars, one group per label of `x`; `stacked` puts the series of a label on one bar.
+         */
+        ColumnsBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default columns
+             * @constant
+             */
+            type?: "columns";
+            /** X */
+            x: string[];
+            /** Series */
+            series: components["schemas"]["ChartSeries"][];
+            /** Unit */
+            unit?: ("usd" | "pct" | "duration" | "tokens" | "datetime" | "number") | null;
+            /**
+             * Stacked
+             * @default false
+             */
+            stacked?: boolean;
+        };
+        /**
+         * ContractField
+         * @description One top-level field of the model a contract file must satisfy.
+         */
+        ContractField: {
+            /** Name */
+            name: string;
+            /**
+             * Type
+             * @description JSON-schema type, `list[...]`, a `$ref` name, or `a|b` for a union
+             */
+            type: string;
+            /** Required */
+            required: boolean;
+        };
+        /**
+         * ContractRecord
+         * @description What one task declared it reads and leaves behind (`contracts/<key>.json`).
+         */
+        ContractRecord: {
+            /** Key */
+            key: string;
+            /**
+             * Kind
+             * @default
+             */
+            kind?: string;
+            /**
+             * Unit
+             * @default
+             */
+            unit?: string;
+            /**
+             * Executor
+             * @default agent
+             * @enum {string}
+             */
+            executor?: "agent" | "python";
+            /**
+             * Params
+             * @description the task's params that are strings, numbers or booleans; an earlier task's output is one of `inputs`
+             */
+            params?: {
+                [key: string]: string | number | boolean;
+            };
+            /** Outputs */
+            outputs?: components["schemas"]["ContractSpec"][];
+            /** Inputs */
+            inputs?: components["schemas"]["ContractSpec"][];
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ContractSpec
+         * @description One declared `OutputContract` / `InputContract` (its record, passed through,
+         *     minus the raw JSON schema, which `fields` summarizes). `status`, `rounds`
+         *     and `errors` are on outputs only.
+         */
+        ContractSpec: {
+            /**
+             * Io
+             * @enum {string}
+             */
+            io: "output" | "input";
+            /** Path */
+            path: string;
+            /**
+             * Producer
+             * @description input: the key of the task whose output it is
+             */
+            producer?: string | null;
+            /** Schema Name */
+            schema_name: string;
+            /**
+             * Schema Ref
+             * @default
+             */
+            schema_ref?: string;
+            /** Fresh */
+            fresh?: boolean | null;
+            /** Required */
+            required?: boolean | null;
+            /** Validators */
+            validators?: string[];
+            /**
+             * Preserve
+             * @description output: JSON pointers to the parts of the file the task keeps as they were (`*`: every member)
+             */
+            preserve?: string[];
+            file: components["schemas"]["FileView"];
+            /** Fields */
+            fields: components["schemas"]["ContractField"][];
+            /** Status */
+            status?: ("valid" | "invalid" | "refused" | "pending" | "failed" | "running") | null;
+            /**
+             * Rounds
+             * @description rounds it took to pass, when the journal recorded it
+             */
+            rounds?: number | null;
+            /** Errors */
+            errors?: string[];
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * CredentialRest
+         * @description A rest of one credential (`rests.jsonl`): why it began, when, and when it ended.
+         */
+        CredentialRest: {
+            /** Credential */
+            credential: string;
+            /**
+             * Window
+             * @default
+             * @enum {string}
+             */
+            window?: "" | "five_hour" | "seven_day";
+            /** Pct */
+            pct?: number | null;
+            /** Cap */
+            cap?: number | null;
+            /**
+             * Rule
+             * @default
+             */
+            rule?: string;
+            /**
+             * Until
+             * @default
+             */
+            until?: string;
+            /**
+             * Account
+             * @default
+             */
+            account?: string;
+            /** Reading */
+            reading?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Since
+             * @description when it began resting, ISO 8601
+             */
+            since: string;
+            /**
+             * Ended
+             * @description when it was found not resting again, ISO 8601; empty while it rests (or the run ended first)
+             * @default
+             */
+            ended?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * CursorMessage
+         * @description The resume cursor, or null for a run that keeps none.
+         */
+        CursorMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "cursor";
+            data: components["schemas"]["CursorView"] | null;
+        };
+        /**
+         * CursorView
+         * @description The run's resume cursor. The REST endpoint answers `{}` (every field
+         *     absent) for a run that keeps none; the live feed sends `null`.
+         */
+        CursorView: {
+            /** Stage */
+            stage?: string | null;
+            /** Completed Stages */
+            completed_stages?: string[];
+            /** History */
+            history?: components["schemas"]["StageEntry"][];
+            /**
+             * Updated At
+             * @default
+             */
+            updated_at?: string;
+            /** Units */
+            units?: {
+                [key: string]: components["schemas"]["UnitPosition"];
+            };
+            /**
+             * Markers
+             * @description free-form event lists by name
+             */
+            markers?: {
+                [key: string]: {
+                    [key: string]: unknown;
+                }[];
+            };
+        };
+        /**
+         * DeferralCause
+         * @description Why a task was deferred, as data (`Deferral.cause`). `cause`: `deadline`,
+         *     `grace_window` (past the deadline's grace window), `cannot_finish` (`need_s`, `left_s`),
+         *     `dependency_not_queued`, `dependency_deferred` (a task whose output it reads was
+         *     deferred: `dependency`), `rest` (the credential of every hop it could take rests:
+         *     `rests`), or a runner's own name. A field a cause does not have is left unset, and
+         *     `deferred.jsonl` records only the fields set.
+         */
+        DeferralCause: {
+            /** Cause */
+            cause: string;
+            /**
+             * Need S
+             * @description `cannot_finish`: the work it needed, in seconds
+             */
+            need_s?: number | null;
+            /**
+             * Left S
+             * @description `cannot_finish`: the time left before the deadline, in seconds
+             */
+            left_s?: number | null;
+            /**
+             * Flow Call
+             * @description `deadline`, `grace_window`, `cannot_finish`: the flow call whose time box it is; null for the run's deadline
+             */
+            flow_call?: string | null;
+            /**
+             * Rests
+             * @description `rest`: each hop passed over and why its credential rests
+             * @default []
+             */
+            rests?: components["schemas"]["SkippedHop"][];
+            /**
+             * Dependency
+             * @description `dependency_deferred`: the key of the deferred task whose output it reads
+             */
+            dependency?: string | null;
+        };
+        /**
+         * DefinitionFile
+         * @description One file that defines a task: its instructions (a task without a plugin), the role's agent file, a skill, the schema ...
+         */
+        DefinitionFile: {
+            /** Path */
+            path: string;
+            /** Part */
+            part: string;
+            /** Text */
+            text: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** DownstreamTask */
+        DownstreamTask: {
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /** Unit */
+            unit: string;
+            /**
+             * Executor
+             * @enum {string}
+             */
+            executor: "agent" | "python";
+        };
+        /**
+         * DroppedRoute
+         * @description A route the preflight dropped: not in its agent's model list, or its probe did not
+         *     complete. `kinds`: the kinds whose chain held it.
+         */
+        DroppedRoute: {
+            /** Agent */
+            agent: string;
+            /**
+             * Model
+             * @description empty: the coding agent's default model
+             */
+            model: string;
+            /** Credential */
+            credential: string;
+            /**
+             * Reason
+             * @description not in its coding agent's model list, or how its probe ended (`rate limited`, ...)
+             */
+            reason: string;
+            /**
+             * Kinds
+             * @description the kinds whose chain held it
+             */
+            kinds: string[];
+        };
+        /**
+         * ExportInfo
+         * @description What an export holds (`contraagent monitor export`): the monitor's views of some
+         *     runs, written as files and read without a server.
+         */
+        ExportInfo: {
+            /**
+             * Exported At
+             * @description when it was written, ISO 8601
+             */
+            exported_at: string;
+            /**
+             * Runs
+             * @description the runs it holds, newest activity first
+             */
+            runs: string[];
+            /**
+             * Left Out
+             * @description the views it does not hold: `transcripts`, `processes`
+             */
+            left_out: string[];
+            /**
+             * Redacted
+             * @description what was taken out of the views: `paths` (made relative, else `<path>`), `host`, and each key named with --exclude
+             */
+            redacted: string[];
+        };
+        /** FeedReady */
+        FeedReady: {
+            /**
+             * Journal
+             * @description journal rows sent before this message
+             */
+            journal: number;
+        };
+        /**
+         * FileView
+         * @description A contract's file as it is now. `content` is the parsed JSON, else the
+         *     text (cut at 20 000 characters, `truncated`), else null when unreadable.
+         */
+        FileView: {
+            /** Exists */
+            exists: boolean;
+            /**
+             * Size
+             * @default 0
+             */
+            size?: number;
+            /**
+             * Mtime
+             * @default
+             */
+            mtime?: string;
+            /**
+             * Truncated
+             * @default false
+             */
+            truncated?: boolean;
+            /** Content */
+            content?: unknown;
+        };
+        /**
+         * FlowCallNode
+         * @description One flow call (`flow_calls.jsonl`): a generator the run drove, or the flow itself.
+         */
+        FlowCallNode: {
+            /**
+             * Id
+             * @description `0` for the top flow, `<parent>.<n>` for a child
+             */
+            id: string;
+            /**
+             * Parent
+             * @description the parent flow call's id; null for a top flow
+             */
+            parent: string | null;
+            /**
+             * Function
+             * @description `module.qualname` of the generator function (or of a flow that does not yield)
+             */
+            function: string;
+            /**
+             * Flow
+             * @description the flow path where the parent yielded it, with its loops' passes; empty for a top flow
+             */
+            flow?: components["schemas"]["Frame"][];
+            /**
+             * State
+             * @enum {string}
+             */
+            state: "running" | "returned" | "raised" | "closed";
+            /**
+             * Error
+             * @description `<type>: <message>` of what it raised (or what closing it raised); else null
+             */
+            error?: string | null;
+            /** @description its own deadline, for a flow call yielded through `time_box`; else null */
+            time_box?: components["schemas"]["TimeBoxRecord"] | null;
+        };
+        /**
+         * Frame
+         * @description One frame of a flow path (outermost first): a call site in flow code where a task
+         *     was created. A comprehension is not a loop.
+         */
+        Frame: {
+            /**
+             * Function
+             * @description `module.qualname`
+             */
+            function: string;
+            /**
+             * File
+             * @description relative to the run's working directory when under it, else as recorded
+             */
+            file: string;
+            /** Line */
+            line: number;
+            /**
+             * Loops
+             * @description the loops of a generator whose pass `line` was in, outermost first; empty outside a loop and for any other frame
+             * @default []
+             */
+            loops?: components["schemas"]["Loop"][];
+        };
+        /**
+         * GridCell
+         * @description One cell of a status grid: the state it is in, in words, and that state's tone.
+         *     `tip` adds a fact about this cell to its tooltip (a run's id, a count).
+         */
+        GridCell: {
+            /** Label */
+            label: string;
+            /**
+             * Tone
+             * @enum {string}
+             */
+            tone: "failed" | "attention" | "done" | "running" | "muted" | "neutral";
+            /** Tip */
+            tip?: string | null;
+        };
+        /** HBar */
+        HBar: {
+            /** Label */
+            label: string;
+            /** Value */
+            value: number;
+            /** Tone */
+            tone?: ("failed" | "attention" | "done" | "running" | "muted" | "neutral") | null;
+        };
+        /**
+         * HBarsBody
+         * @description Horizontal bars, one per label, in the order given.
+         */
+        HBarsBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default hbars
+             * @constant
+             */
+            type?: "hbars";
+            /** Bars */
+            bars: components["schemas"]["HBar"][];
+            /** Unit */
+            unit?: ("usd" | "pct" | "duration" | "tokens" | "datetime" | "number") | null;
+        };
+        /** HTTPValidationError */
+        HTTPValidationError: {
+            /** Detail */
+            detail?: components["schemas"]["ValidationError"][];
+        };
+        /**
+         * HeatmapBody
+         * @description A value per row (`y`) and column (`x`): `values[row][column]`, null where there is none.
+         */
+        HeatmapBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default heatmap
+             * @constant
+             */
+            type?: "heatmap";
+            /** X */
+            x: string[];
+            /** Y */
+            y: string[];
+            /** Values */
+            values: (number | null)[][];
+            /** Unit */
+            unit?: ("usd" | "pct" | "duration" | "tokens" | "datetime" | "number") | null;
+        };
+        /**
+         * Hop
+         * @description One launch of an attempt on one route of its failover chain: where it ran and how
+         *     it ended.
+         */
+        Hop: {
+            /**
+             * Route
+             * @default
+             */
+            route?: string;
+            /**
+             * Agent
+             * @default
+             */
+            agent?: string;
+            /**
+             * Model
+             * @default
+             */
+            model?: string;
+            /**
+             * Credential
+             * @default
+             */
+            credential?: string;
+            /**
+             * Stop
+             * @default
+             */
+            stop?: string;
+            /**
+             * Wall S
+             * @default 0
+             */
+            wall_s?: number;
+            /** Cost Usd */
+            cost_usd?: number | null;
+            usage?: components["schemas"]["TokenUsage"] | null;
+            /** Other Models */
+            other_models?: {
+                [key: string]: components["schemas"]["OtherModel"];
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * HostSummary
+         * @description One host that drives runs.
+         */
+        HostSummary: {
+            /** Host Id */
+            host_id: string;
+            /**
+             * Up
+             * @description its reports keep arriving (a hub: a heartbeat within the TTL; one host: always)
+             */
+            up: boolean;
+            /**
+             * Last Seen
+             * @description when it last reported, ISO 8601; empty when it does not report (one host)
+             */
+            last_seen: string;
+            /**
+             * Interval S
+             * @description seconds between its reports; null when it does not report
+             */
+            interval_s: number | null;
+            /**
+             * Runs
+             * @description its runs
+             */
+            runs: number;
+            /**
+             * Running
+             * @description its runs whose process is alive
+             */
+            running: number;
+            /**
+             * Unresponsive
+             * @description its runs last reported alive since it stopped reporting
+             */
+            unresponsive: number;
+        };
+        /**
+         * Hosts
+         * @description The hosts, and each account's utilization over every run of every host.
+         */
+        Hosts: {
+            /** Hosts */
+            hosts: components["schemas"]["HostSummary"][];
+            /**
+             * Quota
+             * @description per credential (account): its first and last utilization reading over every run; highest weekly use first
+             */
+            quota?: components["schemas"]["AccountQuota"][];
+        };
+        /**
+         * InflightPythonTask
+         * @description A Python task running inside the run's own process.
+         */
+        InflightPythonTask: {
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /** Unit */
+            unit: string;
+            /** Pid */
+            pid: number;
+            /** Age S */
+            age_s: number;
+        };
+        /**
+         * Info
+         * @description What the UI shows before a run is picked: the title, the panel tabs to offer,
+         *     and the version of this contract.
+         */
+        Info: {
+            /** Title */
+            title: string;
+            /** Panels */
+            panels: components["schemas"]["PanelInfo"][];
+            /**
+             * Api Version
+             * @description Version of this API contract (semver)
+             */
+            api_version: string;
+            /**
+             * Hosts
+             * @description the runs come from many hosts (a hub): `/api/hosts` lists them
+             * @default false
+             */
+            hosts?: boolean;
+            /** @description set only in an export: what it holds; a server never sends it */
+            export?: components["schemas"]["ExportInfo"] | null;
+        };
+        /**
+         * JournalMessage
+         * @description One journal row, sent once per row: the whole journal on connect, then each new row.
+         */
+        JournalMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "journal";
+            data: components["schemas"]["JournalRow"];
+        };
+        /**
+         * JournalPage
+         * @description Journal rows after a line offset; pass `total` back as `since` to get only newer rows.
+         */
+        JournalPage: {
+            /** Entries */
+            entries: components["schemas"]["JournalRow"][];
+            /** Total */
+            total: number;
+        };
+        /**
+         * JournalRow
+         * @description One finished attempt. `key` is the stable `Task.key`, one task; `kind`
+         *     and `unit` are its kind and unit; `executor` says who ran it; `stop` is
+         *     `Stop.value` (or a Python task's completed/error).
+         */
+        JournalRow: {
+            /** Ts */
+            ts: string;
+            /**
+             * Run Id
+             * @default
+             */
+            run_id?: string;
+            /**
+             * Run Group
+             * @default
+             */
+            run_group?: string;
+            /** Key */
+            key: string;
+            /**
+             * Attempt
+             * @default 0
+             */
+            attempt?: number;
+            /** Kind */
+            kind: string;
+            /**
+             * Executor
+             * @default agent
+             * @enum {string}
+             */
+            executor?: "agent" | "python";
+            /**
+             * Unit
+             * @default
+             */
+            unit?: string;
+            /**
+             * Agent
+             * @default
+             */
+            agent?: string;
+            /**
+             * Model
+             * @default
+             */
+            model?: string;
+            /**
+             * Credential
+             * @default
+             */
+            credential?: string;
+            /**
+             * Route
+             * @default
+             */
+            route?: string;
+            /** Hops */
+            hops?: components["schemas"]["Hop"][];
+            /** Skipped Hops */
+            skipped_hops?: components["schemas"]["SkippedHop"][];
+            /**
+             * Stop
+             * @enum {string}
+             */
+            stop: "completed" | "timeout" | "max_turns" | "budget" | "context_budget" | "stalled" | "auth_failed" | "api_error" | "rate_limited" | "refused" | "aborted" | "denied" | "error" | "no_output" | "launch_failed" | "invalid_output" | "invalid_input" | "credential_mismatch" | "skipped" | "partial";
+            /** Ok */
+            ok: boolean;
+            /**
+             * Wall S
+             * @default 0
+             */
+            wall_s?: number;
+            /** Exit Code */
+            exit_code?: number | null;
+            /** Signal */
+            signal?: number | null;
+            /**
+             * Reason
+             * @default
+             */
+            reason?: string;
+            /** Rounds */
+            rounds?: number | null;
+            /** Round Errors */
+            round_errors?: string[][];
+            /** Hook Errors */
+            hook_errors?: string[][];
+            usage?: components["schemas"]["TokenUsage"] | null;
+            /** Cost Usd */
+            cost_usd?: number | null;
+            /** Quota */
+            quota?: components["schemas"]["QuotaReading"][];
+            /** Web Queries */
+            web_queries?: string[];
+            /** Unread Events */
+            unread_events?: {
+                [key: string]: number;
+            };
+            changes?: components["schemas"]["Changes"] | null;
+            /** Context Budget */
+            context_budget?: number | null;
+            /**
+             * Context Warned
+             * @default false
+             */
+            context_warned?: boolean;
+            /**
+             * Fingerprint
+             * @default
+             */
+            fingerprint?: string;
+            /** Flow Call */
+            flow_call?: string | null;
+            /**
+             * Replayed
+             * @default false
+             */
+            replayed?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * KeptKind
+         * @description A kind with no route left, run as configured all the same (`substitute`), and why.
+         */
+        KeptKind: {
+            /** Kind */
+            kind: string;
+            /** Agent */
+            agent: string;
+            /** Model */
+            model: string;
+            /** Reason */
+            reason: string;
+        };
+        /**
+         * LaunchEvent
+         * @description Head of one invocation: the exact argv, cwd and the submitted prompt.
+         */
+        LaunchEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "launch";
+            /**
+             * Ts
+             * @description Unix time the launch started
+             */
+            ts?: number | null;
+            /** Argv */
+            argv: string[];
+            /** Cwd */
+            cwd: string;
+            /**
+             * Prompt
+             * @description cut at 200 000 characters
+             */
+            prompt: string;
+            /**
+             * Prompt Truncated
+             * @description characters of the prompt not shown
+             * @default 0
+             */
+            prompt_truncated?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        /** LinesBody */
+        LinesBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default lines
+             * @constant
+             */
+            type?: "lines";
+            /** X */
+            x: string[];
+            /** Series */
+            series: components["schemas"]["ChartSeries"][];
+            /** Unit */
+            unit?: ("usd" | "pct" | "duration" | "tokens" | "datetime" | "number") | null;
+        };
+        /**
+         * Loop
+         * @description A `for` or `while` loop of a generator around a call site, and the pass the call
+         *     site was in.
+         */
+        Loop: {
+            /**
+             * Line
+             * @description the loop's first line, which names it
+             */
+            line: number;
+            /**
+             * Pass
+             * @description one iteration of this loop, numbered from 1 since the loop was last entered in that frame; null when not counted
+             */
+            pass: number | null;
+        };
+        /**
+         * MessageEvent
+         * @description omp: a whole message or a turn's closing thinking. Either `role` + `text`, or `thinking`.
+         */
+        MessageEvent: {
+            /**
+             * Type
+             * @enum {string}
+             */
+            type: "message_start" | "message_end" | "turn_end";
+            /** Role */
+            role?: string | null;
+            /** Text */
+            text?: string | null;
+            /** Thinking */
+            thinking?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * MessageUpdateEvent
+         * @description A piece of assistant prose: `ev` is `text_delta` or `thinking_delta` (omp may send its other delta kinds).
+         */
+        MessageUpdateEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "message_update";
+            /** Ev */
+            ev: string;
+            /** Delta */
+            delta: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ModelUsage
+         * @description What a run's agent sessions spent on one model of one coding agent, from each
+         *     journal row's hops (a failover's hops on two models count apart), a hop's spend on
+         *     other models (`Hop.other_models`) on each of them. Python tasks have no model and are
+         *     not counted.
+         */
+        ModelUsage: {
+            /** Agent */
+            agent: string;
+            /** Model */
+            model: string;
+            /**
+             * Sessions
+             * @description hops: agent sessions launched on it (pool members tried on one hop count once); 0 for an other model only
+             */
+            sessions: number;
+            /**
+             * Calls
+             * @description API calls
+             * @default 0
+             */
+            calls?: number;
+            /**
+             * Input
+             * @default 0
+             */
+            input?: number;
+            /**
+             * Output
+             * @default 0
+             */
+            output?: number;
+            /**
+             * Cache Read
+             * @default 0
+             */
+            cache_read?: number;
+            /**
+             * Cache Creation
+             * @default 0
+             */
+            cache_creation?: number;
+            /**
+             * Cost Usd
+             * @description what the coding agent reported; null when no session on it reported a cost
+             */
+            cost_usd?: number | null;
+            /**
+             * Wall S
+             * @default 0
+             */
+            wall_s?: number;
+            /**
+             * Peak Context
+             * @description peak context: the largest input of one API call of a session on it (tokens); null when none reported one
+             */
+            peak_context?: number | null;
+            /**
+             * Context Window
+             * @description its context window (tokens of one API call's input) as the coding agent reported it; null when none did
+             */
+            context_window?: number | null;
+        };
+        /**
+         * NoteBody
+         * @description Text beside the figures: what a part shows, how to read a number. `text` is
+         *     markdown (paragraphs, lists, emphasis, code, http(s) links; any markup in it is shown
+         *     as text). `tone` marks a note that warns (`attention`) or reports a failure (`failed`).
+         */
+        NoteBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default note
+             * @constant
+             */
+            type?: "note";
+            /** Text */
+            text: string;
+            /** Tone */
+            tone?: ("failed" | "attention" | "done" | "running" | "muted" | "neutral") | null;
+        };
+        /**
+         * NoticeEvent
+         * @description A line of session bookkeeping: init, a retry, a rate-limit status, a custom message.
+         */
+        NoticeEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "notice";
+            /** Text */
+            text: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * OtherEvent
+         * @description Any other event: omp's bare lifecycle markers (`agent_start`, `agent_end`,
+         *     `turn_start`, `auto_retry_end`) and whatever a custom backend's registered
+         *     normalizer emits, including a known `type` whose fields do not match above.
+         */
+        OtherEvent: {
+            /** Type */
+            type: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * OtherModel
+         * @description What a hop spent on a model other than its own (`Hop.other_models`).
+         */
+        OtherModel: {
+            /** Cost Usd */
+            cost_usd?: number | null;
+            /**
+             * Input
+             * @default 0
+             */
+            input?: number;
+            /**
+             * Output
+             * @default 0
+             */
+            output?: number;
+            /**
+             * Cache Read
+             * @default 0
+             */
+            cache_read?: number;
+            /**
+             * Cache Creation
+             * @default 0
+             */
+            cache_creation?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        /** OutputTally */
+        OutputTally: {
+            /** Valid */
+            valid: number;
+            /** Invalid */
+            invalid: number;
+            /** Refused */
+            refused: number;
+            /** Pending */
+            pending: number;
+            /** Failed */
+            failed: number;
+            /** Running */
+            running: number;
+        };
+        /** Outputs */
+        Outputs: {
+            /** Contracts */
+            contracts: components["schemas"]["ContractRecord"][];
+            /** @description output contracts per status */
+            tally: components["schemas"]["OutputTally"];
+        };
+        /** OutputsMessage */
+        OutputsMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "outputs";
+            data: components["schemas"]["Outputs"];
+        };
+        /**
+         * PanelInfo
+         * @description A panel a domain registered: its tab label, tooltip and glyph, and what it is
+         *     computed over (`run`: one run, a tab of the run; `trends`: the runs of a period).
+         */
+        PanelInfo: {
+            /** Name */
+            name: string;
+            /** Title */
+            title: string;
+            /** Description */
+            description: string;
+            /** Icon */
+            icon: string;
+            /**
+             * Scope
+             * @default run
+             * @enum {string}
+             */
+            scope?: "run" | "trends";
+            /**
+             * Tab
+             * @description a trends panel's tab of the Trends page, with the panels of the same `tab`; '': on the first tab
+             * @default
+             */
+            tab?: string;
+        };
+        /**
+         * PanelMessage
+         * @description A domain panel's body (`PanelBody`), sent when it changed. `{"error": ...}`
+         *     when the panel raised.
+         */
+        PanelMessage: {
+            /**
+             * Event
+             * @description `panel:<name>`, one per run panel in /api/info `panels`
+             */
+            event: string;
+            /** Data */
+            data: components["schemas"]["TilesBody"] | components["schemas"]["TableBody"] | components["schemas"]["ColumnsBody"] | components["schemas"]["LinesBody"] | components["schemas"]["HeatmapBody"] | components["schemas"]["HBarsBody"] | components["schemas"]["StatusGridBody"] | components["schemas"]["NoteBody"] | components["schemas"]["BlocksBody"] | {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * PanelTile
+         * @description A figure as a tile (`cae-stat-tiles`). `sub`: lines under the value, each a row of facts.
+         */
+        PanelTile: {
+            /** Id */
+            id: string;
+            /** Label */
+            label: string;
+            /**
+             * Value
+             * @description a number as given (an integer stays one), or text already formatted
+             */
+            value: number | string;
+            /** Tone */
+            tone?: ("failed" | "attention" | "done" | "running" | "muted" | "neutral") | null;
+            /** Tip */
+            tip?: string | null;
+            /** Sub */
+            sub?: string[][];
+        };
+        /**
+         * Plan
+         * @description The queued tasks, their groups, and the flow calls that created them. A run with
+         *     no `flow_calls.jsonl` (its tasks queued by hand, not by a flow) has no flow call.
+         */
+        Plan: {
+            /** Nodes */
+            nodes: components["schemas"]["PlanNode"][];
+            /** Groups */
+            groups: components["schemas"]["PlanGroup"][];
+            /**
+             * Flow Calls
+             * @description in start order
+             */
+            flow_calls?: components["schemas"]["FlowCallNode"][];
+            /**
+             * Quota Caps
+             * @description the run's credentials that have quota caps (`run.json`)
+             */
+            quota_caps?: components["schemas"]["QuotaCap"][];
+            /**
+             * Quota Rule
+             * @description `module.qualname` of the run's quota rule (`Pipeline(quota_rule=)`); empty for none
+             * @default
+             */
+            quota_rule?: string;
+            /**
+             * Rests
+             * @description each rest of a credential in the run (`rests.jsonl`), in start order
+             */
+            rests?: components["schemas"]["CredentialRest"][];
+            /**
+             * Models
+             * @description each model the run's agent sessions ran on, in order of first use
+             */
+            models?: components["schemas"]["ModelUsage"][];
+            /** @description what the run's preflight did (`run.json`); null when its run.json records none */
+            preflight?: components["schemas"]["PreflightRecord"] | null;
+        };
+        /**
+         * PlanGroup
+         * @description A group: a column of the pipeline view (a kind, the kinds `Monitor(groups=)` puts
+         *     together, or the implementation kinds of a base kind), its members counted by state.
+         */
+        PlanGroup: {
+            /** Id */
+            id: string;
+            /** Label */
+            label: string;
+            /** Total */
+            total: number;
+            /** Done */
+            done: number;
+            /**
+             * Partial
+             * @default 0
+             */
+            partial?: number;
+            /** Failed */
+            failed: number;
+            /** Running */
+            running: number;
+            /** Pending */
+            pending: number;
+            /** Skipped */
+            skipped: number;
+            /** Blocked */
+            blocked: number;
+        };
+        /** PlanMessage */
+        PlanMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "plan";
+            data: components["schemas"]["Plan"];
+        };
+        /**
+         * PlanNode
+         * @description A queued task (a `plan.jsonl` row, passed through) with its state and
+         *     layout. The journal fields (`wall_s` .. `attempts`) appear once it finished.
+         *     The origin fields (`flow` .. `flow_call`) say where the flow created it.
+         */
+        PlanNode: {
+            /**
+             * Ts
+             * @description when it was queued (absent for a node rebuilt from the journal)
+             * @default
+             */
+            ts?: string;
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /**
+             * Unit
+             * @default
+             */
+            unit?: string;
+            /**
+             * Claims
+             * @description the names it holds while it runs, its kind's `claims` filled in
+             */
+            claims?: string[];
+            /**
+             * After
+             * @description task keys it waits for
+             */
+            after?: string[];
+            /**
+             * Priority
+             * @description its task call's `priority`: a tie-breaker in the queue, higher first
+             * @default 0
+             */
+            priority?: number;
+            /**
+             * Executor
+             * @default agent
+             * @enum {string}
+             */
+            executor?: "agent" | "python";
+            /**
+             * Flow
+             * @description the flow path: frames of flow code that created it, outermost first
+             */
+            flow?: components["schemas"]["Frame"][];
+            /**
+             * Created From
+             * @description keys whose results its flow call had received when it created it
+             */
+            created_from?: string[];
+            /**
+             * Flow Call
+             * @description the id of the flow call that created it; null for a task with no origin
+             */
+            flow_call?: string | null;
+            /**
+             * Base Kind
+             * @description an implementation kind's base kind (`agent_task(implementations=)`), its group unless `groups` lists it; else empty
+             * @default
+             */
+            base_kind?: string;
+            /**
+             * State
+             * @enum {string}
+             */
+            state: "pending" | "running" | "done" | "partial" | "failed" | "skipped" | "blocked";
+            /**
+             * Level
+             * @description depth in the dependency graph, 0 for a task that waits for nothing
+             */
+            level: number;
+            /** Group */
+            group: string;
+            /**
+             * Wall S
+             * @default 0
+             */
+            wall_s?: number;
+            /**
+             * Stop
+             * @default
+             */
+            stop?: string;
+            /**
+             * Route
+             * @default
+             */
+            route?: string;
+            /**
+             * Attempts
+             * @default 1
+             */
+            attempts?: number;
+            /**
+             * Deferred
+             * @description why the queue deferred it, never launched (`deferred.jsonl`): a deadline, a resting credential; empty when it was not
+             * @default
+             */
+            deferred?: string;
+            /** @description the same as data; null when it was not deferred, or the run recorded no cause */
+            deferred_cause?: components["schemas"]["DeferralCause"] | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * PreflightRecord
+         * @description What a preflight did, as `run.json` records it (`preflight`): its policy, the routes
+         *     it dropped, and, for each kind left with no route, its substitution, the kind kept
+         *     as configured, or the kind that stopped the run (`stopped`).
+         */
+        PreflightRecord: {
+            /**
+             * Policy
+             * @description `Pipeline(preflight=)`; `off`: no route was probed
+             * @enum {string}
+             */
+            policy: "substitute" | "stop" | "off";
+            /** Dropped */
+            dropped?: components["schemas"]["DroppedRoute"][];
+            /** Substituted */
+            substituted?: components["schemas"]["Substitution"][];
+            /** Kept */
+            kept?: components["schemas"]["KeptKind"][];
+            /**
+             * Stopped
+             * @description the kinds with no route left that stopped the run (policy `stop`)
+             */
+            stopped?: string[];
+        };
+        /**
+         * ProcNode
+         * @description A process in the run's tree (three levels deep at most). The launch fields
+         *     are set on the topmost process of an agent launch.
+         */
+        ProcNode: {
+            /** Pid */
+            pid: number;
+            /** Age S */
+            age_s: number;
+            /**
+             * Cmd
+             * @description the first three words of the command line
+             */
+            cmd: string;
+            /** Full Cmd */
+            full_cmd: string;
+            /** Children */
+            children?: components["schemas"]["ProcNode"][];
+            /** Key */
+            key?: string | null;
+            /** Kind */
+            kind?: string | null;
+            /** Unit */
+            unit?: string | null;
+            /**
+             * Role
+             * @description the role it runs as, from the prompt's TELEMETRY line
+             */
+            role?: string | null;
+            /** Model */
+            model?: string | null;
+            /** Plugin */
+            plugin?: string | null;
+        };
+        /**
+         * Procs
+         * @description The run's live processes. Everything but the run's own fields is empty when it is not alive.
+         */
+        Procs: {
+            /** Run */
+            run: string;
+            /** Alive */
+            alive: boolean;
+            /** Pid */
+            pid: number | null;
+            /** Argv */
+            argv: string[];
+            /** Started At */
+            started_at: string;
+            /** Max Workers */
+            max_workers: number | null;
+            /** Run Group */
+            run_group: string;
+            /** Launches */
+            launches: components["schemas"]["AgentProcess"][];
+            /** Tree */
+            tree: components["schemas"]["ProcNode"][];
+            /** Python Tasks */
+            python_tasks: components["schemas"]["InflightPythonTask"][];
+        };
+        /**
+         * ProcsMessage
+         * @description The live processes, sent when a launch starts or ends (not on every age tick).
+         */
+        ProcsMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "procs";
+            data: components["schemas"]["Procs"];
+        };
+        /**
+         * QuotaCap
+         * @description One credential's quota caps (`[credentials.<name>] max_five_hour_pct`, `max_seven_day_pct`):
+         *     the utilization (%) of a window past which it rests; None for a window with no cap.
+         */
+        QuotaCap: {
+            /** Credential */
+            credential: string;
+            /** Five Hour Pct */
+            five_hour_pct?: number | null;
+            /** Seven Day Pct */
+            seven_day_pct?: number | null;
+        };
+        /**
+         * QuotaReading
+         * @description A subscription's utilization during a launch, from one of these sources:
+         *
+         *     * Claude Code: in its stream, when a session starts or resumes;
+         *     * Codex: in its stream, with each API call of a ChatGPT login;
+         *     * omp (`omp`, `omp-rpc`): at each launch, what the account's latest request reported
+         *       (`omp usage --json`, read before the launch: `Backend.usage_reading`);
+         *     * opencode and pi: for an OpenCode Go model only, OpenCode's usage endpoint, read by
+         *       contraagent before each launch (`Backend.usage_reading`); the agents report none.
+         *
+         *     Account-wide: it includes whatever else used the same account, parallel tasks too.
+         *     `LaunchResult.quota` holds a launch's, the journal's `quota` an attempt's that give a
+         *     5-hour or weekly utilization.
+         */
+        QuotaReading: {
+            /** Observed At */
+            observed_at?: string | null;
+            /**
+             * Credential
+             * @default
+             */
+            credential?: string;
+            /** Five Hour Pct */
+            five_hour_pct?: number | null;
+            /** Five Hour Resets At */
+            five_hour_resets_at?: string | null;
+            /** Seven Day Pct */
+            seven_day_pct?: number | null;
+            /** Seven Day Resets At */
+            seven_day_resets_at?: string | null;
+            /**
+             * Status
+             * @default
+             */
+            status?: string;
+            /**
+             * Account
+             * @default
+             */
+            account?: string;
+            /**
+             * Status Window
+             * @default
+             */
+            status_window?: string;
+            /** Threshold Pct */
+            threshold_pct?: number | null;
+            /**
+             * Overage Status
+             * @default
+             */
+            overage_status?: string;
+            /**
+             * Overage Disabled Reason
+             * @default
+             */
+            overage_disabled_reason?: string;
+            /** Using Overage */
+            using_overage?: boolean | null;
+            /** Windows */
+            windows?: {
+                [key: string]: components["schemas"]["QuotaWindow"];
+            };
+            /** Extra */
+            extra?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * QuotaWindow
+         * @description One window of a reading: its utilization (%) and when it resets (ISO 8601).
+         */
+        QuotaWindow: {
+            /** Pct */
+            pct?: number | null;
+            /** Resets At */
+            resets_at?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ReadyMessage
+         * @description Sent once per connection, after the first round of messages: the journal
+         *     replayed so far and the current value of every other view. A row that
+         *     arrives after it is new, not part of the replay.
+         */
+        ReadyMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "ready";
+            data: components["schemas"]["FeedReady"];
+        };
+        /**
+         * RetryEvent
+         * @description omp: the agent retrying after a provider error.
+         */
+        RetryEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "auto_retry_start";
+            /** Attempt */
+            attempt?: number | null;
+            /**
+             * Err
+             * @default
+             */
+            err?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * RunEvent
+         * @description One message of /events?run=
+         */
+        RunEvent: components["schemas"]["JournalMessage"] | components["schemas"]["ProcsMessage"] | components["schemas"]["PlanMessage"] | components["schemas"]["OutputsMessage"] | components["schemas"]["CursorMessage"] | components["schemas"]["PanelMessage"] | components["schemas"]["ReadyMessage"];
+        /**
+         * RunSummary
+         * @description One run directory, as the run picker lists it.
+         */
+        RunSummary: {
+            /** Run */
+            run: string;
+            /**
+             * Run Group
+             * @description the label grouping runs (`Run(run_group=)`); the run id when none was given
+             */
+            run_group: string;
+            /**
+             * Attempts
+             * @description journal rows: finished task attempts
+             */
+            attempts: number;
+            /**
+             * Ok
+             * @description journal rows that passed, not counting `partial` ones
+             */
+            ok: number;
+            /**
+             * Partial
+             * @description journal rows with stop `partial`
+             * @default 0
+             */
+            partial?: number;
+            /**
+             * Not Run
+             * @description journal rows of tasks that never ran: refused for an input (`invalid_input`) or skipped
+             * @default 0
+             */
+            not_run?: number;
+            tasks: components["schemas"]["TaskCounts"];
+            /**
+             * Cost Usd
+             * @description what the coding agents reported the run cost, in USD; null when none reported
+             */
+            cost_usd?: number | null;
+            /** @description tokens of every attempt, summed */
+            tokens: components["schemas"]["TokenUsage"];
+            /**
+             * Quota
+             * @description per credential (account): the run's first and last utilization reading; highest weekly use first
+             */
+            quota?: components["schemas"]["AccountQuota"][];
+            /**
+             * Wall S
+             * @description sum of the rows' wall time, rounded to seconds
+             */
+            wall_s: number;
+            /**
+             * Last Ts
+             * @description ISO time of the last journal row, else the directory's mtime
+             */
+            last_ts: string;
+            /**
+             * Kinds
+             * @description journal rows per task kind
+             */
+            kinds: {
+                [key: string]: number;
+            };
+            /**
+             * Running
+             * @description the process that runs it is alive
+             */
+            running: boolean;
+            /**
+             * Unresponsive
+             * @description its host last reported it alive and has stopped reporting (a hub only)
+             * @default false
+             */
+            unresponsive?: boolean;
+            /**
+             * Host Id
+             * @description the host that drives it; empty when its run.json does not say
+             * @default
+             */
+            host_id?: string;
+            /**
+             * Run Uid
+             * @description the id no other run has, on any host; empty when its run.json does not say
+             * @default
+             */
+            run_uid?: string;
+            /** Started At */
+            started_at: string;
+            /**
+             * Stub
+             * @description a stub run: the stub agent, or a replay's recordings, played its tasks (`Pipeline(stub=)`, `contraagent run --stub`)
+             * @default false
+             */
+            stub?: boolean;
+            /**
+             * Replay
+             * @description a replay: the directory of the recordings it played (`Pipeline(replay=)`), and with `record_missing` recorded into (then `stub` is false, and each played attempt's journal row says `replayed`); empty otherwise
+             * @default
+             */
+            replay?: string;
+            /**
+             * Row Extras
+             * @description the journal columns that are the pipeline's own (`Run(row_extras=)`), in the order they first appear
+             */
+            row_extras?: string[];
+        };
+        /**
+         * SkippedHop
+         * @description A hop of the failover chain an attempt passed over without a launch, because its
+         *     credential rested: its route label and model, and the rest.
+         */
+        SkippedHop: {
+            /** Credential */
+            credential: string;
+            /**
+             * Window
+             * @default
+             * @enum {string}
+             */
+            window?: "" | "five_hour" | "seven_day";
+            /** Pct */
+            pct?: number | null;
+            /** Cap */
+            cap?: number | null;
+            /**
+             * Rule
+             * @default
+             */
+            rule?: string;
+            /**
+             * Until
+             * @default
+             */
+            until?: string;
+            /**
+             * Account
+             * @default
+             */
+            account?: string;
+            /** Reading */
+            reading?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Route
+             * @default
+             */
+            route?: string;
+            /**
+             * Model
+             * @default
+             */
+            model?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * StageEntry
+         * @description One transition of the cursor (`HistoryEntry`), its time as `datetime.isoformat` gives it.
+         */
+        StageEntry: {
+            /** Name */
+            name: string;
+            /** At */
+            at: string;
+        };
+        /**
+         * StatusGridBody
+         * @description A state per row (`y`) and column (`x`): `cells[row][column]`, null where there is
+         *     none. Each cell is coloured by its tone and named by its label (in the legend, the
+         *     tooltip and the table): the states of hourly cycles by day, say.
+         */
+        StatusGridBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default status_grid
+             * @constant
+             */
+            type?: "status_grid";
+            /** X */
+            x: string[];
+            /** Y */
+            y: string[];
+            /** Cells */
+            cells: (components["schemas"]["GridCell"] | null)[][];
+        };
+        /**
+         * StreamMessage
+         * @description `/events/stream`: the first message is the transcript's tail page, then each
+         *     message carries only the events after the previous one.
+         */
+        StreamMessage: {
+            /**
+             * Event
+             * @constant
+             */
+            event: "stream";
+            data: components["schemas"]["StreamPage"];
+        };
+        /**
+         * StreamPage
+         * @description A page of one transcript. `total` is the file's line count: pass it back as
+         *     `since` for the next page. The first page (`since=0`) is the tail; `behind`
+         *     lines precede it, fetched by asking again with a smaller `since`.
+         */
+        StreamPage: {
+            /** Events */
+            events: (components["schemas"]["LaunchEvent"] | components["schemas"]["MessageUpdateEvent"] | components["schemas"]["ToolStartEvent"] | components["schemas"]["ToolEndEvent"] | components["schemas"]["ToolCallEchoEvent"] | components["schemas"]["ToolResultEchoEvent"] | components["schemas"]["MessageEvent"] | components["schemas"]["NoticeEvent"] | components["schemas"]["RetryEvent"] | components["schemas"]["OtherEvent"])[];
+            /** Total */
+            total: number;
+            /** Behind */
+            behind: number;
+        };
+        /**
+         * Substitution
+         * @description A kind with no route left, run on the first route that answered (`substitute`).
+         */
+        Substitution: {
+            /** Kind */
+            kind: string;
+            /** From Agent */
+            from_agent: string;
+            /** From Model */
+            from_model: string;
+            /** To Agent */
+            to_agent: string;
+            /** To Model */
+            to_model: string;
+        };
+        /**
+         * TableBody
+         * @description Rows of values, one key per column; a row's `_tone` is its status (a `Tone`).
+         */
+        TableBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default table
+             * @constant
+             */
+            type?: "table";
+            /** Columns */
+            columns: components["schemas"]["TableColumn"][];
+            /** Rows */
+            rows: {
+                [key: string]: unknown;
+            }[];
+        };
+        /**
+         * TableColumn
+         * @description A column of a table body: `id` names the key of each row it shows. `bar`: a bar in
+         *     the cell, as long as the value against the column's largest. `link`: the key of each
+         *     row that holds the URL the cell leads to (http or https; any other is no link).
+         */
+        TableColumn: {
+            /** Id */
+            id: string;
+            /** Label */
+            label: string;
+            /** Align */
+            align?: ("start" | "end") | null;
+            /** Format */
+            format?: ("usd" | "pct" | "duration" | "tokens" | "datetime" | "number") | null;
+            /**
+             * Bar
+             * @default false
+             */
+            bar?: boolean;
+            /**
+             * Link
+             * @description the key of the row that holds the cell's URL
+             */
+            link?: string | null;
+            /** Tip */
+            tip?: string | null;
+        };
+        /**
+         * TaskCounts
+         * @description A run's tasks (not attempts) by how they ended. `not_started`: refused for
+         *     an input, or waiting behind a task that failed; `running`: running now (in a
+         *     live run); `waiting`: queued in a live run; `not_run`: deferred, or queued in a
+         *     run that is no longer live (it will not run).
+         */
+        TaskCounts: {
+            /** Total */
+            total: number;
+            /** Done */
+            done: number;
+            /**
+             * Partial
+             * @description tasks whose last result was `partial`: ok, the output a placeholder; not in `done`
+             * @default 0
+             */
+            partial?: number;
+            /** Failed */
+            failed: number;
+            /** Not Started */
+            not_started: number;
+            /**
+             * Running
+             * @default 0
+             */
+            running?: number;
+            /** Waiting */
+            waiting: number;
+            /**
+             * Not Run
+             * @default 0
+             */
+            not_run?: number;
+            /** Skipped */
+            skipped: number;
+        };
+        /**
+         * TaskDefinition
+         * @description What defined one kind of task in this run (`definitions/<kind>.json`).
+         *     Beyond `kind`, the keys are the task adapter's choice; these are the ones
+         *     the bundled adapters write.
+         */
+        TaskDefinition: {
+            /** Kind */
+            kind: string;
+            /** Role */
+            role?: string | null;
+            /** Plugin Dirs */
+            plugin_dirs?: string[];
+            /** Files */
+            files?: components["schemas"]["DefinitionFile"][];
+            /** Plugin */
+            plugin?: boolean | null;
+            /** Name */
+            name?: string | null;
+            /** Root */
+            root?: string | null;
+            /** Params */
+            params?: string | null;
+            /** Requires */
+            requires?: string[];
+            /** Output */
+            output?: string | null;
+            /**
+             * Output From
+             * @description agent task: `file`, the agent writes its output; `message`, its final message is the output
+             */
+            output_from?: ("file" | "message") | null;
+            /** Validators */
+            validators?: string[];
+            /**
+             * Preserve
+             * @description agent task: JSON pointers to the parts of its output file it keeps (`agent_task(preserve=)`)
+             */
+            preserve?: string[];
+            /**
+             * Output Of
+             * @description agent task: the kind whose output file it writes (`agent_task(output_of=)`)
+             */
+            output_of?: string | null;
+            /**
+             * Base Kind
+             * @description agent task: an implementation kind's base kind (`agent_task(implementations=)`)
+             */
+            base_kind?: string | null;
+            /**
+             * Tools
+             * @description agent task: `[]`, a light launch with no tools (`agent_task(tools=())`); null, the tools its role allows
+             */
+            tools?: string[] | null;
+            /** Executor */
+            executor?: ("agent" | "python") | null;
+            /**
+             * Function
+             * @description Python task: `module.qualname` of its function
+             */
+            function?: string | null;
+            /**
+             * Signature
+             * @description Python task: the function's signature
+             */
+            signature?: string | null;
+            /**
+             * Doc
+             * @description Python task: the function's docstring
+             */
+            doc?: string | null;
+            /**
+             * File
+             * @description Python task: the source file, relative to the run's working directory when inside it
+             */
+            file?: string | null;
+            /**
+             * Line
+             * @description Python task: the function's first line in `file`
+             */
+            line?: number | null;
+            /**
+             * Retries
+             * @description Python task: the fresh attempts after the first, each after an exception of `retry_on` (`@python_task(retries=)`)
+             */
+            retries?: number | null;
+            /**
+             * Retry On
+             * @description Python task: the exception classes that give an attempt a fresh one
+             */
+            retry_on?: string[] | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * TaskDetail
+         * @description One task, by its key. Open: the `task_detail` callback merges its own keys
+         *     in (a failing one leaves `task_detail_error` instead).
+         */
+        TaskDetail: {
+            /**
+             * Key
+             * @description the task key asked for
+             */
+            key: string;
+            /** Rows */
+            rows: components["schemas"]["JournalRow"][];
+            /**
+             * Launches
+             * @description its launches running now; empty once it has finished (finished attempts are `rows`)
+             */
+            launches: components["schemas"]["TaskLaunch"][];
+            definition: components["schemas"]["TaskDefinition"] | null;
+            io: components["schemas"]["TaskIO"];
+            /**
+             * Stream
+             * @description the transcript's task key for /stream and /events/stream, null when it has none
+             */
+            stream: string | null;
+            /**
+             * Row Extras
+             * @description the columns of `rows` that are the pipeline's own (`Run(row_extras=)`), in the order they first appear
+             */
+            row_extras?: string[];
+            /** Task Detail Error */
+            task_detail_error?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * TaskIO
+         * @description The task's params, what it reads and leaves behind, and its neighbours in the plan.
+         */
+        TaskIO: {
+            /** Params */
+            params: {
+                [key: string]: unknown;
+            };
+            /** Inputs */
+            inputs: components["schemas"]["ContractSpec"][];
+            /** Outputs */
+            outputs: components["schemas"]["ContractSpec"][];
+            /**
+             * Executor
+             * @enum {string}
+             */
+            executor: "agent" | "python";
+            /** Upstream */
+            upstream: components["schemas"]["UpstreamTask"][];
+            /** Downstream */
+            downstream: components["schemas"]["DownstreamTask"][];
+        };
+        /**
+         * TaskLaunch
+         * @description A live launch of the task (a child process, or an in-process marker with empty plugin/model/role/cmd).
+         */
+        TaskLaunch: {
+            /** Key */
+            key: string | null;
+            /** Kind */
+            kind: string | null;
+            /** Unit */
+            unit: string | null;
+            /** Pid */
+            pid: number | null;
+            /** Age S */
+            age_s: number | null;
+            /** Plugin */
+            plugin: string | null;
+            /** Model */
+            model: string | null;
+            /** Role */
+            role: string | null;
+            /**
+             * Cmd
+             * @description the full command line, cut at 600 characters
+             */
+            cmd: string;
+        };
+        /** TilesBody */
+        TilesBody: {
+            /**
+             * Title
+             * @description a heading over the body
+             */
+            title?: string | null;
+            /**
+             * Collapsed
+             * @description shown folded, under its title
+             * @default false
+             */
+            collapsed?: boolean;
+            /**
+             * Type
+             * @default tiles
+             * @constant
+             */
+            type?: "tiles";
+            /** Tiles */
+            tiles: components["schemas"]["PanelTile"][];
+        };
+        /**
+         * TimeBoxRecord
+         * @description A flow call's own deadline (`time_box`, `TimeBox`), as `flow_calls.jsonl` records it.
+         */
+        TimeBoxRecord: {
+            /**
+             * Started At
+             * @description when the flow call started, where its deadline counts from (UTC ISO 8601)
+             */
+            started_at: string;
+            /**
+             * Deadline S
+             * @description seconds from `started_at` to the deadline
+             */
+            deadline_s: number;
+            /**
+             * Grace S
+             * @description seconds past the deadline its `finishing_kinds` still launch
+             */
+            grace_s: number;
+            /**
+             * Slack S
+             * @description seconds before the deadline from which its tasks are ordered for it
+             */
+            slack_s: number;
+            /**
+             * Finishing Kinds
+             * @description the kinds that still launch past the deadline
+             * @default []
+             */
+            finishing_kinds?: string[];
+        };
+        /**
+         * TokenUsage
+         * @description Tokens summed over API calls: an attempt's (its rounds and hops, in `JournalRow.usage`)
+         *     or one hop's (`Hop.usage`).
+         */
+        TokenUsage: {
+            /**
+             * Input
+             * @default 0
+             */
+            input?: number;
+            /**
+             * Output
+             * @default 0
+             */
+            output?: number;
+            /**
+             * Cache Read
+             * @default 0
+             */
+            cache_read?: number;
+            /**
+             * Cache Creation
+             * @default 0
+             */
+            cache_creation?: number;
+            /**
+             * Calls
+             * @default 0
+             */
+            calls?: number;
+            /** Resident */
+            resident?: number | null;
+            /** Peak Context */
+            peak_context?: number | null;
+            /** Context Window */
+            context_window?: number | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ToolCallEchoEvent
+         * @description omp: a tool call carried on a message or turn (`acall`).
+         */
+        ToolCallEchoEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "acall";
+            /** Tool */
+            tool: string | null;
+            /** Cmd */
+            cmd: string;
+            /** Call */
+            call: string;
+            /** Intent */
+            intent: string;
+            /**
+             * Web Query
+             * @description the query, when the call is a web search
+             */
+            web_query?: string | null;
+            /**
+             * Web Fetch
+             * @description the URL, when the call reads a web page
+             */
+            web_fetch?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ToolEndEvent
+         * @description A tool call's result. `tool` is empty for claude, which names only the call id.
+         */
+        ToolEndEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "tool_execution_end";
+            /** Tool */
+            tool: string | null;
+            /** Out */
+            out: string;
+            /** Err */
+            err: boolean;
+            /** Call */
+            call: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ToolResultEchoEvent
+         * @description omp: a tool result carried as a `toolResult` message (`aresult`).
+         */
+        ToolResultEchoEvent: {
+            /**
+             * Type
+             * @constant
+             */
+            type: "aresult";
+            /** Tool */
+            tool: string | null;
+            /** Call */
+            call: string;
+            /** Out */
+            out: string;
+            /** Err */
+            err: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * ToolStartEvent
+         * @description A tool call starting (or omp's progress update for it). `call` pairs it with its end event.
+         */
+        ToolStartEvent: {
+            /**
+             * Type
+             * @enum {string}
+             */
+            type: "tool_execution_start" | "tool_execution_update";
+            /** Tool */
+            tool: string | null;
+            /**
+             * Cmd
+             * @description a one-line preview: the command, pattern, path, URL or query
+             */
+            cmd: string;
+            /** Intent */
+            intent: string;
+            /** Call */
+            call: string;
+            /**
+             * Web Query
+             * @description the query, when the call is a web search
+             */
+            web_query?: string | null;
+            /**
+             * Web Fetch
+             * @description the URL, when the call reads a web page
+             */
+            web_fetch?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * TrendDay
+         * @description One day: its attempts (by when they ended), and its cost per group (`Monitor(groups=)`; a kind in none is its own).
+         */
+        TrendDay: {
+            /** Day */
+            day: string;
+            /**
+             * Cost Usd
+             * @description group -> cost, USD; a group with no cost reported is absent
+             */
+            cost_usd: {
+                [key: string]: number;
+            };
+            /** Attempts */
+            attempts: number;
+            /**
+             * Ok
+             * @description attempts that passed, not counting `partial` ones
+             */
+            ok: number;
+            /**
+             * Partial
+             * @description attempts with stop `partial`: ok, counted apart from `ok`
+             * @default 0
+             */
+            partial?: number;
+        };
+        /**
+         * TrendDeferral
+         * @description A deferred task (`deferred.jsonl`), with its run; `cause` is `DeferralCause.cause`.
+         */
+        TrendDeferral: {
+            /** Run */
+            run: string;
+            /** Ts */
+            ts: string;
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /** Cause */
+            cause: string;
+            /** Reason */
+            reason: string;
+        };
+        /**
+         * TrendDenial
+         * @description Tool calls the coding agent's permissions refused, of one tool (`launches.jsonl` `denied`).
+         */
+        TrendDenial: {
+            /** Tool */
+            tool: string;
+            /** Count */
+            count: number;
+            /** Kinds */
+            kinds: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * TrendKind
+         * @description One kind over the period. A task is one key of one run; its last attempt in the period says how it ended.
+         */
+        TrendKind: {
+            /** Kind */
+            kind: string;
+            /** Group */
+            group: string;
+            /**
+             * Executor
+             * @enum {string}
+             */
+            executor: "agent" | "python";
+            /** Tasks */
+            tasks: number;
+            /**
+             * Tasks Ok
+             * @description tasks whose last attempt passed, not counting `partial` ones
+             */
+            tasks_ok: number;
+            /**
+             * Tasks Partial
+             * @description tasks whose last attempt was `partial`
+             * @default 0
+             */
+            tasks_partial?: number;
+            /** Attempts */
+            attempts: number;
+            /**
+             * Ok
+             * @description attempts that passed, not counting `partial` ones
+             */
+            ok: number;
+            /**
+             * Partial
+             * @description attempts with stop `partial`: ok, counted apart from `ok`
+             * @default 0
+             */
+            partial?: number;
+            /**
+             * Wall S
+             * @description every attempt's wall time, summed
+             */
+            wall_s: number;
+            /**
+             * Wall S Median
+             * @description the median attempt's wall time
+             */
+            wall_s_median: number;
+            /** Cost Usd */
+            cost_usd: number | null;
+            tokens: components["schemas"]["TokenUsage"];
+        };
+        /**
+         * TrendPeriod
+         * @description The period: days `from`..`to`, both included, in the time zone `tz` (an IANA name).
+         */
+        TrendPeriod: {
+            /**
+             * From
+             * @description the first day, YYYY-MM-DD
+             */
+            from: string;
+            /**
+             * To
+             * @description the last day, YYYY-MM-DD
+             */
+            to: string;
+            /** Tz */
+            tz: string;
+            /**
+             * Days
+             * @description every day of the period, in order
+             */
+            days: string[];
+        };
+        /**
+         * TrendQuota
+         * @description One account's utilization of one window over the period: each day's and each hour's highest reading.
+         *     A credential whose token was replaced has one entry per account.
+         */
+        TrendQuota: {
+            /** Credential */
+            credential: string;
+            /**
+             * Account
+             * @description the account the readings are of (`QuotaReading.account`); empty when not known
+             * @default
+             */
+            account?: string;
+            /**
+             * Window
+             * @description `five_hour`, `seven_day`, or another window a reading names (`seven_day_opus`)
+             */
+            window: string;
+            /**
+             * Daily Peak
+             * @description per day of `period.days`; null when no reading arrived that day
+             */
+            daily_peak: (number | null)[];
+            /**
+             * Hourly Peak
+             * @description per hour from the period's first instant (the first day's midnight in `tz`); null when no reading arrived in it
+             */
+            hourly_peak: (number | null)[];
+        };
+        /**
+         * TrendRest
+         * @description A start or end of a credential's rest (a `rests.jsonl` row), with its run.
+         */
+        TrendRest: {
+            /** Credential */
+            credential: string;
+            /**
+             * Window
+             * @default
+             * @enum {string}
+             */
+            window?: "" | "five_hour" | "seven_day";
+            /** Pct */
+            pct?: number | null;
+            /** Cap */
+            cap?: number | null;
+            /**
+             * Rule
+             * @default
+             */
+            rule?: string;
+            /**
+             * Until
+             * @default
+             */
+            until?: string;
+            /**
+             * Account
+             * @default
+             */
+            account?: string;
+            /** Reading */
+            reading?: {
+                [key: string]: unknown;
+            } | null;
+            /** Ts */
+            ts: string;
+            /**
+             * Event
+             * @enum {string}
+             */
+            event: "start" | "end";
+            /** Run */
+            run: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * TrendRun
+         * @description One run of the period: its attempts in the period.
+         */
+        TrendRun: {
+            /** Run */
+            run: string;
+            /** Run Group */
+            run_group: string;
+            /** Host Id */
+            host_id: string;
+            /** Started At */
+            started_at: string;
+            /** Finished At */
+            finished_at: string;
+            /**
+             * Last Ts
+             * @description when its last attempt in the period ended; empty when it has none
+             */
+            last_ts: string;
+            /** Attempts */
+            attempts: number;
+            /**
+             * Ok
+             * @description attempts that passed, not counting `partial` ones
+             */
+            ok: number;
+            /**
+             * Partial
+             * @description attempts with stop `partial`: ok, counted apart from `ok`
+             * @default 0
+             */
+            partial?: number;
+            /** Cost Usd */
+            cost_usd: number | null;
+            /** Wall S */
+            wall_s: number;
+            /** Stub */
+            stub: boolean;
+        };
+        /**
+         * TrendStarts
+         * @description Run starts by weekday (`weekdays`, Monday first) and hour (`hours`) in the period's time zone: `counts[weekday][hour]`.
+         */
+        TrendStarts: {
+            /** Weekdays */
+            weekdays: string[];
+            /** Hours */
+            hours: number[];
+            /** Counts */
+            counts: number[][];
+        };
+        /**
+         * TrendStop
+         * @description Attempts that ended on one `stop`, and by which kinds.
+         */
+        TrendStop: {
+            /** Stop */
+            stop: string;
+            /** Attempts */
+            attempts: number;
+            /** Kinds */
+            kinds: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * TrendTotals
+         * @description The period's runs and attempts, summed.
+         */
+        TrendTotals: {
+            /**
+             * Runs
+             * @description runs with an attempt in the period, or started in it
+             */
+            runs: number;
+            /** Attempts */
+            attempts: number;
+            /**
+             * Ok
+             * @description attempts that passed, not counting `partial` ones
+             */
+            ok: number;
+            /**
+             * Partial
+             * @description attempts with stop `partial`: ok, counted apart from `ok`
+             * @default 0
+             */
+            partial?: number;
+            /**
+             * Cost Usd
+             * @description what the coding agents reported; null when no attempt reported a cost
+             */
+            cost_usd: number | null;
+            /** Wall S */
+            wall_s: number;
+            tokens: components["schemas"]["TokenUsage"];
+        };
+        /**
+         * Trends
+         * @description What the runs of a period add up to (`Monitor.trends`). `bodies`: the same numbers as
+         *     panel bodies (`{"type": "blocks", ...}`), in English, for a page with no words of its own;
+         *     `panels`: the trend panels a domain registered (`Panel(scope="trends")`).
+         */
+        Trends: {
+            period: components["schemas"]["TrendPeriod"];
+            totals: components["schemas"]["TrendTotals"];
+            /** Daily */
+            daily: components["schemas"]["TrendDay"][];
+            /** Kinds */
+            kinds: components["schemas"]["TrendKind"][];
+            /** Models */
+            models: components["schemas"]["ModelUsage"][];
+            /** Stops */
+            stops: components["schemas"]["TrendStop"][];
+            /** Denials */
+            denials: components["schemas"]["TrendDenial"][];
+            /** Quota */
+            quota: components["schemas"]["TrendQuota"][];
+            /** Rests */
+            rests: components["schemas"]["TrendRest"][];
+            /** Deferred */
+            deferred: components["schemas"]["TrendDeferral"][];
+            /** Deferred Causes */
+            deferred_causes: {
+                [key: string]: number;
+            };
+            /** Runs */
+            runs: components["schemas"]["TrendRun"][];
+            starts: components["schemas"]["TrendStarts"];
+            /** Bodies */
+            bodies: {
+                [key: string]: {
+                    [key: string]: unknown;
+                };
+            };
+            /** Panels */
+            panels: components["schemas"]["PanelInfo"][];
+        };
+        /**
+         * UnitPosition
+         * @description One unit's place in the per-unit step sequence; `inflight` are the work
+         *     items dispatched but not yet recorded.
+         */
+        UnitPosition: {
+            /** Stage */
+            stage: string | null;
+            /** Step */
+            step: string | null;
+            /** Completed */
+            completed: string[];
+            /** Loop Pass */
+            loop_pass: number;
+            /** Inflight */
+            inflight: string[];
+        };
+        /** UpstreamTask */
+        UpstreamTask: {
+            /** Key */
+            key: string;
+            /** Kind */
+            kind: string;
+            /** Unit */
+            unit: string;
+            /**
+             * Executor
+             * @enum {string}
+             */
+            executor: "agent" | "python";
+            /** Outputs */
+            outputs: components["schemas"]["ContractSpec"][];
+        };
+        /** ValidationError */
+        ValidationError: {
+            /** Location */
+            loc: (string | number)[];
+            /** Message */
+            msg: string;
+            /** Error Type */
+            type: string;
+            /** Input */
+            input?: unknown;
+            /** Context */
+            ctx?: Record<string, never>;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+};
+export type $defs = Record<string, never>;
+export interface operations {
+    api_info_api_info_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Info"];
+                };
+            };
+        };
+    };
+    api_runs_api_runs_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RunSummary"][];
+                };
+            };
+        };
+    };
+    api_hosts_api_hosts_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Hosts"];
+                };
+            };
+        };
+    };
+    api_trends_api_trends_get: {
+        parameters: {
+            query?: {
+                /** @description the first day, YYYY-MM-DD (default: 13 days before `to`) */
+                from?: string;
+                /** @description the last day, YYYY-MM-DD (default: today in `tz`) */
+                to?: string;
+                /** @description the time zone the days are in, an IANA name (default UTC) */
+                tz?: string;
+                /** @description only the runs of this run group */
+                run_group?: string;
+                /** @description count stub runs too */
+                stub?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Trends"];
+                };
+            };
+            /** @description a period it cannot read */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_trend_panel_api_trends_panels__name__get: {
+        parameters: {
+            query?: {
+                from?: string;
+                to?: string;
+                tz?: string;
+                run_group?: string;
+            };
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TilesBody"] | components["schemas"]["TableBody"] | components["schemas"]["ColumnsBody"] | components["schemas"]["LinesBody"] | components["schemas"]["HeatmapBody"] | components["schemas"]["HBarsBody"] | components["schemas"]["StatusGridBody"] | components["schemas"]["NoteBody"] | components["schemas"]["BlocksBody"] | {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @description a period it cannot read */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description no trend panel of that name */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_journal_api_runs__run__journal_get: {
+        parameters: {
+            query?: {
+                since?: number;
+            };
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JournalPage"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_plan_api_runs__run__plan_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Plan"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_outputs_api_runs__run__outputs_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Outputs"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_definitions_api_runs__run__definitions_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TaskDefinition"][];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_cursor_api_runs__run__cursor_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CursorView"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_procs_api_runs__run__procs_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Procs"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_task_api_runs__run__task__key__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TaskDetail"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_stream_api_runs__run__stream__key__get: {
+        parameters: {
+            query?: {
+                since?: number;
+            };
+            header?: never;
+            path: {
+                run: string;
+                key: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StreamPage"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    api_panel_api_runs__run__panels__name__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                run: string;
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TilesBody"] | components["schemas"]["TableBody"] | components["schemas"]["ColumnsBody"] | components["schemas"]["LinesBody"] | components["schemas"]["HeatmapBody"] | components["schemas"]["HBarsBody"] | components["schemas"]["StatusGridBody"] | components["schemas"]["NoteBody"] | components["schemas"]["BlocksBody"] | {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @description no run panel of that name */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    events_events_get: {
+        parameters: {
+            query: {
+                run: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server-Sent Events; each message is one `RunEvent` */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["RunEvent"];
+                };
+            };
+            /** @description not a plain run id */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    events_stream_events_stream_get: {
+        parameters: {
+            query: {
+                run: string;
+                key: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server-Sent Events; each message is one `StreamMessage` */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["StreamMessage"];
+                };
+            };
+            /** @description not a plain run id or task key */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map