@demlik/tea 0.13.0 → 0.15.0

package/dist/machine-DGlPWCWI.d.ts

@@ -0,0 +1,1781 @@
+import { C as Cmd, j as Tagged, I as Interpret, A as AnyCmdDef, a as CmdOf, b as CmdDef, e as Settled, i as NoCtx, O as OkOf, E as ErrOf, k as MalformedResult, l as CmdValue, g as PortEmitter, m as Requirements, n as TaggedError, M as Machine } from './core-DnzqWy6u.js';
+import { a as MonitoredRunState, R as RunFailure, M as MonitoredRunCmd } from './index-KXqTRJyb.js';
+import { R as RunCmd, S as SucceedMsg, F as FailMsg, a as ResilientState } from './index-CA_7I5g9.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-HSYgG2Yt.js';
+import { M as MsgType, a as MsgTypeValue } from './protocol-D8VbH-VH.js';
+import { F as FanOutState } from './index-CuNO9m8i.js';
+import { RetryPolicy, AnyRetryPolicy } from './retry-backoff/index.js';
+import { Result } from 'better-result';
+import { z } from 'zod';
+
+/**
+ * @packageDocumentation
+ * internal/llm-call — `resilient-call` + structured-output parse + a typed
+ * failure variant, around a purpose-discriminated LLM invocation. Internal
+ * since #49 — not published on any subpath; `@demlik/tea/agent` re-exports
+ * the types a consumer meets.
+ *
+ * This is the ~60-line `call_llm` handler from the audit-agent seed
+ * (`interpret.ts` / `effects.ts`) collapsed into the uniform L2 knob: a config
+ * object, the resilient-call slice it inherits, and one interpret handler that
+ * assembles messages, binds the structured-output schema for the call's
+ * `purpose`, invokes the model (retry composed from `../resilient-call`, NOT
+ * reinvented), parses the output, and RETURNS the enriched resilient settle Msg
+ * (`resilient_ok` / `resilient_err`) so it re-enters the host reducer and drives
+ * the inherited succeed/fail → backoff → onTimer loop.
+ *
+ * ## What it adds over `../resilient-call`
+ *
+ *   - **Two DI ports** (the seed's two seams):
+ *       1. `model` — either `async (messages) => answer`, the plain-function
+ *          port (#58), or `(modelId) => LLM`, the model factory that binds the
+ *          structured-output schema itself. Tests pass a fake so the handler
+ *          runs end-to-end without touching a real provider; the production
+ *          worker wires `createChatModel(env, …)`.
+ *       2. `loadMessages: Loader` — the SDK / message loader. The seed lazy-
+ *          imports `@langchain/core/messages` (a top-level `import type` blows
+ *          up the workers test runner); the loader keeps that import lazy and
+ *          stubbable. It produces the `BaseMessage[]` for a given call.
+ *   - **Structured-output parse** — each `purpose` maps to a `Schema` in
+ *     `config.schemas`. The handler binds `model.withStructuredOutput(schema)`
+ *     so the invoke resolves to a typed object; a `Schema.parse` that throws
+ *     becomes a `resilient_err` carrying an `LlmErr` (a parse failure is a
+ *     failure, not a stall — "errors are data"). `withStructuredOutput` is the
+ *     seed's brain-only path; the fake model in tests returns the typed object
+ *     directly.
+ *   - **A typed failure variant** — every failure (model throw, timeout-via-
+ *     retry-exhaustion, schema parse) is surfaced as the `LlmErr` carried on the
+ *     enriched `resilient_err` settle Msg, tagged with the `purpose` so the
+ *     consumer's reducer routes per-stage. The seed dispatched
+ *     `llm_failed{purpose}`; the consumer rebuilds that shape in its reducer arm
+ *     from `m.error: LlmErr`.
+ *
+ * ## Inheriting resilient-call by composition (not reinvention)
+ *
+ * The retry / backoff lives in `../resilient-call`: `createLlmCall` builds a
+ * `createResilientCall` knob over the model-invoke port and DELEGATES `init`,
+ * `attempt`, `succeed`, `fail`, `onTimer`, `subs` to it verbatim — the slice is
+ * literally resilient-call's slice (the spec's "retry lives here"). There is no
+ * second backoff implementation here. The handler runs the invoke through the
+ * resilient-call handler so a transient model failure backs off exactly as a
+ * resilient HTTP call would; the `purpose`-branch + structured parse wrap the
+ * port the resilient handler drives.
+ *
+ * ## The two non-negotiables (canon, inherited)
+ *
+ *   - **Durable** — the slice is resilient-call's plain-data slice (a Model
+ *     field). Input carried on the `resilient_run` Cmd is the plain
+ *     `LlmCall` request (purpose + modelId + payload) — no closures.
+ *   - **Replayable** — every transition is a resilient-call verb; the handler
+ *     is the only impurity, and the one clock read is `Date.now()` at the
+ *     effect boundary (inside the handler), exactly as the seed stamped its
+ *     `llm_responded` / `llm_failed` Msgs.
+ *
+ * ## Typical wiring
+ *
+ *   const llm = createLlmCall<MyPurpose, MyOutputs>({
+ *     model: (id) => createChatModel(env, id),
+ *     schemas: { plan: planSchema, report: reportSchema },
+ *     retry: defaultRetryPolicy,
+ *     loadMessages: defaultMessagesLoader,
+ *   });
+ *
+ *   // `mountResilientCall` pre-assembles the wiring. The settle cells run the
+ *   // inherited verb and hand the ALREADY-settled model to `onOk` / `onErr`,
+ *   // so the fold-before-settle order that wedges the slice at `running` is
+ *   // not something a mounted cell can express; `subscribe` and `interpret`
+ *   // ride along, so neither can be forgotten.
+ *   const mounted = mountResilientCall(llm, {
+ *     slice: "resilience",
+ *     attempt: {
+ *       on: "call_llm",
+ *       run: (slice, m: CallLlm) => llm.attempt(slice, m.input, m.at),
+ *     },
+ *     onOk: (s, m) => [{ ...s, output: m.result.output }, []],
+ *     onErr: (s, m) => [{ ...s, failure: m.error }, []],
+ *     // A deadline-exceeded call settles inside the slice and emits no
+ *     // settle Msg, so it reaches no `onErr`. This is its fold.
+ *     onDeadline: (s, m) => [{ ...s, failure: m.error }, []],
+ *   });
+ *
+ *   // in the machine:
+ *   init: () => [{ ...mounted.init(), output: null, failure: null }, []],
+ *   update: { ...mounted.update },
+ *   subscriptions: mounted.subscriptions,
+ *   subscribe: mounted.subscribe,
+ *   interpret: mounted.interpret,
+ *
+ * The slice stays a plain readable field at `resilience`, and every verb above
+ * is still exported: a consumer that wants a settle cell the mount cannot
+ * express writes that one cell with `llm.succeed` / `llm.fail` / `liftLlmCall`
+ * and spreads the rest.
+ */
+
+/**
+ * The minimal structured-output schema contract: `parse(unknown) => T`, the
+ * zod-style call the handler uses to validate the model's output before it
+ * settles `resilient_ok`. A throwing `parse` (the zod contract on invalid
+ * input) propagates out of `invokeOne` and is caught by the resilient handler,
+ * which settles `resilient_err` (enriched to `LlmErr`) — a parse failure is a
+ * failure, never a silent pass. Structural so a real `z.ZodType<T>` satisfies
+ * it without an import.
+ */
+interface Schema<T> {
+    /** Validate + narrow `value` to `T`, or throw on mismatch (the zod contract). */
+    parse(value: unknown): T;
+}
+/**
+ * The minimal chat-model contract every model the handler talks to must
+ * satisfy — the seed's `InjectableChatModel`, trimmed to the one operation
+ * llm-call drives for brain-only stages:
+ *
+ *   `withStructuredOutput(schema)` → a runnable whose `invoke(messages)`
+ *   resolves to a typed object matching `schema`.
+ *
+ * `BaseChatModel` from `@langchain/core` is the runtime type; this surface
+ * names only what llm-call calls so a test fake can ignore the rest. Generic
+ * over the message shape `Msg` so a consumer's loader and model agree on it
+ * without llm-call inspecting messages.
+ */
+interface Llm<Msg> {
+    withStructuredOutput<T>(schema: Schema<T>): {
+        invoke(messages: readonly Msg[]): Promise<T>;
+    };
+}
+/**
+ * Build the `Msg[]` the handler hands to the bound model for a given call. The
+ * SDK / message-assembly seam — the seed's `buildBaseMessages` + the lazy
+ * `loadMessages` loader rolled into one injected port. Async because the seed
+ * lazy-imports the SDK (a top-level `import type` of the langchain messages
+ * package explodes the workers test runner). Receives the full `LlmCall` so it
+ * can branch on `purpose` exactly as the seed's `buildBaseMessages` did.
+ */
+type MessageLoader<P extends string, Msg> = (call: LlmCall<P>) => Promise<readonly Msg[]>;
+/**
+ * The model factory — the first DI port. `(modelId) => Llm`. Tests pass a fake
+ * builder; production wires `createChatModel(env, getModelConfig(id))`. `null`
+ * means "the host's default model" (the seed's `string | null`).
+ */
+type ModelFactory<Msg> = (modelId: string | null) => Llm<Msg>;
+/**
+ * The plain-function model port — the common path. One async function
+ * from the assembled messages to the model's answer; the handler validates the
+ * answer through the purpose's `Schema` exactly as it re-validates the
+ * structured-output path, so a malformed answer is a `resilient_err`, never a
+ * corrupt success. `ModelFactory` → `withStructuredOutput(schema).invoke(...)`
+ * stays the advanced form for a model that binds the schema itself.
+ *
+ * `T` is the answer type the schema narrows to — for the agent, an `AgentTurn`.
+ */
+type PlainModel<Msg, T = unknown> = (messages: readonly Msg[]) => Promise<T>;
+/**
+ * Either model port. A bare `async` function is read as a `PlainModel` (see
+ * {@link asModelFactory}); a sync function is the factory.
+ */
+type ModelPort<Msg, T = unknown> = ModelFactory<Msg> | PlainModel<Msg, T>;
+/**
+ * Lift a plain-function model into the `ModelFactory` port. The factory ignores
+ * `modelId` (the function IS the model) and its `Llm` runs the bound schema over
+ * the function's answer, so both ports meet the handler as one shape.
+ *
+ * Reach for this explicitly when the function is not declared `async` — a sync
+ * function that returns a promise (`(m) => client.chat(m)`) carries no runtime
+ * mark that tells it apart from a factory. Passed bare, `asModelFactory`
+ * refuses it on the first call with an `LlmErr` whose reason is
+ * {@link PLAIN_MODEL_MISROUTE_REASON}.
+ */
+declare function plainModel<Msg, T>(fn: PlainModel<Msg, T>): ModelFactory<Msg>;
+/**
+ * The reason an `LlmErr` carries when a sync promise-returning function was
+ * passed as `model` bare — the one runtime shape neither port can own.
+ */
+declare const PLAIN_MODEL_MISROUTE_REASON: string;
+/**
+ * One LLM call request — the resilient-call `input` for this module, carried on
+ * the `resilient_run` Cmd as plain data — no closures, so it survives
+ * persistence and replay. Purpose-discriminated: a `purpose` selecting the
+ * schema + prompt assembly, the `model` id, and the opaque per-purpose
+ * `payload` the loader consumes.
+ *
+ * `key` defaults to `purpose` when the consumer calls `attempt(s, purpose, …)`,
+ * so one in-flight call per purpose is tracked under the resilient-call slice —
+ * the common single-call-per-stage shape. A consumer that fans out many calls
+ * of one purpose passes a distinct `key`.
+ */
+interface LlmCall<P extends string> {
+    /** The stage / schema selector — drives both `schemas[purpose]` and message assembly. */
+    readonly purpose: P;
+    /** The model id to invoke; `null` = the host's default model. */
+    readonly model: string | null;
+    /** The per-purpose prompt payload the `MessageLoader` consumes. Opaque to the knob. */
+    readonly payload: unknown;
+}
+/** The parsed, typed success carried on the `resilient_ok` settle Msg, tagged with its purpose. */
+interface LlmOk<P extends string, O extends Record<P, unknown>> {
+    readonly key: string;
+    readonly purpose: P;
+    readonly output: O[P];
+}
+/** The typed failure variant — every failure path surfaces this, tagged by purpose. */
+interface LlmErr<P extends string> {
+    readonly key: string;
+    readonly purpose: P;
+    /** A human-readable cause (model throw, retry-exhaustion, or schema parse). */
+    readonly reason: string;
+    /** The original error, carried untouched for the consumer to inspect. */
+    readonly error: unknown;
+}
+/**
+ * The settle Msgs llm-call's handler RETURNS from `interpret` so the substrate
+ * enqueues them as follow-up Msgs (re-entry) into the host reducer — exactly as
+ * `../resilient-call` does. They are the resilient-call settle Msgs with the
+ * payloads ENRICHED to llm-call's typed variants: `result` is the parsed,
+ * purpose-tagged `LlmOk`; `error` is the typed `LlmErr` (purpose + reason +
+ * raw). The host wires `resilient_ok` → `succeed` and `resilient_err` → `fail`
+ * reducer arms (the doc-comment wiring), and folds the enriched payload into its
+ * own state there — llm-call never forces a Msg vocabulary on the host, and the
+ * settle Msg drives the inherited succeed/fail → backoff → onTimer loop instead
+ * of bypassing it.
+ */
+type LlmSucceedMsg<P extends string, O extends Record<P, unknown>> = SucceedMsg<LlmOk<P, O>>;
+/**
+ * The FAILURE settle Msg (`resilient_err`) — resilient-call's `FailMsg` with its
+ * `error: unknown` narrowed to the typed `LlmErr`, so the host reducer reads the
+ * purpose, the reason and the raw payload without a cast.
+ */
+type LlmFailMsg<P extends string> = Omit<FailMsg, "error"> & {
+    readonly error: LlmErr<P>;
+};
+/** The retry / deadline timer Msg — `DeadlineExceeded`, inherited from resilient-call. */
+type LlmTimerMsg = DeadlineExceeded;
+/**
+ * The ports the LEGACY detached `handlers(ports)` form takes. Two outbound Msg
+ * builders the handler hands the typed Ok / Err; the consumer returns its own
+ * Msg (or `undefined`). KEPT only for `../agent`, which still inherits the
+ * detached shape; that path does NOT drive the retry loop (it dispatches the
+ * consumer's Msg directly and never re-enters the resilient settle Msg). New
+ * consumers use the no-arg `handlers()` form, which RETURNS the settle Msg for
+ * re-entry and drives the inherited succeed/fail → backoff → onTimer loop.
+ * `../agent` carries the same retry-loop gap and is fixed separately.
+ *
+ * The builders return `M | undefined` — `undefined` is the "dispatch nothing"
+ * sentinel the detached form checks (`!== undefined`), spelled as `undefined`
+ * rather than `void` so the union is unambiguous (a `void` member of a union is
+ * confusing and reads as "may return anything").
+ */
+interface LlmCallPorts<P extends string, O extends Record<P, unknown>, M> {
+    /** Build the Msg dispatched on a parsed success. Return `undefined` to dispatch nothing. */
+    readonly onOk: (ok: LlmOk<P, O>) => M | undefined;
+    /** Build the Msg dispatched on any failure (throw / retry-exhausted / parse). */
+    readonly onErr: (err: LlmErr<P>) => M | undefined;
+}
+/**
+ * The effect Cmd this module emits: run the LLM call for `key` with `input`. The
+ * `input` is the plain `LlmCall` request — the handler reads `purpose` /
+ * `model` / `payload` off it (invariant 3: Cmds are data).
+ *
+ * It is `../resilient-call`'s `RunCmd` specialized to the `LlmCall` input — NOT a
+ * re-declared shape — so the resilient verbs' return tuples (`[State, RunCmd[]]`)
+ * are this exact type and thread through `attempt` / `succeed` / `fail` /
+ * `onTimer` with no cast.
+ */
+type LlmRunCmd<P extends string> = RunCmd<LlmCall<P>>;
+
+/**
+ * @demlik/tea/agent — the domain data model: the tool + turn shapes the consumer
+ * supplies, the agentic-stage conversation, the `createAgent` config object, and
+ * the durable agent slice + its lifecycle status.
+ *
+ * Everything here is plain data (durable + replayable): the composed wrappers'
+ * slices, the conversation, and the config are all JSON-serializable. The
+ * compaction vocabulary lives in `./compaction`; this module imports its
+ * types where the slice / config reference them. The reducer core (the verbs +
+ * the wired `toMachine`) lives in `./index`.
+ */
+
+/**
+ * One tool the model asked to call this turn. Plain data so it round-trips through the
+ * durable fan-out ledger: a stable `callId` (the fan-out identity), the tool
+ * `name`, and the opaque `args` the consumer's own interpret reads.
+ */
+interface ToolCall {
+    /** Stable id the model minted; the fan-out item identity (`idOf`). */
+    readonly callId: string;
+    /** The tool to invoke. The consumer's `toolOf` maps it to an effect Cmd. */
+    readonly name: string;
+    /** Args the model emitted, opaque to the agent. */
+    readonly args: Readonly<Record<string, unknown>>;
+}
+/**
+ * One model turn: the narration `content` the model produced and the
+ * `toolCalls` it asked us to run. An empty
+ * `toolCalls` means the model is done with this stage (advance the pipeline).
+ * This is the parsed output of a brain call; the consumer's schema produces it.
+ *
+ * `provider` is the opaque passthrough slot (#93): whatever the adapter hands
+ * back beside `content` / `toolCalls` that its provider expects echoed
+ * verbatim on the next turn — Anthropic's signed `thinking` blocks,
+ * `server_tool_use`, OpenAI reasoning items. tea stores it on the turn and
+ * returns it unchanged on the `assistant` `AgentMessage` that replays this
+ * turn; it never reads, validates or transforms it. The adapter owns its shape,
+ * which must be JSON-serializable like the rest of the Model. A compaction fold
+ * (ADR 0004) summarises turns into text, so it drops the slot with the turns it
+ * summarises. Optional and additive: a persisted turn without it still parses.
+ */
+interface AgentTurn {
+    /** Free-text narration the model produced this turn (folded into the conversation). */
+    readonly content: string;
+    /** The tools the model asked us to run; empty = stage done. */
+    readonly toolCalls: readonly ToolCall[];
+    /** Provider-opaque blocks to echo back verbatim next turn. tea never reads it. */
+    readonly provider?: unknown;
+}
+/**
+ * One partial piece of a turn the model is still producing — a token delta, as
+ * the provider emitted it.
+ *
+ * A chunk is NOT state. It never reaches the Model, the journal or the Store:
+ * by the time a turn is durable it has settled, and a delta that has not settled
+ * is not an outcome ADR 0011 could fold. So `TurnChunk` carries only what a
+ * progress surface renders — the text so far — and carries no identity, because
+ * an identity would invite someone to store it.
+ */
+interface TurnChunk {
+    /** The text delta this chunk adds to the turn's `content`. */
+    readonly text: string;
+}
+/**
+ * The side channel a {@link StreamingModel} writes its deltas to — the second
+ * argument of the streaming port. One sink, called synchronously by the adapter
+ * as the provider yields; a throw from it is contained by the caller that
+ * supplied it, so a progress surface's defect cannot fail a model call.
+ */
+interface ModelStream {
+    /** Hand one delta to whoever is watching this run. */
+    readonly onChunk: (chunk: TurnChunk) => void;
+}
+/**
+ * The streaming model port — `(messages, { onChunk }) => Promise<AgentTurn>`.
+ *
+ * The second, OPTIONAL shape of the brain. It differs from
+ * `PlainModel<Msg, T>` in one thing: it is handed a {@link ModelStream} it may
+ * write deltas to while the turn is in flight. What it RESOLVES is the same
+ * settled turn the plain port resolves, and that turn is the only thing the
+ * reducer ever sees — the deltas are a side channel that ends at the caller's
+ * listener.
+ *
+ * A `PlainModel` is assignable here (a function may declare fewer parameters
+ * than its type), which is what lets one config field accept either shape.
+ * `isStreamingModel` tells them apart at runtime so a plain model is still
+ * invoked with exactly one argument, as it always was.
+ */
+type StreamingModel<Msg, T = unknown> = (messages: readonly Msg[], stream: ModelStream) => Promise<T>;
+/**
+ * Whether a model port wants the {@link ModelStream} — read off its declared
+ * arity, which is the mark JavaScript already carries. No config flag, and no
+ * marker property for a consumer to forget: a brain written
+ * `async (messages, { onChunk }) => …` streams, and one written
+ * `async (messages) => …` does not.
+ *
+ * The cost of the arity read is the cost of every arity read — a model that
+ * declares a parameter it ignores, or takes `...args`, reads as the other shape.
+ * Both misreads are benign: a `...args` model is handed no stream and emits no
+ * chunks; a model with an unused second parameter is handed a stream it never
+ * writes to. Neither can change the settled turn. PURE.
+ */
+declare function isStreamingModel(model: (...args: never[]) => unknown): boolean;
+/**
+ * Narrow an unknown to an `AgentTurn` — the runtime witness for tea's own
+ * structured-output type. A consumer's brain schema parses the model's output
+ * into an `AgentTurn` (the agentic purpose's output); rather than every consumer
+ * hand-rolling this guard + a `Schema<AgentTurn>` for a type the agent OWNS, the
+ * agent exports both. Checks the load-bearing fields: `content` is a string and
+ * `toolCalls` is an array of `ToolCall` (each element guarded — the narrow is a
+ * real parse of the boundary, not a shallow `Array.isArray`). `provider` is
+ * opaque, so its presence or absence is not a fact the guard reads. PURE —
+ * allocates no Error.
+ */
+declare function isAgentTurn(value: unknown): value is AgentTurn;
+/**
+ * The `Schema<AgentTurn>` for tea's own turn type — the parse target a brain
+ * call binds when the agentic purpose's output is a bare `AgentTurn` (the common
+ * case). Throws on a non-`AgentTurn` (the zod-style `parse` contract the
+ * llm-call handler relies on). Deletes the consumer's hand-rolled
+ * `auditSchema` / `isAgentTurn` pair.
+ *
+ * A consumer whose turn type EXTENDS `AgentTurn` with extra fields still writes
+ * its own schema (it must validate the extra fields); this is for the plain case.
+ */
+declare const agentTurnSchema: Schema<AgentTurn>;
+/**
+ * One settled tool outcome the consumer routes back into the loop.
+ * `ok` carries the result the consumer's interpret produced;
+ * `error` carries the failure as data — see {@link ToolFailure}.
+ */
+type ToolOutcome<R> = {
+    readonly kind: "ok";
+    readonly result: R;
+} | ToolFailure;
+/**
+ * A settled tool failure as the conversation keeps it: the `{ _tag, …payload }`
+ * the tool failed with, spread beside the `reason` string the model reads.
+ *
+ * Both halves are load-bearing and neither replaces the other. `reason` is the
+ * model's channel — `toolErrorReason`'s rendering, which is what the next brain
+ * call carries; `_tag` and the payload are the program's, so host code can
+ * branch on the failure instead of parsing prose out of `reason` (#115). A
+ * payload field never shadows `kind` or `reason`: the router writes those last.
+ *
+ * `_tag` is OPTIONAL here for one reason only — a record persisted by 0.12.x or
+ * earlier was written before the tag was kept, so a Store handing one back has
+ * a failure with no tag, and a required field would be a lie about durable
+ * state. Every failure THIS version mints carries one. For the exhaustive
+ * per-tag union, take `onToolError`'s argument, which is typed from the tools
+ * themselves ({@link ToolFailureOf}).
+ */
+interface ToolFailure {
+    readonly kind: "error";
+    /** The model-facing rendering — `toolErrorReason(error)`. */
+    readonly reason: string;
+    /** The failure's tag; absent only on a record persisted before 0.13. */
+    readonly _tag?: string;
+}
+/**
+ * The failure arm typed against a KNOWN tag union — `{ kind, reason }` beside
+ * each arm of `E`, distributed, so a `switch` on `_tag` narrows the payload and
+ * an unhandled tag is a compile error. `ToolFailure` is its erased form.
+ */
+type TaggedFailure<E extends Tagged> = E extends unknown ? {
+    readonly kind: "error";
+    readonly reason: string;
+} & E : never;
+/**
+ * The per-tool resilience knob — a timeout, a retry ladder, or both, declared on
+ * the `tool()` spec and executed by the agent's reducer through
+ * `../internal/resilience/resilient-call`.
+ *
+ * Both fields are optional and a tool that names neither behaves exactly as it
+ * did before this knob existed: no slice entry is minted, no timer is armed, and
+ * its settle path is the plain fan-out one. The ladder lives in the Model, so a
+ * process killed between two attempts resumes at the attempt it was on rather
+ * than restarting the run — the property a `Promise.race` or a `for` loop inside
+ * the handler cannot have, because those live inside the effect boundary.
+ */
+interface ToolResilience {
+    /**
+     * The budget one tool CALL gets, in ms, measured from the first attempt and
+     * NOT restarted by a retry — the overall cap `resilient-call`'s deadline brick
+     * enforces. When it elapses the call settles as a `ToolOutcome` error
+     * carrying `_tag: "timeout"` beside its `reason`, and the loop moves on, whatever the
+     * in-flight attempt does next — its late settle arrives for a call nothing is
+     * waiting on and folds nothing, so a slow tool costs the budget and not the
+     * turn.
+     *
+     * What it does NOT do is cancel the handler: a promise cannot be cancelled in
+     * JavaScript, so the attempt runs to its own end, and `run`'s teardown still
+     * drains it. A handler that resolves LATE is bounded by this knob; a handler
+     * that never resolves at all holds the runtime's shutdown regardless, and
+     * wants an `AbortSignal` in the handler rather than a budget out here.
+     *
+     * Omit → the call has no cap and ends only when its handler settles.
+     */
+    readonly timeoutMs?: number;
+    /**
+     * The backoff ladder a FAILED attempt climbs — the same
+     * `BackoffCurve & RetryBudget` shape `AgentConfigCore.retry` takes for the
+     * brain call. Each failure is recorded in the Model and the next attempt is
+     * armed as a timer Sub, so the wait is durable and the attempt count survives
+     * a reload. When the budget is spent the call settles as a `ToolOutcome` error
+     * carrying `_tag: "retry_exhausted"` beside its `reason`, plus `attempts` and
+     * `last` as fields — see {@link ToolRetryExhausted}.
+     *
+     * Omit → the first failure is the outcome, exactly as before.
+     */
+    readonly retry?: AnyRetryPolicy;
+}
+/** The reason-tag a timed-out tool call settles under. */
+declare const TOOL_TIMEOUT_TAG = "timeout";
+/** The reason-tag a tool call that spent its retry budget settles under. */
+declare const TOOL_RETRY_EXHAUSTED_TAG = "retry_exhausted";
+/** A call that spent its `timeoutMs` budget — {@link ToolResilience.timeoutMs}. */
+interface ToolTimedOut {
+    readonly _tag: typeof TOOL_TIMEOUT_TAG;
+}
+/** A call that spent its retry budget — {@link ToolResilience.retry}. */
+interface ToolRetryExhausted {
+    readonly _tag: typeof TOOL_RETRY_EXHAUSTED_TAG;
+    /** How many attempts the ladder burned, the failed last one included. */
+    readonly attempts: number;
+    /** The last attempt's own `reason`, so the real failure is not buried. */
+    readonly last: string;
+}
+/**
+ * The two failures the resilience ladder itself authors — `timeout` and
+ * `retry_exhausted`. They are in every tool's
+ * error union rather than only a policied tool's: the policy is a `tool()` spec
+ * field a maintainer can add later, and a union that narrowed with it would turn
+ * adding a `timeoutMs` into a silent behaviour change at every `onToolError`
+ * that had switched exhaustively without them.
+ */
+type ToolResilienceError = ToolTimedOut | ToolRetryExhausted;
+/**
+ * A folded tool record kept on the conversation once a tool settles — the
+ * call + its outcome, in settle order. The consumer's message loader reads
+ * these (plus `turns`) to assemble the next brain call's prompt.
+ *
+ * `turn` is the `turnCount` at the time the record was folded — the association
+ * compaction needs to drop the RIGHT records (#85 / design A1). When compaction
+ * folds `turns[0..N]` into a summary, it must also drop every tool record that
+ * belonged to those turns; without a turn stamp on the record there is no honest
+ * way to know which. It is the round-trip index, not a wall clock — small and
+ * JSON-stable, preserving the durability invariant.
+ */
+interface ToolRecord<R> {
+    readonly call: ToolCall;
+    readonly outcome: ToolOutcome<R>;
+    /** The `turnCount` at fold time — which round-trip this record belongs to (#85, A1). */
+    readonly turn: number;
+}
+/**
+ * Whether the agentic stage is waiting on the model (`llm`), on tools
+ * (`tools`), or on a compaction round-trip (`compacting`). The in-flight
+ * fan-out batch exists ONLY in the `tools` variant — "awaiting llm with tools
+ * pending" is structurally impossible (TEA canon §2.6 / Rule 1
+ * impossible-states pin). Discriminated on `kind`.
+ *
+ * `compacting` is the honest state for the dedicated compaction round-trip
+ * (design B1): the transcript grew, the policy asked to fold `folding` of the
+ * OLDEST turns, and the summarize call is in flight INSTEAD of the next brain
+ * call. `folding` is the count `planCompaction` returned — the fold-back
+ * (`compact_ok`) drops exactly that many head turns + their tool records.
+ */
+type Awaiting = {
+    readonly kind: "llm";
+} | {
+    readonly kind: "tools";
+    readonly batchTurn: number;
+} | {
+    readonly kind: "compacting";
+    readonly folding: number;
+};
+/**
+ * The agentic-stage conversation — durable inside the agent slice so an
+ * eviction mid-loop resumes the exact turn. The model turns + folded tool
+ * records are the consumer's prompt source (via the llm-call message loader);
+ * `turnCount` drives the livelock guard; `awaiting` carries the ONE outstanding
+ * effect for the agentic stage.
+ *
+ * Generic over the consumer's tool-result type `R` (what `toolOk` carries).
+ */
+interface Conversation<R> {
+    /** Model turns this stage has produced, in order. */
+    readonly turns: readonly AgentTurn[];
+    /** Settled tool records, in settle order — the model sees these next turn. */
+    readonly toolRecords: readonly ToolRecord<R>[];
+    /** Monotonic round-trip count; the livelock guard compares it to `maxTurns`. */
+    readonly turnCount: number;
+    /** What the loop is waiting for next. */
+    readonly awaiting: Awaiting;
+}
+/**
+ * The snapshotting discriminant. Checkpointing is either OFF — in which
+ * case `snapshotEvery` is structurally absent and the monitored-run slice never
+ * emits a `snapshot_write` Cmd — or ON, in which case `snapshotEvery` is a
+ * `number`. A `{ snapshotEvery?: never }` member (rather than a bare optional)
+ * makes the OFF case load-bearing: it forbids passing `snapshotEvery` at all, so
+ * `toMachine` can config-derive whether the `snapshot_write` interpret handler
+ * is REQUIRED (ON) or FORBIDDEN (OFF) instead of defaulting it to a silent
+ * no-op.
+ *
+ * This is what kills the type lie: with checkpointing off, `snapshot_write` is
+ * absent from the consumer's interpret contract entirely — never a
+ * `snapshot_write: async () => undefined` ceremony that masks a real wiring bug.
+ */
+type AgentSnapshotConfig = {
+    readonly snapshotEvery?: never;
+} | {
+    readonly snapshotEvery: number;
+};
+/**
+ * The core (non-snapshot, non-compaction) agent configuration. The full `AgentConfig`
+ * intersects this with the `AgentSnapshotConfig` + `AgentCompactionConfig`
+ * discriminants — see those types for why the cadence / policy are discriminated
+ * unions rather than bare optionals.
+ *
+ * Type parameters:
+ *   - `Stage`   — the consumer's pipeline stage id (any JSON value).
+ *   - `P`       — the brain-call purpose union (`"plan" | "act" | ...`).
+ *   - `O`       — the purpose→output map. Every purpose drives the agentic loop,
+ *                 so each output is pinned to `AgentTurn` (or a subtype) by the
+ *                 `O extends Record<P, AgentTurn>` bound — that is what the loop
+ *                 folds. An `Outputs` whose purpose output is NOT an `AgentTurn`
+ *                 fails to compile here; the rule lives in the type, not a cast.
+ *   - `R`       — the consumer's tool-result type (what `toolOk` carries).
+ *   - `TC`      — the consumer's per-tool effect Cmd, the discriminated variant
+ *                 `toolOf` produces. Kept PRECISE (a closed Cmd variant, not the
+ *                 open `Cmd`) so `AgentCmd<P, TC>` stays a closed discriminated
+ *                 union and the wired machine's interpret merge type-checks per
+ *                 key — the brain handler maps to `resilient_run`, the tool one to
+ *                 `TC["type"]` — with no laundering cast. Defaults to `Cmd` for
+ *                 the consumer that does not care to name its tool Cmd.
+ *   - `Msg`     — the model's message shape (threaded through the llm-call loader).
+ */
+interface AgentConfigCore<Stage, P extends string, O extends Record<P, AgentTurn>, R, TC extends Cmd = Cmd, Msg = unknown> {
+    /** The ordered stages. Omit / empty → a single-shot run (one agentic stage). */
+    readonly stages?: readonly Stage[];
+    /** No-progress watchdog budget, in ms. Omit → no watchdog. */
+    readonly deadlineMs?: number;
+    /**
+     * DI port — the brain. `async (messages) => turn` is the common path:
+     * the returned turn is validated through the purpose's schema
+     * (`agentTurnSchema` for the plain case), so a malformed turn is the run's
+     * `llm` failure, not a throw. `(modelId) => Llm` is the advanced form for a
+     * model that binds the structured-output schema itself.
+     */
+    readonly model: ModelPort<Msg, O[P]>;
+    /**
+     * The system prompt, stored ON THE MODEL at `init` (`AgentState.instructions`)
+     * rather than closed over — so a replay reproduces the exact prompt that ran,
+     * a rehydrated run keeps the prompt it started with, and a compaction fold
+     * (which touches only the conversation) can never lose it (ADR 0004). It
+     * reaches the brain call through `payloadOf`'s third argument. Omit → `null`.
+     */
+    readonly instructions?: string;
+    /** One structured-output schema per purpose; the parse target per brain call. */
+    readonly schemas: {
+        readonly [K in P]: Schema<O[K]>;
+    };
+    /** Backoff policy for brain calls, composed into `../llm-call`. Omit → no backoff. */
+    readonly retry?: RetryPolicy;
+    /** DI port — the SDK / message loader. Omit → brain calls invoke with `[]`. */
+    readonly loadMessages?: MessageLoader<P, Msg>;
+    /** Map one tool call to the effect Cmd the consumer's interpret performs. */
+    readonly toolOf: (call: ToolCall) => TC;
+    /**
+     * The per-tool timeout / retry knob for a call, read once per launch. `null`
+     * (or an omitted seam) → the tool runs bare and its settle path is the plain
+     * fan-out one, byte for byte what it was before the knob existed.
+     *
+     * This is the seam a `toolRouter` fills from the `tool()` specs
+     * (`router.resilienceOf`), which is how `defineAgent` grows the knob without
+     * growing a lid option: the policy is declared where the tool is. A hand-wired
+     * `createAgent` supplies it directly. It must be PURE and config-derived — the
+     * reducer calls it on the launch path.
+     */
+    readonly toolResilienceOf?: (call: ToolCall) => ToolResilience | null;
+    /**
+     * How many of ONE turn's tool calls a transition LAUNCHES at once. At the
+     * default `1` a turn's calls go out one at a time; raise it and up to that
+     * many move from `pending` to `running` in the fan-out ledger in a single
+     * transition, so the durable Model (and a `store`'s record of it) says what
+     * was launched.
+     *
+     * Above `1` those calls also OVERLAP on the clock, so a turn of two slow
+     * tools costs the slower rather than the sum — but only for the tool cells a
+     * `toolRouter` owns (the `toMachine({ tools })` path, which `defineAgent`
+     * takes). The overlap lives inside those cells, never in the kernel:
+     * `runInterpret` still interprets a transition's Cmds one after another and
+     * never interleaves two handlers (ADR 0018). A hand-wired `toolInterpret`
+     * cell is yours, so it overlaps only if you write it to.
+     *
+     * Overlapping does NOT reorder the fold. Settle Msgs are dispatched in
+     * Cmd-EMISSION order whichever call finishes first, so a replayed log
+     * reproduces the same Model — invariant 2's serializability, which the knob
+     * was never allowed to spend.
+     *
+     * Omit (or `1`) → serial dispatch, exactly as before.
+     */
+    readonly toolConcurrency?: number;
+    /**
+     * Which brain-call purpose a given stage runs. The agent fires
+     * `call_llm{ turnOf(stage) }` to drive the agentic stage's loop. The purpose's
+     * schema output is an `AgentTurn` — enforced by the `O extends Record<P,
+     * AgentTurn>` bound, not left to a doc-comment.
+     */
+    readonly turnOf: (stage: Stage | undefined) => P;
+    /**
+     * Build the per-purpose brain-call payload from the durable state: the
+     * stage, the conversation, and the Model's `instructions` slot. Omit → `null`.
+     */
+    readonly payloadOf?: (stage: Stage | undefined, conversation: Conversation<R>, instructions: string | null) => unknown;
+    /** The model id every brain call invokes. Omit → `null` (the host's default). */
+    readonly modelId?: string | null;
+    /**
+     * Livelock guard: bound on model round-trips within one run. On
+     * `turnCount >= maxTurns` the run fails `{ reason: "turn_limit" }`. Omit → no
+     * turn guard (the other stop conditions still bound the loop).
+     */
+    readonly maxTurns?: number;
+    /**
+     * Wall-clock guard: total milliseconds from `run.startedAt` the run may take.
+     * At the turn boundary, `at - run.startedAt >= maxElapsedMs` fails the run
+     * `{ reason: "elapsed_limit" }`. Unlike `deadlineMs` — a no-progress watchdog
+     * that RESTARTS on every advance — this budget never restarts, so a run that
+     * keeps progressing is bounded by it. Omit → no wall-clock cap.
+     *
+     * `startedAt` is durable, so a resumed run continues the ORIGINAL budget
+     * rather than starting a fresh one; the elapsed span a killed run spent dead
+     * counts against it.
+     */
+    readonly maxElapsedMs?: number;
+    /**
+     * The consumer's own stop condition, consulted at the turn boundary once the
+     * turn-count and wall-clock guards have passed. `true` settles the run
+     * `cancelled` at `at` — the same terminal an aborted `signal` reaches, so the
+     * transcript stands and no further model call goes out. Omit → no predicate.
+     *
+     * Where `maxTurns` and `maxElapsedMs` bound a quantity this agent counts,
+     * this bounds one only the caller can see (a token ledger, an external flag,
+     * a condition on the turns so far). It must be PURE and total over the state
+     * it is handed — the reducer calls it, so a replay of the same Msg log calls
+     * it with the same state and must get the same answer. It is config, not
+     * Model: a resumed run consults the predicate the config passed to THIS boot.
+     */
+    readonly stopWhen?: (state: AgentState<Stage, P, O, R>) => boolean;
+    /**
+     * The impurity-injection seam for the inherited brain-call retry jitter — the
+     * ONE place this otherwise-pure machine reads randomness. Pass a fixed
+     * `() => 0` to pin backoff (tests, replay, durability proofs). Omit →
+     * `Math.random`, read only at the resilient-call verb boundary.
+     */
+    readonly rng?: () => number;
+}
+/**
+ * The agent configuration — the core seams intersected with the snapshotting discriminant
+ * (`AgentSnapshotConfig`). Type parameters are documented on `AgentConfigCore`;
+ * the only addition here is that `snapshotEvery` is the discriminant that drives
+ * whether `toMachine` requires (or forbids) the `snapshot_write` interpret
+ * handler.
+ */
+type AgentConfig<Stage, P extends string, O extends Record<P, AgentTurn>, R, TC extends Cmd = Cmd, Msg = unknown> = AgentConfigCore<Stage, P, O, R, TC, Msg> & AgentSnapshotConfig & AgentCompactionConfig<R, Msg>;
+/**
+ * Why a run terminated as `failed`, beyond monitored-run's own reasons. The
+ * `turn_limit` reason is the agent's livelock guard and `elapsed_limit` its
+ * wall-clock one; deadline / stage failures surface through the monitored-run
+ * slice's own `failure`.
+ */
+type AgentFailure = {
+    readonly reason: "turn_limit";
+    readonly at: number;
+} | {
+    readonly reason: "elapsed_limit";
+    readonly at: number;
+} | {
+    readonly reason: "llm";
+    readonly error: unknown;
+    readonly at: number;
+};
+/**
+ * The agent slice — every composed wrapper's slice plus the loop's conversation
+ * and the agent-specific failure annotation.
+ *
+ *   - `run`          — the `../monitored-run` slice (pipeline position +
+ *                      lifecycle + watchdog). The OUTER lifecycle truth.
+ *   - `resilience`   — the `../llm-call` (= resilient-call) slice (brain-call
+ *                      retry / backoff). Per-purpose retry lives here.
+ *   - `tools`        — the `../fan-out` ledger for the current turn's tools.
+ *   - `conversation` — the agentic-stage loop state. `null` until the loop is
+ *                      entered (the consumer seeds it at the agentic stage).
+ *   - `failure`      — the agent-specific terminal annotation (turn-limit /
+ *                      llm), null otherwise. Distinct from `run.failure`.
+ *   - `instructions` — the system prompt this run was configured with, set at
+ *                      `init` and never touched by a fold (ADR 0004).
+ */
+interface AgentState<Stage, P extends string, O extends Record<P, unknown>, R> {
+    readonly run: MonitoredRunState<Stage>;
+    readonly resilience: ResilientState<LlmCall<P>, LlmOk<P, O>>;
+    readonly tools: FanOutState<ToolCall, ToolOutcome<R>>;
+    readonly conversation: Conversation<R> | null;
+    /**
+     * The compaction round-trip's resilient slice (#85, design B1) — a DEDICATED
+     * resilient-call slice for the reserved `$compact` purpose, separate from the
+     * brain `resilience` slice so a compaction retry/backoff never disturbs the
+     * brain call's breaker or retry counter. Always present (empty `calls` when no
+     * compaction is in flight, or when no policy is configured) so the slice stays
+     * a flat plain-data record — durable + replayable like every composed wrapper.
+     */
+    readonly compaction: ResilientState<LlmCall<CompactionPurpose>, LlmOk<CompactionPurpose, CompactionOutputs>>;
+    /**
+     * The per-tool timeout / retry ladders (#117) — one dedicated resilient-call
+     * slice PER TOOL NAME, because the policy is declared per tool and one slice
+     * carries one config. Keyed by tool name; each slice's own keys are
+     * {@link toolCallKey}s, so two concurrent calls to the same tool climb
+     * independent ladders while sharing the tool's declared policy.
+     *
+     * A tool declaring neither `timeoutMs` nor `retry` mints no entry, so this is
+     * `{}` for every agent that uses no per-tool knob — the addition costs an
+     * empty record on the durable Model and nothing else.
+     *
+     * The result arm is `null`: a tool's VALUE settles through the fan-out ledger
+     * and the conversation, exactly as before. This slice tracks only the ladder —
+     * which attempt is out, when the next one is due, and when the budget is spent
+     * — which is what has to survive a reload.
+     */
+    readonly toolResilience: Readonly<Record<string, ResilientState<ToolCall, null>>>;
+    /**
+     * The `callId`s whose PUBLIC outcome is already a failure (#145) — a tool the
+     * ladder settled on its deadline or on a spent retry budget, or one whose own
+     * error was folded. A promise cannot be cancelled, so the abandoned attempt
+     * may still resolve; when it does, its late `_ok` names a `callId` listed
+     * here and every public channel stays silent about it.
+     *
+     * The fan-out already drops the late value (its entry is gone, so the fold is
+     * a no-op), but "folds nothing" and "emits nothing" are two different facts:
+     * the event projector is Msg-shaped and would otherwise push a `ToolSettled`
+     * for a `callId` `onToolError` already reported as `{ _tag: "timeout" }`. The
+     * projector reads the post-transition state, by which point the ladder has
+     * forgotten the key, so the discriminator is carried HERE rather than derived
+     * from a presence check that erases both readings.
+     *
+     * Plain data, one string per failed call, cleared by `start` with the rest of
+     * the prior run's bookkeeping. It survives the batch drain and the stage
+     * retire on purpose — that is exactly when a late settle arrives.
+     */
+    readonly refusedCalls: readonly string[];
+    readonly failure: AgentFailure | null;
+    /**
+     * The run's terminal output — the FIRST-CLASS result (issue #46). `null`
+     * until the pipeline finishes; set to the last model turn (the empty-tool
+     * turn that retired the final stage) the instant `run.phase` becomes `"done"`.
+     *
+     * This survives the `conversation` clear on stage retire: clearing the
+     * conversation is correct durability hygiene (a finished stage's transcript
+     * is not live state), but the run's PRODUCT is, so it lives here on the
+     * durable slice rather than being scraped off the `observe` firehose by
+     * matching the private `resilient_ok` Msg and racing the clear (the old
+     * `captureLastTurn` dance this field deletes). A consumer reads
+     * `runtime.result()?.output` / `(await runtime.done()).output`.
+     *
+     * Typed `AgentTurn | null` (not `O[P]`): the run's output is always a model
+     * turn — the `O extends Record<P, AgentTurn>` type bound pins every purpose's
+     * output to an `AgentTurn`, and the terminating turn is the one with no tool
+     * calls. The wider `Record<P, unknown>` bound on `AgentState` itself does not
+     * constrain `O[P]`, so naming the concrete `AgentTurn` keeps this field's type
+     * total without a purpose-indexing narrow.
+     */
+    readonly output: AgentTurn | null;
+    /**
+     * The system prompt, durable beside the transcript it governs. `null` when
+     * the config named none. Read by `brainCall` on every model call — a
+     * rehydrated or replayed run prompts with what the Model says, never with
+     * what a closure happens to hold now.
+     */
+    readonly instructions: string | null;
+}
+/**
+ * The unified terminal failure the agent settles on. The agent terminates `failed`
+ * through TWO independent slice channels:
+ *
+ *   - `state.failure` (`AgentFailure`) — the AGENT'S OWN annotation
+ *     (`turn_limit` livelock guard / `elapsed_limit` wall-clock guard / `llm`
+ *     exhausted-retry). Set WITHOUT moving
+ *     `run.phase` (it stays `running`); `isSettled` treats a non-null `failure`
+ *     as terminal regardless of `run.phase`.
+ *   - `state.run.failure` (`RunFailure`) — the monitored-run channel
+ *     (`deadline` watchdog / `stage` failure), present iff `run.phase` is
+ *     `"failed"`.
+ *
+ * Callers used to union these by hand at every status question. `status`
+ * collapses them into ONE `failure`, so a consumer reads `status(s).failure`
+ * without knowing which channel produced it.
+ */
+type AgentTerminalFailure<Stage> = AgentFailure | RunFailure<Stage>;
+/**
+ * The agent's lifecycle status — THE single typed channel for "what is this run
+ * doing?". A discriminated union on `kind` so any change to the
+ * private slice shape (`Awaiting`, the failure channels, `run.phase`) forces a
+ * compile error at the call sites that switch on it, instead of silently
+ * breaking a hand-rolled re-derivation. Make-invalid-states-unrepresentable:
+ *
+ *   - `idle`      — never started: `run.phase === "idle"`, the slice straight
+ *                   out of `init` before any `agent_start`. Distinct from
+ *                   `running` so a "start or resume?" decision never boots a
+ *                   run that has not begun (#92); the next move is `agent_start`.
+ *   - `running`   — live, NOT awaiting tools (a brain call is in flight, or the
+ *                   run is between stages). Not resumable on cold wake by
+ *                   itself — the in-flight brain call re-fires from `boot`.
+ *                   A `stale` run reads here too: monitored-run documents it
+ *                   as a soft, still-resumable live mark that the next
+ *                   `progress` flips back to `running`.
+ *   - `suspended` — the RESUMABLE case: running + a live conversation +
+ *                   `awaiting.kind === "tools"`. `pending` is the outstanding
+ *                   tool calls (`conversation.awaiting` … the in-flight batch),
+ *                   read off `tools.running`. This is exactly the shape
+ *                   `agentIsResumable` re-derived by hand.
+ *   - `done`      — the pipeline finished; `output` is the terminal model turn
+ *                   stamped on `state.output` (issue #46), `null` if the run
+ *                   produced no turn.
+ *   - `failed`    — terminal failure; `failure` is the UNIFIED channel
+ *                   (`AgentTerminalFailure`), absorbing the `state.failure` vs
+ *                   `state.run.failure` dual channel so callers stop unioning.
+ *   - `cancelled` — stopped because the caller asked — an aborted `AbortSignal`,
+ *                   or their own `stopWhen` answering `true` at a turn boundary;
+ *                   `at` is when the stop landed. Terminal and distinct from
+ *                   `failed`: nothing went wrong, the caller asked, so a consumer
+ *                   branching on failure does not have to except one reason. There is no
+ *                   `output` — a cancelled run produced no terminal turn, and a
+ *                   `null` one here would be indistinguishable from a `done` run
+ *                   that produced none.
+ */
+type AgentStatus<Stage> = {
+    readonly kind: "idle";
+} | {
+    readonly kind: "running";
+} | {
+    readonly kind: "suspended";
+    readonly pending: readonly ToolCall[];
+} | {
+    readonly kind: "done";
+    readonly output: AgentTurn | null;
+} | {
+    readonly kind: "failed";
+    readonly failure: AgentTerminalFailure<Stage>;
+} | {
+    readonly kind: "cancelled";
+    readonly at: number;
+};
+/**
+ * Ask where an agent run stands: pass its state, get back one of `idle`,
+ * `running`, `suspended` (with the tool calls it is waiting on), `done` (with
+ * the output) or `failed` (with the failure).
+ *
+ * Read this instead of picking at the state's own fields. PURE — reads no
+ * clock or randomness, allocates one small record.
+ *
+ * Ordering is terminal-first so a settled run never reports `running`, and a
+ * never-started one never reports live:
+ *
+ *   1. `state.failure` (the agent's own annotation, set WITHOUT moving
+ *      `run.phase`) → `failed`. Checked first because `turn_limit` / `llm`
+ *      leave `run.phase === "running"`; reading `run.phase` first would
+ *      misreport such a run as `running`. This is the canonical failure source
+ *      when present.
+ *   2. `run.phase === "idle"` → `idle`. Never started (#92); after the failure
+ *      check so the annotation stays canonical, before every live reading so
+ *      an `init` slice is never mistaken for a run in flight.
+ *   3. `run.phase === "failed"` → `failed`, carrying `run.failure` (deadline /
+ *      stage). The fallback channel.
+ *   4. `run.phase === "done"` → `done` with `state.output` (#46).
+ *   5. `run.phase === "cancelled"` → `cancelled`, carrying when the stop landed.
+ *   6. `running` / `stale` + conversation + `awaiting.kind === "tools"` →
+ *      `suspended` with the outstanding tool calls (`tools.running`). THE
+ *      resumability condition; otherwise the run reads `running`.
+ *
+ * Steps 2–6 are ONE exhaustive `switch` over `run.phase` closed by `absurd`, not
+ * an `if` chain with a trailing `return { kind: "running" }`. Under the chain a
+ * phase added to the slice and forgotten here reported as `running` — a terminal
+ * run described as live, which is the worst answer this function can give and one
+ * nothing would have caught. The switch turns that omission into a type error.
+ */
+declare function status<Stage, P extends string, O extends Record<P, unknown>, R>(s: AgentState<Stage, P, O, R>): AgentStatus<Stage>;
+
+/**
+ * @demlik/tea/agent — the context-compaction seam.
+ *
+ * The opt-in transcript snapshot-and-compact policy, shaped exactly like
+ * `AgentSnapshotConfig` (see `./types`) so a short agent pays nothing and cannot
+ * even mention the machinery. This module owns the whole `$compact` vocabulary:
+ * the reserved purpose, the summary schema, the consumer policy, the config
+ * discriminant, and the dedicated `compact_run` / `compact_ok` / `compact_err`
+ * Cmd + Msgs re-keyed off the composed resilient call at the agent boundary.
+ */
+
+/**
+ * The reserved purpose the compaction round-trip runs under. Compaction
+ * is a DEDICATED resilient LLM call (design B1), NOT one of the consumer's brain
+ * purposes `P` — so it carries its own purpose literal, kept in the agent's
+ * private `$`-namespace (the same reserved-namespace discipline `with-resilience`
+ * uses) so it never collides with a consumer purpose. A consumer never names it.
+ */
+type CompactionPurpose = "$compact";
+/** The reserved compaction purpose's value — the single in-flight summarize call's key. */
+declare const COMPACTION_PURPOSE: CompactionPurpose;
+/**
+ * The purpose→output map for the compaction LLM call — the single reserved
+ * `$compact` purpose mapping to a {@link CompactionSummary}. Mirrors the brain
+ * call's `O` map, scoped to the one compaction purpose, so the composed
+ * `createLlmCall` parses the summarize output under the same structured-output
+ * contract the brain call uses.
+ */
+interface CompactionOutputs extends Record<CompactionPurpose, unknown> {
+    readonly $compact: CompactionSummary;
+}
+/**
+ * Narrow an unknown to a {@link CompactionSummary} — the runtime witness for the
+ * compaction call's structured output. Checks the one load-bearing field
+ * (`summary` is a string). PURE — allocates no Error.
+ */
+declare function isCompactionSummary(value: unknown): value is CompactionSummary;
+/**
+ * The `Schema<CompactionSummary>` the compaction call binds — tea's own parse
+ * target for the summarize round-trip (it OWNS the `$compact` purpose's output).
+ * Throws on a non-summary (the zod-style `parse` contract the llm-call handler
+ * relies on), so a malformed summary is a `compact_err` (errors are data), never
+ * a corrupt fold-back.
+ */
+declare const compactionSummarySchema: Schema<CompactionSummary>;
+/**
+ * The result a compaction round-trip produces — the model's summary of the
+ * folded-away turns. Tea OWNS this shape (the `$compact` purpose's output): the
+ * fold-back (`compact_ok`) writes `summary` into a synthetic head `AgentTurn`
+ * (design A1), so a consumer's `loadMessages` reads it as a normal turn with no
+ * watermark to learn. Generic-free — the summary is always plain text.
+ */
+interface CompactionSummary {
+    /** The model's summary of the folded-away (oldest) turns + their tool records. */
+    readonly summary: string;
+}
+/**
+ * The consumer's compaction policy. One PURE trigger; the impure
+ * summarize round-trip is composed by the agent (a dedicated resilient LLM call
+ * under the reserved `$compact` purpose, inheriting retry/backoff — design B1),
+ * so the policy never reaches the model itself.
+ *
+ *   - `planCompaction` — PURE: given the live conversation ABOUT to fire a brain
+ *     call, return how many of the OLDEST turns to fold into a summary, or `0`
+ *     to skip. No clock, no RNG → replay re-decides identically (design D). A
+ *     char-length / turn-count / real deterministic-tokenizer heuristic all
+ *     qualify. Returning `>= turns.length` is clamped to "fold all but keep the
+ *     loop alive" by the trigger (it never folds the turn currently in flight).
+ *   - `payloadOf` — build the per-call prompt payload the compaction
+ *     `MessageLoader` reads (the turns being folded). Omit → `null` (the loader,
+ *     if any, reads the conversation off the agent's own state). Opaque to the
+ *     agent, exactly like the brain call's `payloadOf`.
+ */
+interface CompactionPolicy<R, Msg = unknown> {
+    /** PURE trigger: how many OLDEST turns to fold (`0` = skip). No clock/RNG. */
+    readonly planCompaction: (conversation: Conversation<R>) => number;
+    /** Build the summarize call's prompt payload from the turns being folded. Omit → `null`. */
+    readonly payloadOf?: (conversation: Conversation<R>, folding: number) => unknown;
+    /** DI port — the SDK / message loader for the summarize call. Omit → invoke with `[]`. */
+    readonly loadMessages?: MessageLoader<CompactionPurpose, Msg>;
+}
+/**
+ * The compaction discriminant, shaped exactly like {@link
+ * AgentSnapshotConfig}. Compaction is either OFF —
+ * `compaction` is structurally absent and the agent never emits a `compact_run`
+ * Cmd — or ON, in which case `compaction` is a {@link CompactionPolicy}. A `{
+ * compaction?: never }` member (rather than a bare optional) makes the OFF case
+ * load-bearing: it forbids passing `compaction` at all, so `toMachine`
+ * config-derives whether the `compact_run` interpret handler is REQUIRED (ON) or
+ * FORBIDDEN (OFF) — never a silent no-op handler, the same type-lie-killer
+ * `AgentSnapshotConfig` uses.
+ */
+type AgentCompactionConfig<R, Msg> = {
+    readonly compaction?: never;
+} | {
+    readonly compaction: CompactionPolicy<R, Msg>;
+};
+/**
+ * The "summarize the oldest N turns" effect Cmd — the compaction round-trip's
+ * carrier. It mirrors the brain `resilient_run` Cmd's shape (a `key` + the
+ * plain `LlmCall<CompactionPurpose>` input, no closures) but under the dedicated
+ * `compact_run` discriminant so it routes to the compaction interpret handler, not
+ * the brain one. The handler composes the resilient-call wrapper (retry/backoff) and
+ * returns the re-keyed `compact_ok` / `compact_err` settle for re-entry.
+ */
+type AgentCompactRunCmd = Cmd<typeof MsgType.CompactRun> & {
+    readonly key: CompactionPurpose;
+    readonly input: LlmCall<CompactionPurpose>;
+};
+/** The compaction round-trip success settle Msg — carries the parsed {@link CompactionSummary}. */
+type AgentCompactOkMsg = {
+    readonly type: typeof MsgType.CompactOk;
+    readonly key: CompactionPurpose;
+    readonly result: LlmOk<CompactionPurpose, CompactionOutputs>;
+    readonly at: number;
+};
+/** The compaction round-trip failure settle Msg — carries the typed {@link LlmErr}. */
+type AgentCompactErrMsg = {
+    readonly type: typeof MsgType.CompactErr;
+    readonly key: CompactionPurpose;
+    readonly error: LlmErr<CompactionPurpose>;
+    readonly at: number;
+};
+/**
+ * The CONFIG-DERIVED compaction obligation on `toMachine`'s `toolInterpret`
+ * — the exact twin of {@link SnapshotInterpret}.
+ * Resolves on the `Compact` discriminant the compaction overload of
+ * `createAgent` fixes:
+ *
+ *   - compaction ON  → a REQUIRED `compact_run` handler
+ *     (`Interpret<M, AgentCompactRunCmd, Ctx>`). The summarize round-trip MUST be
+ *     wired — the agent never defaults it to a no-op.
+ *   - compaction OFF → `{ compact_run?: never }`. The handler is FORBIDDEN: with no
+ *     policy the agent never emits a `compact_run` Cmd, so wiring it would be
+ *     dead code. The consumer cannot even mention `compact_run`.
+ *
+ * Same type-lie-killer as the snapshot derivation: the obligation is present
+ * EXACTLY when the Cmd can fire, never as a silent gap the agent backfills.
+ */
+type CompactInterpret<M extends {
+    type: string;
+}, Compact extends boolean, Ctx> = Compact extends true ? Interpret<M, AgentCompactRunCmd, Ctx> : {
+    readonly compact_run?: never;
+};
+
+/**
+ * @demlik/tea/agent — `tool()` + `toolRouter()`: declare a tool once and derive
+ * what a consumer used to hand-write twice — the `toolOf` mapping from a
+ * model's `ToolCall` to an effect Cmd, and the interpret handler that runs it
+ * and settles it.
+ *
+ * A tool is a `Cmd.define`d effect whose input is the model's call —
+ * `{ callId, args }` — with the handler colocated on the constructor. The
+ * router folds a set of them into one `toolOf` and one interpret table; the
+ * handlers settle through the minted `<name>_ok` / `<name>_err` Msgs, errors as
+ * `{ _tag }` data (ADR 0011). `createAgent(...).toMachine({ tools })` folds
+ * those settles into the conversation, so a consumer names nothing twice.
+ */
+
+/**
+ * The prefix a protocol discriminant was minted from: `resilient_ok` →
+ * `resilient`, `compact_run` → `compact`. A tool named by that prefix would
+ * mint the same `<name>_ok` / `<name>_err` the agent's reducer already owns.
+ */
+type SettlePrefixOf<T extends string> = T extends `${infer P}_ok` | `${infer P}_err` | `${infer P}_run` ? P : never;
+declare const REJECTED_TYPE = "tool_rejected";
+declare const SNAPSHOT_WRITE_TYPE = "snapshot_write";
+/**
+ * A tool name `tool()` refuses. A tool's name is its Cmd `type` — so
+ * its interpret key — and the prefix of its settle Msgs, so every string
+ * already spoken by the protocol is taken twice over: the settle prefixes
+ * (`resilient`, `agent_tool`, `compact`) would overwrite the agent's own
+ * reducer handlers through `toMachine`'s last-wins spread, and the discriminants
+ * themselves (`compact_run`, `resilient_run`, …) would shadow the interpret
+ * handler of that name. Both halves derive from `MsgType`: a new entry there
+ * reserves its name and its prefix with no second edit. The two names outside
+ * the protocol are the router's own `tool_rejected` and the checkpoint handler
+ * `snapshot_write`, which `toMachine` merges under the consumer's key.
+ */
+type ReservedToolName = MsgTypeValue | SettlePrefixOf<MsgTypeValue> | typeof REJECTED_TYPE | typeof SNAPSHOT_WRITE_TYPE;
+/**
+ * Widens to `unknown` for a name outside the reserved set and to `never`
+ * inside it, so `Name & NotReserved<Name>` is the name itself or
+ * unconstructible. A widened `string` passes here — the runtime check in
+ * `tool()` is what catches a reserved name built from one.
+ */
+type NotReserved<Name extends string> = Name extends ReservedToolName ? never : unknown;
+/** Whether `name` is one `tool()` refuses — the set `ReservedToolName` types. */
+declare function isReservedToolName(name: string): name is ReservedToolName;
+/**
+ * The input a tool Cmd carries: the model's `callId` (the fan-out identity the
+ * settle folds back on) and the `args` already parsed against the tool's
+ * `input` schema — the boundary parses, the handler trusts.
+ */
+type ToolInput<Args> = {
+    readonly callId: string;
+    readonly args: Args;
+};
+/**
+ * The router-minted failure beside a tool's declared tags: the handler threw
+ * (or rejected) with something that is not a declared `{ _tag }`. Plain data
+ * the model sees as a reason, never a rejection out of the interpret handler.
+ */
+type ToolThrown = {
+    readonly _tag: "thrown";
+    readonly message: string;
+};
+/**
+ * The typed success constructor a handler receives: `ok(value)` with `Ok`
+ * fixed to what the `ok` schema parses, so a value of the wrong shape is
+ * refused where it is written.
+ */
+type ToolOk<Ok, E extends Tagged> = (value: Ok) => Result<Ok, E>;
+/**
+ * The typed failure constructor a handler receives: `fail({ _tag })` with `E`
+ * fixed to the declared tags, so the literal is checked against them where it
+ * is written. (A bare `{ _tag: "x" }` built elsewhere infers `_tag: string`
+ * and cannot be — the parameter type is what keeps it literal.)
+ */
+type ToolFail<Ok, E extends Tagged> = (error: E) => Result<Ok, E>;
+/**
+ * The two constructors a handler is handed, one per channel — `ok` for the
+ * value the `ok` schema parses, `fail` for a declared `{ _tag }`. Both are
+ * tea's, so a handler settles either arm without naming the result library
+ * underneath.
+ */
+type ToolConstructors<Ok, E extends Tagged> = {
+    readonly ok: ToolOk<Ok, E>;
+    readonly fail: ToolFail<Ok, E>;
+};
+/**
+ * A tool's handler: the parsed `args`, the ctx slice `requirements` named, and the
+ * typed `{ ok, fail }`, to a result over the declared channels — `Ok` is what
+ * the `ok` schema parses, `E` the declared `_tag` union. An undeclared tag
+ * does not compile.
+ */
+type ToolHandler<Args, Ok, E extends Tagged, R> = (args: Args, ctx: R & PortEmitter, settle: ToolConstructors<Ok, E>) => Promise<Result<Ok, E>>;
+/**
+ * What `tool()` returns: the `Cmd.define`d constructor (so `Settled<typeof t>`
+ * / `CmdOf<typeof t>` read it like any def) plus the colocated `interpret` handler,
+ * the bare `args` schema the router parses a call against, and the
+ * `description` a provider adapter declares to the model beside that schema.
+ * `E` is the full failure union the Cmd settles with — the declared tags plus
+ * `thrown`.
+ */
+type ToolDef<Name extends string, Args, Ok, E extends Tagged, R> = CmdDef<Name, ToolInput<Args>, Ok, E, R> & {
+    readonly description: string;
+    readonly args: z.ZodType<Args>;
+    /**
+     * The timeout / retry knob this tool declared, or `null` when it declared
+     * neither. `toolRouter` serves it to the agent as `resilienceOf`.
+     */
+    readonly resilience: ToolResilience | null;
+    readonly interpret: (cmd: CmdValue<Name, ToolInput<Args>, E, R>, ctx: R & PortEmitter) => Promise<Settled<CmdDef<Name, ToolInput<Args>, Ok, E, R>>>;
+};
+/** The declaration-erased view the router reads. */
+type AnyToolDef = AnyCmdDef & {
+    readonly description: string;
+    readonly args: z.ZodType;
+    readonly resilience: ToolResilience | null;
+    readonly interpret: (cmd: never, ctx: never) => Promise<unknown>;
+};
+/**
+ * Declare one tool the model may call — its name, the schemas for its arguments
+ * and result, the failures it may return and the handler that runs it — and get
+ * back a `Cmd<T, E, R>` definition, whose `T` is what `ok` parses and whose `E`
+ * is the `err` tag union, that you pass to `toolRouter` or `defineAgent`.
+ *
+ * So a tool's two declared channels ARE the kernel's two typed effect channels
+ * (ADR 0014), spelled in schemas rather than in type parameters: a settled
+ * failure keeps its `_tag` into the conversation, so a reducer switching over
+ * `err`'s tags is exhaustive and an unhandled one is a compile error.
+ *
+ * `name` is the name the model calls it
+ * by; `description` is the model-facing sentence — the one place it lives — a
+ * provider adapter declares to the model beside the schema (Anthropic
+ * `description`, OpenAI `function.description`) so the model can tell when to
+ * call the tool, read off `def.description`, never off the `input` schema;
+ * `input` parses the model's `args`; `ok` parses the handler's value at the
+ * edge; `err` is the `_tag` list the handler may fail with; `requirements` is the ctx
+ * slice it reads, demanded at `run`. The handler returns one of the two
+ * constructors it is handed — `ok(value)` or the typed `fail({ _tag })`; a
+ * throw settles `<name>_err` — with the thrown `_tag` when it is a declared
+ * one, else as `{ _tag: "thrown", message }`.
+ *
+ * A `ReservedToolName` does not compile as `name`, and one that reaches here
+ * as a widened `string` throws — the same declaration-bug refusal
+ * `toolRouter` gives a name declared twice.
+ */
+declare function tool<const Name extends string, Args, Ok, const Tags extends readonly string[], R = unknown>(name: Name & NotReserved<Name>, spec: {
+    readonly description: string;
+    readonly input: z.ZodType<Args>;
+    readonly ok: z.ZodType<Ok>;
+    readonly err: Tags;
+    readonly requirements?: Requirements<R>;
+    /**
+     * The budget one call of this tool gets, in ms — the overall cap, measured
+     * from the first attempt and not restarted by a retry. When it elapses the
+     * call settles as a `ToolOutcome` error carrying `_tag: "timeout"` beside
+     * its `reason`, and the loop moves on; the attempt is NOT cancelled (a promise cannot be), so it runs to its
+     * own end and its late settle folds nothing. Omit → no cap.
+     */
+    readonly timeoutMs?: number;
+    /**
+     * The backoff ladder a failed attempt of this tool climbs — the same
+     * `{ baseMs, factor, capMs, jitter, maxAttempts }` shape the brain call's
+     * `retry` takes. The ladder is folded into the Model and its wait is a timer
+     * Sub, so a process killed between two attempts resumes at the attempt it
+     * was on. A spent budget settles as a `ToolOutcome` error carrying
+     * `_tag: "retry_exhausted"` beside its `reason`, with the attempt count and
+     * the last attempt's reason as the `attempts` / `last` fields.
+     * Omit → the first failure is the outcome.
+     */
+    readonly retry?: ToolResilience["retry"];
+}, handler: ToolHandler<Args, Ok, TaggedError<Tags[number]>, R>): ToolDef<Name, Args, Ok, TaggedError<Tags[number] | "thrown">, R>;
+/**
+ * A call the router could not hand to a tool: the model named a tool nobody
+ * declared, or its `args` failed the tool's `input` schema. `toolOf` is total —
+ * it never throws inside the reducer — so the refusal rides its own Cmd and
+ * settles `tool_rejected_err`, which the loop folds like any tool failure.
+ */
+type ToolRejection = {
+    readonly _tag: "unknown_tool";
+    readonly name: string;
+} | {
+    readonly _tag: "malformed_args";
+    readonly name: string;
+    readonly issues: ReadonlyArray<{
+        readonly path: string;
+        readonly message: string;
+    }>;
+};
+declare const rejected: CmdDef<"tool_rejected", {
+    readonly callId: string;
+    readonly error: ToolRejection;
+}, never, {
+    readonly [detail: string]: unknown;
+    readonly _tag: "unknown_tool";
+} | {
+    readonly [detail: string]: unknown;
+    readonly _tag: "malformed_args";
+}, unknown>;
+/** The Cmd `tool_rejected` builds — the router-owned variant of `ToolCmd`. */
+type ToolRejectedCmd = CmdOf<typeof rejected>;
+/** The Cmd union a router's `toolOf` produces — `TC` for `createAgent`. */
+type ToolCmd<T extends AnyToolDef> = CmdOf<T> | ToolRejectedCmd;
+/** The settled Msg union a router's handlers return — folded by `toMachine`. */
+type ToolMsg<T extends AnyToolDef> = Settled<T> | Settled<typeof rejected>;
+/**
+ * `ToolCmd<T>` as `toMachine` reads it: `never` for `T = never` — the "no
+ * router" reading it defaults to — so the router-owned `tool_rejected` arm
+ * does not leak into a machine that wired no router.
+ */
+type WiredToolCmd<T extends AnyToolDef> = [T] extends [never] ? never : ToolCmd<T>;
+/** `ToolMsg<T>` as `toMachine` / `agentEvents` read it — see `WiredToolCmd`. */
+type WiredToolMsg<T extends AnyToolDef> = [T] extends [never] ? never : ToolMsg<T>;
+/** The union of every tool's `ok` value — `R` for `createAgent`. */
+type ToolResult<T extends AnyToolDef> = OkOf<T>;
+/**
+ * Every failure a router over `T` can settle with — the union `outcomeOf`'s
+ * error arm is typed from. Five sources, and a consumer branching on `_tag`
+ * meets all five: each tool's DECLARED tags plus the `thrown` `tool()` appends
+ * (`ErrOf<T>`), the kernel's `malformed_result` (a handler returned a value its
+ * own `ok` schema rejects), the router's own `unknown_tool` / `malformed_args`
+ * rejections, and the ladder's `timeout` / `retry_exhausted` (#117) — which end
+ * a call from outside the handler and so are nothing a tool can declare.
+ */
+type ToolError<T extends AnyToolDef> = ErrOf<T> | MalformedResult | ToolRejection | ToolResilienceError;
+/**
+ * The error outcome a router over `T` produces: `{ kind: "error", _tag,
+ * …payload, reason }`, discriminable on `_tag` over {@link ToolError}. This is
+ * what `defineAgent`'s `onToolError` hands the consumer.
+ */
+type ToolFailureOf<T extends AnyToolDef> = TaggedFailure<ToolError<T>>;
+/** One settled tool, read back off a `ToolMsg` by `outcomeOf`. */
+type ToolSettlement<R, E extends Tagged = Tagged> = {
+    readonly callId: string;
+    readonly outcome: {
+        readonly kind: "ok";
+        readonly result: R;
+    } | TaggedFailure<E>;
+};
+/**
+ * What `toolRouter()` returns: the derived `toolOf` for `createAgent`'s config,
+ * the interpret table `toMachine({ tools })` merges, the defs it puts on
+ * `Machine.cmds`, and the one reader that turns a settled Msg back into the
+ * conversation's `ToolOutcome`.
+ */
+interface ToolRouter<T extends AnyToolDef> {
+    /** Every def the router settles through — hand to `Machine.cmds`. */
+    readonly defs: readonly AnyCmdDef[];
+    /** The `toolOf` for `createAgent`: total, pure, parses `args` at the edge. */
+    readonly toolOf: (call: ToolCall) => ToolCmd<T>;
+    /** One interpret handler per tool plus the `tool_rejected` handler. */
+    readonly interpret: Interpret<ToolMsg<T>, ToolCmd<T>, NoCtx>;
+    /**
+     * The timeout / retry knob the called tool declared — `AgentConfigCore`'s
+     * `toolResilienceOf` seam, filled from the `tool()` specs. `null` for a tool
+     * that declared neither field and for a call no tool answers (the rejection
+     * path settles in the reducer and never runs an effect to time out). PURE.
+     */
+    readonly resilienceOf: (call: ToolCall) => ToolResilience | null;
+    /**
+     * Read a settled tool off a Msg: `null` when the Msg is not one of this
+     * router's `<name>_ok` / `<name>_err`. The one place a `{ _tag }` failure is
+     * rendered to the `reason` string the conversation carries — and the tag and
+     * its payload ride beside that rendering, never instead of it (#115).
+     */
+    readonly outcomeOf: (msg: {
+        readonly type: string;
+    }) => ToolSettlement<ToolResult<T>, ToolError<T>> | null;
+}
+/**
+ * Fold a set of `tool()`s into one router — pass it the tools, get back the
+ * lookup `createAgent` needs, the handlers `toMachine` merges, and a reader that
+ * turns a settled message back into a plain outcome.
+ *
+ * Two tools with one name is a declaration bug, refused here rather than by a
+ * silent last-wins map.
+ */
+declare function toolRouter<T extends AnyToolDef>(tools: readonly T[]): ToolRouter<T>;
+/**
+ * Give a router's interpret cells real wall-clock overlap without touching the
+ * kernel — pass the table `toolRouter` built, get back one whose cells launch
+ * their tool and RETURN, so `runInterpret` reaches the next Cmd of the turn
+ * while the first tool is still running.
+ *
+ * This is ADR 0018's option (c), and the whole of it. `runInterpret` stays the
+ * serial loop the ADR ruled it must be: it still awaits one handler before
+ * reaching the next Cmd — the handlers just stop being the thing that takes the
+ * time. Three properties are what make that safe, and each is a line below:
+ *
+ * - **Settles fold in Cmd-EMISSION order, never completion order.** Each cell
+ *   chains its dispatch behind the previous cell's, so two tools that overlap
+ *   on the clock still settle a-then-b when a's Cmd was emitted first, whichever
+ *   finished first. That is invariant 2's serializability, and it is what keeps
+ *   a replay of a fanned run identical to the run itself.
+ * - **The settle crosses the SAME edge.** A returned Msg is parsed and stamped
+ *   by `run`'s `cmdEdge`; a dispatched one would not be, so the cell settles
+ *   through `cmdEdgeOf(ctx)` — the edge `run` hands handlers for exactly this.
+ *   One parse, one clock, fanned or not.
+ * - **The work stays counted.** The promise the cell does not return is enlisted
+ *   with `detachWorkOf(ctx)`, so `inFlightCmds` and the dispatch tail see it and
+ *   `stop()` / `idle()` answer under fan-out what they answer serially.
+ *
+ * The ordering has a price, and it is the honest one: a call whose Cmd was
+ * emitted FIRST holds its siblings' settles until it finishes. They still RUN
+ * in parallel — the turn costs the slowest call, not the sum — but a first call
+ * that never returns leaves the later folds parked behind it, exactly as a
+ * serial run would leave them unstarted. `timeoutMs` on the tool is what bounds
+ * that, fanned or not.
+ *
+ * The per-turn LIMIT is not this function's: the agent's fan-out slice already
+ * launches at most `toolConcurrency` calls per transition, so the table simply
+ * must not block. Nothing here is applied below that knob — `toMachine` wires
+ * the bare cells at the serial default, and a tool that never overlaps is the
+ * exact function `toolRouter` built.
+ */
+declare function fanOutInterpret<T extends AnyToolDef>(interpret: Interpret<ToolMsg<T>, ToolCmd<T>, NoCtx>): Interpret<ToolMsg<T>, ToolCmd<T>, NoCtx>;
+/**
+ * Turn a tool failure into the human-readable reason string the conversation
+ * carries — pass the `{ _tag, ...detail }` a tool failed with, get the tag
+ * followed by any remaining detail as JSON.
+ *
+ * The
+ * model reads this next turn, so the data survives the rendering intact.
+ */
+declare function toolErrorReason(error: Tagged): string;
+
+/**
+ * @demlik/tea/agent — the wired-machine surface.
+ *
+ * The Cmd / Msg vocabulary the agent speaks, the handle interface `createAgent`
+ * returns (`AgentKnob` / `AgentToMachine`), the do↔agent boot port, the
+ * semantic lifecycle event stream + its projector (`agentEvents`), and the two
+ * pure wiring helpers `mergeInterpret` / `liftAgent`. The reducer core (the
+ * `createAgent` factory that implements this surface) lives in `./index`.
+ */
+
+/** The brain-call effect Cmd, inherited from `../llm-call`. */
+type AgentLlmRunCmd<P extends string> = LlmRunCmd<P>;
+/**
+ * The Cmd union the agent emits, as a CLOSED discriminated union (precise `TC`,
+ * not the open `Cmd`) so `Interpret<M, AgentCmd<P, TC>, Ctx>` maps each key
+ * precisely and `toMachine` merges the interpret halves with no laundering cast:
+ *
+ *   - `AgentLlmRunCmd<P>`     — the brain-call run Cmd (`resilient_run`), folded
+ *                              by the wired `brainHandlers` handler.
+ *   - `MonitoredRunCmd<unknown>` — the durable checkpoint write the monitored-run
+ *                              slice emits, present in the union ONLY when
+ *                              checkpointing is on (`Snap = true`). With
+ *                              checkpointing off the monitored-run slice never
+ *                              emits a `snapshot_write` Cmd, so it is config-derived
+ *                              OUT of the emitted set — the consumer is never asked
+ *                              to interpret a Cmd that can never fire.
+ *   - `TC`                    — the consumer's per-tool effect, mapped to the
+ *                              consumer's own tool interpret handler.
+ *
+ * `Snap` defaults to `true` so the verb-internal usage (which forwards whatever
+ * monitored-run emits) and the published type stay a safe superset; the wired
+ * machine `toMachine` returns is parametrized on the overload-fixed `Snap` so its
+ * Cmd set is exact (`MonitoredRunCmd` present only when checkpointing is on).
+ */
+type AgentCmd<P extends string, TC extends Cmd = Cmd, Snap extends boolean = true, Compact extends boolean = true> = AgentLlmRunCmd<P> | (Snap extends true ? MonitoredRunCmd<unknown> : never) | (Compact extends true ? AgentCompactRunCmd : never) | TC;
+/**
+ * The CONFIG-DERIVED snapshot obligation on `toMachine`'s `toolInterpret`.
+ * Resolves on the `Snap` discriminant the snapshotting overload of `createAgent`
+ * fixes (`true` checkpointing-on / `false` off):
+ *
+ *   - checkpointing ON  → a REQUIRED `snapshot_write` handler
+ *     (`Interpret<M, MonitoredRunCmd<unknown>, Ctx>`). A real checkpoint write
+ *     MUST be wired — the agent never defaults it to a no-op.
+ *   - checkpointing OFF → `{ snapshot_write?: never }`. The handler is FORBIDDEN:
+ *     the Cmd is config-derived out of the emitted set, so wiring it would be
+ *     dead code. The consumer cannot even mention `snapshot_write`.
+ *
+ * This is the type that kills the `snapshot_write: async () => undefined`
+ * ceremony: the obligation is present in the contract EXACTLY when the Cmd can
+ * fire, never as a silent gap the agent backfills.
+ */
+type SnapshotInterpret<M extends {
+    type: string;
+}, Snap extends boolean, Ctx> = Snap extends true ? Interpret<M, MonitoredRunCmd<unknown>, Ctx> : {
+    readonly snapshot_write?: never;
+};
+/**
+ * The `toMachine` signature, parametrized on the `Snap` + `Compact` discriminants
+ * so the snapshotting / compaction overloads of `createAgent` hand back the right
+ * obligations. The `toolInterpret` requires (ON) or forbids (OFF) the
+ * `snapshot_write` handler via {@link SnapshotInterpret} and the `compact_run` handler
+ * via {@link CompactInterpret}, and the machine's Cmd type is the config-derived
+ * `AgentCmd<P, TC, Snap, Compact>`.
+ *
+ * `tools` is a `toolRouter`: its handlers are merged in, its settled
+ * `<name>_ok` / `<name>_err` Msgs join the machine's `M` and fold into the
+ * conversation, and its Cmds leave the `toolInterpret` obligation — a consumer
+ * whose `toolOf` is the router's supplies only the snapshot / compaction handlers.
+ * With no router (`T = never`) every type here reads exactly as before.
+ */
+type AgentToMachine<Stage, P extends string, O extends Record<P, AgentTurn>, R, TC extends Cmd, Snap extends boolean, Compact extends boolean> = <Ctx = object, T extends AnyToolDef = never>(opts?: {
+    readonly tools?: ToolRouter<T>;
+    readonly toolInterpret?: Interpret<AgentMachineMsg<P, O, R> | WiredToolMsg<T>, Exclude<TC, WiredToolCmd<T>>, Ctx> & SnapshotInterpret<AgentMachineMsg<P, O, R> | WiredToolMsg<T>, Snap, Ctx> & CompactInterpret<AgentMachineMsg<P, O, R> | WiredToolMsg<T>, Compact, Ctx>;
+}) => Machine<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R> | WiredToolMsg<T>, AgentCmd<P, TC, Snap, Compact>, DeadlineSub, Ctx>;
+/**
+ * The agent handle `createAgent` returns — the uniform verb contract every tea
+ * composition exposes, plus the wired `toMachine` and the `unsafeDetachedHandlers`
+ * escape hatch. `Snap` flows ONLY into `toMachine`'s `toolInterpret` obligation
+ * (the snapshot derivation); every verb is snapshot-agnostic. The model
+ * message shape `Msg` does not appear on the handle's surface (it is internal to the
+ * brain call's loader), so it is not a type parameter here — only `createAgent`
+ * carries it, to thread the config's `loadMessages` / `model` ports.
+ */
+interface AgentKnob<Stage, P extends string, O extends Record<P, AgentTurn>, R, TC extends Cmd, Snap extends boolean, Compact extends boolean> {
+    readonly init: () => AgentState<Stage, P, O, R>;
+    readonly start: AgentVerb1<Stage, P, O, R, TC, [runId: string, at: number]>;
+    readonly turn: AgentVerb1<Stage, P, O, R, TC, [
+        result: AgentTurn,
+        at: number
+    ]>;
+    readonly toolOk: AgentVerb1<Stage, P, O, R, TC, [
+        callId: string,
+        result: R,
+        at: number
+    ]>;
+    /**
+     * A bare `reason` string still works and settles an untagged failure — the
+     * hand-wired shape this verb has always had. Hand it a whole `ToolFailure`
+     * instead to keep the `{ _tag, …payload }` beside that reason, which is what
+     * `onToolError` and any host code discriminating on `_tag` then read (#115).
+     */
+    readonly toolErr: AgentVerb1<Stage, P, O, R, TC, [
+        callId: string,
+        failure: string | ToolFailure,
+        at: number
+    ]>;
+    readonly succeed: AgentVerb1<Stage, P, O, R, TC, [
+        key: string,
+        msg: AgentLlmOkMsg<P, O>,
+        at: number
+    ]>;
+    readonly fail: AgentVerb1<Stage, P, O, R, TC, [
+        key: string,
+        msg: AgentLlmErrMsg<P>,
+        at: number
+    ]>;
+    readonly compactOk: AgentVerb1<Stage, P, O, R, TC, [
+        key: string,
+        msg: AgentCompactOkMsg,
+        at: number
+    ]>;
+    readonly compactErr: AgentVerb1<Stage, P, O, R, TC, [
+        key: string,
+        msg: AgentCompactErrMsg,
+        at: number
+    ]>;
+    readonly onTimer: AgentVerb1<Stage, P, O, R, TC, [msg: AgentTimerMsg]>;
+    readonly boot: AgentVerb1<Stage, P, O, R, TC, [at: number]>;
+    readonly isSettled: (s: AgentState<Stage, P, O, R>) => boolean;
+    readonly currentStage: (s: AgentState<Stage, P, O, R>) => Stage | undefined;
+    readonly brainCall: (s: AgentState<Stage, P, O, R>) => LlmCall<P>;
+    readonly subs: (s: AgentState<Stage, P, O, R>) => readonly DeadlineSub[];
+    readonly toMachine: AgentToMachine<Stage, P, O, R, TC, Snap, Compact>;
+    readonly unsafeDetachedHandlers: <M>(ports: AgentPorts<P, O, M>) => AgentDetachedHandlers<P, M>;
+}
+/** A verb taking the state + `Args`, returning the agent's `[State, Cmd[]]` tuple. */
+type AgentVerb1<Stage, P extends string, O extends Record<P, AgentTurn>, R, TC extends Cmd, Args extends readonly unknown[]> = (s: AgentState<Stage, P, O, R>, ...args: Args) => readonly [AgentState<Stage, P, O, R>, readonly AgentCmd<P, TC>[]];
+/** The brain-call SUCCESS settle Msg, inherited from `../llm-call`. */
+type AgentLlmOkMsg<P extends string, O extends Record<P, unknown>> = LlmSucceedMsg<P, O>;
+/**
+ * The brain-call FAILURE settle Msg, inherited from `../llm-call` — it re-enters
+ * the agent's `fail` verb, which backs off via the retry ladder rather than
+ * ending the run.
+ */
+type AgentLlmErrMsg<P extends string> = LlmFailMsg<P>;
+/**
+ * The timer Msg (retry + safety deadline) — `DeadlineExceeded`, the shared
+ * shape of both composed wrappers' timer Msgs (`LlmTimerMsg` and `MonitoredRunTimerMsg`
+ * are both `DeadlineExceeded`). One Msg variant covers both timers; `onTimer`
+ * disambiguates by Sub id. This is also the machine Msg the `subscribeDeadline`
+ * handler dispatches directly (no wrapping), matching the sibling gold standard.
+ */
+type AgentTimerMsg = LlmTimerMsg;
+/** Ports the consumer supplies to the llm-call handler — re-exported shape. */
+type AgentPorts<P extends string, O extends Record<P, unknown>, M> = LlmCallPorts<P, O, M>;
+/**
+ * The LEGACY detached brain-call handler dictionary `handlers(ports)` returns,
+ * superseded by the `Interpret` table `AgentKnob.toMachine()` wires — reach for
+ * `toMachine()` unless you are hand-wiring the verbs yourself.
+ *
+ * It is the inherited `../llm-call` detached form's exact shape, NOT an
+ * `Interpret`.
+ * The `resilient_run` handler runs the invoke inside `ctx.waitUntil` and dispatches
+ * the consumer's `onOk` / `onErr` Msg directly (returning `void`), so it is a
+ * fire-and-forget handler with a structural `{ waitUntil, dispatch }` ctx — it
+ * does not re-enter the resilient settle Msg and so does not drive the retry
+ * loop. Naming the type precisely (rather than laundering it through
+ * `as unknown as Interpret<...>`) keeps `agent.unsafeDetachedHandlers(ports)` honest: the
+ * consumer that wires the verbs by hand gets the real detached shape, and its
+ * `resilient_run` is callable with a plain Cmd + a `{ waitUntil, dispatch }` ctx
+ * with no `as never` at the call site.
+ */
+type AgentDetachedHandlers<P extends string, M> = {
+    readonly resilient_run: (cmd: AgentLlmRunCmd<P>, ctx: {
+        waitUntil(p: Promise<unknown>): void;
+        dispatch(msg: M): unknown;
+    }) => void;
+};
+/** The Msg `do/host`'s `autoBoot` fires to re-enter the agent's `boot` verb on rehydrate. */
+type AgentBootMsg = {
+    readonly type: typeof MsgType.AgentBoot;
+    readonly at: number;
+};
+/**
+ * The do↔agent boot port: construct the `agent_boot` Msg `autoBoot` dispatches
+ * on a resumable rehydrate. The agent owns this constructor so the boot Msg
+ * shape lives in ONE place — the host fires it through here, never as a raw
+ * `{ type: "agent_boot" }` literal.
+ */
+declare function agentBootMsg(at: number): AgentBootMsg;
+/**
+ * The Msg an aborted `AbortSignal` fires to settle the run `cancelled`. Owned
+ * here beside the boot Msg for the same reason: the cancel seam lives on the
+ * drive (`driveToDone`'s `cancel`, the lid's `signal`), which is a different
+ * module from the reducer that folds it, so the shape gets ONE home and a
+ * constructor rather than a literal duplicated across the seam.
+ */
+type AgentCancelMsg = {
+    readonly type: typeof MsgType.AgentCancel;
+    readonly at: number;
+};
+/** Construct the `agent_cancel` Msg an abort dispatches. `at` stamps the outcome. */
+declare function agentCancelMsg(at: number): AgentCancelMsg;
+/**
+ * The agent machine's Msg union — one variant per reducer entry point. A
+ * consumer using `toMachine` dispatches `agent_start` to begin and `agent_tool_ok`
+ * / `agent_tool_err` to route settled tools back; the brain-call settle Msgs
+ * (`resilient_ok` / `resilient_err`) RE-ENTER from the FIXED `brainHandlers`
+ * (the substrate enqueues an interpret handler's returned Msg as a follow-up),
+ * driving `succeed` / `fail`. Time enters via `at` on every variant — the
+ * reducer never reads the clock.
+ *
+ * There is deliberately NO `agent_turn` variant here. The wired loop folds a
+ * model turn INSIDE `succeed` from the re-entered `resilient_ok` — a single
+ * settle Msg advances both the retry slice and the conversation (the L3 fix).
+ * Exposing `agent_turn` as a dispatchable Msg re-opened the stuck-`running` bug:
+ * a hand-fed turn folds the conversation without ever re-entering `resilient_ok`,
+ * so `succeed` never runs and the resilient slice stays `running`. The
+ * `turn` verb remains on the handle for the consumer that wires the verbs by hand
+ * (manual wiring), but it is not part of the one wired machine's Msg surface.
+ */
+type AgentMachineMsg<P extends string, O extends Record<P, unknown>, R> = {
+    readonly type: typeof MsgType.AgentStart;
+    readonly runId: string;
+    readonly at: number;
+} | {
+    readonly type: typeof MsgType.AgentToolOk;
+    readonly callId: string;
+    readonly result: R;
+    readonly at: number;
+} | {
+    readonly type: typeof MsgType.AgentToolErr;
+    readonly callId: string;
+    readonly reason: string;
+    readonly at: number;
+} | AgentLlmOkMsg<P, O> | AgentLlmErrMsg<P> | AgentCompactOkMsg | AgentCompactErrMsg | AgentTimerMsg | AgentBootMsg | AgentCancelMsg;
+/**
+ * The agent's PUBLIC lifecycle events — the semantic stream a consumer
+ * subscribes to via `runtime.on(type, …)`. This is the seam that
+ * DECOUPLES observability/SSE code from the agent's PRIVATE retry/loop Msg
+ * vocabulary: where the old code switched on `resilient_ok` / `agent_tool_ok`
+ * (the inherited resilient-call / tool-fan-out plumbing) off the raw `observe`
+ * firehose, a consumer now folds these named events. The private Msg names live
+ * ONLY inside `agentEvents` (the projector) — they appear nowhere in this union
+ * or any exported type, so a UI built on `TurnSettled` does not break the day
+ * the retry plumbing is renamed.
+ *
+ *   - `TurnSettled` — a brain turn settled (the model produced an `AgentTurn`).
+ *     Projected off the private `resilient_ok` settle Msg; carries the parsed
+ *     `turn` (the narration + tool calls the model asked for).
+ *   - `ToolSettled` — a tool call settled OK. Projected off the private
+ *     `agent_tool_ok` Msg; carries the `callId` and the tool `result`.
+ *   - `RunDone` — the run finished. Projected off the post-transition State
+ *     reaching `run.phase === "done"`; carries the run's `output` (the terminal
+ *     model turn, or `null`) — the same first-class result `Runtime.result()`
+ *     reads (#46), surfaced as an event for the streaming consumer.
+ */
+type AgentEvent<R> = {
+    readonly type: "TurnSettled";
+    readonly turn: AgentTurn;
+} | {
+    readonly type: "ToolSettled";
+    readonly callId: string;
+    readonly result: R;
+} | {
+    readonly type: "RunDone";
+    readonly output: AgentTurn | null;
+};
+/**
+ * Project one APPLIED agent transition `(msg, state)` to its semantic
+ * {@link AgentEvent}s — the `events` projector a consumer passes to
+ * `run(machine, { events: agentEvents() })` to light up `runtime.on(...)`.
+ *
+ * This is the ONE place the agent's PRIVATE Msg names are read: it maps
+ * `resilient_ok` → `TurnSettled` and `agent_tool_ok` → `ToolSettled`, and reads
+ * the post-transition `run.phase` for `RunDone`. The mapping is total over the
+ * Msg union (a `default`-free switch on the discriminant) and returns `[]` for
+ * the transitions that carry no public event (start / boot / timer / the error
+ * arms), so a private name never escapes into `AgentEvent`.
+ *
+ * A single transition may emit more than one event: the brain turn that retires
+ * the final stage settles a turn (`TurnSettled`) AND finishes the run
+ * (`RunDone`) — both are projected from that one `resilient_ok` transition.
+ * `RunDone` is gated on `run.phase === "done"`, which the wired loop reaches
+ * exactly once (the agent is terminal there and dispatches no further
+ * transition), so the event fires once per run.
+ *
+ * A `ToolSettled` is gated on `state.refusedCalls` (#145): a call whose public
+ * outcome was already a failure — the ladder's `timeout` / `retry_exhausted`,
+ * or the tool's own error — never emits a success here, however late its
+ * abandoned attempt resolves. Both settle arms read the same list, so a
+ * router-wired agent and a fan-out-wired one are silent on the same calls, and
+ * the decision is made in the PURE layer rather than filtered at a
+ * subscription seam — `runtime.on` and `defineAgent`'s `onEvent` see one
+ * stream.
+ *
+ * A machine wired with `toMachine({ tools })` settles tools through the
+ * router's `<name>_ok` Msgs instead of `agent_tool_ok`; pass the same router
+ * here so those settles project to `ToolSettled` too.
+ *
+ * PURE — reads only the passed `(msg, state)`; no clock, no RNG, no throw.
+ *
+ * @typeParam P     Brain-call purposes.
+ * @typeParam O     Per-purpose outputs (bound to `AgentTurn`, the agentic shape).
+ * @typeParam R     Tool result type.
+ * @typeParam Stage Pipeline stage type.
+ * @typeParam T     The router's tool defs, when one is wired.
+ */
+declare function agentEvents<Stage, P extends string, O extends Record<P, AgentTurn>, R, T extends AnyToolDef = never>(opts?: {
+    readonly tools?: ToolRouter<T>;
+}): (msg: AgentMachineMsg<P, O, R> | WiredToolMsg<T>, state: AgentState<Stage, P, O, R>) => readonly AgentEvent<R>[];
+/**
+ * Join two `Interpret` dictionaries over DISJOINT Cmd subsets `A` and `B` (over
+ * the same Msg union `M` and Ctx) into the full `Interpret<M, A | B, Ctx>`. The
+ * agent uses it to merge the consumer's per-tool / snapshot interpret (`A`) with
+ * the agent-owned brain-call handler (`B = AgentLlmRunCmd`) into the wired
+ * machine's single interpret table.
+ *
+ * The runtime result is exactly the spread of the two key-disjoint records. The
+ * single `as` is a SOUND mapped-type identity, not a laundering cast: `Interpret`
+ * is a homomorphic mapped type keyed by `Cmd["type"]`, so
+ * `Interpret<M, A, Ctx> & Interpret<M, B, Ctx>` IS `Interpret<M, A | B, Ctx>`
+ * (`(A | B)["type"] = A["type"] | B["type"]`). TypeScript does not reduce that
+ * intersection of two GENERIC mapped types on its own, so the equality is
+ * asserted ONCE here — preserving `M` and `Ctx` exactly — rather than smuggled
+ * through `as unknown as Interpret<...>` at every wiring site. Pure.
+ */
+declare function mergeInterpret<M extends {
+    type: string;
+}, A extends Cmd, B extends Cmd, Ctx>(a: Interpret<M, A, Ctx> | undefined, b: Interpret<M, B, Ctx>): Interpret<M, A | B, Ctx>;
+/**
+ * Lift an agent result `[slice, cmds]` into a host `[State, cmds]` where the slice
+ * lives at `state.agent`. Convenience for a host that nests the agent slice
+ * under a named field; the single-slice host uses the verbs' tuple directly.
+ * PURE — a thin record rebuild, no clock / RNG.
+ */
+declare function liftAgent<S extends {
+    agent: AgentState<Stage, P, O, R>;
+}, Stage, P extends string, O extends Record<P, unknown>, R, C extends Cmd>(state: S, [slice, cmds]: readonly [AgentState<Stage, P, O, R>, readonly C[]]): readonly [S, readonly C[]];
+
+export { PLAIN_MODEL_MISROUTE_REASON as $, type AnyToolDef as A, type AgentSnapshotConfig as B, type Conversation as C, type AgentStatus as D, type AgentTerminalFailure as E, type AgentTimerMsg as F, type AgentToMachine as G, type Awaiting as H, COMPACTION_PURPOSE as I, type CompactInterpret as J, type CompactionOutputs as K, type CompactionPurpose as L, type CompactionSummary as M, type LlmCall as N, type LlmErr as O, type PlainModel as P, type LlmFailMsg as Q, type LlmOk as R, type StreamingModel as S, type ToolCall as T, type LlmRunCmd as U, type LlmSucceedMsg as V, type WiredToolMsg as W, type MessageLoader as X, type ModelFactory as Y, type ModelPort as Z, type ModelStream as _, type ToolOutcome as a, type ReservedToolName as a0, type Schema as a1, type SnapshotInterpret as a2, TOOL_RETRY_EXHAUSTED_TAG as a3, TOOL_TIMEOUT_TAG as a4, type TaggedFailure as a5, type ToolConstructors as a6, type ToolDef as a7, type ToolError as a8, type ToolFail as a9, liftAgent as aA, mergeInterpret as aB, plainModel as aC, status as aD, tool as aE, toolErrorReason as aF, toolRouter as aG, type ToolFailure as aa, type ToolHandler as ab, type ToolInput as ac, type ToolMsg as ad, type ToolOk as ae, type ToolRecord as af, type ToolRejectedCmd as ag, type ToolRejection as ah, type ToolResilience as ai, type ToolResilienceError as aj, type ToolRetryExhausted as ak, type ToolRouter as al, type ToolSettlement as am, type ToolThrown as an, type ToolTimedOut as ao, type WiredToolCmd as ap, agentBootMsg as aq, agentCancelMsg as ar, agentEvents as as, agentTurnSchema as at, compactionSummarySchema as au, fanOutInterpret as av, isAgentTurn as aw, isCompactionSummary as ax, isReservedToolName as ay, isStreamingModel as az, type AgentTurn as b, type AgentState as c, type ToolResult as d, type ToolFailureOf as e, type ToolCmd as f, type AgentEvent as g, type TurnChunk as h, type AgentMachineMsg as i, type AgentCmd as j, type AgentConfigCore as k, type CompactionPolicy as l, type AgentKnob as m, type AgentBootMsg as n, type AgentCancelMsg as o, type AgentCompactErrMsg as p, type AgentCompactOkMsg as q, type AgentCompactRunCmd as r, type AgentCompactionConfig as s, type AgentConfig as t, type AgentDetachedHandlers as u, type AgentFailure as v, type AgentLlmErrMsg as w, type AgentLlmOkMsg as x, type AgentLlmRunCmd as y, type AgentPorts as z };