@orkestrel/agent 0.0.35 → 0.0.37

package/dist/src/core/index.d.ts

@@ -1,4 +1,5 @@
 import { ArrayShape } from '@orkestrel/contract';
+import type { AuditFault } from '@orkestrel/contract';
 import { BooleanShape } from '@orkestrel/contract';
 import type { BudgetInterface } from '@orkestrel/budget';
 import { ContractInterface } from '@orkestrel/contract';
@@ -12,9 +13,11 @@ import type { FileInput } from '@orkestrel/workspace';
 import type { FileInterface } from '@orkestrel/workspace';
 import type { Guard } from '@orkestrel/contract';
 import type { JSONRecord } from '@orkestrel/contract';
+import type { JSONSchema } from '@orkestrel/contract';
 import { JSONShape } from '@orkestrel/contract';
 import { JSONValue } from '@orkestrel/contract';
 import { LiteralShape } from '@orkestrel/contract';
+import { NullableShape } from '@orkestrel/contract';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
@@ -510,13 +513,16 @@ export declare interface AgentContextOptions {
 }
 
 /**
- * Reports an `ask` on an authority that has no approver or that its approver refuses, a run sharing accounting or a conversation with a live run, a `limit` that is not a nonnegative safe integer, a name absent from a registry pool, or a strict run whose request exceeds its window. Agent construction, the `stream` and `generate` methods, and registry accessors throw synchronously, before returning a handle or promise; a `'WINDOW'` refusal rejects the run's `result` instead, and an `'APPROVER'` refusal rejects the promise the `ask` method of an `Authority` or the `ask` handler of an `Approver` returns. Await the call inside `try`/`catch` to catch it.
+ * Reports an `ask` on an authority that has no approver or that its approver refuses, an authority missing its fallback or a rule's verdict, tools set with no authority, a run sharing accounting or a conversation with a live run, a `limit` that is not a positive safe integer, a name absent from a registry pool, a strict run's answer that fails its schema, or a strict run whose request exceeds its window. Agent construction, the `stream` and `generate` methods, and registry accessors throw synchronously, before returning a handle or promise; a `'WINDOW'` refusal rejects the run's `result` instead, and an `'APPROVER'` refusal rejects the promise the `ask` method of an `Authority` or the `ask` handler of an `Approver` returns. Await the call inside `try`/`catch` to catch it.
  *
  * @remarks
  * `'APPROVER'` reports an `ask` on an `Authority` built with no `ask` handler, or an ask an
  * `Approver` refuses: a call framed while no ask waited for it, a second ask for a waiting call, or
  * arguments it cannot render. The agent loop reads it as an unanswered ask and denies the call. Its
  * `context` names the asked `tool`.
+ * `'AUTHORITY'` reports an `Authority` built with no valid `fallback`, a rule with no valid `verdict`
+ * (its `context` names the `rule` index), and an agent built with `tools` and no `authority`. Each
+ * throws at construction, with the options a host passes to correct it in the message.
  * `'CONCURRENCY'` reports a run started while another run on the same agent is live, when the
  * agent carries a `window` (a shared context budget) or when the run's effective `budget` or
  * `allowance` is an instance a live run holds — the second run's `start()` would replace that
@@ -525,17 +531,18 @@ export declare interface AgentContextOptions {
  * `agent` id, and the `conversation` id for a shared conversation. For concurrent runs, use
  * separate agents, or one agent with no `window`, distinct budget and allowance instances per
  * run, and a distinct conversation per run.
- * `'LIMIT'` reports a construction or per-run `limit` that is not a nonnegative safe integer,
+ * `'LIMIT'` reports a construction or per-run `limit` that is not a positive safe integer,
  * including one a rehydrated job carries into `build`. `'REGISTRY'` reports a rehydration name
- * absent from its registry pool, on `provider` / `tool` / `authority` / `scheduler` / `build`;
- * its `context` names the `category` and the `name`. `'WINDOW'` reports a `strict` run whose
+ * absent from its registry pool, on `provider` / `tool` / `authority` / `scheduler` / `build`,
+ * whose `context` names the `category` and the `name`, and a job that names `tools` and no
+ * `authority` at `build`, whose `context` names the `tools`. `'WINDOW'` reports a `strict` run whose
  * complete provider request is still over the `window` budget, equal to its `max` included, after
  * the one permitted fold or with no fold possible; it settles the run `error` before the provider
  * is called, and its `context` holds the `agent` id, the measured `consumed`, and the window `max`.
  * Narrow a caught value with {@link isAgentError} and branch on `error.code`.
  */
 export declare class AgentError extends Error {
-    /** Names the machine-readable condition — `'APPROVER'`: an `ask` on an authority that has no approver, or one its approver refuses; `'CONCURRENCY'`: a run sharing accounting or a conversation with a live run; `'LIMIT'`: a `limit` that is not a nonnegative safe integer; `'REGISTRY'`: a rehydration name absent from its registry pool; `'WINDOW'`: a strict run whose complete request is still over its window budget. */
+    /** Names the machine-readable condition — `'APPROVER'`: an `ask` on an authority that has no approver, or one its approver refuses; `'AUTHORITY'`: an authority missing its fallback or a rule's verdict, or tools set with no authority; `'CONCURRENCY'`: a run sharing accounting or a conversation with a live run; `'LIMIT'`: a `limit` that is not a positive safe integer; `'REGISTRY'`: a rehydration name absent from its registry pool; `'WINDOW'`: a strict run whose complete request is still over its window budget. */
     readonly code: AgentErrorCode;
     /** Holds the values that locate the failure, such as the `agent` id of a refused run, or `undefined` when none were supplied. */
     readonly context: Readonly<Record<string, unknown>> | undefined;
@@ -549,8 +556,8 @@ export declare class AgentError extends Error {
     constructor(code: AgentErrorCode, message: string, options?: CodedErrorOptions);
 }
 
-/** Names the machine-readable agent approver, concurrency, limit, registry, and window failures. */
-export declare type AgentErrorCode = 'APPROVER' | 'CONCURRENCY' | 'LIMIT' | 'REGISTRY' | 'WINDOW';
+/** Names the machine-readable agent approver, authority, concurrency, limit, registry, schema, and window failures. */
+export declare type AgentErrorCode = 'APPROVER' | 'AUTHORITY' | 'CONCURRENCY' | 'LIMIT' | 'REGISTRY' | 'SCHEMA' | 'WINDOW';
 
 /**
  * Maps the push observation surface of an {@link AgentInterface} — the lifecycle, usage, and tool
@@ -608,12 +615,11 @@ export declare type AgentEventMap = {
     readonly ask: readonly [call: ToolCall, decision: AuthorityDecision];
     /**
      * Reports a call denied by scope or authority, before dispatch; `decision` is absent for a scope
-     * miss, a call whose name no definition advertises this turn, a no-advertisement drop, an evaluate
-     * throw, an invalid decision, or a cleared call whose tool instance changed before dispatch.
-     * A turn advertising no tools drops each call with `no tool is advertised in the active scope`.
-     * Otherwise a call excluded by the tool allow-list, or whose name no definition advertises this
-     * turn, carries `<tool name> is not in the active scope` and produces a denial tool result and
-     * message. Authority evaluates only admitted calls that name an advertised definition. `reason` is
+     * miss, a call whose name no definition advertises this turn, an evaluate throw, an invalid
+     * decision, a call on an agent that holds no authority, or a cleared call whose tool instance
+     * changed before dispatch. A call excluded by the tool allow-list, or whose name no definition
+     * advertises this turn, a turn advertising no tools included, carries `<tool name> is not in the
+     * active scope` and produces a denial tool result and message. Authority evaluates only admitted calls that name an advertised definition. `reason` is
      * the rule's `deny` reason, the thrown error's text, `invalid decision`, `<tool name> changed after
      * its decision` for a cleared call whose tool instance changed before dispatch (the model reads the
      * `denied` note), or `undefined`. A cancel that ends the turn before dispatch emits no such `deny`.
@@ -898,7 +904,7 @@ export declare interface AgentInterface {
      * A run started while another is live throws an {@link import('./errors.js').AgentError} with
      * `code: 'CONCURRENCY'` when the agent carries a `window`, when the run's effective
      * `budget` or `allowance` is an instance a live run holds, or when a live run is bound to the
-     * run's conversation; a run whose `limit` is not a nonnegative safe
+     * run's conversation; a run whose `limit` is not a positive safe
      * integer throws one with `code: 'LIMIT'`. A `prompt` that `agentPromptContract` refuses, a
      * `budget` or `allowance` that does not implement `BudgetInterface`, or a `conversation` that
      * does not implement `ConversationInterface`, throws a `ContractError` with code `'placement'`
@@ -910,7 +916,7 @@ export declare interface AgentInterface {
      *
      * @param options - Optional per-run {@link AgentRunOptions} (for example `think`); omitted ⇒ defaults
      * @returns The settled {@link AgentResult} (`partial: true` when cancelled)
-     * @throws {AgentError} Thrown when a live run shares the `window`, a budget or allowance instance, or the run's conversation (`code: 'CONCURRENCY'`) or the `limit` is not a nonnegative safe integer (`code: 'LIMIT'`), synchronously before a handle returns.
+     * @throws {AgentError} Thrown when a live run shares the `window`, a budget or allowance instance, or the run's conversation (`code: 'CONCURRENCY'`) or the `limit` is not a positive safe integer (`code: 'LIMIT'`), synchronously before a handle returns.
      * @throws {ContractError} Thrown when the `prompt` is not an exact `AgentPrompt`, the `budget` or `allowance` does not implement `BudgetInterface`, or the `conversation` does not implement `ConversationInterface` (`code: 'placement'`), synchronously before a handle returns.
      */
     generate(options?: AgentRunOptions): Promise<AgentResult>;
@@ -922,7 +928,7 @@ export declare interface AgentInterface {
      * @remarks
      * Like `generate()`, a run that would share the `window`, a live run's budget or allowance
      * instance, or a live run's conversation throws an {@link import('./errors.js').AgentError} with
-     * `code: 'CONCURRENCY'`, an invalid `limit` throws one with `code: 'LIMIT'`, and a `prompt` that
+     * `code: 'CONCURRENCY'`, a `limit` that is not a positive safe integer throws one with `code: 'LIMIT'`, and a `prompt` that
      * `agentPromptContract` refuses, a `budget` or `allowance` that does not implement
      * `BudgetInterface`, or a `conversation` that does not implement `ConversationInterface` throws a
      * `ContractError` with code `'placement'`, synchronously — before the
@@ -937,7 +943,7 @@ export declare interface AgentInterface {
      *
      * @param options - Optional per-run {@link AgentRunOptions} (for example `think`); omitted ⇒ defaults
      * @returns A live {@link AgentStreamInterface} handle (events + result + abort)
-     * @throws {AgentError} Thrown when a live run shares the `window`, a budget or allowance instance, or the run's conversation (`code: 'CONCURRENCY'`) or the `limit` is not a nonnegative safe integer (`code: 'LIMIT'`), synchronously before a handle returns.
+     * @throws {AgentError} Thrown when a live run shares the `window`, a budget or allowance instance, or the run's conversation (`code: 'CONCURRENCY'`) or the `limit` is not a positive safe integer (`code: 'LIMIT'`), synchronously before a handle returns.
      * @throws {ContractError} Thrown when the `prompt` is not an exact `AgentPrompt`, the `budget` or `allowance` does not implement `BudgetInterface`, or the `conversation` does not implement `ConversationInterface` (`code: 'placement'`), synchronously before a handle returns.
      */
     stream(options?: AgentRunOptions): AgentStreamInterface;
@@ -950,6 +956,37 @@ export declare interface AgentInterface {
     abort(reason?: unknown): void;
 }
 
+/** Checks a durable agent job exactly at `AgentRegistry.build`. */
+export declare const agentJobContract: ContractInterface<Readonly<{
+provider: string;
+} & {
+messages?: readonly Readonly<{
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+system?: string;
+tools?: readonly string[];
+authority?: string;
+scheduler?: string;
+limit?: number;
+timeout?: number;
+budget?: number;
+children?: readonly {
+readonly [k: string]: JSONValue;
+}[];
+}>>;
+
 /**
  * Reports an {@link AgentInterface} run that ended {@link AgentResult.partial} under a
  * `partial` policy of `false` (the default) — thrown by an agent-job handler (a
@@ -995,13 +1032,13 @@ export declare class AgentJobError extends Error {
 export declare interface AgentJobInput {
     /** Names the registry key of the {@link ProviderInterface} the job runs against. */
     readonly provider: string;
-    /** Holds the seed conversation added to the rehydrated agent's context (serializable). */
-    readonly messages: readonly MessageInput[];
+    /** Holds the seed conversation added to the rehydrated agent's context (serializable). Default: an empty seed. */
+    readonly messages?: readonly MessageInput[];
     /** Holds an optional system prompt seeding the agent's context. */
     readonly system?: string;
-    /** Names the registry keys of the values of {@link ToolInterface} loaded into the agent's tool manager. */
+    /** Names the registry keys of the values of {@link ToolInterface} loaded into the agent's tool manager; a non-empty list requires `authority`. */
     readonly tools?: readonly string[];
-    /** Names the registry key of an optional {@link AuthorityInterface} policy gate. */
+    /** Names the registry key of the {@link AuthorityInterface} policy gate; required when `tools` names any. */
     readonly authority?: string;
     /** Names the registry key of an optional {@link SchedulerInterface} pacing the loop. */
     readonly scheduler?: string;
@@ -1021,6 +1058,39 @@ export declare interface AgentJobInput {
     readonly children?: readonly AgentJobInput[];
 }
 
+/**
+ * Describes a durable agent job — the record `AgentRegistry.build` checks exactly, so a misspelled key
+ * refuses instead of running an agent without it.
+ *
+ * @remarks
+ * `children` holds JSON records, because each child crosses this shape at its own `build`. `limit`
+ * reads as a number here and as a positive safe integer at the agent's construction, which owns that
+ * refusal.
+ */
+export declare const agentJobShape: ObjectShape<    {
+provider: StringShape;
+messages: OptionalShape<ArrayShape<ObjectShape<    {
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>>;
+system: OptionalShape<StringShape>;
+tools: OptionalShape<ArrayShape<StringShape>>;
+authority: OptionalShape<StringShape>;
+scheduler: OptionalShape<StringShape>;
+limit: OptionalShape<NumberShape>;
+timeout: OptionalShape<NumberShape>;
+budget: OptionalShape<NumberShape>;
+children: OptionalShape<ArrayShape<ObjectShape<Record<never, never>, JSONShape>>>;
+}, boolean | ContractShape>;
+
 /**
  * Implements the bounded HTTP calls, validation, and result merging of a judge behind concrete
  * wire seams.
@@ -1031,7 +1101,9 @@ export declare interface AgentJobInput {
  * order. `ask` validates the request before any call, builds every body before the first call so
  * a wire limit refuses the request before inference, and runs the calls one after another, each
  * under its own deadline folded with the caller's signal. A cancel throws a `JudgeAbortError`
- * whose `partial` merges the calls that completed. A transport error reaches the caller unchanged.
+ * whose `partial` merges the calls that completed. A transport error reaches the caller unchanged. An
+ * answer that does not fit its question throws code `PROTOCOL`, and a call whose `read` reports no
+ * usage bills the estimate of its response text.
  *
  * @example Writing a judge wire
  * ```ts
@@ -1201,9 +1273,8 @@ export declare interface AgentOptions {
      * Each turn snapshots the scope's tool allow-list before advertising and checks calls
      * against that list before applying authority. A call whose name no definition advertises is
      * denied the same way, whatever the authority would decide.
-     * A reply to a turn advertising no tools ends the run as its answer, records an assistant
-     * message without calls, and emits a `deny` event for every dropped call without marking it partial.
-     * Other scoped-out calls produce denial tool results and messages, and the loop continues.
+     * Every scoped-out call, one in a turn advertising no tools included, produces a denial tool
+     * result and message and a `deny` event, and the loop continues.
      * A scope change through the context's `apply` method applies the tool allow-list at the next
      * turn's snapshot, which a `turn` listener reaches for the same turn, and the instructions,
      * skills, memos, files, and `select` at the next build or select site: run entry, the pre-first-turn
@@ -1211,7 +1282,7 @@ export declare interface AgentOptions {
      */
     readonly scope?: ScopeInterface;
     /**
-     * Caps the tool-iteration turns before the loop stops, as a nonnegative safe integer.
+     * Caps the tool-iteration turns before the loop stops, as a positive safe integer.
      * Thrown as an `AgentError` with code `'LIMIT'` when it is not. Default: `DEFAULT_AGENT_LIMIT`.
      */
     readonly limit?: number;
@@ -1248,14 +1319,14 @@ export declare interface AgentOptions {
     /** Carries an external cancel; its abort commits a partial result. */
     readonly signal?: AbortSignal;
     /**
-     * Holds an optional policy gate consulted after scope admits a tool call — a denied call is
+     * Holds the policy gate consulted after scope admits a tool call — a denied call is
      * fed back to the model as a denial {@link ToolResult} (a `tool` chunk + a tool
      * message) rather than executed (no tool execution), so the model receives the
      * denial and can react; an allowed call dispatches normally, and an asked call dispatches only
      * when the authority's `ask` approves it. The loop raises an `allow` for a tool whose advertised
-     * definition is annotated `consequential` to an `ask`, with or without this option. Omitted ⇒ a
-     * default `Authority` with no rules and no approver: an unannotated call dispatches with an
-     * `allow` in zone `'default'`, and a `consequential` call is denied as unanswered.
+     * definition is annotated `consequential` to an `ask`. Required when `tools` is set: construction
+     * throws an `AgentError` coded `'AUTHORITY'` otherwise. Omitted with no `tools` ⇒ no gate, and a
+     * tool added later through `context.tools` is denied rather than run.
      */
     readonly authority?: AuthorityInterface;
     /**
@@ -1293,10 +1364,12 @@ export declare interface AgentOptions {
      * still finds over the window, equal to `max` included, after the one permitted fold, or that
      * cannot fold, is refused before the provider is called: the run settles `error` with an
      * `AgentError` coded `'WINDOW'` whose `context` holds the `agent`, the measured `consumed`, and
-     * the window `max`, and no `fault` fires for it. If `false`, the run continues — over-window
-     * after a summarizer failure or a futile fold, and on the run's conversation's `view()` after a
-     * selection fault. A cancel at a selection site or a fold, a `fault` listener's included, settles
-     * partial instead of `error`. Default: `false`.
+     * the window `max`, and no `fault` fires for it. A final answer that misses the run's `schema`
+     * settles `error` with an `AgentError` coded `'SCHEMA'`. If `false`, the run continues —
+     * over-window after a summarizer failure or a futile fold, on the run's conversation's `view()`
+     * after a selection fault, and with the raw content after a schema miss, which emits `fault`. A
+     * cancel at a selection site or a fold, a `fault` listener's included, settles partial instead of
+     * `error`. Default: `true`.
      */
     readonly strict?: boolean;
     /**
@@ -1346,7 +1419,8 @@ images: OptionalShape<ArrayShape<StringShape>>;
  * have no size limit. A qwen3 implicit-open reclassification corrects the final
  * content while content deltas already yielded cannot be recalled. A subclass fills
  * `name`, `frame`, `encode`, `read`, and `finish`; the constructor takes the `split`
- * and `strict` switches to control reasoning separation and settled-result requirements.
+ * and `strict` switches to control reasoning separation and whether a stream must end with a settled
+ * `result` or a `done` record, which it must by default.
  * The `replay` input names which stored thinking the agent and relay send back. Default: `'none'`.
  * A throw from the framing seam (`parse`, or `finish`) becomes a `ProviderError` with the
  * `PROTOCOL` code whose `cause` is the throw, unless it is already a `ProviderError` or
@@ -1378,7 +1452,8 @@ images: OptionalShape<ArrayShape<StringShape>>;
  * class TextProvider extends AgentProvider<string> {
  * 	readonly name = 'text'
  * 	constructor(options: TextOptions) {
- * 		super({ ...options, path: '/generate' })
+ * 		// Raw text has no terminal record, so a stream that stops reads as complete.
+ * 		super({ ...options, path: '/generate', strict: false })
  * 	}
  * 	frame(): ProviderParserInterface<string> {
  * 		return new TextFrame()
@@ -1443,8 +1518,9 @@ export declare abstract class AgentProvider<TRecord = Readonly<Record<string, un
  * @remarks
  * `path` appends to `url`. If `split` is true, separates in-content reasoning;
  * if false, preserves content verbatim. Default: true.
- * If `strict` is true, requires a settled result record; if false, assembles at end of input.
- * Default: false.
+ * If `strict` is true, a stream that ends with neither a settled `result` nor a `done` record throws
+ * a `ProviderError` with the `PROTOCOL` code, because it was cut; if false, assembles at end of input,
+ * which a wire with no terminal record passes. Default: true.
  */
 export declare interface AgentProviderInput extends ProviderOptions {
     readonly url: string;
@@ -1509,13 +1585,14 @@ export declare interface AgentQueueOptions {
  *   rehydrated job is a programmer / config error that must fail loudly at build time, never
  *   silently resolve to `undefined` and run an agent missing a dependency.
  * - **`build` rehydrates.** Resolve the job's `provider`; assemble a fresh
- *   {@link ToolManager} from the `tools` names; rebuild the token `budget` from its
+ *   {@link ToolManager} from the `tools` names, which refuses with `code: 'REGISTRY'` when the job
+ *   names no `authority`; rebuild the token `budget` from its
  *   ceiling (`createTokenBudget({ max })`); resolve the optional `authority` /
  *   `scheduler` names; construct the {@link Agent} with `system` / `limit` / `timeout` /
  *   the threaded `signal`; seed its context with the job's `messages`; return it. The
  *   `signal` is the queue attempt's / runner unit's cancel, so a bounded abort propagates
  *   into the agent (which commits a partial — the job's `partial` policy then
- *   decides success vs. retry). A job `limit` that is not a nonnegative safe integer throws an
+ *   decides success vs. retry). A job `limit` that is not a positive safe integer throws an
  *   {@link AgentError} carrying `code: 'LIMIT'` from the agent's construction.
  * - **Event-free.** A pure resolver — no Emitter, no events.
  *
@@ -1598,7 +1675,7 @@ export declare interface AgentRegistryInterface {
      * @param input - The serializable {@link AgentJobInput} to rehydrate
      * @param signal - An optional cancel threaded into the agent (a queue / runner abort)
      * @returns The ready agent, its context seeded with the job's messages
-     * @throws {AgentError} Thrown when a referenced provider, tool, authority, or scheduler name is unregistered (`code: 'REGISTRY'`), or when the job's `limit` is not a nonnegative safe integer (`code: 'LIMIT'`)
+     * @throws {AgentError} Thrown when a referenced provider, tool, authority, or scheduler name is unregistered, or the job names `tools` and no `authority` (`code: 'REGISTRY'`), or when the job's `limit` is not a nonnegative safe integer (`code: 'LIMIT'`)
      * @throws {ConversationError} Thrown when a seed message's role is not a `ConversationRole` (`code: 'ROLE'`), before the agent is returned
      */
     build(input: AgentJobInput, signal?: AbortSignal): AgentInterface;
@@ -1640,7 +1717,7 @@ export declare interface AgentRegistryOptions {
  * holding unresolved tool intent (the model requested tools on the very last allowed
  * turn) — a distinct, non-cancel cause covered by {@link AgentRunResult.exhausted} (see
  * the `exhaust` {@link AgentEventMap} event). It is `false` for a turn that ran to a
- * natural finish (including a `limit: 0` run, which never enters the loop). `usage` is
+ * natural finish. `usage` is
  * present only when at least one provider call or selection reported usage — an aborted run's `usage`
  * includes the cancelled turn's tokens when the provider reports partial usage on the
  * abort (folded in exactly like a completed turn's); a provider that cannot observe
@@ -1702,16 +1779,16 @@ export declare function agentResultToFrame(result: AgentResult): Extract<AgentFr
 /**
  * Projects an unknown value onto a fresh, exact `JSONValue` representation of an
  * {@link AgentResult} — capturing each structural field once through a total boundary,
- * accepting conforming accessors and inherited properties, preserving finite negative and
- * fractional usage counts, dropping extras, and resolving `undefined` for a malformed field, a
- * non-finite usage number, a throwing getter, or a malformed or revoked proxy.
+ * accepting conforming accessors and inherited properties, preserving fractional usage counts,
+ * dropping extras, and resolving `undefined` for a malformed field, a negative or non-finite usage
+ * number, a throwing getter, or a malformed or revoked proxy.
  *
  * @remarks
  * This is a total projection that reads untrusted input. Each structural field is captured once
  * through Contract's sanctioned exception boundary, so conforming accessors and inherited
  * properties are supported while a throwing getter or revoked proxy returns `undefined`.
- * Present usage counts must be finite numbers; negative and fractional values are preserved,
- * not normalized. The result is exact `{ content, thinking?, usage?, partial, stop? }`. A present
+ * Present usage counts must be finite and nonnegative; fractional values are preserved, not
+ * normalized. The result is exact `{ content, thinking?, usage?, partial, stop? }`. A present
  * `stop` is read once, then its `layer`, `id`, `max`, `consumed`, `estimate`, and `usage` once each
  * in that order, `max` and `consumed` only on a `meter` or `budget` arm; the arm is rebuilt
  * exactly, omitting absent readings, and a malformed `stop` refuses the whole value. Extra input
@@ -1776,13 +1853,18 @@ export declare interface AgentRunOptions {
     readonly think?: boolean;
     /**
      * Constrains the response to this JSON-Schema shape, forwarded to the provider's `stream`
-     * as {@link ProviderStreamOptions.schema} — a per-run structured-output request. Omitted ⇒
-     * no constraint (the loop sends no schema).
+     * as {@link ProviderStreamOptions.schema} — a per-run structured-output request, and enforced: the
+     * final answer must parse as JSON and satisfy the schema, through the lenient `schemaToShape`. A
+     * miss under {@link AgentOptions.strict} settles the run `error` with an `AgentError` coded
+     * `'SCHEMA'` whose `context` holds the `faults` and stores no answer; under `strict: false` it emits
+     * `fault` with that error and settles with the raw content, the opt-out for a provider that ignores
+     * schemas. A `truncated` answer skips the check and keeps its `model` stop. Omitted ⇒ no constraint
+     * (the loop sends no schema).
      */
     readonly schema?: Readonly<Record<string, unknown>>;
     /**
      * Overrides {@link AgentOptions.limit} for this run only — the max tool-iteration turns
-     * before the loop stops, as a nonnegative safe integer; the call throws an `AgentError` with
+     * before the loop stops, as a positive safe integer; the call throws an `AgentError` with
      * code `'LIMIT'` when it is not. Omitted ⇒ the agent's constructed `limit` applies.
      */
     readonly limit?: number;
@@ -1925,7 +2007,11 @@ export declare type AgentStreamInterface = StreamInterface<AgentChunk, AgentResu
  * @example
  * ```ts
  * const approver = createApprover()
- * const authority = createAuthority({ rules, ask: approver.ask })
+ * const authority = createAuthority({
+ * 	rules,
+ * 	fallback: { zone: 'default', verdict: 'deny' },
+ * 	ask: approver.ask,
+ * })
  * const agent = createAgent(provider, { tools, authority })
  * for await (const frame of agentStreamToFrames(agent.stream({ prompt }), approver)) {
  * 	send(JSON.stringify(frame))
@@ -1993,7 +2079,11 @@ export declare interface AnswerMeasure {
  * @example
  * ```ts
  * const approver = new Approver()
- * const authority = createAuthority({ rules, ask: approver.ask })
+ * const authority = createAuthority({
+ * 	rules,
+ * 	fallback: { zone: 'default', verdict: 'deny' },
+ * 	ask: approver.ask,
+ * })
  * approver.answer({ id, approved: true }) // true while that ask waits
  * ```
  */
@@ -2112,13 +2202,14 @@ export declare function attachImages(message: Message, payloads: readonly string
  * @remarks
  * Pure and total: the conversation and its messages are never mutated, and the returned array
  * replaces exactly the one target message with the copy {@link attachImages} builds. Empty
- * data returns the conversation unchanged; a conversation with no user message returns it
- * unchanged too (there is nowhere to attach, so the images are left out). A hole
- * in a sparse conversation is not a user message.
+ * data returns the conversation unchanged. Data with no user message to carry it refuses, an empty
+ * conversation included, because leaving the images out would run without them. A hole in a sparse
+ * conversation is not a user message.
  *
  * @param conversation - The messages to attach into (left unchanged)
  * @param payloads - The base64 image data to attach
  * @returns The conversation with its last user message replaced by the carrying copy
+ * @throws ContextError Thrown when there is data and no user message to carry it (code `'IMAGES'`)
  *
  * @example
  * ```ts
@@ -2131,19 +2222,18 @@ export declare function attachUserImages(conversation: readonly Message[], paylo
 /**
  * Gates the agent loop's tool calls — the synchronous policy consulted before each call runs,
  * turning one {@link AuthorityContext} into an {@link AuthorityDecision} by walking the ordered
- * rules first-match-wins and falling back to a configurable default, which allows an unmatched
- * call unless its `fallback` decides otherwise, and the approver that answers an `ask` verdict.
+ * rules first-match-wins and falling back to the required `fallback`, and the approver that answers
+ * an `ask` verdict.
  *
  * @remarks
+ * - **Refuses at construction.** The constructor throws an `AgentError` coded `'AUTHORITY'` when the
+ *   `fallback` is missing or malformed, or when a rule has no valid `verdict`, so a policy with a
+ *   hole in it never runs.
  * - **Ordered, first-match-wins.** `evaluate` walks the configured rules in order and
- *   returns the first whose `match(context)` is true as
- *   `{ zone, verdict: rule.verdict ?? 'allow', reason }` — a matched rule with no `verdict`
- *   allows.
- * - **Fallback.** When no rule matches, `evaluate` returns the configured `fallback`.
- *   Default: `{ zone: DEFAULT_AUTHORITY_ZONE, verdict: 'allow' }` (allow-unmatched),
- *   so a rules list of denials behaves as a denylist. To make the gate deny-by-default
- *   (an allowlist — only matched rules that allow get through), pass a `verdict: 'deny'`
- *   `fallback`.
+ *   returns the first whose `match(context)` is true as `{ zone, verdict, reason }`.
+ * - **Fallback.** When no rule matches, `evaluate` returns the configured `fallback`: a
+ *   `verdict: 'deny'` fallback makes an allowlist (only matched rules that allow get through), and a
+ *   `verdict: 'allow'` fallback makes a denylist.
  * - **Consulted before each tool call.** The agent loop calls `evaluate({ call })` for
  *   every {@link import('@orkestrel/tool').ToolCall} the model emits; a denied call is fed
  *   back to the model as a denial {@link import('@orkestrel/tool').ToolResult} (a `tool`
@@ -2158,9 +2248,10 @@ export declare function attachUserImages(conversation: readonly Message[], paylo
  *
  * @example
  * ```ts
- * // A denylist: deny the `delete` tool, allow everything else (default fallback).
+ * // A denylist: deny the `delete` tool, allow everything else.
  * const authority = new Authority({
  * 	rules: [{ match: (c) => c.call.name === 'delete', zone: 'restricted', verdict: 'deny' }],
+ * 	fallback: { zone: 'default', verdict: 'allow' },
  * })
  * authority.evaluate({ call: { id: '1', name: 'delete', arguments: {} } }) // { zone: 'restricted', verdict: 'deny' }
  * authority.evaluate({ call: { id: '2', name: 'add', arguments: {} } }) // { zone: 'default', verdict: 'allow' }
@@ -2168,7 +2259,7 @@ export declare function attachUserImages(conversation: readonly Message[], paylo
  */
 export declare class Authority implements AuthorityInterface {
     #private;
-    constructor(options?: AuthorityOptions);
+    constructor(options: AuthorityOptions);
     evaluate(context: AuthorityContext): AuthorityDecision;
     ask(context: AuthorityContext, decision: AuthorityDecision, signal: AbortSignal): Promise<boolean>;
 }
@@ -2227,7 +2318,7 @@ export declare type AuthorityHandler = (context: AuthorityContext, decision: Aut
 export declare interface AuthorityInterface {
     /**
      * Evaluates one tool call against the ordered rules — returns the first matching rule's
-     * verdict, which allows when the rule names none, or the fallback when none match.
+     * verdict, or the fallback when none match.
      *
      * @param context - The call under consideration (see {@link AuthorityContext})
      * @returns The first matching rule's verdict, or the fallback when none match
@@ -2256,16 +2347,14 @@ export declare interface AuthorityNote {
  *
  * @remarks
  * `rules` are evaluated in order, first match wins (see {@link AuthorityRule}).
- * `fallback` is the {@link AuthorityDecision} returned when no rule matches.
- * Default: `{ zone: DEFAULT_AUTHORITY_ZONE, verdict: 'allow' }` (allow-unmatched — a
- * rules list of denials acts as a denylist). Set `fallback` to a `verdict: 'deny'`
- * decision to flip the gate to deny-by-default (an allowlist — only matched rules
- * that allow get through). `ask` is the {@link AuthorityHandler} that answers each `ask`
- * verdict; absent, every ask is refused as unanswered.
+ * `fallback` is the {@link AuthorityDecision} returned when no rule matches, and it is required:
+ * a `verdict: 'deny'` fallback makes an allowlist (only matched rules that allow get through), and a
+ * `verdict: 'allow'` fallback makes a denylist. `ask` is the {@link AuthorityHandler} that answers
+ * each `ask` verdict; absent, every ask is refused as unanswered.
  */
 export declare interface AuthorityOptions {
     readonly rules?: readonly AuthorityRule[];
-    readonly fallback?: AuthorityDecision;
+    readonly fallback: AuthorityDecision;
     readonly ask?: AuthorityHandler;
 }
 
@@ -2274,13 +2363,14 @@ export declare interface AuthorityOptions {
  *
  * @remarks
  * The first rule whose `match` returns true decides; if none match, the authority's
- * `fallback` decides. A matched rule with no `verdict` allows. `zone` classifies the matched
- * call; `reason` is the optional explanation carried into the {@link AuthorityDecision}.
+ * `fallback` decides. `zone` classifies the matched call; `verdict` is required, and an
+ * `Authority` refuses a rule with none at construction; `reason` is the optional explanation
+ * carried into the {@link AuthorityDecision}.
  */
 export declare interface AuthorityRule {
     readonly match: (context: AuthorityContext) => boolean;
     readonly zone: string;
-    readonly verdict?: AuthorityVerdict;
+    readonly verdict: AuthorityVerdict;
     readonly reason?: string;
 }
 
@@ -2368,6 +2458,17 @@ export declare function buildLedgerCut(steps: ReadonlyArray<LedgerLine | string>
  */
 export declare function buildLedgerIndex(registry: LedgerRegistry): LedgerIndex;
 
+/**
+ * Encodes a sentence's record placement without comparing rendered text.
+ * @param line - The record key, title, source, and zero-based sentence index
+ * @returns The serialized placement identity
+ * @example
+ * ```ts
+ * buildLedgerLineKey({ key: 'rules', title: 'Rules', source: 'one', sentence: 0 })
+ * ```
+ */
+export declare function buildLedgerLineKey(line: Pick<LedgerOccurrence, 'key' | 'title' | 'source' | 'sentence'>): string;
+
 /**
  * Derives complete source identities, first occurrences, and local references from the actual lines of the records.
  * @param messages - Original messages whose indexed sentences establish completeness
@@ -2484,17 +2585,17 @@ export declare function buildRecapMessage(section: Section): Message;
  * Projects the owner records and the rules record from a conversation's messages.
  *
  * @remarks
- * Each line is a sentence of a live message, verbatim except that a sentence that opens with a pronoun opens with its party and a colon. A message is live when it is a user message,
- * or a tool message whose finding is the last finding of its call, and the input neither excludes it nor
- * files it quiet or replaced. A finding with an undefined `result` still replaces the earlier
- * finding of the same call, so the earlier result leaves every record.
+ * Each line is a sentence of a live message, verbatim except that a sentence that opens with a
+ * pronoun opens with its party and a colon. {@link collectLive} retains user messages and the
+ * earliest finding in each call identity's last run of identical text, subject to exclusions,
+ * quiet classification, and supersessions. An undefined result still replaces the earlier finding.
  *
  * A live message joins the owner records its entities name, directly or through a linked lookup
  * argument. A message that names no owner joins where its earlier side of an amendment pair joins,
  * or on the rules record when it is filed as a rule or a correction, and is an orphan otherwise.
  *
- * Every live sentence is retained. Accepted direct edges are listed in `amendments`. An amending message
- * that is itself superseded retains its accepted edge without restoring its text.
+ * Every live sentence is retained. Accepted edges are listed in `amendments`. An amender that is
+ * superseded points to its newest live successor, or retains its endpoint when none exists.
  *
  * A sentence that opens with a pronoun takes the party named in the sentence before it. The reading
  * trusts capitals, so a capitalized word that is no person, such as a carrier named mid-sentence,
@@ -2740,19 +2841,19 @@ export declare class Classifier implements ClassifierInterface {
      * Asks the judge every question the filing still lacks, in the measured order.
      * @param requests - The request ids, which skip category questions and receive only enabled request-topic questions
      * @param signal - The caller's signal; an abort returns a fault with completed judgments and usage
-     * @returns The judgment keys, summed usage, and one attempt per logical question, in asking order; a throw from the assign or entities handler, a scheduler rejection, or a caller abort returns the partial result with `fault`; a judge rejection under a live signal leaves that question undecided and sets no `fault`
+     * @returns The judgment keys, summed usage, and one attempt per logical question, in asking order; a throw from the assign or entities handler, a scheduler rejection, or a caller abort returns the partial result with `fault`; a judge rejection under a live signal leaves that question undecided and sets `failure`
      */
     classify(requests: ReadonlySet<string>, signal: AbortSignal): Promise<ClassifierResult>;
     /**
      * Reads the category a message is filed under.
      * @param id - The message id
-     * @returns The assigned category, the recorded category at the cutoff, or `undefined`
+     * @returns The assigned category, the recorded category at the cutoff, or `undefined`; a quiet winner suppressed by the user literal floor remains undecided
      */
     category(id: string): LedgerCategory | undefined;
     /**
      * Reports whether a message files under a quiet category.
      * @param id - The message id
-     * @returns True if the assigned or recorded category is quiet; false otherwise.
+     * @returns True if the assigned category is quiet or the recorded quiet weight reaches the cutoff, except for a user message carrying an id or number; false otherwise
      */
     quiet(id: string): boolean;
     /**
@@ -2805,18 +2906,18 @@ export declare interface ClassifierInterface {
      *
      * @param requests - The request ids, which skip category questions and receive only enabled request-topic questions
      * @param signal - The signal that aborts the questions; completed judgments stay recorded
-     * @returns The judgment keys, usage spent, and one attempt per logical question; a throw from the assign or entities handler, a scheduler rejection, or a caller abort returns the partial result with `fault`; a judge rejection under a live signal leaves that question undecided and sets no `fault`
+     * @returns The judgment keys, usage spent, and one attempt per logical question; a throw from the assign or entities handler, a scheduler rejection, or a caller abort returns the partial result with `fault`; a judge rejection under a live signal leaves that question undecided and sets `failure`
      */
     classify(requests: ReadonlySet<string>, signal: AbortSignal): Promise<ClassifierResult>;
     /**
-     * Returns the category a message is filed under, or undefined when no category reaches its cutoff.
+     * Returns the assigned or recorded category, or undefined when no category reaches its cutoff or the user literal floor suppresses a quiet winner.
      *
      * @param id - The id of the message
      * @returns The category, or undefined
      */
     category(id: string): LedgerCategory | undefined;
     /**
-     * Returns true if the message is filed as quiet; false otherwise.
+     * Returns true for a quiet assignment or a recorded quiet weight at the cutoff, except for a user message carrying an id or number; false otherwise.
      *
      * @param id - The id of the message
      * @returns True if the message is quiet; false otherwise.
@@ -2861,6 +2962,8 @@ export declare interface ClassifierInterface {
  * no scheduler, the call takes no host turn and reads no added clock.
  */
 export declare interface ClassifierOptions {
+    /** Sets what a refused question or a deterministic judge failure leaves behind. Default `true`: nothing, so the next call asks again. `false` holds the question, so no later call asks it. */
+    readonly strict?: boolean;
     readonly conversation: ConversationInterface;
     readonly judge: JudgeInterface;
     readonly questions: LedgerQuestion;
@@ -2877,7 +2980,7 @@ export declare interface ClassifierOptions {
  *
  * @remarks
  * `cached` means the conversation already held a matching judgment, so the classifier did not call the judgment manager.
- * `skipped` means the classifier held the question, after a deterministic failure or because a message it names left the conversation, and did not call the judgment manager.
+ * `skipped` means the classifier held the question, after a deterministic failure under `strict: false` or because a message it names left the conversation, and did not call the judgment manager.
  * `resolved` means the judgment manager's resolve call fulfilled. `failed` means it rejected while the caller's signal was live.
  * `aborted` means it rejected with a `JudgeAbortError` or after the caller's signal aborted.
  */
@@ -2899,6 +3002,8 @@ export declare interface ClassifierResult {
     readonly attempts: readonly ClassifierAttempt[];
     /** Holds the error when an assign or entities handler throw, a scheduler rejection, or a caller abort interrupts classification; judgments and usage retain the partial result. A judge rejection under a live signal sets no fault. */
     readonly fault?: Error;
+    /** Holds the first judge rejection of this call under a live signal: that question stays undecided and the filing goes on, so the result is whole but for it. A question held from an earlier call reports nothing. */
+    readonly failure?: Error;
 }
 
 /**
@@ -2915,17 +3020,18 @@ export declare interface CodedErrorOptions {
 }
 
 /**
- * Collects accepted direct amendments of live messages.
+ * Collects accepted amendments of live messages, following superseded amenders to live successors.
  *
  * @remarks
  * An accepted edge relates an earlier live message to an amender without claiming which sentences
- * changed. An amender takes effect while live and retains its edge after another message supersedes
- * it, without restoring the superseded text. An excluded or quiet user or tool message has no effect.
+ * changed. A superseded amender points to its newest reachable live successor in conversation order,
+ * with cycles guarded and duplicate endpoints removed. With no live successor, its endpoint stays.
+ * This never restores superseded text. An excluded or quiet user or tool message has no effect.
  *
  * @param input - The exclusions and classification to read
  * @param byId - The messages by id
  * @param live - The live message ids from {@link collectLive}
- * @returns The distinct accepted direct edges in conversation order
+ * @returns The distinct accepted edges in conversation order
  *
  * @example
  * ```ts
@@ -2973,15 +3079,54 @@ export declare function collectExchanges(messages: readonly Message[]): Readonly
  */
 export declare function collectImageData(files: readonly FileInterface[]): readonly string[];
 
+/**
+ * Captures source bytes and direct amendment edges for a held window.
+ * @param messages - Current stored messages
+ * @param sources - Requests, replies, and record sources the window holds
+ * @param amendments - Accepted direct amendment edges from the current projection
+ * @returns Source and edge identities for stale detection
+ * @example
+ * ```ts
+ * collectLedgerEvidence([], new Set(), []).messages.size // 0
+ * ```
+ */
+export declare function collectLedgerEvidence(messages: readonly Message[], sources: ReadonlySet<string>, amendments: readonly LedgerAmendment[]): LedgerEvidence;
+
+/**
+ * Collects the record's sentence receipts not already held by a window.
+ * @param record - The selected record with its original sentence identities
+ * @param held - Placement identities already rendered in the window
+ * @returns The remaining sentences with their record placement
+ * @example
+ * ```ts
+ * collectLedgerLines({ key: 'rules', title: 'Rules', members: [], lines: [] }, new Set()) // []
+ * ```
+ */
+export declare function collectLedgerLines(record: LedgerRecord, held: ReadonlySet<string>): readonly LedgerOccurrence[];
+
+/**
+ * Selects each marked request's unambiguous final call-free reply.
+ * @param messages - Stored conversation messages in order
+ * @param requests - Marked request ids delimiting reply intervals
+ * @param notes - Ledger notes that separate answer passes
+ * @returns Eligible final replies keyed by request id
+ * @example
+ * ```ts
+ * collectLedgerReplies([], new Set(), new Set()).size // 0
+ * ```
+ */
+export declare function collectLedgerReplies(messages: readonly Message[], requests: ReadonlySet<string>, notes: ReadonlySet<string>): ReadonlyMap<string, Message>;
+
 /**
  * Collects the ids of the live messages in conversation order.
  *
  * @remarks
- * A message is live when it is a user message, or a tool message whose finding is the last finding of its
- * call, and the input neither excludes it nor files it quiet or replaced. A finding replaces any
- * earlier finding of the same call, an empty one included, so an empty lookup leaves the earlier
- * result out of every record. A finding with no canonical identity stays live as its own source
- * and participates in no replacement.
+ * A message is live when it is a user message or the first unsuperseded finding in its canonical
+ * call identity's last run of identical text, and the input neither excludes it nor files it quiet
+ * or superseded. When the whole run is superseded, its first finding reaches that final filter.
+ * Different text or an undefined result replaces the earlier run, so an empty lookup leaves the
+ * earlier result out of every record. A thrown lookup leaves the earlier result live. A finding
+ * with no canonical identity participates in no replacement.
  *
  * @param input - The messages, findings, and classification to read
  * @returns The live message ids
@@ -3021,6 +3166,22 @@ export declare function collectNames(text: string): readonly string[];
  */
 export declare function collectProjectionIds(projection: LedgerProjection): ReadonlySet<string>;
 
+/**
+ * Collects stored messages eligible to open the recall offer.
+ * @remarks
+ * Notes and findings without a result do not open the offer. User statements, including quiet
+ * statements available through recall's word route, can open it; this helper does not filter results.
+ * @param input - The messages, findings, and classification
+ * @param requests - The marked request ids
+ * @param notes - The annotation ids to exclude
+ * @returns User statements, lookup findings with results, marked requests, and nonblank call-free replies
+ * @example
+ * ```ts
+ * collectRecallMessages(input, new Set(), new Set()) // eligible stored messages
+ * ```
+ */
+export declare function collectRecallMessages(input: LedgerProjectionInput, requests: ReadonlySet<string>, notes: ReadonlySet<string>): readonly Message[];
+
 /**
  * Collects the ids and the owner names the lookup findings named.
  *
@@ -3115,18 +3276,21 @@ export declare function computeThinking(message: Pick<Message, 'thinking' | 'con
 
 /**
  * Reports a context snapshot that `isMemoSnapshot` refuses, thrown by the construction of a
- * {@link import('./memos/MemoManager.js').MemoManager} before it seats any state, carrying the
- * machine-readable `code` `'SNAPSHOT'`.
+ * {@link import('./memos/MemoManager.js').MemoManager} before it seats any state or by a memo store,
+ * or image files a build has no user turn to carry, carrying the machine-readable `code`
+ * `'SNAPSHOT' | 'IMAGES'`.
  *
  * @remarks
  * A `snapshot` option crosses a foreign boundary (a client, a store, a file), so the manager copies
  * it through JSON and checks the copy: a value JSON cannot carry, a revision missing a field, a
  * non-finite `time`, a sparse `memos` array, a non-string `id`, or a non-array `memos` is a
- * programmer error and throws this with `'SNAPSHOT'`. Narrow a caught value with
- * {@link isContextError} and branch on `error.code`.
+ * programmer error and throws this with `'SNAPSHOT'`, its `context` holding the `faults`. A build
+ * over a conversation that holds turns and no user turn, with image files in the active workspace,
+ * throws `'IMAGES'` rather than dropping them. Narrow a caught value with {@link isContextError} and
+ * branch on `error.code`.
  */
 export declare class ContextError extends Error {
-    /** Names the machine-readable condition — `'SNAPSHOT'`: a snapshot option that is not a memo snapshot. */
+    /** Names the machine-readable condition — `'SNAPSHOT'`: a snapshot that is not a memo snapshot; `'IMAGES'`: image files with no user turn to carry them. */
     readonly code: ContextErrorCode;
     /** Holds the values that locate the failure, or `undefined` when none were supplied. */
     readonly context: Readonly<Record<string, unknown>> | undefined;
@@ -3146,7 +3310,7 @@ export declare class ContextError extends Error {
  * @remarks
  * `'SNAPSHOT'`: a `snapshot` option that `isMemoSnapshot` refuses after it is copied through JSON.
  */
-export declare type ContextErrorCode = 'SNAPSHOT';
+export declare type ContextErrorCode = 'SNAPSHOT' | 'IMAGES';
 
 /**
  * Overrides one context section's format — an `open` / `render` / `close` trio
@@ -3305,12 +3469,12 @@ export declare const CONVERSATION_ROLES: readonly ["user", "assistant", "tool"];
 
 /**
  * Reports a conversation with no {@link ConversationSummaryHandler} to fold its messages with, a
- * `sections` cap below `1`, a `keep` that is not a nonnegative safe integer, a summarizer digest
+ * `sections` cap that is not a positive safe integer, a `keep` that is not a nonnegative safe integer, a summarizer digest
  * whose trimmed text is empty, a judgment or judge request that JSON cannot carry, a stored or
  * selected message whose role is not a conversation role, or a malformed snapshot — thrown by the
  * `compact()` and `add` methods of a {@link ConversationInterface}, its construction, or its
  * judgment store, or returned as the `fault` of an agent selection, carrying the machine-readable
- * `code` `'SUMMARIZER' | 'SECTIONS' | 'JUDGMENT' | 'KEEP' | 'SUMMARY' | 'ROLE' | 'SNAPSHOT'`.
+ * `code` `'SUMMARIZER' | 'SECTIONS' | 'JUDGMENT' | 'KEEP' | 'SUMMARY' | 'ROLE' | 'MESSAGE' | 'SNAPSHOT' | 'ID'`.
  *
  * @remarks
  * Compaction requires a summarizer (it digests the folded slice into a section summary); a
@@ -3318,7 +3482,7 @@ export declare const CONVERSATION_ROLES: readonly ["user", "assistant", "tool"];
  * is a programmer error and throws this with `'SUMMARIZER'`.
  * A `sections` cap (on {@link import('./types.js').ConversationOptions} /
  * {@link import('./types.js').ConversationManagerOptions} /
- * {@link import('./types.js').CompactOptions}) must be `>= 1`, and cannot combine with
+ * {@link import('./types.js').CompactOptions}) must be a positive safe integer, and cannot combine with
  * `cumulative` — either is a programmer error and throws this with `'SECTIONS'`. A `keep` on the same options must be a nonnegative
  * safe integer — any other value is a programmer error and throws this with `'KEEP'`. A judgment
  * record or a judge request that JSON cannot carry, or whose copy fails its guard, is a
@@ -3326,13 +3490,16 @@ export declare const CONVERSATION_ROLES: readonly ["user", "assistant", "tool"];
  * where one exists. A summarizer digest whose trimmed text is empty rejects the `compact()` with
  * `'SUMMARY'`. A stored message plays a `ConversationRole`: `add` refuses any other role with
  * `'ROLE'` before it stores any message of the batch, a hydrating snapshot that holds one throws
- * `'ROLE'`, and an agent's selection that holds one becomes a `'ROLE'` fault. A hydrating snapshot
- * that fails `isConversationSnapshot` or repeats an id throws `'SNAPSHOT'`; a judgment the guard
- * admits but JSON cannot carry still throws `'JUDGMENT'`. Narrow a caught value with
+ * `'ROLE'`, and an agent's selection that holds one becomes a `'ROLE'` fault. `add` refuses an input
+ * whose other members fail `isMessageInput` with `'MESSAGE'`, its `context` holding the `faults`,
+ * before it stores any message of the batch. A hydrating snapshot that fails
+ * `isConversationSnapshot` or repeats an id, and a store row or written snapshot that does, throw
+ * `'SNAPSHOT'`; a judgment the guard admits but JSON cannot carry still throws `'JUDGMENT'`. A
+ * manager's `add` of an id it already holds throws `'ID'`. Narrow a caught value with
  * {@link isConversationError} and branch on `error.code`.
  */
 export declare class ConversationError extends Error {
-    /** Names the machine-readable condition — `'SUMMARIZER'`: a `compact()` with no summarizer; `'SECTIONS'`: a sub-1 `sections` cap, or a cap combined with `cumulative`; `'JUDGMENT'`: a judgment or judge request that is not JSON; `'KEEP'`: a `keep` that is not a nonnegative safe integer; `'SUMMARY'`: a summarizer digest whose trimmed text is empty; `'ROLE'`: a stored or selected message whose role is not a `ConversationRole`; `'SNAPSHOT'`: a snapshot that fails `isConversationSnapshot` or repeats an id. */
+    /** Names the machine-readable condition — `'SUMMARIZER'`: a `compact()` with no summarizer; `'SECTIONS'`: a `sections` cap that is not a positive safe integer, or a cap combined with `cumulative`; `'JUDGMENT'`: a judgment or judge request that is not JSON; `'KEEP'`: a `keep` that is not a nonnegative safe integer; `'SUMMARY'`: a summarizer digest whose trimmed text is empty; `'ROLE'`: a stored or selected message whose role is not a `ConversationRole`; `'MESSAGE'`: a message input whose other members fail `isMessageInput`; `'SNAPSHOT'`: a snapshot that fails `isConversationSnapshot` or repeats an id; `'ID'`: a manager's `add` of an id it already holds. */
     readonly code: ConversationErrorCode;
     /** Holds the values that locate the failure, such as the `question` id of a malformed question, or `undefined` when none were supplied. */
     readonly context: Readonly<Record<string, unknown>> | undefined;
@@ -3359,7 +3526,7 @@ export declare class ConversationError extends Error {
  * `'SNAPSHOT'`: a snapshot that fails `isConversationSnapshot` or repeats an id; a judgment the
  * guard admits but JSON cannot carry still raises `'JUDGMENT'`.
  */
-export declare type ConversationErrorCode = 'SUMMARIZER' | 'SECTIONS' | 'JUDGMENT' | 'KEEP' | 'SUMMARY' | 'ROLE' | 'SNAPSHOT';
+export declare type ConversationErrorCode = 'SUMMARIZER' | 'SECTIONS' | 'JUDGMENT' | 'KEEP' | 'SUMMARY' | 'ROLE' | 'MESSAGE' | 'SNAPSHOT' | 'ID';
 
 /**
  * Maps the push observation surface of a {@link ConversationInterface} — the compaction
@@ -3678,7 +3845,8 @@ export declare interface ConversationInterface {
  * - **Registry.** Conversations live in an insertion-ordered `Map` keyed by `id`. `add(input?)`
  *   mints a {@link Conversation} (its `id` from `input` or `crypto.randomUUID()`), flowing the
  *   default `#summarize` / `#keep` of the manager in unless the `input` overrides them, and stores
- *   it (an already-present `id` overwrites — last write wins). `count` is the map size,
+ *   it (an already-present `id` throws a `ConversationError` coded `'ID'`, because replacing a live
+ *   conversation would orphan its turns). `count` is the map size,
  *   `conversation(id)` looks one up, `conversations()` lists them in insertion order.
  * - **Active pointer.** `active` is the active conversation (the conversation an agent run binds
  *   when it names none), `undefined` until the first `add` (which auto-activates it — a registry
@@ -3728,7 +3896,7 @@ export declare class ConversationManager implements ConversationManagerInterface
  * - **Registry.** `count` is how many are stored. `add(input?)` mints a
  *   {@link ConversationInterface} (its `id` from `input` or a random UUID), flowing the
  *   default `summarize` / `keep` of the manager in unless the `input` overrides them; `add` of an
- *   already-present `id` overwrites it (last write wins). `conversation(id)` looks one up
+ *   already-present `id` throws (code `'ID'`). `conversation(id)` looks one up
  *   (`undefined` when absent); `conversations()` lists them in insertion order.
  * - **Active pointer.** `active` is the active conversation (the conversation an agent run binds
  *   when it names none, and the one the context renders with no selection), `undefined` until the
@@ -3770,11 +3938,11 @@ export declare interface ConversationManagerInterface {
     /**
      * Mints a conversation, taking its `id` from the input or a fresh UUID and flowing the
      * default `summarize` / `keep` of the manager in unless the input overrides them —
-     * auto-activates the first, and an already-present `id` overwrites, last write wins.
+     * auto-activates the first, and an already-present `id` throws.
      *
      * @param input - Optional {@link ConversationInput} overrides
      * @returns The created conversation
-     * @throws ConversationError Thrown when `snapshot` is malformed or repeats an id (code `'SNAPSHOT'`) or holds a message whose role is not a `ConversationRole` (code `'ROLE'`); nothing registers and `active` is unchanged
+     * @throws ConversationError Thrown when the `id` is already live (code `'ID'`), or when `snapshot` is malformed or repeats an id (code `'SNAPSHOT'`) or holds a message whose role is not a `ConversationRole` (code `'ROLE'`); nothing registers and `active` is unchanged
      */
     add(input?: ConversationInput): ConversationInterface;
     /**
@@ -3977,8 +4145,8 @@ export declare type ConversationRole = (typeof CONVERSATION_ROLES)[number];
  * {@link ConversationManagerInterface} hydrates a conversation from it through that seam (see
  * {@link ConversationManagerInterface.open}). It is narrowed back from an untrusted storage read by
  * {@link import('./validators.js').isConversationSnapshot} (the total boundary guard), which
- * admits unknown members: a 0.0.29 snapshot that carries a conversation `summary` passes and
- * hydrates without it.
+ * is exact: an unknown member refuses, so a 0.0.29 snapshot that carries a conversation `summary`
+ * throws until its row is rewritten without the key.
  */
 export declare interface ConversationSnapshot {
     readonly id: string;
@@ -3990,6 +4158,158 @@ export declare interface ConversationSnapshot {
     readonly messages: readonly Message[];
 }
 
+/** Reads the faults of a refused conversation snapshot. */
+export declare const conversationSnapshotContract: ContractInterface<Readonly<{
+id: string;
+sections: readonly Readonly<{
+id: string;
+summary: string;
+messages: readonly Readonly<{
+id: string;
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+} & {}>[];
+messages: readonly Readonly<{
+id: string;
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+} & {
+judgments?: readonly (Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+answer: Readonly<{
+form: "choice";
+probabilities: {
+readonly [k: string]: number;
+};
+} & {}> | Readonly<{
+form: "score";
+probabilities: readonly number[];
+} & {}> | Readonly<{
+form: "noul";
+noul: number;
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}> | Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+refusal: Readonly<{
+missing: readonly string[];
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}>)[];
+}>>;
+
 /**
  * Represents one row of the table a {@link
  * import('./stores/DatabaseConversationStore.js').DatabaseConversationStore} persists
@@ -4014,6 +4334,116 @@ export declare interface ConversationSnapshotRow {
     readonly snapshot: unknown;
 }
 
+/**
+ * Describes a conversation snapshot exactly: an unknown key refuses, so a key a later version adds never
+ * reads as absent.
+ *
+ * @remarks
+ * `isConversationSnapshot` is the door a hydrate and a store read, and this shape fills a refusal's
+ * faults. A lockstep test holds that `is` implies the guard, and on the snapshot fixtures the converse.
+ */
+export declare const conversationSnapshotShape: ObjectShape<    {
+id: StringShape;
+sections: ArrayShape<ObjectShape<    {
+id: StringShape;
+summary: StringShape;
+messages: ArrayShape<ObjectShape<    {
+id: StringShape;
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+messages: ArrayShape<ObjectShape<    {
+id: StringShape;
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+judgments: OptionalShape<ArrayShape<UnionShape<readonly [ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+answer: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+probabilities: ObjectShape<Record<never, never>, NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+probabilities: ArrayShape<NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+noul: NumberShape;
+}, boolean | ContractShape>]>;
+}, boolean | ContractShape>, ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+refusal: ObjectShape<    {
+missing: ArrayShape<StringShape>;
+}, boolean | ContractShape>;
+}, boolean | ContractShape>]>>>;
+}, boolean | ContractShape>;
+
 /**
  * Persists a {@link ConversationSnapshot} durably — the async `get` / `set` / `delete` primitives,
  * keyed by a conversation id and holding no expiry, the exact analogue of {@link
@@ -4251,16 +4681,29 @@ export declare function createAgentQueue(options: AgentQueueOptions): QueueInter
  *
  * @example
  * ```ts
- * import { createAgentRegistry } from '@orkestrel/agent'
+ * import { createAgentRegistry, createAuthority } from '@orkestrel/agent'
  * import type { ProviderInterface } from '@orkestrel/agent'
+ * import { numberShape, objectShape } from '@orkestrel/contract'
  * import { createTool } from '@orkestrel/tool'
  *
  * declare const provider: ProviderInterface // any concrete implementation supplied by the host app
  * const registry = createAgentRegistry({
  * 	providers: { main: provider },
- * 	tools: { add: createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }) },
+ * 	tools: {
+ * 		add: createTool({
+ * 			name: 'add',
+ * 			contract: objectShape({ x: numberShape(), y: numberShape() }),
+ * 			execute: (a) => Number(a.x) + Number(a.y),
+ * 		}),
+ * 	},
+ * 	authorities: { open: createAuthority({ fallback: { zone: 'default', verdict: 'allow' } }) },
+ * })
+ * const agent = registry.build({
+ * 	provider: 'main',
+ * 	messages: [{ role: 'user', content: 'Hi.' }],
+ * 	tools: ['add'],
+ * 	authority: 'open',
  * })
- * const agent = registry.build({ provider: 'main', messages: [{ role: 'user', content: 'Hi.' }] })
  * ```
  */
 export declare function createAgentRegistry(options: AgentRegistryOptions): AgentRegistryInterface;
@@ -4319,7 +4762,11 @@ export declare function createAgentRunner(options: AgentRunnerOptions): RunnerIn
  * @example
  * ```ts
  * const approver = createApprover()
- * const authority = createAuthority({ rules, ask: approver.ask })
+ * const authority = createAuthority({
+ * 	rules,
+ * 	fallback: { zone: 'default', verdict: 'deny' },
+ * 	ask: approver.ask,
+ * })
  * const agent = createAgent(provider, { tools, authority })
  * const stream = agent.stream({ prompt: { content: 'Tidy the notes.' } })
  * for await (const frame of agentStreamToFrames(stream, approver)) {
@@ -4332,20 +4779,20 @@ export declare function createApprover(): ApproverInterface;
 /**
  * Creates a policy gate — an {@link AuthorityInterface} the agent loop consults before
  * each tool call runs, evaluating the ordered rules first-match-wins and falling back
- * to the configured default when none match.
+ * to the required `fallback` when none match.
  *
  * @remarks
- * `rules` are evaluated in order — the first whose `match` is true decides (a matched
- * rule with no `verdict` allows). When no rule matches, the `fallback` decides. Default:
- * `{ zone: DEFAULT_AUTHORITY_ZONE, verdict: 'allow' }` (allow-unmatched — a rules list of
- * denials acts as a denylist). Pass a `verdict: 'deny'` `fallback` to flip the gate to
- * deny-by-default (an allowlist). `ask` answers each `ask` verdict; with none, every ask is
- * refused as unanswered. Wire the result into `createAgent` through `AgentOptions.authority`:
- * a denied call is fed back to the model as a denial `ToolResult` (not executed), so the model
- * can react. Synchronous — `evaluate` returns the verdict directly; only `ask` is async.
+ * `rules` are evaluated in order — the first whose `match` is true decides, and each rule names its
+ * `verdict`. When no rule matches, the `fallback` decides: a `verdict: 'deny'` fallback makes an
+ * allowlist, and a `verdict: 'allow'` fallback makes a denylist. `ask` answers each `ask` verdict;
+ * with none, every ask is refused as unanswered. Wire the result into `createAgent` through
+ * `AgentOptions.authority`: a denied call is fed back to the model as a denial `ToolResult` (not
+ * executed), so the model can react. Synchronous — `evaluate` returns the verdict directly; only
+ * `ask` is async.
  *
- * @param options - Optional `rules` (ordered), `fallback`, and `ask` (see {@link AuthorityOptions})
+ * @param options - The `fallback`, and optional `rules` (ordered) and `ask` (see {@link AuthorityOptions})
  * @returns A working {@link AuthorityInterface}
+ * @throws {AgentError} Thrown when the `fallback` is missing or malformed, or a rule has no valid `verdict` (code `'AUTHORITY'`)
  *
  * @example
  * ```ts
@@ -4354,11 +4801,12 @@ export declare function createApprover(): ApproverInterface;
  * // Deny the `delete` tool, allow everything else.
  * const authority = createAuthority({
  * 	rules: [{ match: (c) => c.call.name === 'delete', zone: 'restricted', verdict: 'deny' }],
+ * 	fallback: { zone: 'default', verdict: 'allow' },
  * })
  * const agent = createAgent(provider, { tools, authority })
  * ```
  */
-export declare function createAuthority(options?: AuthorityOptions): AuthorityInterface;
+export declare function createAuthority(options: AuthorityOptions): AuthorityInterface;
 
 /**
  * Creates an empty unbounded async channel — a {@link ChannelInterface} a producer writes
@@ -4456,7 +4904,7 @@ export declare function createConversation(options?: ConversationOptions): Conve
  * @remarks
  * Starts empty; `add(input?)` mints a {@link ConversationInterface} (its `id` from the input
  * or a random UUID), flowing the manager's default `summarize` / `keep` in unless the input
- * overrides them, and stores it (an already-present `id` overwrites — last write wins) — and
+ * overrides them, and stores it (an already-present `id` throws, code `'ID'`) — and
  * auto-activates the first one (a registry with conversations always has one `active`); a later
  * `add` leaves `active` unchanged. `switch(id)` re-points `active` (an unknown `id` returns
  * `undefined`, leaving `active` unchanged — lenient, never throws); `conversation(id)` /
@@ -4903,10 +5351,12 @@ export declare function createThinkSplitter(): ThinkSplitterInterface;
  * @remarks
  * The cut keeps at least one entry. When it leaves entries out, its last line reads
  * `N older items not shown; name a narrower topic to narrow the recall`, which
- * {@link matchesCutLine} recognizes.
+ * {@link matchesCutLine} recognizes. Pass `more` when the entries aren't in age order, so the line
+ * doesn't claim an omitted entry is older than a kept one.
  *
  * @param entries - The entries in the order they are kept
  * @param room - The estimate units the joined entries can take
+ * @param kind - What the cut line calls an omitted entry. Default: `older`
  * @returns The kept entries followed by the cut line when any were left out, joined by newlines
  *
  * @example
@@ -4914,7 +5364,7 @@ export declare function createThinkSplitter(): ThinkSplitterInterface;
  * cutListing(['first entry', 'second entry'], 1) // 'first entry\n1 older item not shown; name a narrower topic to narrow the recall'
  * ```
  */
-export declare function cutListing(entries: readonly string[], room: number): string;
+export declare function cutListing(entries: readonly string[], room: number, kind?: 'older' | 'more'): string;
 
 /**
  * Backs a {@link ConversationStoreInterface} with one table of the `databases` layer — a
@@ -4946,8 +5396,9 @@ export declare function cutListing(entries: readonly string[], room: number): st
  *   the row `{ id: snapshot.id, snapshot }`.
  * - **`get(id)` resolves the stored snapshot for an id**, narrowing the opaque JSON column back to
  *   a {@link ConversationSnapshot} ({@link import('../validators.js').isConversationSnapshot} — the
- *   total guard for an untrusted storage read), or `undefined` if none is stored, the blob is
- *   malformed, or the blob's own `id` is not the requested one.
+ *   total guard for an untrusted storage read), or `undefined` only when no row is stored. A row whose
+ *   blob is malformed or names another id throws a `ConversationError` coded `'SNAPSHOT'`, so `open`
+ *   and `create` stop rather than overwrite it, and `delete` still removes it.
  * - **`delete(id)` drops a snapshot by id**; an absent id is a no-op (no throw).
  *
  * Unlike a session store there is no idle-TTL / eviction — a persisted conversation lives until an
@@ -4984,12 +5435,12 @@ export declare class DatabaseConversationStore implements ConversationStoreInter
      *
      * @remarks
      * The column is an untrusted storage read, so a blob that fails
-     * {@link import('../validators.js').isConversationSnapshot}, or whose own `id` is not `id`,
-     * resolves `undefined` rather than a conversation under the wrong key.
+     * {@link import('../validators.js').isConversationSnapshot}, or whose own `id` is not `id`, throws
+     * rather than reading as absent, which would let a later `set` overwrite it.
      *
      * @param id - The conversation id to resolve (the row key)
-     * @returns The persisted snapshot, or `undefined` when no row is stored, the blob is malformed,
-     * or the blob names another id
+     * @returns The persisted snapshot, or `undefined` when no row is stored
+     * @throws {ConversationError} Thrown when the row's blob is malformed or names another id (code `'SNAPSHOT'`), with the faults under `context.faults`
      */
     get(id: string): Promise<ConversationSnapshot | undefined>;
     /**
@@ -4998,6 +5449,7 @@ export declare class DatabaseConversationStore implements ConversationStoreInter
      *
      * @param snapshot - The snapshot to store, keyed by its `id`
      * @returns A promise that resolves after the row is written
+     * @throws {ConversationError} Thrown before any write when the snapshot fails the guard `get` reads (code `'SNAPSHOT'`), so no row is written that `get` refuses
      */
     set(snapshot: ConversationSnapshot): Promise<void>;
     /**
@@ -5031,8 +5483,9 @@ export declare class DatabaseConversationStore implements ConversationStoreInter
  *   the row `{ id: snapshot.id, snapshot }`.
  * - **`get(id)` resolves the stored snapshot for an id**, narrowing the opaque JSON column back to
  *   a {@link MemoSnapshot} ({@link import('../validators.js').isMemoSnapshot} — the total guard for
- *   an untrusted storage read), or `undefined` if none is stored, the blob is malformed, or the
- *   blob's own `id` is not the requested one.
+ *   an untrusted storage read), or `undefined` only when no row is stored. A row whose blob is malformed
+ *   or names another id throws a `ContextError` coded `'SNAPSHOT'`, so a host never overwrites it
+ *   unawares, and `delete` still removes it.
  * - **`delete(id)` drops a snapshot by id**; an absent id is a no-op (no throw).
  *
  * @example
@@ -5063,12 +5516,12 @@ export declare class DatabaseMemoStore implements MemoStoreInterface {
      *
      * @remarks
      * The column is an untrusted storage read, so a blob that fails
-     * {@link import('../validators.js').isMemoSnapshot}, or whose own `id` is not `id`, resolves
-     * `undefined` rather than a memo set under the wrong key.
+     * {@link import('../validators.js').isMemoSnapshot}, or whose own `id` is not `id`, throws rather
+     * than reading as absent.
      *
      * @param id - The memo set id to resolve (the row key)
-     * @returns The stored snapshot, or `undefined` when no row is stored, the blob is malformed, or
-     * the blob names another id
+     * @returns The stored snapshot, or `undefined` when no row is stored
+     * @throws {ContextError} Thrown when the row's blob is malformed or names another id (code `'SNAPSHOT'`), with the faults under `context.faults`
      */
     get(id: string): Promise<MemoSnapshot | undefined>;
     /**
@@ -5077,6 +5530,7 @@ export declare class DatabaseMemoStore implements MemoStoreInterface {
      *
      * @param snapshot - The snapshot to store, keyed by its `id`
      * @returns A promise that resolves after the row is written
+     * @throws {ContextError} Thrown before any write when the snapshot fails the guard `get` reads (code `'SNAPSHOT'`), so no row is written that `get` refuses
      */
     set(snapshot: MemoSnapshot): Promise<void>;
     /**
@@ -5098,11 +5552,6 @@ export declare const DECISIVE_CATEGORIES: readonly LedgerCategory[];
  */
 export declare const DEFAULT_AGENT_LIMIT = 10;
 
-/**
- * Names the default zone for an unmatched tool call allowed by an authority.
- */
-export declare const DEFAULT_AUTHORITY_ZONE = "default";
-
 /**
  * Sets the default number of recent live messages the `compact()` method of a
  * {@link ConversationInterface} retains verbatim — `0`, so a manual `compact()` keeps no recent tail and folds every
@@ -5165,6 +5614,25 @@ export declare const DEFAULT_RELAY_LIMIT = 1048576;
  */
 export declare function denyCall(call: ToolCall, reason: string | undefined): ToolResult;
 
+/**
+ * Describes why a judge question refuses, in the text both of its doors throw.
+ *
+ * @remarks
+ * The rule travels in the text because the question shape cannot state it: a record has no minimum
+ * size, so a single-option choice refuses at the guard with no fault for the list to name.
+ *
+ * @param id - The question's id
+ * @param faults - What the question shape's audit found
+ * @param schema - The question shape's JSON Schema
+ * @returns The refusal text, with the fault list on the lines after it
+ * @example
+ * ```ts
+ * describeQuestionRefusal('team', [], judgeQuestionContract.schema)
+ * // 'question team is malformed; a choice names two or more criteria, a score two or more levels, and a noul only true and false'
+ * ```
+ */
+export declare function describeQuestionRefusal(id: string, faults: readonly AuditFault[], schema: JSONSchema): string;
+
 /**
  * Describes one relay refusal as the line its `422` response body carries.
  *
@@ -5186,11 +5654,44 @@ export declare function denyCall(call: ToolCall, reason: string | undefined): To
  */
 export declare function describeRelayRefusal(refusal: RelayRefusal): string;
 
+/**
+ * Describes a snapshot a store refuses, naming its id, the first fault, and what a host does about it.
+ *
+ * @remarks
+ * A store's row is the host's table, so the text tells the host to read the row itself and rewrite it,
+ * or to delete it, rather than reading a refused row as absent, which would let `open` overwrite it.
+ * The id and each fault segment are JSON-encoded and length-capped.
+ *
+ * @param noun - What the snapshot holds, such as `conversation`
+ * @param id - The id the row is keyed by
+ * @param faults - The faults of the snapshot's shape
+ * @returns The refusal's text
+ * @example
+ * ```ts
+ * describeSnapshotRefusal('conversation', 'c1', [{ reason: 'extra', path: ['summary'] }])
+ * // 'conversation "c1" holds a snapshot this version refuses (extra key "summary" at the root; ...'
+ * ```
+ */
+export declare function describeSnapshotRefusal(noun: string, id: unknown, faults: readonly AuditFault[]): string;
+
 /** Matches the logprob decoding failure `invalid or duplicate top logprob token`, which the ledger holds for the ledger's life. */
 export declare const DETERMINISTIC_JUDGE_ERROR: RegExp;
 
 /**
- * Estimates the context-token footprint of a batch of messages — each message's content plus
+ * Digests held messages, lookup call context, stored copies, and sentence receipts using canonical text.
+ * This non-cryptographic checksum detects host edits and makes no security claim.
+ * @param exchanges - The stored exchange entries
+ * @param messages - The conversation holding their messages
+ * @returns The hexadecimal checksum, or undefined when a required message is absent or canonical encoding fails
+ * @example
+ * ```ts
+ * digestLedgerWindow([], []) // a deterministic hexadecimal checksum
+ * ```
+ */
+export declare function digestLedgerWindow(exchanges: readonly LedgerExchangeSnapshot[], messages: readonly Message[]): string | undefined;
+
+/**
+ * Estimates the context-token footprint of a batch of messages — each message's content plus
  * {@link import('./constants.js').MESSAGE_TOKEN_OVERHEAD}, a tool-call JSON estimate, a thinking estimate, and
  * {@link import('./constants.js').IMAGE_TOKEN_ESTIMATE} for each attached image. The {@link estimateRequest} message term
  * for an agent's context budget (the
@@ -5249,8 +5750,8 @@ export declare function estimateRequest(request: ProviderRequest): number;
 
 /**
  * Estimates the context-token footprint of a string — the deterministic `ceil(length / 4)`
- * character heuristic {@link estimateMessages} sums over a conversation's messages (the default
- * context-budget estimator).
+ * character heuristic {@link import('./agents/helpers.js').estimateMessages} sums over a conversation's
+ * messages (the default context-budget estimator).
  *
  * @remarks
  * Approximates `ceil(length / 4)` (4 characters per token), so the same input always yields the same estimate (no model round-trip).
@@ -5455,8 +5956,9 @@ export declare function freezeJSON(value: unknown): unknown;
  * has left.
  *
  * @remarks
- * `observe` rescales from the first call of each finished request with the overhead cost taken out,
- * and keeps that request's calls for the marginal rate and the longest final completion for the reply
+ * `observe` rescales from the first call only when `spared` is absent, zero, or at least `overhead`,
+ * with `max(0, overhead - spared)` taken out. A partially spared call keeps the existing scale.
+ * It keeps that request's calls for the marginal rate and the longest final completion for the reply
  * reserve after subtracting its thinking. `overhead` never changes after construction.
  * {@link GaugeOptions} defines the measured use, reply reserve, and recall-room formulas.
  * {@link LedgerOptions} defines the ledger's plan budget and recall close rule.
@@ -5502,7 +6004,10 @@ export declare class Gauge implements GaugeInterface {
  * @remarks
  * `estimate` is the `estimateMessages` estimate of the call's messages. `prompt` and `completion`
  * are the tokens the provider reported, absent when it reported none. `tools` is the count of tool
- * definitions the call advertised.
+ * definitions the call advertised. `spared` is the tokens of definitions it did not advertise;
+ * estimated use subtracts it from overhead, floored at 0. Omission means 0. Observation rescales
+ * only with exact overhead: `spared` absent or zero retains all overhead, and `spared` at or above
+ * overhead retains none. A partially spared first call keeps the prior scale.
  * `thinking` estimates the completion tokens spent on thinking from its share of the generated
  * characters, rounded to the nearest integer and capped at `completion`. With replay `'none'`,
  * the measured call uses `prompt + completion - thinking`; other policies retain the whole
@@ -5510,6 +6015,8 @@ export declare class Gauge implements GaugeInterface {
  */
 export declare interface GaugeCall {
     readonly estimate: number;
+    /** Tokens spared by tool definitions this call did not advertise. Default: 0. */
+    readonly spared?: number;
     readonly prompt?: number;
     readonly completion?: number;
     readonly thinking?: number;
@@ -5580,7 +6087,8 @@ export declare interface GaugeInterface extends LedgerGauge {
  * nonnegative safe integer less than `capacity`; construction throws `LedgerError` with code
  * `'CAPACITY'` otherwise. `replay` names the thinking the next request carries. Default: `'none'`.
  * Measured use is `prompt + completion - (thinking ?? 0)` for `'none'`, and `prompt + completion`
- * otherwise; absent completion counts as 0. Without prompt usage, use is `overhead + scale * estimate`.
+ * otherwise; absent completion counts as 0. Without prompt usage, use is
+ * `max(0, overhead - (spared ?? 0)) + scale * estimate`.
  * Capacity left is `max(0, capacity - used)`. The reply reserve adds recall uniform at the marginal
  * rate to the largest observed reply's `completion - (thinking ?? 0)` for every policy.
  * Without a positive reply observation, it prices the longest reply text at that rate. Recall room is
@@ -5627,6 +6135,23 @@ export declare function handleAgentQueueJob(registry: AgentRegistryInterface, pa
  */
 export declare function hasCalls(message: Pick<Message, 'calls'>): boolean;
 
+/**
+ * Checks whether an eligible earlier message is absent from the prompt or incompletely covered.
+ * A successful finding is held when a finding with the same canonical identity and text is fully received.
+ * @param input - The messages, findings, and classification
+ * @param request - The current request id; only messages before it count
+ * @param requests - The marked request ids
+ * @param notes - The annotation ids to exclude
+ * @param messages - The seed tail and held exchange messages; lookup stubs retain their rendered text
+ * @param lines - The receipts held by the window and the request copy together
+ * @returns True if an eligible earlier message is absent or only partly covered; false otherwise
+ * @example
+ * ```ts
+ * hasHiddenRecall(input, request.id, requests, notes, tail, lines) // whether to offer recall
+ * ```
+ */
+export declare function hasHiddenRecall(input: LedgerProjectionInput, request: string, requests: ReadonlySet<string>, notes: ReadonlySet<string>, messages: readonly Message[], lines: readonly LedgerReceipt[]): boolean;
+
 /**
  * Identifies a lookup finding for projection by its tool name and normalized arguments.
  *
@@ -6028,6 +6553,20 @@ export declare function isAgentJobError(value: unknown): value is AgentJobError;
  */
 export declare function isAuthorityDecision(value: unknown): value is AuthorityDecision;
 
+/**
+ * Checks whether a value is an authority verdict: `allow`, `ask`, or `deny`.
+ *
+ * @param value - The unknown verdict candidate
+ * @returns True if the value names a verdict; false otherwise
+ *
+ * @example
+ * ```ts
+ * isAuthorityVerdict('ask') // true
+ * isAuthorityVerdict('maybe') // false
+ * ```
+ */
+export declare function isAuthorityVerdict(value: unknown): value is AuthorityVerdict;
+
 /**
  * Narrows an unknown caught value to a {@link ContextError} through its identity brand and declared members, so a
  * `catch` can branch on its `code`.
@@ -6097,12 +6636,12 @@ export declare function isConversationError(value: unknown): value is Conversati
  * valid {@link Message} ({@link isMessage}), and optional valid `judgments` — enough to safely
  * impose the
  * {@link ConversationSnapshot} type at a storage boundary without a cast. The structural twin of
- * {@link import('@orkestrel/workspace').isWorkspaceSnapshot}. Unknown members are admitted, so a
- * 0.0.29 snapshot that carries a conversation `summary` passes. A malformed blob (a non-record,
- * a missing / non-string `id`, a non-array `sections` / `messages`, or any malformed
- * element) resolves `false`, so a
+ * {@link import('@orkestrel/workspace').isWorkspaceSnapshot}. The guard is exact: an unknown member, a
+ * 0.0.35 snapshot's conversation `summary` included, and an own `undefined` `judgments` return
+ * `false`, as a malformed blob (a non-record, a missing / non-string `id`, a non-array `sections` /
+ * `messages`, or any malformed element) does, so a
  * {@link import('./stores/DatabaseConversationStore.js').DatabaseConversationStore}
- * read yields `undefined` rather than a broken conversation. The guard is structural: it admits a
+ * read refuses it rather than seating a broken conversation. The guard is structural: it admits a
  * stored `system` role and a repeated id, which `requireConversationSnapshot` and the
  * {@link import('./Conversation.js').Conversation} constructor then refuse as the stored-data
  * check a conversation runs at hydrate.
@@ -6144,14 +6683,37 @@ export declare function isFraction(value: unknown): value is number;
 export declare function isJudgeAbortError(value: unknown): value is JudgeAbortError;
 
 /**
- * Checks whether a value is a judge entry: a string, a JSON record, or a JSON array.
+ * Checks whether a value is a stored judge answer of the choice, score, or noul form.
+ *
+ * @remarks
+ * Total: an untrusted input returns false. The guard is exact on the answer's own keys and reads each
+ * probability as a finite number, with noul bounded to `[0, 1]`. Whether the answer fits
+ * its question belongs to the write. Every
+ * judgment of a hydrate reads this guard, so it counts keys by hand rather than through a built one,
+ * and `judgeAnswerContract` holds it in lockstep: an answer the contract accepts passes here.
+ *
+ * @param value - The value to test
+ * @returns True if the value has the shape of a {@link JudgeAnswer}; false otherwise
+ * @example
+ * ```ts
+ * isJudgeAnswer({ form: 'noul', noul: 0.9 }) // true
+ * isJudgeAnswer({ form: 'choice', probabilities: { billing: 1 } }) // true
+ * isJudgeAnswer({ form: 'noul', noul: 0.9, note: 'extra' }) // false
+ * ```
+ */
+export declare function isJudgeAnswer(value: unknown): value is JudgeAnswer;
+
+/**
+ * Checks whether a value is a judge entry: a non-empty string, a non-empty JSON record, or a non-empty
+ * JSON array.
  *
  * @remarks
- * Total: a cycle, a non-JSON member, a class instance, and an untrusted input return false. `null`
- * is not an entry; a criteria guard admits it where the protocol keeps it.
+ * Total: a cycle, a non-JSON member, a class instance, and an untrusted input return false. `''`,
+ * `[]`, and `{}` give a judge nothing to read, so they return false. `null` is not an entry; a
+ * criteria guard admits it where the protocol keeps it.
  *
  * @param value - The unknown entry candidate
- * @returns True if the value is a string or JSON structure the model can read; false otherwise
+ * @returns True if the value is a non-empty string or JSON structure the model can read; false otherwise
  * @example
  * ```ts
  * isJudgeEntry('Customer asks for a refund') // true
@@ -6180,8 +6742,10 @@ export declare function isJudgeError(value: unknown): value is JudgeError;
  * @remarks
  * Total: an untrusted input returns false. A choice needs at least 2 options and a score at least 2
  * levels, because the confidence formula divides by the candidate count; a description or a level
- * can be `null`. `instructions` and noul `criteria` are omitted when absent and never `null`.
- * Server limits on option, level, and question counts are left to the server.
+ * can be `null`. `instructions` and noul `criteria` are omitted when absent and never `null`. The
+ * guard is exact on the question's own keys: an unknown member, and an own `undefined` optional,
+ * return false, as `judgeQuestionContract` does. Server limits on option, level, and question counts
+ * are left to the server.
  *
  * @param value - The unknown question candidate
  * @returns True if the value is a question the judge engine can send; false otherwise
@@ -6199,11 +6763,13 @@ export declare function isJudgeQuestion(value: unknown): value is JudgeQuestion;
  * Checks whether a stored judgment carries a valid question and exactly one answer or refusal.
  *
  * @remarks
- * Unknown members, malformed members, and unreadable inputs return false. Answer fields follow
- * the root judge value types; this storage guard does not impose a wire's probability or
- * candidate limits. The `time`, `noul`, and probability numbers must be finite, because a stored
- * record is owned through JSON, which turns `NaN` and the infinities into `null`; so every record
- * this guard accepts hydrates through a `JudgmentManager`.
+ * Unknown members, malformed members, and unreadable inputs return false, the answer's and the
+ * refusal's own included. Answer fields follow the root judge value types; this storage guard does not
+ * impose a wire's probability or candidate limits, and the ties an answer holds to its question run
+ * where a judgment is written, because records written before them can miss them. The `time`, `noul`,
+ * and probability numbers must be finite, because a stored record is owned through JSON, which turns
+ * `NaN` and the infinities into `null`; so every record this guard accepts hydrates through a
+ * `JudgmentManager`.
  *
  * @param value - The unknown stored record
  * @returns True if the record satisfies the judgment contract; false otherwise
@@ -6229,6 +6795,25 @@ export declare const isJudgment: Guard<Judgment>;
  */
 export declare function isLedgerError(value: unknown): value is LedgerError;
 
+/**
+ * Checks whether a value holds the wording a ledger files with: a choice `category` question whose
+ * criteria describe every category, a non-empty `topic` string, and noul `amends` and `supersedes`
+ * questions.
+ *
+ * @remarks
+ * A ledger asks these on every message, so a hole in them would otherwise surface as filing that quietly
+ * stays undecided. Total: an unreadable member returns false.
+ *
+ * @param value - The value to inspect
+ * @returns True if the value holds the wording the ledger's questions read; false otherwise
+ * @example
+ * ```ts
+ * isLedgerQuestion(LEDGER_QUESTIONS) // true
+ * isLedgerQuestion({ topic: 'Does it concern this?' }) // false
+ * ```
+ */
+export declare function isLedgerQuestion(value: unknown): value is LedgerQuestion;
+
 /**
  * Checks whether a value is a ledger snapshot whose marked ids name messages of its own conversation.
  *
@@ -6237,10 +6822,13 @@ export declare function isLedgerError(value: unknown): value is LedgerError;
  * dense arrays of strings. Each request and note id must name a `user` message of
  * `conversation.messages` and each failure id a `tool` message, so an id only a section original
  * holds is refused. A `gauge`, when present, must hold a finite `scale` greater than 0 and a finite
- * `overhead` of at least 0. Unknown members are admitted. Unreadable members and untrusted inputs
- * return false. The guard is structural: it admits a conversation holding a stored `system` role
+ * `overhead` of at least 0. The guard is exact: an unknown member and an own `undefined` `gauge` return
+ * false, at the snapshot and in its `gauge`. Unreadable members and untrusted inputs return false. The
+ * guard is structural: it admits a conversation holding a stored `system` role
  * or a repeated id, which `requireConversationSnapshot` and the `Conversation` constructor then
  * refuse as the stored-data check a ledger's hydrate runs.
+ * A present `window` must be nonempty and exactly shaped. This guard does not audit its references
+ * or sentence ranges. Hydration discards the window when its digest disagrees or cannot be computed.
  *
  * @param value - The value to inspect, such as a parsed checkpoint
  * @returns True if the value has the shape of a ledger snapshot whose marked ids name messages of its own conversation; false otherwise
@@ -6253,15 +6841,28 @@ export declare function isLedgerError(value: unknown): value is LedgerError;
  */
 export declare function isLedgerSnapshot(value: unknown): value is LedgerSnapshot;
 
+/**
+ * Checks whether a value has the exact shape of a nonempty exchange window.
+ * @param value - The untrusted window
+ * @returns True if the window and its members are well shaped; false otherwise
+ * @example
+ * ```ts
+ * isLedgerWindowSnapshot({ digest: 'checksum', exchanges: [{ request: 'request', reply: 'reply', lines: [] }], amendments: [] }) // true
+ * ```
+ */
+export declare function isLedgerWindowSnapshot(value: unknown): value is LedgerWindowSnapshot;
+
 /**
  * Checks whether a value is a stored memo revision: a record with a string `id`, `name`,
  * `description`, and `content`, a finite `time`, and an optional `origin`.
  *
  * @remarks
  * An `origin`, when present, is a record with a string `conversation` and an optional string
- * `message`. Unknown members are admitted. The `time` must be finite, because a stored revision
- * is owned through JSON, which turns `NaN` and the infinities into `null`. Malformed and
- * unreadable inputs, a throwing getter or a revoked proxy included, return false.
+ * `message`. The guard is exact: an unknown member and an own `undefined` optional return false. The
+ * `time` must be finite, because a stored revision is owned through JSON, which turns `NaN` and the
+ * infinities into `null`. Malformed and unreadable inputs, a throwing getter or a revoked proxy
+ * included, return false. Every revision of a hydrate reads this guard, so it counts keys by hand
+ * rather than through a built one, and `memoSnapshotContract` holds it in lockstep.
  *
  * @param value - The value to test
  * @returns True if `value` has the shape of a {@link Memo}; false otherwise
@@ -6274,15 +6875,33 @@ export declare function isLedgerSnapshot(value: unknown): value is LedgerSnapsho
  * isMemo({ id: 'm1', name: 'tone', description: 'Prefers short replies.', content: 'Answer briefly.', time: Number.NaN }) // false
  * ```
  */
-export declare const isMemo: Guard<Memo>;
+export declare function isMemo(value: unknown): value is Memo;
+
+/**
+ * Checks whether a value is a memo's origin: a record with a string `conversation` and an optional
+ * string `message`.
+ *
+ * @remarks
+ * The guard is exact: an unknown member and an own `undefined` `message` return false. Malformed and
+ * unreadable inputs return false.
+ *
+ * @param value - The value to test
+ * @returns True if `value` has the shape of a {@link MemoOrigin}; false otherwise
+ * @example
+ * ```ts
+ * isMemoOrigin({ conversation: 'c1', message: 'm1' }) // true
+ * isMemoOrigin({ conversation: 'c1', extra: true }) // false
+ * ```
+ */
+export declare function isMemoOrigin(value: unknown): value is MemoOrigin;
 
 /**
  * Checks whether a value is a stored memo set: a record with a string `id` and a dense `memos`
  * array of {@link isMemo} values.
  *
  * @remarks
- * Unknown members are admitted. A sparse `memos` array, a malformed revision, and unreadable
- * inputs, a throwing getter or a revoked proxy included, return false.
+ * The guard is exact: an unknown member returns false, as a sparse `memos` array, a malformed
+ * revision, and unreadable inputs, a throwing getter or a revoked proxy included, do.
  *
  * @param value - The value to test (an opaque storage read)
  * @returns True if `value` has the shape of a {@link MemoSnapshot}; false otherwise
@@ -6303,8 +6922,9 @@ export declare function isMemoSnapshot(value: unknown): value is MemoSnapshot;
  * @remarks
  * Roles belong to MessageRole, image elements are strings, `thinking` is a string, and `call` is a string on any
  * role, as the flat Message type admits. Tool arguments may carry non-JSON values, as the
- * domain type permits; the message wire contract is narrower. Unreadable fields and untrusted
- * inputs return false.
+ * domain type permits; the message wire contract is narrower. The guard is exact on the message's own
+ * keys: an unknown member, and an own `undefined` optional, return false. Unreadable fields and
+ * untrusted inputs return false.
  *
  * @param value - The unknown message candidate
  * @returns True if the domain message fields are valid; false otherwise
@@ -6318,6 +6938,25 @@ export declare function isMemoSnapshot(value: unknown): value is MemoSnapshot;
  */
 export declare function isMessage(value: unknown): value is Message;
 
+/**
+ * Checks whether a value is a message input a conversation can store: a string `content`, and `calls`,
+ * `call`, `images`, and `thinking` absent or of their declared types.
+ *
+ * @remarks
+ * A hand guard, because `add` checks every message: it reads the members once and composes no record
+ * guard. The role is `requireRole`'s to refuse, so its text can name the role received. Unknown members
+ * are left behind by the store. An unreadable member returns false.
+ *
+ * @param value - The unknown input candidate
+ * @returns True if the input's members are valid; false otherwise
+ * @example
+ * ```ts
+ * isMessageInput({ role: 'user', content: 'hi' }) // true
+ * isMessageInput({ role: 'user' }) // false
+ * ```
+ */
+export declare function isMessageInput(value: unknown): value is MessageInput;
+
 /**
  * Checks whether a value is a non-negative safe integer, `-0` included.
  *
@@ -6346,6 +6985,7 @@ export declare function isNonNegativeSafeInteger(value: unknown): value is numbe
  * @example
  * ```ts
  * isPositiveSafeInteger(4096) // true
+ * isPositiveSafeInteger(0) // false
  * ```
  */
 export declare function isPositiveSafeInteger(value: unknown): value is number;
@@ -6380,6 +7020,28 @@ export declare function isProviderAbortError(value: unknown): value is ProviderA
  */
 export declare function isProviderError(value: unknown): value is ProviderError;
 
+/**
+ * Checks whether a value carries the members {@link ProviderResult} publishes: a string `content`, and
+ * `thinking`, `tools`, `usage`, and `truncated` absent or of their published types.
+ *
+ * @remarks
+ * A provider is a foreign interface, so the guard is open: unknown members and a class instance pass,
+ * and each `usage` count is a finite nonnegative number with no integer check. An unreadable member
+ * returns false. {@link import('./helpers.js').requireProviderResult} runs it on an owned copy, the one
+ * door a run's result crosses.
+ *
+ * @param value - The unknown result candidate
+ * @returns True if the value satisfies the published result; false otherwise
+ *
+ * @example
+ * ```ts
+ * isProviderResult({ content: 'answer', extra: true }) // true
+ * isProviderResult({}) // false
+ * isProviderResult({ content: 'answer', usage: { prompt: -1, completion: 0, total: 0 } }) // false
+ * ```
+ */
+export declare const isProviderResult: Guard<ProviderResult>;
+
 /**
  * Checks whether an `unknown` is structurally a {@link Section} record — a `string` `id` and
  * `summary` beside a `messages` array of valid {@link Message} records, the per-section step of
@@ -6390,8 +7052,8 @@ export declare function isProviderError(value: unknown): value is ProviderError;
  * A total guard (it never throws — untrusted input, a throwing getter included, returns
  * `false`). It checks the shape of the section: a record with a `string` `id`, a `string`
  * `summary`, and a dense `messages` array every element of which is a valid {@link Message}
- * record ({@link isMessage}); a sparse `messages` array is refused. Enough to safely impose
- * the {@link Section} type at a storage boundary without a cast.
+ * record ({@link isMessage}), and no other member; a sparse `messages` array is refused. Enough to
+ * safely impose the {@link Section} type at a storage boundary without a cast.
  *
  * @param value - The value to test (one element of a snapshot's `sections` array)
  * @returns True if `value` has the structural shape of a {@link Section}; false otherwise
@@ -6489,9 +7151,50 @@ export declare class JudgeAbortError extends Error {
 /** Names one answer by its form; it stores only the distribution a server returned. */
 export declare type JudgeAnswer = ChoiceAnswer | ScoreAnswer | NoulAnswer;
 
+/** Reads the faults of a refused judge answer. */
+export declare const judgeAnswerContract: ContractInterface<Readonly<{
+form: "choice";
+probabilities: {
+readonly [k: string]: number;
+};
+} & {}> | Readonly<{
+form: "score";
+probabilities: readonly number[];
+} & {}> | Readonly<{
+form: "noul";
+noul: number;
+} & {}>>;
+
+/**
+ * Describes a judge answer: one exact object per form, each probability in `[0, 1]`.
+ *
+ * @remarks
+ * The ties an answer holds to its question run at the write doors through `scanJudgmentTies`, which a
+ * shape over the answer alone cannot state.
+ */
+export declare const judgeAnswerShape: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+probabilities: ObjectShape<Record<never, never>, NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+probabilities: ArrayShape<NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+noul: NumberShape;
+}, boolean | ContractShape>]>;
+
 /** Carries text or structured JSON the model reads; mirrors the TypeSafe `EntryType` without its null arm. */
 export declare type JudgeEntry = string | JSONRecord | readonly JSONValue[];
 
+/**
+ * Describes the text or JSON a judge reads: a non-empty string, a non-empty JSON array, or a JSON record.
+ *
+ * @remarks
+ * A shape has no `minProperties`, so this one admits the empty record that `isJudgeEntry` refuses;
+ * the guard is the door, and this shape only fills a refusal's faults.
+ */
+export declare const judgeEntryShape: UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>;
+
 /**
  * Reports a coded judge failure with its HTTP status and underlying cause when available.
  *
@@ -6506,6 +7209,8 @@ export declare class JudgeError extends Error {
     readonly code: JudgeErrorCode;
     /** Holds the response status for an HTTP failure, or undefined for other codes. */
     readonly status: number | undefined;
+    /** Holds the values that locate the failure, such as the `faults` of a refused question, or `undefined` when none were supplied. */
+    readonly context: Readonly<Record<string, unknown>> | undefined;
     constructor(code: JudgeErrorCode, message: string, options?: ProviderErrorOptions);
 }
 
@@ -6531,6 +7236,67 @@ export declare interface JudgeInterface {
 /** Names one question by its form, the protocol's type field under the fleet's named discriminant. */
 export declare type JudgeQuestion = ChoiceQuestion | ScoreQuestion | NoulQuestion;
 
+/** Reads the faults of a refused judge question. */
+export declare const judgeQuestionContract: ContractInterface<Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>>;
+
+/**
+ * Describes a judge question: one exact object per form, the schema an LLM-facing wire can publish.
+ *
+ * @remarks
+ * `isJudgeQuestion` is the door; this shape fills a refusal's faults. A choice needing at least 2
+ * options is the guard's alone, because a shape has no `minProperties`.
+ */
+export declare const judgeQuestionShape: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+
 /** Carries one state and the questions asked about it, keyed by caller ids the prompt never carries; each question is evaluated on its own. */
 export declare interface JudgeRequest {
     readonly state: JudgeEntry;
@@ -6562,6 +7328,118 @@ export declare interface Judgment {
     readonly usage?: TokenUsage;
 }
 
+/** Reads the faults of a refused judgment. */
+export declare const judgmentContract: ContractInterface<Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+answer: Readonly<{
+form: "choice";
+probabilities: {
+readonly [k: string]: number;
+};
+} & {}> | Readonly<{
+form: "score";
+probabilities: readonly number[];
+} & {}> | Readonly<{
+form: "noul";
+noul: number;
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}> | Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+refusal: Readonly<{
+missing: readonly string[];
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}>>;
+
 /** Supplies an answered or refused question for storage before its time is stamped. */
 export declare interface JudgmentInput {
     readonly id: string;
@@ -6661,6 +7539,83 @@ export declare interface JudgmentManagerInterface {
     resolve(judge: JudgeInterface, request: JudgeRequest, sources: readonly string[], signal: AbortSignal): Promise<readonly Judgment[]>;
 }
 
+/**
+ * Describes a stored judgment: exactly one of an answer or a refusal, with its question, sources,
+ * state, model, and storage time.
+ *
+ * @remarks
+ * `isJudgment` is the door a hydrate reads and this shape fills a refusal's faults, because hydrate is
+ * a per-element path. A lockstep test holds that `is` implies the guard.
+ */
+export declare const judgmentShape: UnionShape<readonly [ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+answer: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+probabilities: ObjectShape<Record<never, never>, NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+probabilities: ArrayShape<NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+noul: NumberShape;
+}, boolean | ContractShape>]>;
+}, boolean | ContractShape>, ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+refusal: ObjectShape<    {
+missing: ArrayShape<StringShape>;
+}, boolean | ContractShape>;
+}, boolean | ContractShape>]>;
+
 /**
  * Serves one conversation through classified records, a bounded copy of each request turn that carries them, and a final answer pass.
  * @example
@@ -6678,7 +7633,8 @@ export declare class Ledger implements LedgerInterface {
      * @param options - The filing policy, capacity, and request bounds
      * @throws {LedgerError} Thrown when a threshold, share, capacity, limit, topic, lookup, or gauge is invalid
      * @throws {LedgerError} Thrown when `predict` is not a nonnegative safe integer less than `capacity` (code `'CAPACITY'`)
-     * @throws {LedgerError} Thrown when `snapshot` is malformed or marks an id its conversation does not hold (code `'SNAPSHOT'`)
+     * @throws {LedgerError} Thrown when `questions` fails `isLedgerQuestion` (code `'QUESTION'`)
+     * @throws {LedgerError} Thrown when `snapshot` is malformed or marks an id its conversation does not hold (code `'SNAPSHOT'`, its faults under `context.faults`)
      * @throws {ConversationError} Thrown when `isLedgerSnapshot` admits `snapshot` but its conversation holds a `system` message (code `'ROLE'`) or repeats an id (code `'SNAPSHOT'`)
      */
     constructor(provider: ProviderInterface, options: LedgerOptions);
@@ -6706,15 +7662,15 @@ export declare class Ledger implements LedgerInterface {
      */
     calibrate(signal: AbortSignal): Promise<LedgerGauge>;
     /**
-     * Serializes the conversation, the marked ids, and the gauge into a snapshot a later ledger hydrates from.
-     * @returns The snapshot, each id list in conversation order and `gauge` present after the ledger holds one
+     * Serializes the conversation, marked ids, gauge, and completed exchange window for a later ledger.
+     * @returns The snapshot, each id list in conversation order, with a gauge and window only when held
      * @throws {AgentError} Thrown when a request or calibration is active (code `'CONCURRENCY'`)
      */
     snapshot(): LedgerSnapshot;
     /**
      * Appends a request and serves it, recovering an unfinished or rejected first pass with one answer pass.
      * A calibration call that reports no prompt usage, or a prompt usage of 0 or less, rejects with `LedgerError` code `'GAUGE'`; a provider error during calibration rejects with that error.
-     * When the answer pass rejects, `respond` rejects with that error. Every rejection leaves the ledger free for a later call.
+     * When the answer pass rejects, `respond` rejects with that error, and under the default `strict` a judge failure or another selection failure rejects it too. A rejection belongs to its own call: the ledger stays free, and the next call asks the judge again about whatever is still unanswered.
      * @param content - The request text
      * @param signal - The caller's cancellation signal; an abort during calibration rejects with its reason
      * @returns The final pass, the usage of every pass, and the filing attempts of this request alone
@@ -6748,6 +7704,12 @@ export declare const LEDGER_OWNER_PREFIX = "owner:";
  */
 export declare const LEDGER_QUESTIONS: LedgerQuestion;
 
+/** Labels recalled conversation text by its origin. */
+export declare const LEDGER_RECALL_LABELS: Readonly<{
+    request: "Earlier request:";
+    reply: "Earlier reply:";
+}>;
+
 /** Names the key of the record that holds the rules no owner claims. */
 export declare const LEDGER_RULES_KEY = "rules";
 
@@ -6783,15 +7745,19 @@ export declare const LEDGER_WORD: RegExp;
  * Selects the agent bounds, hooks, scheduler, and context libraries a ledger passes through to the agent it builds.
  *
  * @remarks
- * `limit` must be a nonnegative safe integer. Default: the `DEFAULT_LEDGER_LIMIT` constant. The
+ * `limit` must be a positive safe integer. Default: the `DEFAULT_LEDGER_LIMIT` constant. The
  * ledger owns every other agent option: the conversation, the tools, the selection handler, and
  * the scope. One memo set can serve many ledgers of one principal, and the plan prices what these
  * libraries add to the head. `scheduler` also reaches the ledger's classifier, which hands the host
  * a turn while it files, so a page passes it to keep the filing out of one long task. The classifier
  * and the loop race its yield against the run signal, so a scheduler that ignores its signal still
- * ends on a cancel.
+ * ends on a cancel. `strict` defaults to `true`: a judge failure or another selection failure rejects
+ * that `respond` call after the `fault` event, and the next call asks the judge again about whatever is
+ * still unanswered. With `strict: false` the request goes on with that question undecided, or from the
+ * conversation's `view()`. A provider failure in the first pass is the one
+ * failure the answer pass recovers under either value.
  */
-export declare type LedgerAgentOptions = Pick<AgentOptions, 'limit' | 'timeout' | 'on' | 'scheduler' | 'instructions' | 'skills' | 'memos' | 'workspaces'>;
+export declare type LedgerAgentOptions = Pick<AgentOptions, 'limit' | 'timeout' | 'on' | 'scheduler' | 'instructions' | 'skills' | 'memos' | 'workspaces' | 'strict'>;
 
 /** Identifies an accepted direct message amendment whose sentence scope remains unresolved. */
 export declare interface LedgerAmendment {
@@ -6839,6 +7805,14 @@ export declare interface LedgerCorrectionOptions {
     readonly narrow?: boolean;
 }
 
+/** Carries a planned copy and its validity evidence to request settlement. */
+export declare interface LedgerDraft {
+    readonly copy: Message;
+    readonly lines: readonly LedgerOccurrence[];
+    readonly evidence: LedgerEvidence;
+    readonly window: readonly LedgerExchange[];
+}
+
 /**
  * Lists the registry ids and owner ids a text names.
  *
@@ -6853,10 +7827,10 @@ export declare type LedgerEntityHandler = (text: string, partial: boolean) => Re
  * carrying the machine-readable `code`.
  *
  * @remarks
- * A threshold, share, capacity, limit, topic, lookup, or gauge outside its bounds is a programmer
- * error and throws this with the matching {@link LedgerErrorCode}. A calibration call that reports
+ * A threshold, share, capacity, limit, topic, lookup, question, or gauge outside its bounds is a
+ * programmer error and throws this with the matching {@link LedgerErrorCode}. A calibration call that reports
  * no prompt usage throws this with `'GAUGE'`. A snapshot option that `isLedgerSnapshot` refuses
- * throws this with `'SNAPSHOT'`. Narrow a caught value with {@link isLedgerError} and
+ * throws this with `'SNAPSHOT'`, its `context` holding the `faults`. Narrow a caught value with {@link isLedgerError} and
  * branch on `error.code`. A selection without an active `respond` call, for a conversation other
  * than the ledger's, or for a request other than that call's request or a ledger note, reports
  * `'REQUEST'` through the selection's fault.
@@ -6864,13 +7838,16 @@ export declare type LedgerEntityHandler = (text: string, partial: boolean) => Re
 export declare class LedgerError extends Error {
     /** Names the machine-readable condition; the {@link LedgerErrorCode} union describes each code. */
     readonly code: LedgerErrorCode;
+    /** Holds the values that locate the failure, such as the `faults` of a refused snapshot, or `undefined` when none were supplied. */
+    readonly context: Readonly<Record<string, unknown>> | undefined;
     /**
      * Records the failure condition and its description.
      *
      * @param code - The machine-readable condition, exposed as `error.code`
      * @param message - The human-readable description of the failure
+     * @param options - The optional {@link CodedErrorOptions}; `cause` reaches `Error.cause` only when present
      */
-    constructor(code: LedgerErrorCode, message: string);
+    constructor(code: LedgerErrorCode, message: string, options?: CodedErrorOptions);
 }
 
 /** Names the machine-readable conditions a `LedgerError` error reports. */
@@ -6883,7 +7860,7 @@ export declare type LedgerErrorCode =
 | 'SHARE'
 /** Reports an invalid capacity or a generation cap that is not a nonnegative safe integer less than capacity. */
 | 'CAPACITY'
-/** Reports a recall limit or an agent limit that is not a nonnegative safe integer. */
+/** Reports a recall limit that is not a nonnegative safe integer, or an agent limit that is not a positive safe integer. */
 | 'LIMIT'
 /** Reports a topic with an empty name or a name another topic carries. */
 | 'TOPIC'
@@ -6894,7 +7871,30 @@ export declare type LedgerErrorCode =
 /** Reports a render context that holds no reference for a source it annotates. */
 | 'REFERENCE'
 /** Reports a snapshot that is malformed or that marks an id its conversation does not hold. */
-| 'SNAPSHOT';
+| 'SNAPSHOT'
+/** Reports filing wording that `isLedgerQuestion` refuses. */
+| 'QUESTION';
+
+/** Captures held message identities and the accepted edges used to validate their copies. */
+export declare interface LedgerEvidence {
+    readonly messages: ReadonlySet<string>;
+    readonly amendments: ReadonlyMap<string, LedgerAmendment>;
+}
+
+/** Carries a completed request copy, its stored reply, and the sentences the copy rendered. */
+export declare interface LedgerExchange {
+    readonly request: Message;
+    readonly reply: Message;
+    readonly lines: readonly LedgerOccurrence[];
+}
+
+/** Carries the sent request text, stored pair ids, and sentence placements of one exchange. */
+export declare interface LedgerExchangeSnapshot {
+    readonly request: string;
+    readonly copy?: string;
+    readonly reply: string;
+    readonly lines: readonly LedgerReceipt[];
+}
 
 /**
  * Carries the price of a prompt in tokens, measured against the model the ledger serves.
@@ -6967,14 +7967,15 @@ export declare interface LedgerInterface {
      * rejects with an `AgentError` whose `code` is `'CONCURRENCY'`. A calibration call that reports no prompt usage, or a prompt usage of 0 or less, rejects with
      * `LedgerError` code `'GAUGE'`; a provider error during calibration rejects with that error.
      * A direct agent run on `conversation` while a `respond` call's pass runs is refused with an
-     * `AgentError` whose `code` is `'CONCURRENCY'`; during the calibration that opens the call it is a
-     * run no active `respond` call owns. The ledger's agent serves only `conversation`: a run on
-     * another conversation started during a `respond` call gets no ledger selection, yet adds its
-     * turns and usage to that call's gauge readings and shares its repeat stop, and it can still
-     * reach the `recall` and lookup tools, which read `conversation`. The ledger's own guard refuses
-     * only `respond`, `calibrate`, and `snapshot` calls.
-     * A run no `respond` call owns, including a run during calibration, reads no request's state:
-     * its lookup and `recall` calls run with no repeat stop, recall limit, or close rule.
+     * `AgentError` whose `code` is `'CONCURRENCY'`. Under the default `strict`, any other run no active
+     * `respond` call owns rejects with a `LedgerError` whose `code` is `'REQUEST'`: a direct run between
+     * requests, one during calibration, and a run on another conversation during a call. Under
+     * `strict: false` that run goes on over the whole view with no ledger selection; a run on another
+     * conversation then adds its turns and usage to that call's gauge readings and shares its repeat
+     * stop, and it can still reach the `recall` and lookup tools, which read `conversation`. The
+     * ledger's own guard refuses only `respond`, `calibrate`, and `snapshot` calls.
+     * Under `strict: false`, a run no `respond` call owns, including a run during calibration, reads no
+     * request's state: its lookup and `recall` calls run with no repeat stop, recall limit, or close rule.
      * Every rejection leaves the ledger free for a later call.
      *
      * @param content - The request text
@@ -7114,6 +8115,10 @@ export declare interface LedgerNote {
     readonly closure: string;
 }
 
+/** Carries a rendered sentence with its record placement. */
+export declare interface LedgerOccurrence extends LedgerLine, LedgerReceipt {
+}
+
 /**
  * Configures a ledger: its judge and the wording and cutoffs it files with, the desk topics, the
  * context capacity, and the optional first-pass thinking, lookups, gauge, shares, snapshot, recall
@@ -7244,6 +8249,14 @@ export declare interface LedgerRecallOptions {
     readonly limit?: number;
 }
 
+/** Identifies an original sentence at one record placement. */
+export declare interface LedgerReceipt {
+    readonly key: string;
+    readonly title: string;
+    readonly source: string;
+    readonly sentence: number;
+}
+
 /**
  * Carries one record: the live messages placed on one owner or on the rules, as lines.
  *
@@ -7291,6 +8304,12 @@ export declare interface LedgerRenderContext {
     readonly references: ReadonlyMap<string, string>;
 }
 
+/** Carries rendered record text and its sentences in emission order. */
+export declare interface LedgerRenderResult {
+    readonly text: string;
+    readonly lines: readonly LedgerOccurrence[];
+}
+
 /**
  * Holds what one ledger request keeps while it is served: its message, its filing attempts and
  * plan, the gauge calls of its passes, and its repeat and recall stops.
@@ -7332,6 +8351,10 @@ export declare class LedgerRequest implements LedgerRequestInterface {
      * @returns The planned selection, or undefined before one
      */
     get plan(): Selection | undefined;
+    get scope(): ScopeInterface | undefined;
+    apply(scope: ScopeInterface): void;
+    /** Returns the copy and receipts adopted by the last provider turn. */
+    get sent(): LedgerDraft | undefined;
     /**
      * Returns the selection the current pass's run adopted last.
      *
@@ -7368,7 +8391,9 @@ export declare class LedgerRequest implements LedgerRequestInterface {
     observe(call: GaugeCall, position: number): void;
     spend(usage: TokenUsage): void;
     think(messages: readonly Message[]): void;
-    file(attempts: readonly ClassifierAttempt[], plan?: Selection): void;
+    fault(error: unknown): void;
+    faulted(error: unknown): boolean;
+    file(attempts: readonly ClassifierAttempt[], plan?: Selection, draft?: LedgerDraft): void;
     admit(name: string, args: Readonly<Record<string, unknown>>): void;
     recall(): void;
     close(): void;
@@ -7389,6 +8414,21 @@ export declare class LedgerRequest implements LedgerRequestInterface {
  * thinking, until its pass observes the next call, and is final from then on.
  */
 export declare interface LedgerRequestInterface {
+    /** Holds the scope last applied by the ledger's plan, or undefined before one. */
+    readonly scope: ScopeInterface | undefined;
+    /** Records the scope applied by the ledger's plan for conditional restoration at settle. */
+    apply(scope: ScopeInterface): void;
+    /** Holds the copy and receipts adopted by the last provider turn, or undefined for a view fallback. */
+    readonly sent: LedgerDraft | undefined;
+    /** Records an error the request's run reported through its `fault` event. */
+    fault(error: unknown): void;
+    /**
+     * Reports whether the request's run reported this error through its `fault` event.
+     *
+     * @param error - The value a pass rejected with
+     * @returns True if the run reported it; false otherwise
+     */
+    faulted(error: unknown): boolean;
     /** Holds the request message, or undefined until `enter` appends it. */
     readonly message: Message | undefined;
     /** Holds the selection the request's last successful plan produced, or undefined before one. */
@@ -7452,8 +8492,9 @@ export declare interface LedgerRequestInterface {
      *
      * @param attempts - The selection's filing attempts, in asking order
      * @param plan - The planned selection, or undefined when planning failed
+     * @param draft - The copy and receipts eligible for adoption; omission discards that eligibility
      */
-    file(attempts: readonly ClassifierAttempt[], plan?: Selection): void;
+    file(attempts: readonly ClassifierAttempt[], plan?: Selection, draft?: LedgerDraft): void;
     /**
      * Admits one tool call of the request, compared by tool name and canonical arguments.
      *
@@ -7510,7 +8551,11 @@ export declare interface LedgerResult extends AgentResult {
  *
  * @remarks
  * `prompt` is a share of the ledger's `capacity`; the overhead tokens of the gauge come out of it
- * before the records and the tail take the rest. `tail` is a share of what remains for messages.
+ * before the records and the tail take the rest. `tail` bounds only the seed tail. The seed and
+ * records are planned before the completed-exchange window spends spare room. The full window
+ * with a delta copy, then its newest plain exchange with a full copy, then no exchange are priced
+ * in that order. Admission cannot close an otherwise open recall or displace a selected record
+ * line or seed message. A seed stub reads visibility across the window and the copy together.
  * Each share must be finite, greater than 0, and at most 1.
  */
 export declare interface LedgerShare {
@@ -7528,9 +8573,16 @@ export declare interface LedgerShare {
  * of `conversation.messages`: a request or note a `user` message and a failure a `tool` message.
  * `gauge` carries the scale and overhead alone. The gauge's observations of earlier requests are
  * not carried, so a hydrated ledger sizes and closes `recall` from its fallback reserve until it
- * completes a request. A question the classifier held after a deterministic judge failure is not
- * carried, so a hydrated ledger asks it again. Hydrating a second ledger from one snapshot forks
- * it at the parent's frontier.
+ * completes a request. A question a `strict: false` classifier held after a deterministic judge
+ * failure is not carried, so a hydrated ledger asks it again. Hydrating a second ledger from one snapshot forks
+ * it at the parent's frontier. `window`, when present, retains sent request copies, reply ids,
+ * sentence receipts, and accepted amendment edges. The next plan keeps the same conversation
+ * prefix when the live and hydrated reserves admit the same exchange rung. A rung between those
+ * reserves can differ because hydration carries no gauge observations; this moves the prefix,
+ * never the record coverage. A plain request omits `copy` because its content already lives in `conversation`.
+ * The required window `digest` checks canonical held messages, lookup call context, copies, and receipts. A mismatch drains
+ * the window and its evidence; a missing digest refuses the snapshot. An unencodable held message
+ * makes `snapshot()` omit the window. The checksum detects edits, not authenticity.
  */
 export declare interface LedgerSnapshot {
     readonly conversation: ConversationSnapshot;
@@ -7538,8 +8590,328 @@ export declare interface LedgerSnapshot {
     readonly notes: readonly string[];
     readonly failures: readonly string[];
     readonly gauge?: LedgerGauge;
+    readonly window?: LedgerWindowSnapshot;
 }
 
+/** Reads structural faults of a ledger snapshot, including its optional held exchange window. */
+export declare const ledgerSnapshotContract: ContractInterface<Readonly<{
+conversation: Readonly<{
+id: string;
+sections: readonly Readonly<{
+id: string;
+summary: string;
+messages: readonly Readonly<{
+id: string;
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+} & {}>[];
+messages: readonly Readonly<{
+id: string;
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+} & {
+judgments?: readonly (Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+answer: Readonly<{
+form: "choice";
+probabilities: {
+readonly [k: string]: number;
+};
+} & {}> | Readonly<{
+form: "score";
+probabilities: readonly number[];
+} & {}> | Readonly<{
+form: "noul";
+noul: number;
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}> | Readonly<{
+id: string;
+question: Readonly<{
+form: "choice";
+criteria: {
+readonly [k: string]: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null;
+};
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "score";
+criteria: readonly (string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+} | null)[];
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}> | Readonly<{
+form: "noul";
+} & {
+instructions?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+criteria?: Readonly<{} & {
+true?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+false?: string | readonly JSONValue[] | {
+readonly [k: string]: JSONValue;
+};
+}>;
+}>;
+model: string;
+sources: readonly string[];
+state: string;
+time: number;
+refusal: Readonly<{
+missing: readonly string[];
+} & {}>;
+} & {
+usage?: Readonly<{
+prompt: number;
+completion: number;
+total: number;
+} & {}>;
+}>)[];
+}>;
+requests: readonly string[];
+notes: readonly string[];
+failures: readonly string[];
+} & {
+gauge?: Readonly<{
+scale: number;
+overhead: number;
+} & {}>;
+window?: Readonly<{
+digest: string;
+exchanges: readonly Readonly<{
+request: string;
+reply: string;
+lines: readonly Readonly<{
+key: string;
+title: string;
+source: string;
+sentence: number;
+} & {}>[];
+} & {
+copy?: string;
+}>[];
+amendments: readonly Readonly<{
+earlier: string;
+later: string;
+} & {}>[];
+} & {}>;
+}>>;
+
+/**
+ * Describes a ledger snapshot exactly: an unknown key refuses, so a key a later version adds never reads
+ * as absent.
+ *
+ * @remarks
+ * `isLedgerSnapshot` is the door a hydrate reads, and this shape fills a refusal's faults. What the shape
+ * cannot state, that each marked id names a message of the snapshot's own conversation, is the guard's
+ * alone.
+ */
+export declare const ledgerSnapshotShape: ObjectShape<    {
+conversation: ObjectShape<    {
+id: StringShape;
+sections: ArrayShape<ObjectShape<    {
+id: StringShape;
+summary: StringShape;
+messages: ArrayShape<ObjectShape<    {
+id: StringShape;
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+messages: ArrayShape<ObjectShape<    {
+id: StringShape;
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+judgments: OptionalShape<ArrayShape<UnionShape<readonly [ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+answer: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+probabilities: ObjectShape<Record<never, never>, NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+probabilities: ArrayShape<NumberShape>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+noul: NumberShape;
+}, boolean | ContractShape>]>;
+}, boolean | ContractShape>, ObjectShape<    {
+id: StringShape;
+question: UnionShape<readonly [ObjectShape<    {
+form: LiteralShape<readonly ["choice"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ObjectShape<Record<never, never>, NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["score"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: ArrayShape<NullableShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>>;
+}, boolean | ContractShape>, ObjectShape<    {
+form: LiteralShape<readonly ["noul"]>;
+instructions: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+criteria: OptionalShape<ObjectShape<    {
+true: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+false: OptionalShape<UnionShape<readonly [StringShape, ArrayShape<JSONShape>, ObjectShape<Record<never, never>, JSONShape>]>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>]>;
+model: StringShape;
+sources: ArrayShape<StringShape>;
+state: StringShape;
+time: NumberShape;
+usage: OptionalShape<ObjectShape<    {
+prompt: NumberShape;
+completion: NumberShape;
+total: NumberShape;
+}, boolean | ContractShape>>;
+refusal: ObjectShape<    {
+missing: ArrayShape<StringShape>;
+}, boolean | ContractShape>;
+}, boolean | ContractShape>]>>>;
+}, boolean | ContractShape>;
+requests: ArrayShape<StringShape>;
+notes: ArrayShape<StringShape>;
+failures: ArrayShape<StringShape>;
+gauge: OptionalShape<ObjectShape<    {
+scale: NumberShape;
+overhead: NumberShape;
+}, boolean | ContractShape>>;
+window: OptionalShape<ObjectShape<    {
+digest: StringShape;
+exchanges: ArrayShape<ObjectShape<    {
+request: StringShape;
+copy: OptionalShape<StringShape>;
+reply: StringShape;
+lines: ArrayShape<ObjectShape<    {
+key: StringShape;
+title: StringShape;
+source: StringShape;
+sentence: NumberShape;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+amendments: ArrayShape<ObjectShape<    {
+earlier: StringShape;
+later: StringShape;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>;
+
 /**
  * Carries the probability cutoff of each reading the ledger takes from its judge.
  *
@@ -7577,6 +8949,54 @@ export declare interface LedgerTopic {
     readonly requested?: boolean;
 }
 
+/** Reads structural faults of a serialized exchange window. */
+export declare const ledgerWindowContract: ContractInterface<Readonly<{
+digest: string;
+exchanges: readonly Readonly<{
+request: string;
+reply: string;
+lines: readonly Readonly<{
+key: string;
+title: string;
+source: string;
+sentence: number;
+} & {}>[];
+} & {
+copy?: string;
+}>[];
+amendments: readonly Readonly<{
+earlier: string;
+later: string;
+} & {}>[];
+} & {}>>;
+
+/** Describes the minimal serialized evidence of a nonempty exchange window. */
+export declare const ledgerWindowShape: ObjectShape<    {
+digest: StringShape;
+exchanges: ArrayShape<ObjectShape<    {
+request: StringShape;
+copy: OptionalShape<StringShape>;
+reply: StringShape;
+lines: ArrayShape<ObjectShape<    {
+key: StringShape;
+title: StringShape;
+source: StringShape;
+sentence: NumberShape;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+amendments: ArrayShape<ObjectShape<    {
+earlier: StringShape;
+later: StringShape;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>;
+
+/** Carries a nonempty exchange window, its message, copy, and receipt checksum, and its accepted edges. */
+export declare interface LedgerWindowSnapshot {
+    readonly digest: string;
+    readonly exchanges: readonly LedgerExchangeSnapshot[];
+    readonly amendments: readonly LedgerAmendment[];
+}
+
 /** Carries the lowercase words and non-opening capitalized names of a message. */
 export declare interface LedgerWordSet {
     readonly words: ReadonlySet<string>;
@@ -7702,6 +9122,18 @@ export declare function matchesJSON(left: unknown, right: unknown): boolean;
  */
 export declare function matchesJudgment(judgment: Judgment, question: JudgeQuestion, sources: readonly string[], state: string, model: string): boolean;
 
+/**
+ * Checks whether two successful findings carry the same text for the same canonical lookup.
+ * @param left - The finding to compare
+ * @param right - The candidate copy
+ * @returns True for the same finding or equal canonical identities and text; unkeyable findings match only themselves
+ * @example
+ * ```ts
+ * matchesLookup(finding, finding) // true when it has a result
+ * ```
+ */
+export declare function matchesLookup(left: LedgerLookupFinding, right: LedgerLookupFinding): boolean;
+
 /**
  * Bounds the decoded error excerpt's input in bytes — `2048`, the leading bytes of a non-OK
  * response body handed to the decoder before the read cancels the remainder, so a `ProviderError`
@@ -7821,6 +9253,21 @@ export declare interface Memo {
  */
 export declare const MEMO_SECTION_HEADER = "## Memos";
 
+/** Reads the faults of a refused memo revision. */
+export declare const memoContract: ContractInterface<Readonly<{
+id: string;
+name: string;
+description: string;
+content: string;
+time: number;
+} & {
+origin?: Readonly<{
+conversation: string;
+} & {
+message?: string;
+}>;
+}>>;
+
 /**
  * Carries the data to author a {@link Memo} revision; the {@link MemoManagerInterface} that
  * stores it mints the `id` and records the `time`.
@@ -8154,6 +9601,19 @@ export declare class MemoryMemoStore implements MemoStoreInterface {
     delete(id: string): Promise<void>;
 }
 
+/** Describes a stored memo revision exactly. */
+export declare const memoShape: ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: StringShape;
+content: StringShape;
+time: NumberShape;
+origin: OptionalShape<ObjectShape<    {
+conversation: StringShape;
+message: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>;
+
 /**
  * Holds every revision of a memo set, oldest first; the current memo of a name is its last
  * revision.
@@ -8170,6 +9630,24 @@ export declare interface MemoSnapshot {
     readonly memos: readonly Memo[];
 }
 
+/** Reads the faults of a refused memo snapshot. */
+export declare const memoSnapshotContract: ContractInterface<Readonly<{
+id: string;
+memos: readonly Readonly<{
+id: string;
+name: string;
+description: string;
+content: string;
+time: number;
+} & {
+origin?: Readonly<{
+conversation: string;
+} & {
+message?: string;
+}>;
+}>[];
+} & {}>>;
+
 /**
  * Represents one row of the table a {@link
  * import('./stores/DatabaseMemoStore.js').DatabaseMemoStore} persists — a memo set `id` plus its
@@ -8187,6 +9665,28 @@ export declare interface MemoSnapshotRow {
     readonly snapshot: unknown;
 }
 
+/**
+ * Describes a stored memo set exactly: an unknown key refuses.
+ *
+ * @remarks
+ * `isMemoSnapshot` is the door a hydrate and a store read, and this shape fills a refusal's faults. A
+ * lockstep test holds that `is` implies the guard, and on the snapshot fixtures the converse.
+ */
+export declare const memoSnapshotShape: ObjectShape<    {
+id: StringShape;
+memos: ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: StringShape;
+content: StringShape;
+time: NumberShape;
+origin: OptionalShape<ObjectShape<    {
+conversation: StringShape;
+message: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>;
+
 /**
  * Persists a {@link MemoSnapshot} by its memo set id — the async `get` / `set` / `delete`
  * primitives, holding no expiry, the memo twin of {@link
@@ -8330,6 +9830,45 @@ export declare interface MessageInput {
     readonly thinking?: string;
 }
 
+/** Reads the faults of a refused message input and validates a job's seed messages. */
+export declare const messageInputContract: ContractInterface<Readonly<{
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>>;
+
+/**
+ * Describes a message input's JSON projection: a {@link messageShape} with no `id`, which the
+ * storing conversation mints.
+ *
+ * @remarks
+ * A conversation's `add` checks a hoisted hand guard on every message and reads this shape's `audit`
+ * only to fill a refusal's faults. A job's seed messages cross it at `build`. The role literal admits
+ * `system`, so the conversation's `ROLE` refusal explains that case.
+ */
+export declare const messageInputShape: ObjectShape<    {
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>;
+
 /**
  * Stores immutable {@link Message} records in insertion order and mints each `id` on `add` — the
  * message-store contract every {@link ConversationInterface} satisfies structurally, the
@@ -8576,7 +10115,7 @@ export declare type ProviderDelta = {
  *
  * @remarks
  * The provider base throws this error for a non-OK HTTP response, a missing response
- * body, or a missing settled result when strict assembly is enabled, and with code `'PROTOCOL'`
+ * body, a stream that ended with no settled result and no terminal record, a result or delta the published contract refuses, and with code `'PROTOCOL'`
  * when the framing seam's `parse` or `finish` throws anything but a provider error, with the throw
  * as `cause`. Concrete wire decoders also use it for malformed records and relayed provider
  * failures.
@@ -8587,6 +10126,8 @@ export declare class ProviderError extends Error {
     readonly code: ProviderErrorCode;
     /** Holds the response status for an HTTP failure, or undefined for other codes. */
     readonly status: number | undefined;
+    /** Holds what the refusal found, such as its faults, or undefined when it carries none. */
+    readonly context: Readonly<Record<string, unknown>> | undefined;
     constructor(code: ProviderErrorCode, message: string, options?: ProviderErrorOptions);
 }
 
@@ -8594,7 +10135,7 @@ export declare class ProviderError extends Error {
 export declare type ProviderErrorCode = 
 /** Reports a non-OK HTTP response, including a relay request rejected with status 413. */
 'HTTP'
-/** Reports a missing body, malformed wire record, or missing required settled result. */
+/** Reports a missing body, malformed wire record, a stream that ended with no settled result and no terminal record, or a result or delta the published contract refuses. */
 | 'PROTOCOL'
 /** Reports an upstream provider failure carried by a relay error record. */
 | 'PROVIDER';
@@ -8603,6 +10144,8 @@ export declare type ProviderErrorCode =
 export declare interface ProviderErrorOptions {
     readonly status?: number;
     readonly cause?: unknown;
+    /** Holds the values that locate the failure, such as the `faults` of a refused question. */
+    readonly context?: Readonly<Record<string, unknown>>;
 }
 
 /** Holds the decoded contribution of a wire record to a provider turn. */
@@ -8613,6 +10156,8 @@ export declare interface ProviderIncrement {
     readonly usage?: TokenUsage;
     readonly truncated?: boolean;
     readonly result?: ProviderResult;
+    /** Marks the wire's terminal record, so a strict engine folds every increment into the settled result. */
+    readonly done?: boolean;
 }
 
 /**
@@ -8989,6 +10534,41 @@ export declare function readChunks(body: ReadableStream<Uint8Array>, signal?: Ab
  */
 export declare function readFailure(response: Response, prefix: string, signal: AbortSignal): Promise<FailureRead>;
 
+/**
+ * Reads what a judge result holds for one question, from its own keys alone.
+ *
+ * @param result - The reported answers and refusals
+ * @param id - The question's id
+ * @returns The answer and the refusal, each undefined when the result holds none
+ * @example
+ * ```ts
+ * readJudgeOutcome({ model: 'm', answers: {} }, 'q') // { answer: undefined, refusal: undefined }
+ * ```
+ */
+export declare function readJudgeOutcome(result: JudgeResult, id: string): {
+    readonly answer: JudgeAnswer | undefined;
+    readonly refusal: Refusal | undefined;
+};
+
+/**
+ * Reads a foreign delta's two members once into an owned copy, the value a run checks and consumes.
+ *
+ * @remarks
+ * A stream checks every delta, so this is a hand read rather than a record guard. Reading each member
+ * once means a getter can't pass the check with one value and hand the run another. Unknown members
+ * and a class instance pass, and an unreadable member reads as no delta.
+ *
+ * @param value - The value the stream yielded
+ * @returns The owned delta, or undefined when the value is not one
+ *
+ * @example
+ * ```ts
+ * readProviderDelta({ channel: 'content', text: 'Hi' }) // { channel: 'content', text: 'Hi' }
+ * readProviderDelta({ channel: 'audio', text: 'Hi' }) // undefined
+ * ```
+ */
+export declare function readProviderDelta(value: unknown): ProviderDelta | undefined;
+
 /** Reports a question a wire could not read a candidate for; it lists the caller's keys and invents no probability. */
 export declare interface Refusal {
     readonly missing: readonly string[];
@@ -9581,26 +11161,27 @@ export declare function renderSection<T>(open: string, members: readonly T[], re
 export declare function renderStub(name: string, args: Readonly<Record<string, unknown>>, state: LedgerLookupState): string;
 
 /**
- * Renders a tool's output as the string content of its tool message.
+ * Renders a tool's output as the string content of its tool message, or returns `undefined` when JSON
+ * cannot carry it.
  *
  * @remarks
  * A string passes through unchanged and `undefined` renders as `''`. Any other value renders as
  * its `JSON.stringify` text, byte for byte, when JSON can carry it. A value JSON cannot carry (a
- * `BigInt`, a cycle, a symbol, a throwing `toJSON`) renders as `String(value)`, and as `''` when
- * that conversion throws too, so a tool's output never rejects the run that dispatched it.
+ * `BigInt`, a cycle, a symbol, a function, a throwing `toJSON`) returns `undefined`, which
+ * {@link settleToolResult} turns into a tool failure.
  *
  * @param value - The tool's output (`ToolSuccess.value`, which may be `undefined`)
- * @returns The message content
+ * @returns The message content, or `undefined` when JSON cannot carry the value
  *
  * @example
  * ```ts
  * renderToolValue('sunny') // 'sunny'
  * renderToolValue({ count: 2 }) // '{"count":2}'
  * renderToolValue(undefined) // ''
- * renderToolValue(10n) // '10'
+ * renderToolValue(10n) // undefined
  * ```
  */
-export declare function renderToolValue(value: unknown): string;
+export declare function renderToolValue(value: unknown): string | undefined;
 
 /**
  * Renders topic names as a comma-separated list in their supplied order.
@@ -9652,6 +11233,28 @@ export declare interface RequestMeasure {
  */
 export declare function requestToRelay(request: ProviderRequest): ProviderRequest;
 
+/**
+ * Checks a run's final answer against its schema: the content must parse as JSON and satisfy the
+ * schema, or the call throws a coded error carrying the faults.
+ *
+ * @remarks
+ * The schema enters through the lenient `schemaToShape`, which widens every keyword it cannot express
+ * and never narrows, because a provider constrains its own output and a false refusal would discard a
+ * good answer. The check is `is`, because `explain` alone passes what `parse` would repair. Each call
+ * compiles once, and a run has one final answer.
+ *
+ * @param content - The final answer's text
+ * @param schema - The run's JSON Schema
+ * @throws {AgentError} Thrown when the content is not JSON, misses the schema, or the schema does not compile (code `'SCHEMA'`), with the faults under `context.faults` for the first two
+ *
+ * @example
+ * ```ts
+ * requireAnswer('{"a":5}', { type: 'object', properties: { a: { type: 'number' } } })
+ * requireAnswer('nope', { type: 'object' }) // throws AgentError ('SCHEMA')
+ * ```
+ */
+export declare function requireAnswer(content: string, schema: Readonly<Record<string, unknown>>): void;
+
 /**
  * Returns a run's budget or allowance after checking it implements `BudgetInterface`, or throws a
  * coded error before the run starts it.
@@ -9700,28 +11303,29 @@ export declare function requireConversation(value: unknown): ConversationInterfa
  * throws a coded error.
  *
  * @remarks
- * The check reads `id`, `sections`, `messages`, and `judgments` from `value` once each and builds
- * a candidate from those reads: each array member becomes a fresh array holding the same element
- * objects, and a member that is not an array stays as read, so the guard refuses it. The candidate
- * must pass `isConversationSnapshot`, every section message and live message must play a
- * `ConversationRole`, and no id may repeat across section ids, section message ids, and live
+ * The check reads every own member of `value` once and builds a candidate from those reads: each
+ * array member becomes a fresh array holding the same element objects, and a member that is not an
+ * array stays as read, so the guard refuses it. The candidate must pass `isConversationSnapshot`, which
+ * is exact, so an unknown key refuses rather than being dropped; every section message and live message
+ * must play a `ConversationRole`; and no id may repeat across section ids, section message ids, and live
  * message ids. The `'ROLE'` refusal of a `system` message names the row a snapshot written before
  * 0.0.35 can hold, and each `'SNAPSHOT'` refusal asks for what `snapshot()` returned. The candidate
  * is returned, never `value`, so the check and the seating share one read. Element objects are kept
  * by reference, so a host is trusted not to edit a seated message object or to back its members
- * with accessors.
+ * with accessors. The contract's `audit` runs only after the guard refused, to fill `context.faults`.
  *
  * @param value - The snapshot to check, typically a stored read
- * @returns The candidate snapshot, holding `id`, `sections`, `messages`, and `judgments` when present
- * @throws ConversationError Thrown when the value fails `isConversationSnapshot` or repeats an id (code `'SNAPSHOT'`), or holds a message whose role is not a `ConversationRole` (code `'ROLE'`)
+ * @param contract - The snapshot contract, whose `audit` is read only on a refusal
+ * @returns The candidate snapshot
+ * @throws ConversationError Thrown when the value fails `isConversationSnapshot` (code `'SNAPSHOT'`, its faults under `context.faults`), repeats an id (code `'SNAPSHOT'`), or holds a message whose role is not a `ConversationRole` (code `'ROLE'`)
  *
  * @example
  * ```ts
- * requireConversationSnapshot({ id: 'c1', sections: [], messages: [] }) // { id: 'c1', sections: [], messages: [] }
- * requireConversationSnapshot({ id: 'c1', sections: 'nope', messages: [] }) // throws ConversationError ('SNAPSHOT')
+ * requireConversationSnapshot({ id: 'c1', sections: [], messages: [] }, conversationSnapshotContract) // { id: 'c1', sections: [], messages: [] }
+ * requireConversationSnapshot({ id: 'c1', sections: 'nope', messages: [] }, conversationSnapshotContract) // throws ConversationError ('SNAPSHOT')
  * ```
  */
-export declare function requireConversationSnapshot(value: unknown): ConversationSnapshot;
+export declare function requireConversationSnapshot(value: unknown, contract: Pick<ContractInterface<unknown>, 'audit' | 'schema'>): ConversationSnapshot;
 
 /**
  * Returns the cumulative switch after checking it does not combine with a `sections` cap, or throws a
@@ -9752,7 +11356,7 @@ export declare function requireCumulative(cumulative: boolean, cap: number | und
  * @param category - The registry category named in an error
  * @param name - The requested key
  * @returns The registered value
- * @throws {AgentError} Thrown when the name is absent, with code REGISTRY and a `context` naming the `category` and the `name`.
+ * @throws {AgentError} Thrown when the name is absent, with code REGISTRY, the name encoded and capped in its text because a tool refusal reaches a model, and a `context` naming the `category` and the `name`.
  * @example
  * ```ts
  * requireEntry(new Map([['main', provider]]), 'provider', 'main') // provider
@@ -9760,6 +11364,47 @@ export declare function requireCumulative(cumulative: boolean, cap: number | und
  */
 export declare function requireEntry<T>(pool: ReadonlyMap<string, T>, category: string, name: string): T;
 
+/**
+ * Returns an authority's no-match decision after checking the options carry one, or throws a coded
+ * error naming the two fallbacks a host chooses between.
+ *
+ * @remarks
+ * A rules list says nothing about the calls it does not match, so no fallback is assumed: a denylist
+ * and an allowlist differ only here. The check is {@link isAuthorityDecision}, a total guard, so a
+ * missing options object and a malformed fallback refuse alike.
+ *
+ * @param options - The authority's options as a host passed them
+ * @returns The fallback, narrowed to an {@link AuthorityDecision}
+ * @throws {AgentError} Thrown when the options carry no valid `fallback` (code `'AUTHORITY'`)
+ *
+ * @example
+ * ```ts
+ * requireFallback({ fallback: { zone: 'default', verdict: 'deny' } }) // { zone: 'default', verdict: 'deny' }
+ * ```
+ */
+export declare function requireFallback(options: AuthorityOptions): AuthorityDecision;
+
+/**
+ * Returns after checking a complete judge result answered or refused every question it was asked, or
+ * throws a coded error naming those it left out.
+ *
+ * @remarks
+ * A cancelled call's partial is not complete, so `JudgmentManager` reads this on a settled result only,
+ * and {@link buildJudgments} stores whatever a partial holds.
+ *
+ * An undefined value is no answer, as {@link buildJudgments} reads it, so a key alone doesn't count.
+ *
+ * @param request - The request whose question keys must be answered
+ * @param result - The result the judge settled
+ * @throws ConversationError Thrown when a question has neither an answer nor a refusal (code `'JUDGMENT'`), naming them under `context.questions`
+ * @example
+ * ```ts
+ * requireJudgeResult({ state: 'text', questions: { a: { form: 'noul' } } }, { model: 'm', answers: {} })
+ * // throws ConversationError ('JUDGMENT')
+ * ```
+ */
+export declare function requireJudgeResult(request: JudgeRequest, result: JudgeResult): void;
+
 /**
  * Returns a stored judgment record after checking it, or throws a coded error.
  *
@@ -9801,26 +11446,67 @@ export declare function requireJudgment(value: unknown): Judgment;
 export declare function requireKeep(keep: number): number;
 
 /**
- * Returns a tool-iteration cap after checking it is a nonnegative safe integer, or throws a coded
- * error.
+ * Returns a tool-iteration cap after checking it is a positive safe integer, or throws a coded error.
  *
  * @remarks
- * The check is {@link import('../validators.js').isNonNegativeSafeInteger}, so `0` and `-0`
- * pass while `NaN`, a fraction, a negative, and either infinity are refused. The error's `context`
- * carries the refused value as `limit`.
+ * The check is {@link import('../validators.js').isPositiveSafeInteger}, so `0`, `-0`, `NaN`, a
+ * fraction, a negative, and either infinity are refused, because a run of no turns asks the provider
+ * nothing and answers nothing. The error's `context` carries the refused value as `limit`.
  *
  * @param limit - The tool-iteration cap to check
  * @returns The cap unchanged
- * @throws {AgentError} Thrown when `limit` is not a nonnegative safe integer (code `'LIMIT'`)
+ * @throws {AgentError} Thrown when `limit` is not a positive safe integer (code `'LIMIT'`)
  *
  * @example
  * ```ts
  * requireLimit(3) // 3
- * requireLimit(1.5) // throws AgentError ('LIMIT')
+ * requireLimit(0) // throws AgentError ('LIMIT')
  * ```
  */
 export declare function requireLimit(limit: number): number;
 
+/**
+ * Returns a message input after checking its role and its members, or throws a coded error.
+ *
+ * @remarks
+ * The role goes first, through {@link requireRole}, so its refusal names what it received. The members
+ * cross {@link isMessageInput}, and `audit` runs only after it refused, so a stored message costs one
+ * guard read. Tool-call arguments must also be JSON values before a message is stored.
+ *
+ * @param input - The message input to check
+ * @param contract - The message input contract, whose `audit` is read only on a refusal
+ * @returns The input, narrowed
+ * @throws ConversationError Thrown when the role is not a `ConversationRole` (code `'ROLE'`) or a member fails `isMessageInput` (code `'MESSAGE'`), with the faults under `context.faults`
+ *
+ * @example
+ * ```ts
+ * requireMessageInput({ role: 'user', content: 'hi' }, messageInputContract) // the input
+ * requireMessageInput({ role: 'user' }, messageInputContract) // throws ConversationError ('MESSAGE')
+ * ```
+ */
+export declare function requireMessageInput(input: unknown, contract: Pick<ContractInterface<unknown>, 'audit' | 'schema'>): MessageInput;
+
+/**
+ * Owns a provider's settled result: reads each published member of the foreign value once into a fresh
+ * record, checks that copy, and returns it, or throws a coded error the run rejects with.
+ *
+ * @remarks
+ * The check is {@link isProviderResult}, so a class instance carrying the published members passes and
+ * an unknown member is left behind. `usage` is copied count by count; `tools` keeps the array the
+ * provider returned. An absent `usage` stays absent, which the loop bills as its estimate.
+ *
+ * @param value - The value a provider's stream returned
+ * @returns The owned result
+ * @throws {ProviderError} Thrown when the value does not carry the published members (code `PROTOCOL`)
+ *
+ * @example
+ * ```ts
+ * requireProviderResult({ content: 'answer', extra: true }) // { content: 'answer' }
+ * requireProviderResult({}) // throws ProviderError ('PROTOCOL')
+ * ```
+ */
+export declare function requireProviderResult(value: unknown): ProviderResult;
+
 /**
  * Returns a stored message role after checking it is a conversation role, or throws a coded error.
  *
@@ -9843,15 +11529,34 @@ export declare function requireLimit(limit: number): number;
 export declare function requireRole(role: unknown): ConversationRole;
 
 /**
- * Returns a `sections` cap after checking its lower bound, or throws a coded error.
+ * Returns an authority's rules after checking each one names a verdict, or throws a coded error naming
+ * the first rule that does not.
+ *
+ * @remarks
+ * Absent rules return an empty list. A rule's verdict decides a tool call, so a rule with none is
+ * refused rather than read as an allow. The error's `context` carries the rule's index as `rule`.
+ *
+ * @param rules - The ordered rules, or `undefined` for none
+ * @returns The rules unchanged, or an empty list when none were supplied
+ * @throws {AgentError} Thrown when a rule has no valid `verdict` (code `'AUTHORITY'`)
+ *
+ * @example
+ * ```ts
+ * requireRules([{ match: () => true, zone: 'files', verdict: 'ask' }]).length // 1
+ * ```
+ */
+export declare function requireRules(rules: readonly AuthorityRule[] | undefined): readonly AuthorityRule[];
+
+/**
+ * Returns a `sections` cap after checking it is a positive safe integer, or throws a coded error.
  *
  * @remarks
- * A supplied cap must satisfy `>= 1`; fractional caps and positive infinity pass, and `NaN`
- * is refused. An absent cap leaves the sections list unbounded.
+ * A fraction, positive infinity, and `NaN` are refused with `0` and a negative, because a count of
+ * sections is a whole number. An absent cap leaves the sections list unbounded.
  *
  * @param cap - The cap to check, or `undefined` for no cap
  * @returns The cap unchanged, or `undefined` when none was supplied
- * @throws ConversationError Thrown when the cap does not satisfy `>= 1` (code `'SECTIONS'`, including `NaN`)
+ * @throws ConversationError Thrown when the cap is not a positive safe integer (code `'SECTIONS'`)
  *
  * @example
  * ```ts
@@ -9935,7 +11640,8 @@ export declare function sanitizeToken(value: number): number;
 /**
  * Sanitizes a {@link TokenUsage} into non-negative integers — the guard an agent's
  * abort-usage path applies to a provider's partial usage before it is charged against a
- * budget or folded into the run total.
+ * budget or folded into the run total, because a cancelled stream has no settled result to refuse;
+ * a settled result's usage crosses the provider-result door instead.
  *
  * @remarks
  * Per field (`prompt` / `completion` / `total`): a non-finite value (`NaN`, `+Infinity`,
@@ -9965,6 +11671,39 @@ export declare function sanitizeUsage(usage: TokenUsage): TokenUsage;
  */
 export declare function scanAmendments(amendments: ReadonlyMap<string, readonly string[]>, start: string, admit: (id: string) => boolean): readonly string[];
 
+/**
+ * Scans what a judge's answer must hold to its question: the same form, every probability in
+ * `[0, 1]`, a choice's keys equal to the criteria keys, and a score as long as its levels.
+ *
+ * @remarks
+ * These ties run where a judgment is written, at `JudgmentManager.add` and the `AgentJudge` result
+ * ingestion. A read of a stored record checks only exact keys, literal forms, and number types,
+ * because records written before the ties can miss them.
+ *
+ * @param question - The question that was asked
+ * @param answer - The answer the judge gave
+ * @returns Every broken tie as a fault, or an empty list
+ * @example
+ * ```ts
+ * scanJudgmentTies({ form: 'noul' }, { form: 'noul', noul: 2 })
+ * // [{ reason: 'constraint', path: ['answer', 'noul'], expected: 'number', constraint: 'max', limit: 1, received: '2' }]
+ * ```
+ */
+export declare function scanJudgmentTies(question: JudgeQuestion, answer: JudgeAnswer): readonly AuditFault[];
+
+/**
+ * Scans one probability against `[0, 1]`.
+ *
+ * @param value - The probability
+ * @param path - Where it sits
+ * @returns A constraint fault when it is out of bounds, or an empty list
+ * @example
+ * ```ts
+ * scanProbability(0.5, ['answer', 'noul']) // []
+ * ```
+ */
+export declare function scanProbability(value: number | undefined, path: readonly string[]): readonly AuditFault[];
+
 /**
  * Represents a named, immutable filter over a richer context's items — an optional allow-list per
  * category (`instructions` / `skills` / `memos` / `tools` / `files`), each keyed by that category's
@@ -10252,6 +11991,47 @@ export declare interface Section {
     readonly messages: readonly Message[];
 }
 
+/** Reads the faults of a refused section. */
+export declare const sectionContract: ContractInterface<Readonly<{
+id: string;
+summary: string;
+messages: readonly Readonly<{
+id: string;
+role: "assistant" | "system" | "tool" | "user";
+content: string;
+} & {
+calls?: readonly Readonly<{
+id: string;
+name: string;
+arguments: {
+readonly [k: string]: JSONValue;
+};
+} & {}>[];
+call?: string;
+images?: readonly string[];
+thinking?: string;
+}>[];
+} & {}>>;
+
+/** Describes a compacted section: its id, its summary, and the originals it folded. */
+export declare const sectionShape: ObjectShape<    {
+id: StringShape;
+summary: StringShape;
+messages: ArrayShape<ObjectShape<    {
+id: StringShape;
+role: LiteralShape<readonly ["system", "user", "assistant", "tool"]>;
+content: StringShape;
+calls: OptionalShape<ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+arguments: ObjectShape<Record<never, never>, JSONShape>;
+}, boolean | ContractShape>>>;
+call: OptionalShape<StringShape>;
+images: OptionalShape<ArrayShape<StringShape>>;
+thinking: OptionalShape<StringShape>;
+}, boolean | ContractShape>>;
+}, boolean | ContractShape>;
+
 /**
  * Carries the conversation part of the next prompt and the receipt for it.
  *
@@ -10352,6 +12132,29 @@ export declare function selectRecords(projection: LedgerProjection, request: Led
  */
 export declare function settleAgentJob(agent: AgentInterface, partial: boolean): Promise<AgentResult>;
 
+/**
+ * Settles one dispatched result into the result the loop reports and the content of its tool message,
+ * turning a success whose value JSON cannot carry into a tool failure the model reads.
+ *
+ * @remarks
+ * A failure passes through with its `error` as the content. A success renders through
+ * {@link renderToolValue}. A success that renders to `undefined` becomes the failure arm with the
+ * call's `id` and `name`, whose `error` names the tool and the remedy.
+ *
+ * @param result - The result the tool manager returned for one call
+ * @returns The result to report and the tool message content
+ *
+ * @example
+ * ```ts
+ * settleToolResult({ success: true, id: '1', name: 'read', value: { count: 2 } }).content // '{"count":2}'
+ * settleToolResult({ success: true, id: '1', name: 'read', value: 10n }).outcome.success // false
+ * ```
+ */
+export declare function settleToolResult(result: ToolResult): {
+    readonly outcome: ToolResult;
+    readonly content: string;
+};
+
 /**
  * Holds one skill: a name and a description the index shows, the instructions loading adds, and
  * bundled files.
@@ -10945,7 +12748,7 @@ export declare interface ThinkSplitterInterface {
  * counts, shared by the provider result and the agent frame wires.
  *
  * @remarks
- * The guard refuses extra members; the contract parser drops them.
+ * Each count is a nonnegative number. The guard refuses extra members; the contract parser drops them.
  */
 export declare const tokenUsageShape: ObjectShape<    {
 prompt: NumberShape;
@@ -10955,9 +12758,9 @@ total: NumberShape;
 
 /**
  * Projects an unknown value onto a fresh, exact `TokenUsage` — capturing `prompt`, `completion`, and
- * `total` once each through a total boundary, preserving finite negative and fractional counts,
- * dropping extras, and resolving `undefined` for a non-object, a missing or non-finite count, a
- * throwing getter, or a malformed or revoked proxy.
+ * `total` once each through a total boundary, preserving fractional counts, dropping extras, and
+ * resolving `undefined` for a non-object, a missing, negative, or non-finite count, a throwing getter,
+ * or a malformed or revoked proxy.
  *
  * @remarks
  * The capture runs inside Contract's sanctioned exception boundary, so conforming accessors and
@@ -10966,13 +12769,14 @@ total: NumberShape;
  * before it projects, because this function refuses `undefined` like any other non-object.
  *
  * @param value - The unknown value to project
- * @returns A fresh `{ prompt, completion, total }`, or `undefined` when the value is not a finite usage triple
+ * @returns A fresh `{ prompt, completion, total }`, or `undefined` when the value is not a finite nonnegative usage triple
  *
  * @example
  * ```ts
  * import { tokenUsageToJSON } from '@orkestrel/agent'
  *
- * tokenUsageToJSON({ prompt: 2, completion: -1, total: 1.5, cached: 4 }) // { prompt: 2, completion: -1, total: 1.5 }
+ * tokenUsageToJSON({ prompt: 2, completion: 1, total: 1.5, cached: 4 }) // { prompt: 2, completion: 1, total: 1.5 }
+ * tokenUsageToJSON({ prompt: 2, completion: -1, total: 1 }) // undefined
  * tokenUsageToJSON({ prompt: 2, completion: Infinity, total: 3 }) // undefined
  * ```
  */