@cat-factory/contracts 0.187.0 → 0.189.0

package/dist/debug-api.d.ts

@@ -0,0 +1,1397 @@
+import * as v from 'valibot';
+/** Hard ceiling on rows one page may return. */
+export declare const DEBUG_MAX_PAGE_LIMIT = 100;
+/** Hard ceiling on the per-field body preview a LIST may inline. */
+export declare const DEBUG_MAX_PREVIEW_CHARS = 4000;
+/** Hard ceiling on the per-field body a POINT READ may return. */
+export declare const DEBUG_MAX_BODY_CHARS = 200000;
+/**
+ * Hard ceiling on a point read's slice offset — comfortably above the store's own per-body
+ * cap (512 kB), so every stored character is reachable, while still rejecting a garbage
+ * offset instead of quietly serving an empty slice for it.
+ */
+export declare const DEBUG_MAX_BODY_OFFSET = 2000000;
+/** Hard ceiling on a `contains` search term's length. */
+export declare const DEBUG_MAX_SEARCH_CHARS = 256;
+/**
+ * A bounded slice of a stored text body, and enough metadata to know what was left out.
+ *
+ * This is THE reason the surface is safe to hand to a model: a bare truncated string is
+ * indistinguishable from a short one, so a reader would confidently conclude "the agent
+ * returned nothing" from a payload that merely hit its budget. `totalChars` is always the
+ * full stored length, measured in SQL, even when `text` is empty.
+ */
+export declare const debugTextSchema: v.ObjectSchema<{
+    /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+    readonly text: v.StringSchema<undefined>;
+    /**
+     * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+     * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+     */
+    readonly chars: v.NumberSchema<undefined>;
+    /**
+     * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+     * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+     * `offset + chars <= totalChars` always holds.
+     */
+    readonly offset: v.NumberSchema<undefined>;
+    /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+    readonly totalChars: v.NumberSchema<undefined>;
+    /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+    readonly truncated: v.BooleanSchema<undefined>;
+    /**
+     * 0-based code-point offset of the first case-insensitive occurrence of the request's
+     * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+     * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+     * to jump straight to the match without transferring the bytes before it.
+     */
+    readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type DebugText = v.InferOutput<typeof debugTextSchema>;
+/**
+ * The lean run projection every debug list/overview leads with. Deliberately a SUMMARY, not
+ * the internal `ExecutionInstance`: a run's persisted `detail` blob carries per-step gate,
+ * judge, follow-up, container and validation state that is megabytes on a long run and means
+ * nothing to an external caller. What survives is what identifies a run and says whether it
+ * is worth opening.
+ */
+export declare const debugRunSummarySchema: v.ObjectSchema<{
+    readonly runId: v.StringSchema<undefined>;
+    /** The board block the run is anchored on (a task, a service frame, or a headless anchor). */
+    readonly blockId: v.StringSchema<undefined>;
+    readonly pipelineId: v.StringSchema<undefined>;
+    readonly pipelineName: v.StringSchema<undefined>;
+    readonly status: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
+    /** Epoch-ms creation stamp — also the value the keyset cursor is minted from. */
+    readonly createdAt: v.NumberSchema<undefined>;
+    /** Index of the step the run is currently on. */
+    readonly currentStep: v.NumberSchema<undefined>;
+    /** How many steps the run's pipeline has. */
+    readonly stepCount: v.NumberSchema<undefined>;
+    /** Structured failure diagnostics when the run failed; null otherwise. */
+    readonly failure: v.NullableSchema<v.ObjectSchema<{
+        readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly occurredAt: v.NumberSchema<undefined>;
+        readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
+            readonly completed: v.NumberSchema<undefined>;
+            readonly inProgress: v.NumberSchema<undefined>;
+            readonly total: v.NumberSchema<undefined>;
+            readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                readonly label: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
+            }, undefined>, undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type DebugRunSummary = v.InferOutput<typeof debugRunSummarySchema>;
+/** Query params for `GET /api/v1/debug/runs`. */
+export declare const listDebugRunsQuerySchema: v.ObjectSchema<{
+    /** Filter to one internal execution status (`running`/`blocked`/`paused`/`done`/`failed`/…). */
+    readonly status: v.OptionalSchema<v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>, undefined>;
+    /** Inclusive lower bound on the run's `createdAt`. */
+    readonly since: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number of epoch milliseconds">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    /** Cap on rows returned (default 25, hard max {@link DEBUG_MAX_PAGE_LIMIT}). */
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>, undefined>;
+    /** Opaque keyset cursor from a previous page's `nextCursor`. */
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+}, undefined>;
+export type ListDebugRunsQuery = v.InferOutput<typeof listDebugRunsQuerySchema>;
+export declare const debugRunListSchema: v.ObjectSchema<{
+    readonly runs: v.ArraySchema<v.ObjectSchema<{
+        readonly runId: v.StringSchema<undefined>;
+        /** The board block the run is anchored on (a task, a service frame, or a headless anchor). */
+        readonly blockId: v.StringSchema<undefined>;
+        readonly pipelineId: v.StringSchema<undefined>;
+        readonly pipelineName: v.StringSchema<undefined>;
+        readonly status: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
+        /** Epoch-ms creation stamp — also the value the keyset cursor is minted from. */
+        readonly createdAt: v.NumberSchema<undefined>;
+        /** Index of the step the run is currently on. */
+        readonly currentStep: v.NumberSchema<undefined>;
+        /** How many steps the run's pipeline has. */
+        readonly stepCount: v.NumberSchema<undefined>;
+        /** Structured failure diagnostics when the run failed; null otherwise. */
+        readonly failure: v.NullableSchema<v.ObjectSchema<{
+            readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
+            readonly message: v.StringSchema<undefined>;
+            readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly occurredAt: v.NumberSchema<undefined>;
+            readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
+                readonly completed: v.NumberSchema<undefined>;
+                readonly inProgress: v.NumberSchema<undefined>;
+                readonly total: v.NumberSchema<undefined>;
+                readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly label: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** Cursor for the next page, or null when this was the last page. */
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugRunList = v.InferOutput<typeof debugRunListSchema>;
+/**
+ * One step of the run, projected to what a diagnosis actually reads. The internal
+ * `PipelineStep` carries two dozen per-kind state blobs (gate, judge, follow-ups, container,
+ * validation, reproduction, …) that are megabytes on a long run and meaningless without the
+ * engine's vocabulary; what survives here is the step's identity, its clocks, and the two
+ * things that explain a stuck step — whether its container kept dying, and what killed it.
+ */
+export declare const debugRunStepSchema: v.ObjectSchema<{
+    readonly index: v.NumberSchema<undefined>;
+    readonly agentKind: v.StringSchema<undefined>;
+    /** Lifecycle state (`pending` / `working` / `waiting_decision` / `done` / …). */
+    readonly state: v.StringSchema<undefined>;
+    readonly progress: v.NumberSchema<undefined>;
+    /** The resolved model this step dispatched on, when the engine recorded one. */
+    readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Whether the pipeline skipped this step. */
+    readonly skipped: v.BooleanSchema<undefined>;
+    /** Epoch ms the step first began executing; null until it starts. */
+    readonly startedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /** Epoch ms the step finished; null until it completes. */
+    readonly finishedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * Epoch ms of the container agent's last observed sign of life. The field that separates a
+     * genuinely-active-but-quiet step (a reviewer reading hundreds of files) from a wedged one,
+     * which no other clock here can distinguish. Null on non-container steps.
+     */
+    readonly lastActivityAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /** Live/last subtask counts for an async container step; null when none were reported. */
+    readonly subtasks: v.NullableSchema<v.ObjectSchema<{
+        readonly completed: v.NumberSchema<undefined>;
+        readonly inProgress: v.NumberSchema<undefined>;
+        readonly total: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    /** Characters of prose output the step produced (0 ⇒ it produced none). */
+    readonly outputChars: v.NumberSchema<undefined>;
+    /** Whether the step produced a structured result (`step.custom`). */
+    readonly hasStructuredResult: v.BooleanSchema<undefined>;
+    /** How many times this step's container was evicted/crashed and automatically re-dispatched. */
+    readonly evictionRecoveries: v.NumberSchema<undefined>;
+    /**
+     * The post-mortem retained from the FIRST container death on this step (exit state plus a
+     * scrubbed log tail). Null when the step's containers never died. Bounded like every other
+     * body on this surface.
+     */
+    readonly firstEvictionDetail: v.NullableSchema<v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type DebugRunStep = v.InferOutput<typeof debugRunStepSchema>;
+/**
+ * Whether one telemetry sink has anything for this run, and how much. The point of the block
+ * is to stop a caller issuing four detail requests to discover three of them are empty —
+ * `available: false` means the sink's repository is not wired on this deployment, so a zero
+ * count there is "we never recorded this", not "nothing happened".
+ *
+ * Availability is REPOSITORY presence only. The capture-time gates (`LLM_RECORD_PROMPTS`, the
+ * per-workspace `storeAgentContext`) act at record time and are invisible here: a workspace
+ * that opted out of capture reads `available: true, count: 0`.
+ */
+export declare const debugSinkStatusSchema: v.ObjectSchema<{
+    readonly available: v.BooleanSchema<undefined>;
+    readonly count: v.NumberSchema<undefined>;
+}, undefined>;
+export type DebugSinkStatus = v.InferOutput<typeof debugSinkStatusSchema>;
+/** Severity of a derived diagnostic signal. */
+export declare const debugSignalSeveritySchema: v.PicklistSchema<["info", "warning", "error"], undefined>;
+export type DebugSignalSeverity = v.InferOutput<typeof debugSignalSeveritySchema>;
+/**
+ * A precomputed diagnostic hint. These are derivations the caller could make itself from the
+ * rollups — which is exactly why they are here: a model that has to rediscover "13 of 40 calls
+ * were truncated" by arithmetic over a payload will sometimes get it wrong, and will always
+ * spend context doing it. `code` is machine-readable and stable; `message` restates it in
+ * prose so the payload is useful with no external key.
+ */
+export declare const debugSignalSchema: v.ObjectSchema<{
+    readonly code: v.StringSchema<undefined>;
+    readonly severity: v.PicklistSchema<["info", "warning", "error"], undefined>;
+    readonly message: v.StringSchema<undefined>;
+    /** How many occurrences the signal counts (truncated calls, failed provisions, …); null when it counts nothing. */
+    readonly count: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /** The agent kind the signal is about, when it is scoped to one. */
+    readonly agentKind: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The step index the signal is about, when it is scoped to one. */
+    readonly stepIndex: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugSignal = v.InferOutput<typeof debugSignalSchema>;
+/**
+ * The run's diagnostic map: identity, per-step state, what each telemetry sink holds, the
+ * SQL-aggregated LLM rollups, and the derived signals. Composed from aggregates only — it
+ * reads no prompt, response or context body, so it stays cheap enough to be the first call a
+ * debugging client always makes.
+ */
+export declare const debugRunOverviewSchema: v.ObjectSchema<{
+    /** Schema marker so a consuming model knows the shape without external docs. */
+    readonly kind: v.LiteralSchema<"cat-factory.run-debug-overview", undefined>;
+    readonly version: v.LiteralSchema<1, undefined>;
+    /** When this projection was computed (epoch ms). */
+    readonly generatedAt: v.NumberSchema<undefined>;
+    readonly run: v.ObjectSchema<{
+        readonly runId: v.StringSchema<undefined>;
+        /** The board block the run is anchored on (a task, a service frame, or a headless anchor). */
+        readonly blockId: v.StringSchema<undefined>;
+        readonly pipelineId: v.StringSchema<undefined>;
+        readonly pipelineName: v.StringSchema<undefined>;
+        readonly status: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
+        /** Epoch-ms creation stamp — also the value the keyset cursor is minted from. */
+        readonly createdAt: v.NumberSchema<undefined>;
+        /** Index of the step the run is currently on. */
+        readonly currentStep: v.NumberSchema<undefined>;
+        /** How many steps the run's pipeline has. */
+        readonly stepCount: v.NumberSchema<undefined>;
+        /** Structured failure diagnostics when the run failed; null otherwise. */
+        readonly failure: v.NullableSchema<v.ObjectSchema<{
+            readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
+            readonly message: v.StringSchema<undefined>;
+            readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly occurredAt: v.NumberSchema<undefined>;
+            readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
+                readonly completed: v.NumberSchema<undefined>;
+                readonly inProgress: v.NumberSchema<undefined>;
+                readonly total: v.NumberSchema<undefined>;
+                readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly label: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly steps: v.ArraySchema<v.ObjectSchema<{
+        readonly index: v.NumberSchema<undefined>;
+        readonly agentKind: v.StringSchema<undefined>;
+        /** Lifecycle state (`pending` / `working` / `waiting_decision` / `done` / …). */
+        readonly state: v.StringSchema<undefined>;
+        readonly progress: v.NumberSchema<undefined>;
+        /** The resolved model this step dispatched on, when the engine recorded one. */
+        readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Whether the pipeline skipped this step. */
+        readonly skipped: v.BooleanSchema<undefined>;
+        /** Epoch ms the step first began executing; null until it starts. */
+        readonly startedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /** Epoch ms the step finished; null until it completes. */
+        readonly finishedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /**
+         * Epoch ms of the container agent's last observed sign of life. The field that separates a
+         * genuinely-active-but-quiet step (a reviewer reading hundreds of files) from a wedged one,
+         * which no other clock here can distinguish. Null on non-container steps.
+         */
+        readonly lastActivityAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /** Live/last subtask counts for an async container step; null when none were reported. */
+        readonly subtasks: v.NullableSchema<v.ObjectSchema<{
+            readonly completed: v.NumberSchema<undefined>;
+            readonly inProgress: v.NumberSchema<undefined>;
+            readonly total: v.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        /** Characters of prose output the step produced (0 ⇒ it produced none). */
+        readonly outputChars: v.NumberSchema<undefined>;
+        /** Whether the step produced a structured result (`step.custom`). */
+        readonly hasStructuredResult: v.BooleanSchema<undefined>;
+        /** How many times this step's container was evicted/crashed and automatically re-dispatched. */
+        readonly evictionRecoveries: v.NumberSchema<undefined>;
+        /**
+         * The post-mortem retained from the FIRST container death on this step (exit state plus a
+         * scrubbed log tail). Null when the step's containers never died. Bounded like every other
+         * body on this surface.
+         */
+        readonly firstEvictionDetail: v.NullableSchema<v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Where and on what the run's most recent container step executed (backend, model, repo,
+     * control-plane host), when the engine recorded it. Null for a pure-inline run.
+     */
+    readonly diagnostics: v.NullableSchema<v.ObjectSchema<{
+        readonly lastDispatch: v.OptionalSchema<v.ObjectSchema<{
+            readonly stepIndex: v.NumberSchema<undefined>;
+            readonly agentKind: v.StringSchema<undefined>;
+            readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly executionBackend: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly repo: v.OptionalSchema<v.ObjectSchema<{
+                readonly owner: v.StringSchema<undefined>;
+                readonly name: v.StringSchema<undefined>;
+                readonly baseBranch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly at: v.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly host: v.OptionalSchema<v.ObjectSchema<{
+            readonly platform: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly sinks: v.ObjectSchema<{
+        readonly llmCalls: v.ObjectSchema<{
+            readonly available: v.BooleanSchema<undefined>;
+            readonly count: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly agentContext: v.ObjectSchema<{
+            readonly available: v.BooleanSchema<undefined>;
+            readonly count: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly searchQueries: v.ObjectSchema<{
+            readonly available: v.BooleanSchema<undefined>;
+            readonly count: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly provisioningLog: v.ObjectSchema<{
+            readonly available: v.BooleanSchema<undefined>;
+            readonly count: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>;
+    /**
+     * The run's model activity, aggregated in SQL. `byAgentKind` reuses the same insight shape
+     * the LLM-metrics export publishes, derived ratios included, so the two never disagree.
+     *
+     * `byPhase` re-cuts the SAME aggregate along the other axis — WHICH slice of the run's work
+     * spent the tokens (the agent's edit loop, a validation repair round, a reproduction-proof
+     * round, …) — with the carry cost that says how much each phase burdened the turns after it.
+     * It is the axis a caller asked "why did this trivial task cost a million tokens" needs, and
+     * `byAgentKind` cannot answer it: one coder step contains every phase. Both are folds over
+     * one `GROUP BY`, so their totals agree by construction. Rows are ordered by descending
+     * carry cost — the expensive slice first, which is what the caller is looking for.
+     */
+    readonly llm: v.ObjectSchema<{
+        readonly totals: v.ObjectSchema<{
+            readonly calls: v.NumberSchema<undefined>;
+            readonly promptTokens: v.NumberSchema<undefined>;
+            readonly cacheReadTokens: v.NumberSchema<undefined>;
+            readonly cacheWriteTokens: v.NumberSchema<undefined>;
+            readonly cacheHitRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly completionTokens: v.NumberSchema<undefined>;
+            readonly upstreamMs: v.NumberSchema<undefined>;
+            readonly overheadMs: v.NumberSchema<undefined>;
+            readonly transportOverheadRatio: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly errors: v.NumberSchema<undefined>;
+            readonly warnings: v.NumberSchema<undefined>;
+            readonly truncatedCalls: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly byAgentKind: v.ArraySchema<v.ObjectSchema<{
+            readonly agentKind: v.StringSchema<undefined>;
+            readonly calls: v.NumberSchema<undefined>;
+            readonly promptTokens: v.NumberSchema<undefined>;
+            readonly cacheReadTokens: v.NumberSchema<undefined>;
+            readonly cacheWriteTokens: v.NumberSchema<undefined>;
+            readonly cacheHitRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly completionTokens: v.NumberSchema<undefined>;
+            readonly peakCompletionTokens: v.NumberSchema<undefined>;
+            readonly maxOutputTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly outputHeadroomRatio: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly truncatedCalls: v.NumberSchema<undefined>;
+            readonly upstreamMs: v.NumberSchema<undefined>;
+            readonly overheadMs: v.NumberSchema<undefined>;
+            readonly transportOverheadRatio: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly errors: v.NumberSchema<undefined>;
+            readonly warnings: v.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly byPhase: v.ArraySchema<v.ObjectSchema<{
+            readonly phase: v.StringSchema<undefined>;
+            readonly calls: v.NumberSchema<undefined>;
+            readonly promptTokens: v.NumberSchema<undefined>;
+            readonly cacheReadTokens: v.NumberSchema<undefined>;
+            readonly cacheWriteTokens: v.NumberSchema<undefined>;
+            readonly cacheHitRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly completionTokens: v.NumberSchema<undefined>;
+            readonly carryCostTokens: v.NumberSchema<undefined>;
+            readonly carryCostShare: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly upstreamMs: v.NumberSchema<undefined>;
+            readonly overheadMs: v.NumberSchema<undefined>;
+            readonly errors: v.NumberSchema<undefined>;
+            readonly warnings: v.NumberSchema<undefined>;
+            readonly truncatedCalls: v.NumberSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly signals: v.ArraySchema<v.ObjectSchema<{
+        readonly code: v.StringSchema<undefined>;
+        readonly severity: v.PicklistSchema<["info", "warning", "error"], undefined>;
+        readonly message: v.StringSchema<undefined>;
+        /** How many occurrences the signal counts (truncated calls, failed provisions, …); null when it counts nothing. */
+        readonly count: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /** The agent kind the signal is about, when it is scoped to one. */
+        readonly agentKind: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The step index the signal is about, when it is scoped to one. */
+        readonly stepIndex: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type DebugRunOverview = v.InferOutput<typeof debugRunOverviewSchema>;
+/** Classification of a recorded call, precomputed so a caller need not re-derive it. */
+export declare const debugCallOutcomeSchema: v.PicklistSchema<["ok", "warning", "error"], undefined>;
+export type DebugCallOutcome = v.InferOutput<typeof debugCallOutcomeSchema>;
+/** Chronological direction a call page walks in. */
+export declare const debugCallOrderSchema: v.PicklistSchema<["newest", "oldest"], undefined>;
+export type DebugCallOrder = v.InferOutput<typeof debugCallOrderSchema>;
+/** How the single-call point read presents the prompt delta. */
+export declare const debugCallViewSchema: v.PicklistSchema<["raw", "messages"], undefined>;
+export type DebugCallView = v.InferOutput<typeof debugCallViewSchema>;
+/**
+ * One message of a parsed prompt delta (`?view=messages` on the point read). The parse is
+ * LENIENT — both telemetry producers store `JSON.stringify` of a `{ role, content }` array,
+ * but the content shapes differ (OpenAI-style strings/parts/`tool_calls` from the proxy,
+ * vendor content blocks from the harness transcript), so unrecognised parts degrade to a
+ * `[type]` placeholder rather than failing the message.
+ */
+export declare const debugPromptMessageSchema: v.ObjectSchema<{
+    /**
+     * The message's absolute position in the FULL conversation (`elidedLeadingMessages` +
+     * its position in the delta), so two calls' parsed views line up without arithmetic.
+     */
+    readonly index: v.NumberSchema<undefined>;
+    /** The message's role verbatim (`system` / `user` / `assistant` / `tool` / …), `unknown` when absent. */
+    readonly role: v.StringSchema<undefined>;
+    /** The message's `name` field (a named tool/function turn), when the producer recorded one. */
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The tool invocation a tool-result turn answers, when the producer recorded the id. */
+    readonly toolCallId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Tool invocations an assistant turn requested: the tool's name plus its budgeted serialized arguments. */
+    readonly toolCalls: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly args: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    /** The message's textual content, budgeted INDEPENDENTLY of every other message's. */
+    readonly content: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type DebugPromptMessage = v.InferOutput<typeof debugPromptMessageSchema>;
+/**
+ * One recorded model call. The three body fields are always PRESENT but empty unless the
+ * caller asked for a preview — their `totalChars` is measured in SQL either way, so a
+ * zero-cost sweep still shows exactly how much text each call holds.
+ *
+ * `prompt` is the call's DELTA — only the messages this call appended to its conversation.
+ * That is how the store keeps prompts (a container agent re-sends its whole growing history
+ * every turn, so storing the full array per call is ~21x redundant), and it is also the right
+ * shape for reading: walk one agent kind's calls with `order=oldest` and the concatenated
+ * deltas ARE the conversation, with no prefix re-sent to the caller either.
+ */
+export declare const debugLlmCallSchema: v.ObjectSchema<{
+    readonly callId: v.StringSchema<undefined>;
+    readonly runId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly agentKind: v.StringSchema<undefined>;
+    readonly provider: v.StringSchema<undefined>;
+    readonly model: v.StringSchema<undefined>;
+    readonly createdAt: v.NumberSchema<undefined>;
+    readonly outcome: v.PicklistSchema<["ok", "warning", "error"], undefined>;
+    readonly ok: v.BooleanSchema<undefined>;
+    readonly httpStatus: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly errorMessage: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly finishReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly streaming: v.BooleanSchema<undefined>;
+    /**
+     * WHICH slice of the run spent this call: the agent's own edit loop (`agent`), a pre-PR
+     * validation repair round (`validation-repair`), a reproduction-proof repair round
+     * (`reproduction-repair`), … Stamped by whoever owns the loop boundary, never reconstructed
+     * from timestamps, which is why it is worth reading rather than inferring.
+     *
+     * `''` means the call could not be attributed — an older harness image, an inline call, or the
+     * un-phased proxy path. That is a REAL slice, not a gap: a run whose calls are all `''` was
+     * metered by something that has no phase concept, NOT one that spent nothing outside the agent.
+     */
+    readonly phase: v.StringSchema<undefined>;
+    /**
+     * The call's ordinal within its job's telemetry sequence (0-based), so a phase's calls can be
+     * ordered by TURN rather than by wall clock.
+     *
+     * `null` where the producing channel has no turn concept — the LLM proxy sees one HTTP request
+     * at a time with no job-scoped counter. Deliberately not faked to 0, which would read as "the
+     * first turn" and sort every proxied call to the front of its phase.
+     */
+    readonly turnIndex: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /** Messages in the FULL request (not just the delta below). */
+    readonly messageCount: v.NumberSchema<undefined>;
+    /** Tools offered to the model (0 ⇒ the agent could not edit anything). */
+    readonly toolCount: v.NumberSchema<undefined>;
+    readonly requestMaxTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /** FRESH (uncached) input tokens — exclusive of both cache classes below. */
+    readonly promptTokens: v.NumberSchema<undefined>;
+    /** Input tokens served from the provider's prefix cache (priced around 0.1x fresh). */
+    readonly cacheReadTokens: v.NumberSchema<undefined>;
+    /**
+     * Input tokens WRITTEN into the provider's cache (priced 1.25-2x fresh). Kept apart from
+     * the reads because summed together, a loop that keeps invalidating and re-writing its
+     * prefix is indistinguishable from one riding a warm cache — and telling those apart is
+     * often the whole question when a run costs more than it should.
+     */
+    readonly cacheWriteTokens: v.NumberSchema<undefined>;
+    readonly completionTokens: v.NumberSchema<undefined>;
+    readonly totalTokens: v.NumberSchema<undefined>;
+    readonly upstreamMs: v.NumberSchema<undefined>;
+    readonly overheadMs: v.NumberSchema<undefined>;
+    readonly totalMs: v.NumberSchema<undefined>;
+    /** Leading messages elided from `prompt` because an earlier call in the chain stored them. */
+    readonly elidedLeadingMessages: v.NumberSchema<undefined>;
+    /** The messages this call APPENDED, as JSON (see the note above). */
+    readonly prompt: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    /** The assistant's visible reply. */
+    readonly response: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    /** The model's separate reasoning channel, when it emits one. */
+    readonly reasoning: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    /**
+     * The prompt delta parsed into per-message rows, each budgeted independently — present only
+     * on a `?view=messages` point read. `null` there means the stored delta did not parse as a
+     * message array (the raw `prompt` is served instead, so the view degrades rather than
+     * returning nothing); absent means the caller did not ask for the view. Independent budgets
+     * are the point: in the raw view one enormous leading tool result must be paid for before
+     * anything after it is visible, while here every message shows its head. The response's
+     * worst case stays computable — `(messageCount − elidedLeadingMessages) × bodyChars`, both
+     * factors already on the list row.
+     */
+    readonly promptMessages: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
+        /**
+         * The message's absolute position in the FULL conversation (`elidedLeadingMessages` +
+         * its position in the delta), so two calls' parsed views line up without arithmetic.
+         */
+        readonly index: v.NumberSchema<undefined>;
+        /** The message's role verbatim (`system` / `user` / `assistant` / `tool` / …), `unknown` when absent. */
+        readonly role: v.StringSchema<undefined>;
+        /** The message's `name` field (a named tool/function turn), when the producer recorded one. */
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The tool invocation a tool-result turn answers, when the producer recorded the id. */
+        readonly toolCallId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Tool invocations an assistant turn requested: the tool's name plus its budgeted serialized arguments. */
+        readonly toolCalls: v.ArraySchema<v.ObjectSchema<{
+            readonly name: v.StringSchema<undefined>;
+            readonly args: v.ObjectSchema<{
+                /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+                readonly text: v.StringSchema<undefined>;
+                /**
+                 * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+                 * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+                 */
+                readonly chars: v.NumberSchema<undefined>;
+                /**
+                 * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+                 * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+                 * `offset + chars <= totalChars` always holds.
+                 */
+                readonly offset: v.NumberSchema<undefined>;
+                /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+                readonly totalChars: v.NumberSchema<undefined>;
+                /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+                readonly truncated: v.BooleanSchema<undefined>;
+                /**
+                 * 0-based code-point offset of the first case-insensitive occurrence of the request's
+                 * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+                 * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+                 * to jump straight to the match without transferring the bytes before it.
+                 */
+                readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+        /** The message's textual content, budgeted INDEPENDENTLY of every other message's. */
+        readonly content: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>, undefined>, undefined>;
+}, undefined>;
+export type DebugLlmCall = v.InferOutput<typeof debugLlmCallSchema>;
+/** Query params for `GET /api/v1/debug/runs/:runId/llm-calls`. */
+export declare const listDebugLlmCallsQuerySchema: v.ObjectSchema<{
+    /** Narrow to one step kind's conversation (`coder`, `ci-fixer`, …), applied in SQL. */
+    readonly agentKind: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>, undefined>;
+    /**
+     * Narrow to one PHASE's calls (`agent`, `validation-repair`, `reproduction-repair`, …), an
+     * exact match applied in SQL. This is how "what did the repair rounds cost" is answered in one
+     * request rather than by paging the run and grouping client-side.
+     *
+     * Unlike `agentKind` the EMPTY string is accepted and meaningful: it selects the unattributed
+     * slice (an older harness image, an inline call, the un-phased proxy path), which is otherwise
+     * unreachable as a query.
+     */
+    readonly phase: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 120, undefined>]>, undefined>;
+    /** Narrow to failing or warning (truncated / filtered) calls only. */
+    readonly outcome: v.OptionalSchema<v.PicklistSchema<["ok", "warning", "error"], undefined>, undefined>;
+    /**
+     * Narrow to calls whose prompt delta, response or reasoning CONTAINS this literal substring,
+     * matched case-insensitively in SQL. This is the surface's grep — the way a caller finds a
+     * tool-validation error, a repeated apology, or any known marker across thousands of calls
+     * in ONE request instead of paging every body through its own context. Matched rows report
+     * a per-body `matchOffset`; wildcards (`%`/`_`) match literally.
+     */
+    readonly contains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>, undefined>;
+    /** `newest` (default) for triage; `oldest` to read a conversation forwards. */
+    readonly order: v.OptionalSchema<v.PicklistSchema<["newest", "oldest"], undefined>, undefined>;
+    /** Cap on rows returned (default 25, hard max {@link DEBUG_MAX_PAGE_LIMIT}). */
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>, undefined>;
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+    /**
+     * Per-field body preview budget, 0..{@link DEBUG_MAX_PREVIEW_CHARS}. Default 0: the sweep
+     * returns sizes only. Bodies are sliced IN SQL, so an un-previewed page never reads the
+     * text columns out of the store at all.
+     */
+    readonly bodyChars: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 4000, undefined>]>, undefined>;
+}, undefined>;
+export type ListDebugLlmCallsQuery = v.InferOutput<typeof listDebugLlmCallsQuerySchema>;
+export declare const debugLlmCallListSchema: v.ObjectSchema<{
+    readonly calls: v.ArraySchema<v.ObjectSchema<{
+        readonly callId: v.StringSchema<undefined>;
+        readonly runId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly agentKind: v.StringSchema<undefined>;
+        readonly provider: v.StringSchema<undefined>;
+        readonly model: v.StringSchema<undefined>;
+        readonly createdAt: v.NumberSchema<undefined>;
+        readonly outcome: v.PicklistSchema<["ok", "warning", "error"], undefined>;
+        readonly ok: v.BooleanSchema<undefined>;
+        readonly httpStatus: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly errorMessage: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly finishReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly streaming: v.BooleanSchema<undefined>;
+        /**
+         * WHICH slice of the run spent this call: the agent's own edit loop (`agent`), a pre-PR
+         * validation repair round (`validation-repair`), a reproduction-proof repair round
+         * (`reproduction-repair`), … Stamped by whoever owns the loop boundary, never reconstructed
+         * from timestamps, which is why it is worth reading rather than inferring.
+         *
+         * `''` means the call could not be attributed — an older harness image, an inline call, or the
+         * un-phased proxy path. That is a REAL slice, not a gap: a run whose calls are all `''` was
+         * metered by something that has no phase concept, NOT one that spent nothing outside the agent.
+         */
+        readonly phase: v.StringSchema<undefined>;
+        /**
+         * The call's ordinal within its job's telemetry sequence (0-based), so a phase's calls can be
+         * ordered by TURN rather than by wall clock.
+         *
+         * `null` where the producing channel has no turn concept — the LLM proxy sees one HTTP request
+         * at a time with no job-scoped counter. Deliberately not faked to 0, which would read as "the
+         * first turn" and sort every proxied call to the front of its phase.
+         */
+        readonly turnIndex: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /** Messages in the FULL request (not just the delta below). */
+        readonly messageCount: v.NumberSchema<undefined>;
+        /** Tools offered to the model (0 ⇒ the agent could not edit anything). */
+        readonly toolCount: v.NumberSchema<undefined>;
+        readonly requestMaxTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /** FRESH (uncached) input tokens — exclusive of both cache classes below. */
+        readonly promptTokens: v.NumberSchema<undefined>;
+        /** Input tokens served from the provider's prefix cache (priced around 0.1x fresh). */
+        readonly cacheReadTokens: v.NumberSchema<undefined>;
+        /**
+         * Input tokens WRITTEN into the provider's cache (priced 1.25-2x fresh). Kept apart from
+         * the reads because summed together, a loop that keeps invalidating and re-writing its
+         * prefix is indistinguishable from one riding a warm cache — and telling those apart is
+         * often the whole question when a run costs more than it should.
+         */
+        readonly cacheWriteTokens: v.NumberSchema<undefined>;
+        readonly completionTokens: v.NumberSchema<undefined>;
+        readonly totalTokens: v.NumberSchema<undefined>;
+        readonly upstreamMs: v.NumberSchema<undefined>;
+        readonly overheadMs: v.NumberSchema<undefined>;
+        readonly totalMs: v.NumberSchema<undefined>;
+        /** Leading messages elided from `prompt` because an earlier call in the chain stored them. */
+        readonly elidedLeadingMessages: v.NumberSchema<undefined>;
+        /** The messages this call APPENDED, as JSON (see the note above). */
+        readonly prompt: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+        /** The assistant's visible reply. */
+        readonly response: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+        /** The model's separate reasoning channel, when it emits one. */
+        readonly reasoning: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+        /**
+         * The prompt delta parsed into per-message rows, each budgeted independently — present only
+         * on a `?view=messages` point read. `null` there means the stored delta did not parse as a
+         * message array (the raw `prompt` is served instead, so the view degrades rather than
+         * returning nothing); absent means the caller did not ask for the view. Independent budgets
+         * are the point: in the raw view one enormous leading tool result must be paid for before
+         * anything after it is visible, while here every message shows its head. The response's
+         * worst case stays computable — `(messageCount − elidedLeadingMessages) × bodyChars`, both
+         * factors already on the list row.
+         */
+        readonly promptMessages: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
+            /**
+             * The message's absolute position in the FULL conversation (`elidedLeadingMessages` +
+             * its position in the delta), so two calls' parsed views line up without arithmetic.
+             */
+            readonly index: v.NumberSchema<undefined>;
+            /** The message's role verbatim (`system` / `user` / `assistant` / `tool` / …), `unknown` when absent. */
+            readonly role: v.StringSchema<undefined>;
+            /** The message's `name` field (a named tool/function turn), when the producer recorded one. */
+            readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The tool invocation a tool-result turn answers, when the producer recorded the id. */
+            readonly toolCallId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** Tool invocations an assistant turn requested: the tool's name plus its budgeted serialized arguments. */
+            readonly toolCalls: v.ArraySchema<v.ObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly args: v.ObjectSchema<{
+                    /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+                    readonly text: v.StringSchema<undefined>;
+                    /**
+                     * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+                     * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+                     */
+                    readonly chars: v.NumberSchema<undefined>;
+                    /**
+                     * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+                     * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+                     * `offset + chars <= totalChars` always holds.
+                     */
+                    readonly offset: v.NumberSchema<undefined>;
+                    /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+                    readonly totalChars: v.NumberSchema<undefined>;
+                    /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+                    readonly truncated: v.BooleanSchema<undefined>;
+                    /**
+                     * 0-based code-point offset of the first case-insensitive occurrence of the request's
+                     * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+                     * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+                     * to jump straight to the match without transferring the bytes before it.
+                     */
+                    readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+                }, undefined>;
+            }, undefined>, undefined>;
+            /** The message's textual content, budgeted INDEPENDENTLY of every other message's. */
+            readonly content: v.ObjectSchema<{
+                /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+                readonly text: v.StringSchema<undefined>;
+                /**
+                 * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+                 * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+                 */
+                readonly chars: v.NumberSchema<undefined>;
+                /**
+                 * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+                 * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+                 * `offset + chars <= totalChars` always holds.
+                 */
+                readonly offset: v.NumberSchema<undefined>;
+                /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+                readonly totalChars: v.NumberSchema<undefined>;
+                /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+                readonly truncated: v.BooleanSchema<undefined>;
+                /**
+                 * 0-based code-point offset of the first case-insensitive occurrence of the request's
+                 * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+                 * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+                 * to jump straight to the match without transferring the bytes before it.
+                 */
+                readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>, undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugLlmCallList = v.InferOutput<typeof debugLlmCallListSchema>;
+/** Query params for the single-call point read. */
+export declare const getDebugLlmCallQuerySchema: v.ObjectSchema<{
+    /**
+     * Per-field budget, 0..{@link DEBUG_MAX_BODY_CHARS}. Absent ⇒ the ceiling itself: a body
+     * longer than {@link DEBUG_MAX_BODY_CHARS} is still cut (and says so via `truncated`).
+     * Under `view=messages` this is the PER-MESSAGE content budget.
+     */
+    readonly bodyChars: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 200000, undefined>]>, undefined>;
+    /**
+     * 0-based code-point offset the body slices start at (raw view only; a parsed message view
+     * always reads each message whole and budgets its head). Pair with a searched list row's
+     * `matchOffset` to read the text AROUND a match — the `grep -C` of this surface.
+     */
+    readonly bodyOffset: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 2000000, undefined>]>, undefined>;
+    /**
+     * `raw` (default) returns the delta as stored JSON; `messages` parses it into per-message
+     * rows with independent budgets (see `promptMessages`). Falls back to `raw` semantics when
+     * the stored delta does not parse.
+     */
+    readonly view: v.OptionalSchema<v.PicklistSchema<["raw", "messages"], undefined>, undefined>;
+}, undefined>;
+export type GetDebugLlmCallQuery = v.InferOutput<typeof getDebugLlmCallQuerySchema>;
+/**
+ * One captured dispatch, SIZES ONLY. A snapshot carries the whole composed system prompt, the
+ * whole user prompt, every folded fragment body and the full content of every injected
+ * context file — a single row can be megabytes, so the list never inlines any of it (there is
+ * no `bodyChars` here on purpose: a truncated prefix of a fragment ARRAY answers no question a
+ * size does not, and the point read is one hop away).
+ */
+export declare const debugAgentContextEntrySchema: v.ObjectSchema<{
+    readonly snapshotId: v.StringSchema<undefined>;
+    readonly agentKind: v.StringSchema<undefined>;
+    /** The step index within the run's pipeline this dispatch belongs to. */
+    readonly stepIndex: v.NumberSchema<undefined>;
+    readonly createdAt: v.NumberSchema<undefined>;
+    readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly harness: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly systemPromptChars: v.NumberSchema<undefined>;
+    readonly userPromptChars: v.NumberSchema<undefined>;
+    /**
+     * Serialized size of the best-practice fragments folded into the system prompt, and of the
+     * files injected into the container as `.cat-context/*` (their bodies included).
+     *
+     * Sizes rather than element counts on purpose: counting the entries of those two JSON
+     * columns means either parsing them — which reads the very bodies this projection exists to
+     * avoid — or calling `json_array_length` on a column where one malformed row would fail the
+     * whole page. For "is there a lot in here, and did it change between attempts", a length
+     * answers just as well; the point read gives the actual arrays.
+     */
+    readonly fragmentsChars: v.NumberSchema<undefined>;
+    readonly contextFilesChars: v.NumberSchema<undefined>;
+}, undefined>;
+export type DebugAgentContextEntry = v.InferOutput<typeof debugAgentContextEntrySchema>;
+/** Query params for `GET /api/v1/debug/runs/:runId/agent-context`. */
+export declare const listDebugAgentContextQuerySchema: v.ObjectSchema<{
+    /** Narrow to one step's dispatches (a step re-dispatched on retry records one snapshot each). */
+    readonly stepIndex: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>, undefined>;
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+}, undefined>;
+export type ListDebugAgentContextQuery = v.InferOutput<typeof listDebugAgentContextQuerySchema>;
+export declare const debugAgentContextListSchema: v.ObjectSchema<{
+    readonly snapshots: v.ArraySchema<v.ObjectSchema<{
+        readonly snapshotId: v.StringSchema<undefined>;
+        readonly agentKind: v.StringSchema<undefined>;
+        /** The step index within the run's pipeline this dispatch belongs to. */
+        readonly stepIndex: v.NumberSchema<undefined>;
+        readonly createdAt: v.NumberSchema<undefined>;
+        readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly harness: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly systemPromptChars: v.NumberSchema<undefined>;
+        readonly userPromptChars: v.NumberSchema<undefined>;
+        /**
+         * Serialized size of the best-practice fragments folded into the system prompt, and of the
+         * files injected into the container as `.cat-context/*` (their bodies included).
+         *
+         * Sizes rather than element counts on purpose: counting the entries of those two JSON
+         * columns means either parsing them — which reads the very bodies this projection exists to
+         * avoid — or calling `json_array_length` on a column where one malformed row would fail the
+         * whole page. For "is there a lot in here, and did it change between attempts", a length
+         * answers just as well; the point read gives the actual arrays.
+         */
+        readonly fragmentsChars: v.NumberSchema<undefined>;
+        readonly contextFilesChars: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugAgentContextList = v.InferOutput<typeof debugAgentContextListSchema>;
+/** One folded best-practice fragment, with its body bounded. */
+export declare const debugAgentContextFragmentSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly body: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type DebugAgentContextFragment = v.InferOutput<typeof debugAgentContextFragmentSchema>;
+/** One injected context file, with its (already secret-scrubbed) body bounded. */
+export declare const debugAgentContextFileSchema: v.ObjectSchema<{
+    readonly path: v.StringSchema<undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly url: v.StringSchema<undefined>;
+    readonly content: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type DebugAgentContextFile = v.InferOutput<typeof debugAgentContextFileSchema>;
+/**
+ * The full context one dispatch was provided. Every body is budgeted independently so one
+ * enormous injected file cannot crowd out the prompts a reader actually came for.
+ */
+export declare const debugAgentContextDetailSchema: v.ObjectSchema<{
+    readonly snapshotId: v.StringSchema<undefined>;
+    readonly runId: v.StringSchema<undefined>;
+    readonly agentKind: v.StringSchema<undefined>;
+    readonly stepIndex: v.NumberSchema<undefined>;
+    readonly createdAt: v.NumberSchema<undefined>;
+    readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly harness: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly systemPrompt: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly userPrompt: v.ObjectSchema<{
+        /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+         * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+         */
+        readonly chars: v.NumberSchema<undefined>;
+        /**
+         * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+         * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+         * `offset + chars <= totalChars` always holds.
+         */
+        readonly offset: v.NumberSchema<undefined>;
+        /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+        readonly totalChars: v.NumberSchema<undefined>;
+        /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+        readonly truncated: v.BooleanSchema<undefined>;
+        /**
+         * 0-based code-point offset of the first case-insensitive occurrence of the request's
+         * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+         * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+         * to jump straight to the match without transferring the bytes before it.
+         */
+        readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly fragments: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly body: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    readonly contextFiles: v.ArraySchema<v.ObjectSchema<{
+        readonly path: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly url: v.StringSchema<undefined>;
+        readonly content: v.ObjectSchema<{
+            /** The returned slice — `chars` characters of the stored body, starting at `offset`. */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * Characters actually returned in {@link debugTextSchema} `text`, in Unicode CODE POINTS —
+             * the unit SQL `length()`/`substr()` measure in (an emoji counts once, not twice).
+             */
+            readonly chars: v.NumberSchema<undefined>;
+            /**
+             * 0-based code-point position `text` starts at within the stored body — 0 unless the caller
+             * asked for a later window via `?bodyOffset=`. Clamped to `totalChars`, so
+             * `offset + chars <= totalChars` always holds.
+             */
+            readonly offset: v.NumberSchema<undefined>;
+            /** Characters stored for this field (the full code-point length, regardless of what was returned). */
+            readonly totalChars: v.NumberSchema<undefined>;
+            /** True when `chars < totalChars`, i.e. `text` is not the entire stored body. */
+            readonly truncated: v.BooleanSchema<undefined>;
+            /**
+             * 0-based code-point offset of the first case-insensitive occurrence of the request's
+             * `?contains=` term in this body, or null when the term occurs only in a sibling body.
+             * Present ONLY on rows of a searched list — pair it with the point read's `?bodyOffset=`
+             * to jump straight to the match without transferring the bytes before it.
+             */
+            readonly matchOffset: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Redacted structural context (repo, branches, infra spec, the run's decisions and revision
+     * feedback). Small and already deep-scrubbed at capture time, so it is returned whole.
+     */
+    readonly extras: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+}, undefined>;
+export type DebugAgentContextDetail = v.InferOutput<typeof debugAgentContextDetailSchema>;
+/** Query params for the single-snapshot point read. */
+export declare const getDebugAgentContextQuerySchema: v.ObjectSchema<{
+    /**
+     * Per-body budget, 0..{@link DEBUG_MAX_BODY_CHARS}. Absent ⇒ the ceiling itself: a body
+     * longer than {@link DEBUG_MAX_BODY_CHARS} is still cut (and says so via `truncated`).
+     */
+    readonly bodyChars: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 200000, undefined>]>, undefined>;
+    /**
+     * 0-based code-point offset every body slice starts at. Applied to ALL of the snapshot's
+     * bodies uniformly (it exists to reach the tail of ONE large body the index sized; the
+     * others simply run out and return empty slices past their end).
+     */
+    readonly bodyOffset: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 2000000, undefined>]>, undefined>;
+}, undefined>;
+export type GetDebugAgentContextQuery = v.InferOutput<typeof getDebugAgentContextQuerySchema>;
+/** Query params for the two small-row lists (`search-queries`, `logs`). */
+export declare const listDebugPageQuerySchema: v.ObjectSchema<{
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Must be a whole number">, v.TransformAction<any, number>, v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>, undefined>;
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
+}, undefined>;
+export type ListDebugPageQuery = v.InferOutput<typeof listDebugPageQuerySchema>;
+/**
+ * The web searches the run's agents performed. Rows are small (the query text is capped at
+ * 8 kB at capture time), so they are returned whole rather than as {@link debugTextSchema}.
+ */
+export declare const debugSearchQueryListSchema: v.ObjectSchema<{
+    readonly queries: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly workspaceId: v.StringSchema<undefined>;
+        readonly executionId: v.StringSchema<undefined>;
+        readonly agentKind: v.StringSchema<undefined>;
+        readonly provider: v.NullableSchema<v.PicklistSchema<["brave", "searxng"], undefined>, undefined>;
+        readonly query: v.StringSchema<undefined>;
+        readonly resultCount: v.NumberSchema<undefined>;
+        readonly createdAt: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugSearchQueryList = v.InferOutput<typeof debugSearchQueryListSchema>;
+/**
+ * The run's slice of the provisioning event log — every attempt to spin up or tear down the
+ * throwaway infrastructure it ran on, with the verbatim (secret-scrubbed) provider error. This
+ * is the half of "why did it fail" that no model call can answer: a run whose container never
+ * came up has no LLM telemetry at all, and this is where its cause of death is written.
+ */
+export declare const debugLogListSchema: v.ObjectSchema<{
+    readonly entries: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly workspaceId: v.StringSchema<undefined>;
+        readonly subsystem: v.PicklistSchema<["environment", "runner-pool", "container"], undefined>;
+        readonly operation: v.PicklistSchema<["provision", "teardown", "status", "dispatch", "release", "poll-failure"], undefined>;
+        readonly targetId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly providerId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly blockId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly outcome: v.PicklistSchema<["success", "failure"], undefined>;
+        readonly error: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly createdAt: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type DebugLogList = v.InferOutput<typeof debugLogListSchema>;
+//# sourceMappingURL=debug-api.d.ts.map