@orkestrel/agent 0.0.35 → 0.0.37

package/dist/src/core/index.js

@@ -1,10 +1,10 @@
-import { ContractError, INTRINSICS, andOf, arrayOf, arrayShape, attempt, booleanShape, boundsOf, canonicalStringify, cloneJSONValue, createContract, errorToMessage, failure, holds, isArray, isBoolean, isError, isFiniteNumber, isFunction, isJSONValue, isNumber, isObject, isRecord, isString, jsonShape, literalOf, literalShape, nullableOf, numberShape, objectOf, objectShape, optionalOf, optionalShape, parseJSON, parseJSONAs, parseJSONValue, preview, rawShape, recordOf, recordShape, stringShape, success, unionOf, unionShape, whereOf } from "@orkestrel/contract";
-import { createTokenBudget, createTokenMeter, isBudget, isBudgetError, isTokenUsage } from "@orkestrel/budget";
+import { ContractError, INTRINSICS, arrayOf, arrayShape, attempt, booleanShape, boundsOf, canonicalStringify, cloneJSONValue, createContract, describeFaults, errorToMessage, failure, holds, isArray, isBoolean, isError, isFiniteNumber, isFunction, isJSONValue, isNumber, isObject, isRecord, isString, jsonShape, literalShape, nullableOf, nullableShape, numberShape, objectOf, objectShape, optionalOf, optionalShape, parseJSON, parseJSONAs, parseJSONValue, preview, rawShape, recordOf, recordShape, schemaToShape, stringShape, success, unionOf, unionShape } from "@orkestrel/contract";
+import { createTokenBudget, createTokenMeter, isBudget, isBudgetAmount, isBudgetError, isTokenUsage } from "@orkestrel/budget";
+import { ToolManager, createTool, createToolManager, isToolCall } from "@orkestrel/tool";
 import { createNDJSONParser } from "@orkestrel/ndjson";
 import { Timeout, createTimeout } from "@orkestrel/timeout";
 import { createDatabase, createMemoryDriver } from "@orkestrel/database";
 import { Emitter } from "@orkestrel/emitter";
-import { ToolManager, createTool, createToolManager, isToolCall } from "@orkestrel/tool";
 import { WorkspaceManager, createFile, isBinary, isTextContent } from "@orkestrel/workspace";
 import { createQueue } from "@orkestrel/queue";
 import { createRunner } from "@orkestrel/workflow";
@@ -104,6 +104,23 @@ var toolCallShape = objectShape({
 	arguments: recordShape(jsonShape())
 });
 /**
+* 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.
+*/
+var messageInputShape = objectShape({
+	role: literalShape(MESSAGE_ROLES),
+	content: stringShape(),
+	calls: optionalShape(arrayShape(toolCallShape)),
+	call: optionalShape(stringShape()),
+	images: optionalShape(arrayShape(stringShape())),
+	thinking: optionalShape(stringShape())
+});
+/**
 * Describes a conversation message's JSON wire projection.
 *
 * @remarks
@@ -120,20 +137,83 @@ var messageShape = objectShape({
 	thinking: optionalShape(stringShape())
 });
 /**
+* 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.
+*/
+var judgeEntryShape = unionShape(stringShape({ min: 1 }), arrayShape(jsonShape(), { min: 1 }), recordShape(jsonShape()));
+/**
+* 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`.
+*/
+var judgeQuestionShape = unionShape(objectShape({
+	form: literalShape(["choice"]),
+	instructions: optionalShape(judgeEntryShape),
+	criteria: recordShape(nullableShape(judgeEntryShape))
+}), objectShape({
+	form: literalShape(["score"]),
+	instructions: optionalShape(judgeEntryShape),
+	criteria: arrayShape(nullableShape(judgeEntryShape), { min: 2 })
+}), objectShape({
+	form: literalShape(["noul"]),
+	instructions: optionalShape(judgeEntryShape),
+	criteria: optionalShape(objectShape({
+		true: optionalShape(judgeEntryShape),
+		false: optionalShape(judgeEntryShape)
+	}))
+}));
+/**
+* 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.
+*/
+var judgeAnswerShape = unionShape(objectShape({
+	form: literalShape(["choice"]),
+	probabilities: recordShape(numberShape({
+		min: 0,
+		max: 1
+	}))
+}), objectShape({
+	form: literalShape(["score"]),
+	probabilities: arrayShape(numberShape({
+		min: 0,
+		max: 1
+	}))
+}), objectShape({
+	form: literalShape(["noul"]),
+	noul: numberShape({
+		min: 0,
+		max: 1
+	})
+}));
+/**
 * Describes a token usage record's JSON wire projection — its `prompt`, `completion`, and `total`
 * 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.
 */
 var tokenUsageShape = objectShape({
-	prompt: numberShape(),
-	completion: numberShape(),
-	total: numberShape()
+	prompt: numberShape({ min: 0 }),
+	completion: numberShape({ min: 0 }),
+	total: numberShape({ min: 0 })
 });
 // src/core/contracts.ts
 /** Validates and projects conversation messages at a JSON wire boundary. */
 var messageContract = createContract(messageShape);
+/** Reads the faults of a refused judge question. */
+var judgeQuestionContract = createContract(judgeQuestionShape);
+/** Reads the faults of a refused judge answer. */
+var judgeAnswerContract = createContract(judgeAnswerShape);
+/** Reads the faults of a refused message input and validates a job's seed messages. */
+var messageInputContract = createContract(messageInputShape);
 // src/core/cloners.ts
 /**
 * Owns a value by serializing it to JSON and parsing the text, so the copy shares nothing with its source.
@@ -280,6 +360,168 @@ function stripThinking(messages, replay) {
 	});
 }
 /**
+* Estimates the context-token footprint of a string — the deterministic `ceil(length / 4)`
+* 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).
+* Empty text is `0`. This is a planning heuristic for reasoning about how much a turn's
+* messages cost the next request, not an exact tokenizer count — it never calls a provider,
+* so the agent layer stays provider-agnostic and synchronous where it can be.
+*
+* @param text - The text to estimate (a section summary, a message's content)
+* @returns The estimated token count (`ceil(text.length / 4)`; `0` for empty text)
+*
+* @example
+* ```ts
+* estimateTokens('') // 0
+* estimateTokens('hello') // 2  (ceil(5 / 4))
+* estimateTokens('a'.repeat(40)) // 10
+* ```
+*/
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+/**
+* 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; ...'
+* ```
+*/
+function describeSnapshotRefusal(noun, id, faults) {
+	const [first] = faults;
+	const path = first === void 0 ? [] : isString(first.path) ? [first.path] : first.path;
+	const held = preview(id);
+	return `${noun} ${held} holds a snapshot this version refuses (${first?.reason === "extra" ? `extra key ${preview(path.at(-1))} at ${path.length === 1 ? "the root" : preview(path.slice(0, -1).join("."))}` : first === void 0 ? "a value its shape cannot name" : `${first.reason} at ${path.length === 0 ? "the root" : preview(path.join("."))}`}; a snapshot written before this change can carry it); read the row through your own table and ${first?.reason === "extra" ? "rewrite it without the key" : "rewrite it to the declared shape"}, or delete it with store.delete(${held})`;
+}
+/**
+* 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'
+* ```
+*/
+function describeQuestionRefusal(id, faults, schema) {
+	const refusal = `question ${id} is malformed; a choice names two or more criteria, a score two or more levels, and a noul only true and false`;
+	return faults.length === 0 ? refusal : `${refusal}\n${describeFaults(faults, schema)}`;
+}
+/**
+* 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' }]
+* ```
+*/
+function scanJudgmentTies(question, answer) {
+	if (question.form === "noul" && answer.form === "noul") return scanProbability(answer.noul, ["answer", "noul"]);
+	if (question.form === "choice" && answer.form === "choice") {
+		const wanted = Object.keys(question.criteria);
+		const held = Object.keys(answer.probabilities);
+		return [
+			...wanted.filter((key) => !Object.hasOwn(answer.probabilities, key)).map((key) => ({
+				reason: "missing",
+				path: [
+					"answer",
+					"probabilities",
+					key
+				],
+				expected: "number"
+			})),
+			...held.filter((key) => !Object.hasOwn(question.criteria, key)).map((key) => ({
+				reason: "extra",
+				path: [
+					"answer",
+					"probabilities",
+					key
+				]
+			})),
+			...held.flatMap((key) => scanProbability(answer.probabilities[key], [
+				"answer",
+				"probabilities",
+				key
+			]))
+		];
+	}
+	if (question.form === "score" && answer.form === "score") {
+		const levels = question.criteria.length;
+		const count = answer.probabilities.length;
+		return [...count === levels ? [] : [{
+			reason: "constraint",
+			path: ["answer", "probabilities"],
+			expected: "array",
+			constraint: count < levels ? "min" : "max",
+			limit: levels,
+			received: String(count)
+		}], ...answer.probabilities.flatMap((value, index) => scanProbability(value, [
+			"answer",
+			"probabilities",
+			String(index)
+		]))];
+	}
+	return [{
+		reason: "type",
+		path: ["answer", "form"],
+		expected: "literal",
+		received: answer.form
+	}];
+}
+/**
+* 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']) // []
+* ```
+*/
+function scanProbability(value, path) {
+	if (value !== void 0 && value >= 0 && value <= 1) return [];
+	return [{
+		reason: "constraint",
+		path,
+		expected: "number",
+		constraint: value !== void 0 && value < 0 ? "min" : "max",
+		limit: value !== void 0 && value < 0 ? 0 : 1,
+		received: String(value)
+	}];
+}
+/**
 * Sanitizes one reported token count into a non-negative integer — a non-finite or
 * non-positive value becomes `0`, and a positive fractional value floors down.
 *
@@ -298,7 +540,8 @@ function sanitizeToken(value) {
 /**
 * 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`,
@@ -578,14 +821,16 @@ function extractLiterals(text) {
 }
 // src/core/validators.ts
 /**
-* Checks whether a value is a judge entry: a string, a JSON record, or a JSON array.
+* 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
@@ -595,8 +840,9 @@ function extractLiterals(text) {
 * ```
 */
 function isJudgeEntry(value) {
-	if (isString(value)) return true;
-	return (isRecord(value) || isArray(value)) && isJSONValue(value);
+	if (isString(value)) return value.length > 0;
+	if (isArray(value)) return isJSONValue(value) && value.length > 0;
+	return isRecord(value) && isJSONValue(value) && Object.keys(value).length > 0;
 }
 /**
 * Checks whether a value is a well-formed judge question of the choice, score, or noul form.
@@ -604,8 +850,10 @@ function isJudgeEntry(value) {
 * @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
@@ -622,16 +870,60 @@ function isJudgeQuestion(value) {
 		if (!isRecord(value)) return false;
 		const { form, instructions, criteria } = value;
 		if (instructions !== void 0 && !isJudgeEntry(instructions)) return false;
+		const owned = 1 + (instructions === void 0 ? 0 : 1) + (criteria === void 0 ? 0 : 1);
+		if (Object.keys(value).length !== owned) return false;
 		if (form === "choice") return isRecord(criteria) && Object.keys(criteria).length >= 2 && Object.values(criteria).every(nullableOf(isJudgeEntry));
 		if (form === "score") return arrayOf(nullableOf(isJudgeEntry))(criteria) && criteria.length >= 2;
 		if (form !== "noul") return false;
 		if (criteria === void 0) return true;
 		if (!isRecord(criteria)) return false;
-		return optionalOf(isJudgeEntry)(criteria.true) && optionalOf(isJudgeEntry)(criteria.false);
+		const held = (criteria.true === void 0 ? 0 : 1) + (criteria.false === void 0 ? 0 : 1);
+		return Object.keys(criteria).length === held && optionalOf(isJudgeEntry)(criteria.true) && optionalOf(isJudgeEntry)(criteria.false);
 	});
 	return checked.success && checked.value;
 }
 /**
+* 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
+* ```
+*/
+function isJudgeAnswer(value) {
+	return holds(() => {
+		if (!isRecord(value) || Object.keys(value).length !== 2) return false;
+		const { form, noul, probabilities } = value;
+		if (form === "noul") return isFiniteNumber(noul) && noul >= 0 && noul <= 1;
+		if (form === "score") return arrayOf(isFiniteNumber)(probabilities);
+		return form === "choice" && isRecord(probabilities) && Object.values(probabilities).every(isFiniteNumber);
+	});
+}
+/**
+* Checks whether a value is a positive safe integer.
+* @param value - The value to inspect
+* @returns True if the value is a positive safe integer; false otherwise
+* @example
+* ```ts
+* isPositiveSafeInteger(4096) // true
+* isPositiveSafeInteger(0) // false
+* ```
+*/
+function isPositiveSafeInteger(value) {
+	return isFiniteNumber(value) && Number.isSafeInteger(value) && value > 0;
+}
+/**
 * Checks whether a value is a non-negative safe integer, `-0` included.
 *
 * @remarks
@@ -791,7 +1083,7 @@ function isProviderAbortError(value) {
 *
 * @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.
@@ -802,12 +1094,15 @@ var ProviderError = class extends Error {
 	code;
 	/** Holds the response status for an HTTP failure, or undefined for other codes. */
 	status;
+	/** Holds what the refusal found, such as its faults, or undefined when it carries none. */
+	context;
 	constructor(code, message, options) {
 		super(message, options);
 		this.name = "ProviderError";
 		INTRINSICS.define(this, Symbol.for("@orkestrel/agent.ProviderError"), { value: this });
 		this.code = code;
 		this.status = options?.status;
+		this.context = options?.context;
 	}
 };
 /**
@@ -826,7 +1121,8 @@ function isProviderError(value) {
 		const code = INTRINSICS.reflect.read(value, "code");
 		if (!(code === "HTTP" || code === "PROTOCOL" || code === "PROVIDER")) return false;
 		const status = INTRINSICS.reflect.read(value, "status");
-		return status === void 0 || isNumber(status);
+		const context = INTRINSICS.reflect.read(value, "context");
+		return (status === void 0 || isNumber(status)) && (context === void 0 || isObject(context) || isFunction(context));
 	});
 }
 /**
@@ -843,12 +1139,15 @@ var JudgeError = class extends Error {
 	code;
 	/** Holds the response status for an HTTP failure, or undefined for other codes. */
 	status;
+	/** Holds the values that locate the failure, such as the `faults` of a refused question, or `undefined` when none were supplied. */
+	context;
 	constructor(code, message, options) {
 		super(message, options);
 		this.name = "JudgeError";
 		INTRINSICS.define(this, Symbol.for("@orkestrel/agent.JudgeError"), { value: this });
 		this.code = code;
 		this.status = options?.status;
+		this.context = options?.context;
 	}
 };
 /**
@@ -867,7 +1166,8 @@ function isJudgeError(value) {
 		const code = INTRINSICS.reflect.read(value, "code");
 		if (!(code === "HTTP" || code === "PROTOCOL" || code === "QUESTION")) return false;
 		const status = INTRINSICS.reflect.read(value, "status");
-		return status === void 0 || isNumber(status);
+		const context = INTRINSICS.reflect.read(value, "context");
+		return (status === void 0 || isNumber(status)) && (context === void 0 || isObject(context) || isFunction(context));
 	});
 }
 // src/core/providers/shapers.ts
@@ -933,6 +1233,100 @@ var providerRequestContract = createContract(providerRequestShape);
 var providerResultContract = createContract(providerResultShape);
 /** Validates and projects channel-discriminated relay frames at a JSON wire boundary. */
 var relayFrameContract = createContract(relayFrameShape);
+// src/core/providers/validators.ts
+/**
+* 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
+* ```
+*/
+var isProviderResult = objectOf({
+	content: isString,
+	thinking: isString,
+	tools: arrayOf(isToolCall),
+	usage: objectOf({
+		prompt: isBudgetAmount,
+		completion: isBudgetAmount,
+		total: isBudgetAmount
+	}),
+	truncated: isBoolean
+}, [
+	"thinking",
+	"tools",
+	"usage",
+	"truncated"
+]);
+/**
+* Checks whether a value is a System One response envelope with optional model and usage.
+*
+* @remarks
+* Answers remain unknown until checked against their questions. Missing and null usage counts
+* are accepted. Extra members are ignored, and unreadable fields return false.
+*
+* @param value - The unknown response candidate
+* @returns True if the envelope fields have their wire types; false otherwise
+* @example
+* ```ts
+* isSystemOneResponse({ answers: {}, usage: { input_tokens: null } }) // true
+* ```
+*/
+function isSystemOneResponse(value) {
+	const checked = attempt(() => {
+		if (!isRecord(value)) return false;
+		const { model, answers, usage } = value;
+		if (!optionalOf(isString)(model) || !isRecord(answers)) return false;
+		if (usage === void 0) return true;
+		if (!isRecord(usage)) return false;
+		return optionalOf(nullableOf(isNumber))(usage.input_tokens) && optionalOf(nullableOf(isNumber))(usage.output_tokens);
+	});
+	return checked.success && checked.value;
+}
+/**
+* Checks whether a value is a System One answer whose type and distribution the wire can read.
+*
+* @remarks
+* The guard checks `type` and the distribution the wire dereferences: the `noul` number for a
+* noul, the `probabilities` map for a choice, and the `probabilities` map or dense array for a
+* score, each probability a finite number in [0, 1]. The `choice`, `score`, `confidence`, and
+* `legend` members are carried unchecked, because the wire never reads them, so a value this
+* guard accepts can hold any value in those members. Distribution sums are not constrained;
+* values are never normalized. A read that throws returns false.
+*
+* @param value - The unknown answer candidate
+* @returns True if the type and the distribution satisfy the wire contract; false otherwise
+* @example
+* ```ts
+* isSystemOneAnswer({ type: 'noul', noul: 0.9 }) // true
+* isSystemOneAnswer({ type: 'score', probabilities: [0.2, 0.8] }) // true
+* isSystemOneAnswer({ type: 'noul', noul: 1.1 }) // false
+* ```
+*/
+function isSystemOneAnswer(value) {
+	const checked = attempt(() => {
+		if (!isRecord(value)) return false;
+		const { type } = value;
+		if (type === "noul") return boundsOf(0, 1)(value.noul);
+		if (type !== "choice" && type !== "score") return false;
+		const { probabilities } = value;
+		if (type === "score" && isArray(probabilities)) return arrayOf(boundsOf(0, 1))(probabilities);
+		return isRecord(probabilities) && Object.values(probabilities).every(boundsOf(0, 1));
+	});
+	return checked.success && checked.value;
+}
 // src/core/providers/helpers.ts
 /**
 * Assembles a provider result with only populated optional fields.
@@ -958,6 +1352,76 @@ function buildProviderResult(content, thinking, tools, usage, truncated) {
 	};
 }
 /**
+* 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
+* ```
+*/
+function readProviderDelta(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	try {
+		const { channel, text } = value;
+		return (channel === "content" || channel === "thinking") && typeof text === "string" ? {
+			channel,
+			text
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* 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')
+* ```
+*/
+function requireProviderResult(value) {
+	const owned = attempt(() => {
+		if (!isObject(value) && !isFunction(value)) return void 0;
+		const thinking = Reflect.get(value, "thinking");
+		const tools = Reflect.get(value, "tools");
+		const usage = Reflect.get(value, "usage");
+		const truncated = Reflect.get(value, "truncated");
+		return {
+			content: Reflect.get(value, "content"),
+			...thinking === void 0 ? {} : { thinking },
+			...tools === void 0 ? {} : { tools },
+			...usage === void 0 ? {} : { usage: isObject(usage) ? {
+				prompt: Reflect.get(usage, "prompt"),
+				completion: Reflect.get(usage, "completion"),
+				total: Reflect.get(usage, "total")
+			} : usage },
+			...truncated === void 0 ? {} : { truncated }
+		};
+	});
+	if (owned.success && isProviderResult(owned.value)) return owned.value;
+	throw new ProviderError("PROTOCOL", `provider error: a provider must return string content, with thinking, tools, usage, and truncated absent or of their published types, and usage counts finite and nonnegative; received ${preview(owned.success ? owned.value : value)}`, owned.success ? void 0 : { cause: owned.error });
+}
+/**
 * Cancels a stream reader and releases its lock, swallowing a cancellation failure so the
 * caller's own outcome stands.
 *
@@ -1778,7 +2242,8 @@ var ThinkSplitter = class {
 * 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
@@ -1810,7 +2275,8 @@ var ThinkSplitter = class {
 * 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()
@@ -1846,7 +2312,7 @@ var AgentProvider = class {
 		this.#transport = input.fetch ?? globalThis.fetch.bind(globalThis);
 		this.#headers = input.headers;
 		this.#split = input.split ?? true;
-		this.#strict = input.strict ?? false;
+		this.#strict = input.strict ?? true;
 	}
 	/** Exposes the instance's minted UUID. */
 	get id() {
@@ -1941,7 +2407,7 @@ var AgentProvider = class {
 				text: tail
 			};
 			combined.throwIfAborted();
-			if (this.#strict) throw new ProviderError("PROTOCOL", "provider error: missing settled result");
+			if (this.#strict && increments.at(-1)?.done !== true) throw new ProviderError("PROTOCOL", "provider error: the stream ended with no settled result and no terminal record; the response was cut, or a wire with no terminal record passes strict: false");
 			return this.#assemble(splitter, increments);
 		} catch (error) {
 			throw this.#translate(error, combined, splitter, increments);
@@ -2129,7 +2595,9 @@ var RelayProvider = class extends AgentProvider {
 * 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
@@ -2207,7 +2675,13 @@ var AgentJudge = class {
 		if (questions.length === 0) throw new JudgeError("QUESTION", "judge error: no questions");
 		const entries = questions.map(([id, question]) => {
 			const copy = copyJSON(question);
-			if (!isJudgeQuestion(copy)) throw new JudgeError("QUESTION", `judge error: question ${id} is malformed`);
+			if (!isJudgeQuestion(copy)) {
+				const faults = judgeQuestionContract.audit(copy);
+				throw new JudgeError("QUESTION", `judge error: ${describeQuestionRefusal(id, faults, judgeQuestionContract.schema)}`, { context: {
+					question: id,
+					faults
+				} });
+			}
 			return [id, copy];
 		});
 		const owned = {
@@ -2249,7 +2723,24 @@ var AgentJudge = class {
 			if (value === void 0) throw new JudgeError("PROTOCOL", "judge error: invalid JSON body");
 			const result = this.read(value, request);
 			combined.throwIfAborted();
-			return result;
+			for (const [id, answer] of Object.entries(result.answers)) {
+				const question = Object.hasOwn(request.questions, id) ? request.questions[id] : void 0;
+				const faults = question === void 0 ? [] : scanJudgmentTies(question, answer);
+				if (faults.length > 0) throw new JudgeError("PROTOCOL", `judge error: the answer to question ${id} does not fit it\n${describeFaults(faults, judgeAnswerContract.schema)}`, { context: {
+					question: id,
+					faults
+				} });
+			}
+			if (result.usage !== void 0) return result;
+			const estimate = estimateTokens(text.text);
+			return {
+				...result,
+				usage: {
+					prompt: 0,
+					completion: estimate,
+					total: estimate
+				}
+			};
 		} catch (error) {
 			if (combined.aborted) throw new JudgeAbortError(buildJudgeResult(this.#model, completed), error === combined.reason ? void 0 : { cause: error });
 			throw error;
@@ -2258,75 +2749,17 @@ var AgentJudge = class {
 		}
 	}
 };
-// src/core/providers/validators.ts
+// src/core/providers/SystemOneJudge.ts
 /**
-* Checks whether a value is a System One response envelope with optional model and usage.
+* Carries judge questions over the System One protocol and derives answers from server distributions.
 *
 * @remarks
-* Answers remain unknown until checked against their questions. Missing and null usage counts
-* are accepted. Extra members are ignored, and unreadable fields return false.
+* The caller supplies the server origin and model. Every question travels in one request.
+* Server measures are ignored; the response model is preserved.
+* `headers` supplies authentication through the shared judge engine.
+* The example readings are those of the response Ollama 0.40.0 returned for that request on 2026-10-07.
 *
-* @param value - The unknown response candidate
-* @returns True if the envelope fields have their wire types; false otherwise
-* @example
-* ```ts
-* isSystemOneResponse({ answers: {}, usage: { input_tokens: null } }) // true
-* ```
-*/
-function isSystemOneResponse(value) {
-	const checked = attempt(() => {
-		if (!isRecord(value)) return false;
-		const { model, answers, usage } = value;
-		if (!optionalOf(isString)(model) || !isRecord(answers)) return false;
-		if (usage === void 0) return true;
-		if (!isRecord(usage)) return false;
-		return optionalOf(nullableOf(isNumber))(usage.input_tokens) && optionalOf(nullableOf(isNumber))(usage.output_tokens);
-	});
-	return checked.success && checked.value;
-}
-/**
-* Checks whether a value is a System One answer whose type and distribution the wire can read.
-*
-* @remarks
-* The guard checks `type` and the distribution the wire dereferences: the `noul` number for a
-* noul, the `probabilities` map for a choice, and the `probabilities` map or dense array for a
-* score, each probability a finite number in [0, 1]. The `choice`, `score`, `confidence`, and
-* `legend` members are carried unchecked, because the wire never reads them, so a value this
-* guard accepts can hold any value in those members. Distribution sums are not constrained;
-* values are never normalized. A read that throws returns false.
-*
-* @param value - The unknown answer candidate
-* @returns True if the type and the distribution satisfy the wire contract; false otherwise
-* @example
-* ```ts
-* isSystemOneAnswer({ type: 'noul', noul: 0.9 }) // true
-* isSystemOneAnswer({ type: 'score', probabilities: [0.2, 0.8] }) // true
-* isSystemOneAnswer({ type: 'noul', noul: 1.1 }) // false
-* ```
-*/
-function isSystemOneAnswer(value) {
-	const checked = attempt(() => {
-		if (!isRecord(value)) return false;
-		const { type } = value;
-		if (type === "noul") return boundsOf(0, 1)(value.noul);
-		if (type !== "choice" && type !== "score") return false;
-		const { probabilities } = value;
-		if (type === "score" && isArray(probabilities)) return arrayOf(boundsOf(0, 1))(probabilities);
-		return isRecord(probabilities) && Object.values(probabilities).every(boundsOf(0, 1));
-	});
-	return checked.success && checked.value;
-}
-// src/core/providers/SystemOneJudge.ts
-/**
-* Carries judge questions over the System One protocol and derives answers from server distributions.
-*
-* @remarks
-* The caller supplies the server origin and model. Every question travels in one request.
-* Server measures are ignored; the response model is preserved.
-* `headers` supplies authentication through the shared judge engine.
-* The example readings are those of the response Ollama 0.40.0 returned for that request on 2026-10-07.
-*
-* @example Asking a System One server a choice, a noul, and a score
+* @example Asking a System One server a choice, a noul, and a score
 * ```ts
 * import { measureAnswer, createSystemOneJudge } from '@orkestrel/agent'
 *
@@ -2400,11 +2833,11 @@ var SystemOneJudge = class extends AgentJudge {
 	* the message names the question id of an invalid answer
 	*/
 	read(value, request) {
-		if (!isSystemOneResponse(value)) throw new JudgeError("PROTOCOL", "judge error: invalid System One response envelope");
+		if (!isSystemOneResponse(value)) throw new JudgeError("PROTOCOL", `judge error: invalid System One response envelope; received ${preview(value)}`);
 		const entries = Object.entries(request.questions).map(([id, question]) => {
 			if (!Object.hasOwn(value.answers, id)) throw new JudgeError("PROTOCOL", `judge error: question ${id} has no System One answer`);
 			const wire = value.answers[id];
-			if (!isSystemOneAnswer(wire)) throw new JudgeError("PROTOCOL", `judge error: question ${id} has an invalid System One answer`);
+			if (!isSystemOneAnswer(wire)) throw new JudgeError("PROTOCOL", `judge error: question ${id} has an invalid System One answer; received ${preview(wire)}`);
 			const answer = extractSystemOneAnswer(wire, question);
 			if (answer === void 0) throw new JudgeError("PROTOCOL", `judge error: question ${id} has a mismatched or incomplete System One answer`);
 			return [id, answer];
@@ -2624,12 +3057,12 @@ var CONVERSATION_RECAP_PREFIX = "[Summary of earlier messages] ";
 // src/core/conversations/errors.ts
 /**
 * 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
@@ -2637,7 +3070,7 @@ var CONVERSATION_RECAP_PREFIX = "[Summary of earlier messages] ";
 * 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
@@ -2645,13 +3078,16 @@ var CONVERSATION_RECAP_PREFIX = "[Summary of earlier messages] ";
 * 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`.
 */
 var ConversationError = class 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. */
 	code;
 	/** Holds the values that locate the failure, such as the `question` id of a malformed question, or `undefined` when none were supplied. */
 	context;
@@ -2690,11 +3126,66 @@ function isConversationError(value) {
 	return holds(() => {
 		if (!(value instanceof Error && INTRINSICS.prototype(value) !== Error.prototype && INTRINSICS.describe(value, Symbol.for("@orkestrel/agent.ConversationError"))?.value === value)) return false;
 		const code = INTRINSICS.reflect.read(value, "code");
-		if (!(code === "SUMMARIZER" || code === "SECTIONS" || code === "JUDGMENT" || code === "KEEP" || code === "SUMMARY" || code === "ROLE" || code === "SNAPSHOT")) return false;
+		if (!(code === "SUMMARIZER" || code === "SECTIONS" || code === "JUDGMENT" || code === "KEEP" || code === "SUMMARY" || code === "ROLE" || code === "MESSAGE" || code === "SNAPSHOT" || code === "ID")) return false;
 		const context = INTRINSICS.reflect.read(value, "context");
 		return context === void 0 || isObject(context) || isFunction(context);
 	});
 }
+// src/core/conversations/shapers.ts
+/**
+* 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.
+*/
+var judgmentShape = unionShape(objectShape({
+	id: stringShape(),
+	question: judgeQuestionShape,
+	model: stringShape(),
+	sources: arrayShape(stringShape()),
+	state: stringShape(),
+	time: numberShape(),
+	usage: optionalShape(tokenUsageShape),
+	answer: judgeAnswerShape
+}), objectShape({
+	id: stringShape(),
+	question: judgeQuestionShape,
+	model: stringShape(),
+	sources: arrayShape(stringShape()),
+	state: stringShape(),
+	time: numberShape(),
+	usage: optionalShape(tokenUsageShape),
+	refusal: objectShape({ missing: arrayShape(stringShape()) })
+}));
+/** Describes a compacted section: its id, its summary, and the originals it folded. */
+var sectionShape = objectShape({
+	id: stringShape(),
+	summary: stringShape(),
+	messages: arrayShape(messageShape)
+});
+/**
+* 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.
+*/
+var conversationSnapshotShape = objectShape({
+	id: stringShape(),
+	sections: arrayShape(sectionShape),
+	messages: arrayShape(messageShape),
+	judgments: optionalShape(arrayShape(judgmentShape))
+});
+// src/core/conversations/contracts.ts
+/** Reads the faults of a refused judgment. */
+var judgmentContract = createContract(judgmentShape);
+/** Reads the faults of a refused section. */
+var sectionContract = createContract(sectionShape);
+/** Reads the faults of a refused conversation snapshot. */
+var conversationSnapshotContract = createContract(conversationSnapshotShape);
 // src/core/conversations/validators.ts
 /**
 * Checks whether a value satisfies the domain conversation-message contract.
@@ -2702,8 +3193,9 @@ function isConversationError(value) {
 * @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
@@ -2724,7 +3216,33 @@ function isMessage(value) {
 		if (calls !== void 0 && !arrayOf(isToolCall)(calls)) return false;
 		if (call !== void 0 && !isString(call)) return false;
 		if (images !== void 0 && !arrayOf(isString)(images)) return false;
-		return thinking === void 0 || isString(thinking);
+		if (thinking !== void 0 && !isString(thinking)) return false;
+		return Object.keys(value).length === 3 + (calls === void 0 ? 0 : 1) + (call === void 0 ? 0 : 1) + (images === void 0 ? 0 : 1) + (thinking === void 0 ? 0 : 1);
+	});
+	return checked.success && checked.value;
+}
+/**
+* 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
+* ```
+*/
+function isMessageInput(value) {
+	const checked = attempt(() => {
+		if (!isRecord(value)) return false;
+		const { content, calls, call, images, thinking } = value;
+		return isString(content) && (calls === void 0 || arrayOf(isToolCall)(calls)) && (call === void 0 || isString(call)) && (images === void 0 || arrayOf(isString)(images)) && (thinking === void 0 || isString(thinking));
 	});
 	return checked.success && checked.value;
 }
@@ -2732,11 +3250,13 @@ function isMessage(value) {
 * 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
@@ -2754,16 +3274,7 @@ var isJudgment = unionOf(recordOf({
 	state: isString,
 	time: isFiniteNumber,
 	usage: isTokenUsage,
-	answer: andOf(isRecord, unionOf(objectOf({
-		form: literalOf("noul"),
-		noul: isFiniteNumber
-	}), objectOf({
-		form: literalOf("score"),
-		probabilities: arrayOf(isFiniteNumber)
-	}), objectOf({
-		form: literalOf("choice"),
-		probabilities: whereOf(isRecord, (value) => Object.values(value).every(isFiniteNumber))
-	})))
+	answer: isJudgeAnswer
 }, ["usage"]), recordOf({
 	id: isString,
 	question: isJudgeQuestion,
@@ -2772,7 +3283,7 @@ var isJudgment = unionOf(recordOf({
 	state: isString,
 	time: isFiniteNumber,
 	usage: isTokenUsage,
-	refusal: andOf(isRecord, objectOf({ missing: arrayOf(isString) }))
+	refusal: recordOf({ missing: arrayOf(isString) })
 }, ["usage"]));
 /**
 * Checks whether an `unknown` is structurally a {@link Section} record — a `string` `id` and
@@ -2784,8 +3295,8 @@ var isJudgment = unionOf(recordOf({
 * 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
@@ -2798,11 +3309,11 @@ var isJudgment = unionOf(recordOf({
 * ```
 */
 function isSection(value) {
-	return isRecord(value) && objectOf({
-		id: isString,
-		summary: isString,
-		messages: arrayOf(isMessage)
-	})(value);
+	return holds(() => {
+		if (!isRecord(value) || Object.keys(value).length !== 3) return false;
+		const { id, summary, messages } = value;
+		return isString(id) && isString(summary) && arrayOf(isMessage)(messages);
+	});
 }
 /**
 * Narrows an `unknown` to a {@link ConversationSnapshot} — a `string` `id` and valid
@@ -2818,12 +3329,12 @@ function isSection(value) {
 * 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.
@@ -2839,12 +3350,11 @@ function isSection(value) {
 * ```
 */
 function isConversationSnapshot(value) {
-	return isRecord(value) && objectOf({
-		id: isString,
-		sections: arrayOf(isSection),
-		messages: arrayOf(isMessage),
-		judgments: optionalOf(arrayOf(isJudgment))
-	}, ["judgments"])(value);
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		const { id, sections, messages, judgments } = value;
+		return Object.keys(value).length === (judgments === void 0 ? 3 : 4) && isString(id) && arrayOf(isSection)(sections) && arrayOf(isMessage)(messages) && optionalOf(arrayOf(isJudgment))(judgments);
+	});
 }
 /**
 * Checks whether a value carries the {@link ConversationInterface} members a run reads: a string
@@ -2872,6 +3382,50 @@ function isConversation(value) {
 }
 // src/core/conversations/helpers.ts
 /**
+* 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 }
+* ```
+*/
+function readJudgeOutcome(result, id) {
+	return {
+		answer: Object.hasOwn(result.answers, id) ? result.answers[id] : void 0,
+		refusal: result.refusals !== void 0 && Object.hasOwn(result.refusals, id) ? result.refusals[id] : void 0
+	};
+}
+/**
+* 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')
+* ```
+*/
+function requireJudgeResult(request, result) {
+	const left = Object.keys(request.questions).filter((id) => {
+		const { answer, refusal } = readJudgeOutcome(result, id);
+		return answer === void 0 && refusal === void 0;
+	});
+	if (left.length === 0) return;
+	throw new ConversationError("JUDGMENT", `conversation error: the judge left ${left.map((id) => preview(id)).join(", ")} neither answered nor refused; a judge must answer or refuse every question it is asked`, { context: { questions: left } });
+}
+/**
 * Builds records for answered or refused request keys, attaching usage only for a single question.
 *
 * @param request - The request whose question keys define record order
@@ -2888,8 +3442,7 @@ function isConversation(value) {
 function buildJudgments(request, result, sources, state, model) {
 	const single = Object.keys(request.questions).length === 1;
 	return Object.entries(request.questions).flatMap(([id, question]) => {
-		const answer = Object.hasOwn(result.answers, id) ? result.answers[id] : void 0;
-		const refusal = result.refusals !== void 0 && Object.hasOwn(result.refusals, id) ? result.refusals[id] : void 0;
+		const { answer, refusal } = readJudgeOutcome(result, id);
 		if (answer === void 0 && refusal === void 0) return [];
 		return [{
 			id,
@@ -3001,43 +3554,74 @@ function requireRole(role) {
 	return stored;
 }
 /**
+* 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')
+* ```
+*/
+function requireMessageInput(input, contract) {
+	requireRole(isRecord(input) ? input.role : void 0);
+	if (isMessageInput(input) && (input.calls === void 0 || input.calls.every((call) => isJSONValue(call.arguments)))) return input;
+	const faults = contract.audit(input);
+	throw new ConversationError("MESSAGE", `a message input must carry string content, and calls, call, images, and thinking of their declared types\n${describeFaults(faults, contract.schema)}`, { context: { faults } });
+}
+/**
 * Returns a conversation snapshot after checking its shape, its stored roles, and its ids, or
 * 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')
 * ```
 */
-function requireConversationSnapshot(value) {
+function requireConversationSnapshot(value, contract) {
 	const candidate = attempt(() => {
 		if (!isRecord(value)) return void 0;
-		const { id, sections, messages, judgments } = value;
+		const read = { ...value };
+		const { sections, messages, judgments } = read;
 		return {
-			id,
+			...read,
 			sections: isArray(sections) ? Array.from(sections) : sections,
 			messages: isArray(messages) ? Array.from(messages) : messages,
 			...judgments === void 0 ? {} : { judgments: isArray(judgments) ? Array.from(judgments) : judgments }
 		};
 	});
-	if (!candidate.success || !isConversationSnapshot(candidate.value)) throw new ConversationError("SNAPSHOT", "a conversation snapshot must carry a string id, valid sections and messages, and valid judgments when present; pass what snapshot() returned", candidate.success ? void 0 : { cause: candidate.error });
+	if (!candidate.success) throw new ConversationError("SNAPSHOT", "a conversation snapshot must be readable; pass what snapshot() returned", { cause: candidate.error });
+	if (!isConversationSnapshot(candidate.value)) {
+		const faults = contract.audit(candidate.value);
+		throw new ConversationError("SNAPSHOT", `a conversation snapshot must carry a string id, valid sections and messages, valid judgments when present, and no other member; pass what snapshot() returned\n${describeFaults(faults, contract.schema)}`, { context: { faults } });
+	}
 	const snapshot = candidate.value;
 	snapshot.sections.flatMap((section) => section.messages).concat(snapshot.messages).forEach((message) => {
 		if (message.role === "system") throw new ConversationError("ROLE", "a conversation snapshot holds a system message; a snapshot written before 0.0.35 can hold a system row; remove it before loading");
@@ -3055,15 +3639,15 @@ function requireConversationSnapshot(value) {
 	return snapshot;
 }
 /**
-* Returns a `sections` cap after checking its lower bound, or throws a coded error.
+* 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
@@ -3073,7 +3657,7 @@ function requireConversationSnapshot(value) {
 * ```
 */
 function requireSectionsCap(cap) {
-	if (cap !== void 0 && !(cap >= 1)) throw new ConversationError("SECTIONS", "a sections cap must be >= 1");
+	if (cap !== void 0 && !isPositiveSafeInteger(cap)) throw new ConversationError("SECTIONS", "a sections cap must be a positive safe integer", { context: { sections: cap } });
 	return cap;
 }
 /**
@@ -3231,9 +3815,16 @@ var JudgmentManager = class {
 		const rendered = typeof state === "string" ? state : JSON.stringify(state);
 		const origins = [...sources];
 		const entries = isRecord(request.questions) ? Object.entries(request.questions) : [];
+		if (entries.length === 0) throw new ConversationError("JUDGMENT", "conversation error: a judge request needs at least one question, keyed by id");
 		const checked = entries.map(([id, raw]) => {
 			const question = copyJSON(raw);
-			if (!isJudgeQuestion(question)) throw new ConversationError("JUDGMENT", `conversation error: question ${id} is malformed`, { context: { question: id } });
+			if (!isJudgeQuestion(question)) {
+				const faults = judgeQuestionContract.audit(question);
+				throw new ConversationError("JUDGMENT", `conversation error: ${describeQuestionRefusal(id, faults, judgeQuestionContract.schema)}`, { context: {
+					question: id,
+					faults
+				} });
+			}
 			return [id, question];
 		});
 		const matched = new Map(checked.flatMap(([id, question]) => {
@@ -3258,6 +3849,7 @@ var JudgmentManager = class {
 		});
 		try {
 			const result = await judge.ask(unmatched, signal);
+			requireJudgeResult(unmatched, result);
 			return this.add(buildJudgments(unmatched, result, origins, rendered, judge.model));
 		} catch (error) {
 			if (isJudgeAbortError(error)) this.add(buildJudgments(unmatched, error.partial, origins, rendered, judge.model));
@@ -3266,10 +3858,19 @@ var JudgmentManager = class {
 	}
 	#store(input) {
 		const copy = copyJSON(input);
+		if (isRecord(copy) && copy.answer !== void 0 && !judgeAnswerContract.is(copy.answer)) {
+			const faults = judgeAnswerContract.audit(copy.answer);
+			throw new ConversationError("JUDGMENT", `conversation error: a judgment answer must satisfy its shape\n${describeFaults(faults, judgeAnswerContract.schema)}`, { context: { faults } });
+		}
 		const judgment = requireJudgment(freezeJSON(isRecord(copy) ? {
 			...copy,
 			time: Date.now()
 		} : copy));
+		const faults = judgment.answer === void 0 ? [] : scanJudgmentTies(judgment.question, judgment.answer);
+		if (faults.length > 0) throw new ConversationError("JUDGMENT", `conversation error: judgment ${judgment.id} answers its question wrongly\n${describeFaults(faults, judgeAnswerContract.schema)}`, { context: {
+			question: judgment.id,
+			faults
+		} });
 		this.#judgments.set(judgment.id, judgment);
 		return judgment;
 	}
@@ -3354,7 +3955,7 @@ var Conversation = class {
 	#pending = /* @__PURE__ */ new Set();
 	constructor(options) {
 		const supplied = options?.snapshot;
-		const snapshot = supplied === void 0 ? void 0 : requireConversationSnapshot(supplied);
+		const snapshot = supplied === void 0 ? void 0 : requireConversationSnapshot(supplied, conversationSnapshotContract);
 		this.#judgments = new JudgmentManager(snapshot?.judgments);
 		this.#id = snapshot?.id ?? options?.id ?? crypto.randomUUID();
 		this.#emitter = new Emitter(options);
@@ -3386,10 +3987,10 @@ var Conversation = class {
 	}
 	add(input) {
 		if (isArray(input)) {
-			input.forEach((one) => requireRole(one.role));
+			input.forEach((one) => requireMessageInput(one, messageInputContract));
 			return input.map((one) => this.#create(one));
 		}
-		return this.#create(input);
+		return this.#create(requireMessageInput(input, messageInputContract));
 	}
 	message(id) {
 		return this.#messages.get(id);
@@ -3498,9 +4099,13 @@ var Conversation = class {
 	#create(input) {
 		const message = {
 			id: crypto.randomUUID(),
-			role: requireRole(input.role),
+			role: input.role,
 			content: input.content,
-			...input.calls === void 0 ? {} : { calls: input.calls },
+			...input.calls === void 0 ? {} : { calls: input.calls.map(({ id, name, arguments: arguments_ }) => ({
+				id,
+				name,
+				arguments: arguments_
+			})) },
 			...input.call === void 0 ? {} : { call: input.call },
 			...input.images === void 0 ? {} : { images: input.images },
 			...input.thinking === void 0 ? {} : { thinking: input.thinking }
@@ -3522,7 +4127,8 @@ var Conversation = class {
 * - **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
@@ -3571,6 +4177,8 @@ var ConversationManager = class {
 		return [...this.#conversations.values()];
 	}
 	add(input) {
+		const held = input?.id ?? input?.snapshot?.id;
+		if (held !== void 0 && this.#conversations.has(held)) throw new ConversationError("ID", `conversation ${preview(held)} is already live; pick another id, or remove it first`, { context: { conversation: held } });
 		const sections = input?.sections ?? this.#sections;
 		const summarize = input?.summarize ?? this.#summarize;
 		const conversation = new Conversation({
@@ -3606,7 +4214,8 @@ var ConversationManager = class {
 			this.#active = id;
 			return registered;
 		}
-		if (snapshot === void 0 || snapshot.id !== id) return void 0;
+		if (snapshot === void 0) return void 0;
+		if (snapshot.id !== id) throw new ConversationError("SNAPSHOT", `the store answered ${preview(id)} with the snapshot of ${preview(snapshot.id)}; a store returns only the row of the id it is asked`);
 		const conversation = this.add({ snapshot });
 		this.#active = conversation.id;
 		return conversation;
@@ -3739,8 +4348,9 @@ var MemoryConversationStore = class {
 *   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
@@ -3779,18 +4389,35 @@ var DatabaseConversationStore = class {
 	*
 	* @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`
 	*/
 	async get(id) {
 		const row = await this.#table.get(id);
 		if (row === void 0) return void 0;
 		const snapshot = row.snapshot;
-		return isConversationSnapshot(snapshot) && snapshot.id === id ? snapshot : void 0;
+		if (isConversationSnapshot(snapshot)) {
+			if (snapshot.id === id) return snapshot;
+			const faults = [{
+				reason: "type",
+				path: ["id"],
+				expected: "literal",
+				received: preview(snapshot.id)
+			}];
+			throw new ConversationError("SNAPSHOT", describeSnapshotRefusal("conversation", id, faults), { context: {
+				id,
+				faults
+			} });
+		}
+		const faults = conversationSnapshotContract.audit(snapshot);
+		throw new ConversationError("SNAPSHOT", describeSnapshotRefusal("conversation", id, faults), { context: {
+			id,
+			faults
+		} });
 	}
 	/**
 	* Inserts or replaces under the snapshot's own `id` (no separate id param) — the row is
@@ -3798,8 +4425,14 @@ var DatabaseConversationStore = class {
 	*
 	* @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
 	*/
 	async set(snapshot) {
+		if (!isConversationSnapshot(snapshot)) {
+			const unchecked = snapshot;
+			const faults = conversationSnapshotContract.audit(unchecked);
+			throw new ConversationError("SNAPSHOT", `a conversation store writes only what snapshot() returned\n${describeFaults(faults, conversationSnapshotContract.schema)}`, { context: { faults } });
+		}
 		await this.#table.set({
 			id: snapshot.id,
 			snapshot
@@ -3885,7 +4518,7 @@ function createConversation(options) {
 * @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)` /
@@ -4027,18 +4660,21 @@ var SKILL_SECTION_HEADER = "## Skills";
 // src/core/contexts/errors.ts
 /**
 * 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`.
 */
 var ContextError = class 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. */
 	code;
 	/** Holds the values that locate the failure, or `undefined` when none were supplied. */
 	context;
@@ -4076,7 +4712,8 @@ var ContextError = class extends Error {
 function isContextError(value) {
 	return holds(() => {
 		if (!(value instanceof Error && INTRINSICS.prototype(value) !== Error.prototype && INTRINSICS.describe(value, Symbol.for("@orkestrel/agent.ContextError"))?.value === value)) return false;
-		if (INTRINSICS.reflect.read(value, "code") !== "SNAPSHOT") return false;
+		const code = INTRINSICS.reflect.read(value, "code");
+		if (code !== "SNAPSHOT" && code !== "IMAGES") return false;
 		const context = INTRINSICS.reflect.read(value, "context");
 		return context === void 0 || isObject(context) || isFunction(context);
 	});
@@ -4309,13 +4946,14 @@ function attachImages(message, payloads) {
 * @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
@@ -4326,7 +4964,7 @@ function attachImages(message, payloads) {
 function attachUserImages(conversation, payloads) {
 	if (payloads.length === 0) return conversation;
 	const target = conversation.findLastIndex((message) => message?.role === "user");
-	if (target === -1) return conversation;
+	if (target === -1) throw new ContextError("IMAGES", `the active workspace holds ${payloads.length} image file(s) and the conversation holds no user turn to carry them; add a user message or scope the files out`);
 	return conversation.map((message, index) => index === target ? attachImages(message, payloads) : message);
 }
 /**
@@ -4400,16 +5038,70 @@ function intersectKeys(parent, child) {
 function renderIndexEntry(entry) {
 	return `- ${entry.name}: ${entry.description}`.replace(/[\n\v\f\r\u0085\u2028\u2029]+/g, " ");
 }
+// src/core/contexts/shapers.ts
+/** Describes a stored memo revision exactly. */
+var memoShape = objectShape({
+	id: stringShape(),
+	name: stringShape(),
+	description: stringShape(),
+	content: stringShape(),
+	time: numberShape(),
+	origin: optionalShape(objectShape({
+		conversation: stringShape(),
+		message: optionalShape(stringShape())
+	}))
+});
+/**
+* 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.
+*/
+var memoSnapshotShape = objectShape({
+	id: stringShape(),
+	memos: arrayShape(memoShape)
+});
+// src/core/contexts/contracts.ts
+/** Reads the faults of a refused memo revision. */
+var memoContract = createContract(memoShape);
+/** Reads the faults of a refused memo snapshot. */
+var memoSnapshotContract = createContract(memoSnapshotShape);
 // src/core/contexts/validators.ts
 /**
+* 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
+* ```
+*/
+function isMemoOrigin(value) {
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		const { conversation, message } = value;
+		return isString(conversation) && (message === void 0 || isString(message)) && Object.keys(value).length === (message === void 0 ? 1 : 2);
+	});
+}
+/**
 * 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
@@ -4422,24 +5114,20 @@ function renderIndexEntry(entry) {
 * isMemo({ id: 'm1', name: 'tone', description: 'Prefers short replies.', content: 'Answer briefly.', time: Number.NaN }) // false
 * ```
 */
-var isMemo = andOf(isRecord, objectOf({
-	id: isString,
-	name: isString,
-	description: isString,
-	content: isString,
-	time: isFiniteNumber,
-	origin: andOf(isRecord, objectOf({
-		conversation: isString,
-		message: isString
-	}, ["message"]))
-}, ["origin"]));
+function isMemo(value) {
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		const { id, name, description, content, time, origin } = value;
+		return isString(id) && isString(name) && isString(description) && isString(content) && isFiniteNumber(time) && (origin === void 0 || isMemoOrigin(origin)) && Object.keys(value).length === (origin === void 0 ? 5 : 6);
+	});
+}
 /**
 * 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
@@ -4453,10 +5141,11 @@ var isMemo = andOf(isRecord, objectOf({
 * ```
 */
 function isMemoSnapshot(value) {
-	return isRecord(value) && objectOf({
-		id: isString,
-		memos: arrayOf(isMemo)
-	})(value);
+	return holds(() => {
+		if (!isRecord(value) || Object.keys(value).length !== 2) return false;
+		const { id, memos } = value;
+		return isString(id) && arrayOf(isMemo)(memos);
+	});
 }
 // src/core/contexts/memos/MemoManager.ts
 /**
@@ -4508,7 +5197,10 @@ var MemoManager = class {
 		const supplied = options?.snapshot;
 		const owned = supplied === void 0 ? void 0 : copyJSON(supplied);
 		const snapshot = isMemoSnapshot(owned) ? owned : void 0;
-		if (supplied !== void 0 && snapshot === void 0) throw new ContextError("SNAPSHOT", "context error: memo snapshot is malformed; pass what snapshot() returned");
+		if (supplied !== void 0 && snapshot === void 0) {
+			const faults = memoSnapshotContract.audit(owned);
+			throw new ContextError("SNAPSHOT", `context error: memo snapshot is malformed; pass what snapshot() returned\n${describeFaults(faults, memoSnapshotContract.schema)}`, { context: { faults } });
+		}
 		this.#id = snapshot?.id ?? options?.id ?? crypto.randomUUID();
 		this.#emitter = new Emitter(options);
 		this.#format = options?.format;
@@ -4899,8 +5591,9 @@ var MemoryMemoStore = class {
 *   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
@@ -4933,18 +5626,35 @@ var DatabaseMemoStore = class {
 	*
 	* @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`
 	*/
 	async get(id) {
 		const row = await this.#table.get(id);
 		if (row === void 0) return void 0;
 		const snapshot = row.snapshot;
-		return isMemoSnapshot(snapshot) && snapshot.id === id ? snapshot : void 0;
+		if (isMemoSnapshot(snapshot)) {
+			if (snapshot.id === id) return snapshot;
+			const faults = [{
+				reason: "type",
+				path: ["id"],
+				expected: "literal",
+				received: preview(snapshot.id)
+			}];
+			throw new ContextError("SNAPSHOT", describeSnapshotRefusal("memo set", id, faults), { context: {
+				id,
+				faults
+			} });
+		}
+		const faults = memoSnapshotContract.audit(snapshot);
+		throw new ContextError("SNAPSHOT", describeSnapshotRefusal("memo set", id, faults), { context: {
+			id,
+			faults
+		} });
 	}
 	/**
 	* Inserts or replaces under the snapshot's own `id` (no separate id param) — the row is
@@ -4952,8 +5662,14 @@ var DatabaseMemoStore = class {
 	*
 	* @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
 	*/
 	async set(snapshot) {
+		if (!isMemoSnapshot(snapshot)) {
+			const unchecked = snapshot;
+			const faults = memoSnapshotContract.audit(unchecked);
+			throw new ContextError("SNAPSHOT", `a memo store writes only what snapshot() returned\n${describeFaults(faults, memoSnapshotContract.schema)}`, { context: { faults } });
+		}
 		await this.#table.set({
 			id: snapshot.id,
 			snapshot
@@ -5442,10 +6158,6 @@ function createAgentContext(options) {
 */
 var DEFAULT_AGENT_LIMIT = 10;
 /**
-* Names the default zone for an unmatched tool call allowed by an authority.
-*/
-var DEFAULT_AUTHORITY_ZONE = "default";
-/**
 * Holds the model-facing texts the loop writes after a tool name in a denial result — the
 * `denied` note for a deny with no reason, an evaluate throw, an invalid decision, or a tool
 * changed after its decision; the `refused` note for an ask the approver refused; and the
@@ -5550,13 +6262,16 @@ function isAgentJobError(value) {
 	});
 }
 /**
-* 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
@@ -5565,17 +6280,18 @@ function isAgentJobError(value) {
 * `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`.
 */
 var AgentError = class 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. */
 	code;
 	/** Holds the values that locate the failure, such as the `agent` id of a refused run, or `undefined` when none were supplied. */
 	context;
@@ -5614,13 +6330,34 @@ function isAgentError(value) {
 	return holds(() => {
 		if (!(value instanceof Error && INTRINSICS.prototype(value) !== Error.prototype && INTRINSICS.describe(value, Symbol.for("@orkestrel/agent.AgentError"))?.value === value)) return false;
 		const code = INTRINSICS.reflect.read(value, "code");
-		if (!(code === "APPROVER" || code === "CONCURRENCY" || code === "LIMIT" || code === "REGISTRY" || code === "WINDOW")) return false;
+		if (!(code === "APPROVER" || code === "AUTHORITY" || code === "CONCURRENCY" || code === "LIMIT" || code === "REGISTRY" || code === "SCHEMA" || code === "WINDOW")) return false;
 		const context = INTRINSICS.reflect.read(value, "context");
 		return context === void 0 || isObject(context) || isFunction(context);
 	});
 }
 // src/core/agents/shapers.ts
 /**
+* 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.
+*/
+var agentJobShape = objectShape({
+	provider: stringShape(),
+	messages: optionalShape(arrayShape(messageInputShape)),
+	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(recordShape(jsonShape())))
+});
+/**
 * Describes the agent frame wire — one exact object per `AgentFrame` arm, discriminated by
 * `category`.
 *
@@ -5692,72 +6429,10 @@ var agentAnswerShape = objectShape({
 var agentFrameContract = createContract(agentFrameShape);
 /** Validates and projects agent prompts at the run's `prompt` option and a page's request body. */
 var agentPromptContract = createContract(agentPromptShape);
+/** Checks a durable agent job exactly at `AgentRegistry.build`. */
+var agentJobContract = createContract(agentJobShape);
 /** Validates and projects a page's answers to `ask` frames at a JSON wire boundary. */
 var agentAnswerContract = createContract(agentAnswerShape);
-// src/core/agents/Authority.ts
-/**
-* 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.
-*
-* @remarks
-* - **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`.
-* - **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`
-*   chunk + a tool message) instead of being executed — no tool execution —
-*   so the model receives the denial and can react.
-* - **Approver.** `ask` answers an `ask` verdict through the `ask` option's
-*   {@link AuthorityHandler}, as a promise for a synchronous or an async handler; a handler
-*   throw rejects it. With no handler it rejects with an `AgentError` coded `'APPROVER'`, which
-*   the loop reads as an unanswered ask. It never throws synchronously.
-* - **Synchronous.** `evaluate` returns the verdict directly; only `ask` is async.
-* - **Event-free.** A purely functional gate — no Emitter, no events.
-*
-* @example
-* ```ts
-* // A denylist: deny the `delete` tool, allow everything else (default fallback).
-* const authority = new Authority({
-* 	rules: [{ match: (c) => c.call.name === 'delete', zone: 'restricted', verdict: 'deny' }],
-* })
-* authority.evaluate({ call: { id: '1', name: 'delete', arguments: {} } }) // { zone: 'restricted', verdict: 'deny' }
-* authority.evaluate({ call: { id: '2', name: 'add', arguments: {} } }) // { zone: 'default', verdict: 'allow' }
-* ```
-*/
-var Authority = class {
-	#rules;
-	#fallback;
-	#handler;
-	constructor(options) {
-		this.#rules = options?.rules ?? [];
-		this.#fallback = options?.fallback ?? {
-			zone: "default",
-			verdict: "allow"
-		};
-		this.#handler = options?.ask;
-	}
-	evaluate(context) {
-		for (const rule of this.#rules) if (rule.match(context)) return {
-			zone: rule.zone,
-			verdict: rule.verdict ?? "allow",
-			...rule.reason === void 0 ? {} : { reason: rule.reason }
-		};
-		return this.#fallback;
-	}
-	async ask(context, decision, signal) {
-		if (this.#handler === void 0) throw new AgentError("APPROVER", "an asked call needs an approver and none is set", { context: { tool: context.call.name } });
-		return this.#handler(context, decision, signal);
-	}
-};
 // src/core/agents/ChannelCell.ts
 /**
 * Holds one value a `Channel` buffers and the cell pushed after it.
@@ -5882,20 +6557,61 @@ var Channel = class {
 		});
 	}
 };
+// src/core/agents/validators.ts
+/**
+* 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
+* ```
+*/
+function isAuthorityVerdict(value) {
+	return value === "allow" || value === "ask" || value === "deny";
+}
+/**
+* Checks whether a value is an authority decision: an object whose `zone` is a string, whose
+* `verdict` is `allow`, `ask`, or `deny`, and whose `reason` is absent or a string.
+*
+* @remarks
+* Total: each member is read once, unknown members are admitted, and a non-object, a 0.0.34
+* `{ zone, allowed }` decision, an unknown verdict, a throwing getter, and a revoked or throwing
+* `Proxy` return false rather than throw.
+*
+* @param value - The unknown decision candidate
+* @returns True if the value satisfies the decision contract; false otherwise
+*
+* @example
+* ```ts
+* isAuthorityDecision({ zone: 'default', verdict: 'ask', reason: 'confirm' }) // true
+* isAuthorityDecision({ zone: 'default', allowed: true }) // false
+* ```
+*/
+function isAuthorityDecision(value) {
+	return objectOf({
+		zone: isString,
+		verdict: isAuthorityVerdict,
+		reason: isString
+	}, ["reason"])(value);
+}
 // src/core/agents/helpers.ts
 /**
 * 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
@@ -5962,9 +6678,9 @@ function agentResultToJSON(value) {
 }
 /**
 * 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
@@ -5973,13 +6689,14 @@ function agentResultToJSON(value) {
 * 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
 * ```
 */
@@ -5989,7 +6706,7 @@ function tokenUsageToJSON(value) {
 		const prompt = Reflect.get(value, "prompt");
 		const completion = Reflect.get(value, "completion");
 		const total = Reflect.get(value, "total");
-		return isFiniteNumber(prompt) && isFiniteNumber(completion) && isFiniteNumber(total) ? {
+		return isBudgetAmount(prompt) && isBudgetAmount(completion) && isBudgetAmount(total) ? {
 			prompt,
 			completion,
 			total
@@ -6098,7 +6815,11 @@ function agentResultToFrame(result) {
 * @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))
@@ -6174,30 +6895,6 @@ function inferStop(reason, allowance, budget, provider, turn) {
 	};
 }
 /**
-* 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).
-*
-* @remarks
-* Approximates `ceil(length / 4)` (4 characters per token), so the same input always yields the same estimate (no model round-trip).
-* Empty text is `0`. This is a planning heuristic for reasoning about how much a turn's
-* messages cost the next request, not an exact tokenizer count — it never calls a provider,
-* so the agent layer stays provider-agnostic and synchronous where it can be.
-*
-* @param text - The text to estimate (a section summary, a message's content)
-* @returns The estimated token count (`ceil(text.length / 4)`; `0` for empty text)
-*
-* @example
-* ```ts
-* estimateTokens('') // 0
-* estimateTokens('hello') // 2  (ceil(5 / 4))
-* estimateTokens('a'.repeat(40)) // 10
-* ```
-*/
-function estimateTokens(text) {
-	return Math.ceil(text.length / 4);
-}
-/**
 * 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
@@ -6492,6 +7189,84 @@ function resolveDecision(decision, definition) {
 	};
 }
 /**
+* 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')
+* ```
+*/
+function requireAnswer(content, schema) {
+	const compiled = attempt(() => createContract(schemaToShape(schema)));
+	if (!compiled.success) throw new AgentError("SCHEMA", "the run schema does not compile; pass a JSON Schema built from plain values", { cause: compiled.error });
+	const parsed = parseJSON(content);
+	const faults = parsed === void 0 ? [{
+		reason: "type",
+		path: [],
+		expected: "json",
+		received: preview(content)
+	}] : compiled.value.is(parsed) ? [] : compiled.value.audit(parsed);
+	if (faults.length > 0) throw new AgentError("SCHEMA", `the final answer does not satisfy the run schema; pass strict: false to createAgent to take the raw content from a provider that ignores schemas\n${describeFaults(faults, compiled.value.schema)}`, { context: { faults } });
+}
+/**
+* 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' }
+* ```
+*/
+function requireFallback(options) {
+	const fallback = attempt(() => isObject(options) ? Reflect.get(options, "fallback") : void 0);
+	if (fallback.success && isAuthorityDecision(fallback.value)) return fallback.value;
+	throw new AgentError("AUTHORITY", "an authority needs a fallback for the calls no rule matches; pass fallback: { zone: 'default', verdict: 'deny' } for an allowlist, or fallback: { zone: 'default', verdict: 'allow' } for a denylist");
+}
+/**
+* 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
+* ```
+*/
+function requireRules(rules) {
+	if (rules === void 0) return [];
+	const refused = Array.from(rules).findIndex((rule) => !objectOf({ verdict: isAuthorityVerdict })(rule));
+	if (refused !== -1) throw new AgentError("AUTHORITY", `rule ${refused} has no verdict; set verdict: 'allow' | 'ask' | 'deny'`, { context: { rule: refused } });
+	return rules;
+}
+/**
 * Consumes a reported usage against a budget over what was already charged, so a turn's total
 * draw is never less than the report and nothing is charged twice.
 *
@@ -6521,26 +7296,25 @@ function chargeUsage(budget, usage, charged) {
 	});
 }
 /**
-* 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')
 * ```
 */
 function requireLimit(limit) {
-	if (!isNonNegativeSafeInteger(limit)) throw new AgentError("LIMIT", "a limit must be a nonnegative safe integer", { context: { limit } });
+	if (!isPositiveSafeInteger(limit)) throw new AgentError("LIMIT", "a limit must be a positive safe integer, because a run of no turns answers nothing", { context: { limit } });
 	return limit;
 }
 /**
@@ -6605,32 +7379,69 @@ function requireConversation(value) {
 	});
 }
 /**
-* 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
 * ```
 */
 function renderToolValue(value) {
 	if (typeof value === "string") return value;
 	if (value === void 0) return "";
-	const rendered = renderJSON(value);
-	if (rendered !== void 0) return rendered;
-	const fallback = attempt(() => String(value));
-	return fallback.success ? fallback.value : "";
+	return renderJSON(value);
+}
+/**
+* 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
+* ```
+*/
+function settleToolResult(result) {
+	if (!result.success) return {
+		outcome: result,
+		content: result.error
+	};
+	const content = renderToolValue(result.value);
+	if (content !== void 0) return {
+		outcome: result,
+		content
+	};
+	const error = `${preview(result.name)} returned a value JSON cannot carry; return strings, numbers, booleans, null, arrays, and plain records`;
+	return {
+		outcome: {
+			success: false,
+			id: result.id,
+			name: result.name,
+			error
+		},
+		content: error
+	};
 }
 /**
 * Returns a registered value or throws when its name is absent.
@@ -6638,7 +7449,7 @@ function renderToolValue(value) {
 * @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
@@ -6646,7 +7457,7 @@ function renderToolValue(value) {
 */
 function requireEntry(pool, category, name) {
 	const value = pool.get(name);
-	if (value === void 0) throw new AgentError("REGISTRY", `unknown ${category}: ${name}`, { context: {
+	if (value === void 0) throw new AgentError("REGISTRY", `unknown ${category}: ${preview(name)}`, { context: {
 		category,
 		name
 	} });
@@ -6669,32 +7480,6 @@ function extractQueueOptions(options) {
 		...timeout === void 0 ? {} : { timeout }
 	};
 }
-// src/core/agents/validators.ts
-/**
-* Checks whether a value is an authority decision: an object whose `zone` is a string, whose
-* `verdict` is `allow`, `ask`, or `deny`, and whose `reason` is absent or a string.
-*
-* @remarks
-* Total: each member is read once, unknown members are admitted, and a non-object, a 0.0.34
-* `{ zone, allowed }` decision, an unknown verdict, a throwing getter, and a revoked or throwing
-* `Proxy` return false rather than throw.
-*
-* @param value - The unknown decision candidate
-* @returns True if the value satisfies the decision contract; false otherwise
-*
-* @example
-* ```ts
-* isAuthorityDecision({ zone: 'default', verdict: 'ask', reason: 'confirm' }) // true
-* isAuthorityDecision({ zone: 'default', allowed: true }) // false
-* ```
-*/
-function isAuthorityDecision(value) {
-	return objectOf({
-		zone: isString,
-		verdict: literalOf("allow", "ask", "deny"),
-		reason: isString
-	}, ["reason"])(value);
-}
 // src/core/agents/Agent.ts
 /**
 * Composes a {@link ProviderInterface}, an {@link AgentContext}, and a
@@ -6762,6 +7547,7 @@ var Agent = class {
 	#settled = "idle";
 	#runs = /* @__PURE__ */ new Map();
 	constructor(provider, options) {
+		if (options?.tools !== void 0 && options.authority === void 0) throw new AgentError("AUTHORITY", "tools are set and no authority is; pass authority: createAuthority({ fallback: { zone: 'default', verdict: 'allow' } }) to allow every call, or rules with a deny fallback");
 		this.#limit = requireLimit(options?.limit ?? 10);
 		this.#id = crypto.randomUUID();
 		this.#provider = provider;
@@ -6782,9 +7568,9 @@ var Agent = class {
 		this.#allowance = options?.allowance;
 		this.#scheduler = options?.scheduler;
 		this.#signal = options?.signal;
-		this.#authority = options?.authority ?? new Authority();
+		this.#authority = options?.authority;
 		this.#window = options?.window;
-		this.#strict = options?.strict ?? false;
+		this.#strict = options?.strict ?? true;
 		this.#emitter = new Emitter(options);
 	}
 	get id() {
@@ -6804,14 +7590,17 @@ var Agent = class {
 	}
 	stream(options) {
 		const prompt = options?.prompt;
-		if (prompt !== void 0 && !agentPromptContract.is(prompt)) throw new ContractError("Agent: prompt must be an exact AgentPrompt", {
-			code: "placement",
-			context: {
-				path: ["options", "prompt"],
-				limit: "AgentPrompt",
-				received: preview(prompt)
-			}
-		});
+		if (prompt !== void 0 && !agentPromptContract.is(prompt)) {
+			const faults = attempt(() => describeFaults(agentPromptContract.audit(prompt), agentPromptContract.schema));
+			throw new ContractError(`Agent: prompt must be an exact AgentPrompt${faults.success ? `\n${faults.value}` : ""}`, {
+				code: "placement",
+				context: {
+					path: ["options", "prompt"],
+					limit: "AgentPrompt",
+					received: preview(prompt)
+				}
+			});
+		}
 		const limit = options?.limit === void 0 ? this.#limit : requireLimit(options.limit);
 		const budget = requireBudget(options?.budget ?? this.#budget, "budget");
 		const allowance = requireBudget(options?.allowance ?? this.#allowance, "allowance");
@@ -6899,7 +7688,6 @@ var Agent = class {
 			...schema === void 0 ? {} : { schema }
 		};
 		this.#window?.clear();
-		const cancelled = abort.signal.aborted;
 		const turns = [];
 		while (turns.length < limit && (turns.at(-1)?.outcome ?? "tools") === "tools") {
 			const index = turns.length;
@@ -6974,12 +7762,11 @@ var Agent = class {
 					estimate: settled.estimate
 				};
 			}
-			if (definitions === void 0) for (const call of result.tools ?? []) this.#emitter.emit("deny", call, "no tool is advertised in the active scope", void 0);
-			else if (result.tools !== void 0 && result.tools.length > 0) {
+			if (result.tools !== void 0 && result.tools.length > 0) {
 				const admittedCalls = filterAllowList(names, result.tools, (call) => call.name);
 				const authorization = this.#authorize(result.tools, admittedCalls, advertised, held);
 				if (authorization.asked.length > 0 && !abort.signal.aborted) yield* this.#approve(tools, authorization, abort.signal);
-				if (!abort.signal.aborted) this.#confirm(tools, authorization);
+				if (!abort.signal.aborted) this.#confirm(tools, authorization, advertised);
 				if (abort.signal.aborted) {
 					turns.push({
 						...settled,
@@ -6994,11 +7781,12 @@ var Agent = class {
 					calls: result.tools,
 					...recorded
 				});
-				const results = await this.#dispatch(tools, result.tools, abort.signal, authorization);
+				const results = await this.#dispatch(tools, result.tools, abort.signal, authorization, advertised);
 				const replies = [];
 				for (const [position, call] of result.tools.entries()) {
-					const outcome = results[position];
-					if (outcome === void 0) continue;
+					const dispatched = results[position];
+					if (dispatched === void 0) continue;
+					const { outcome, content } = settleToolResult(dispatched);
 					this.#emitter.emit("tool", call, outcome);
 					yield {
 						category: "tool",
@@ -7007,7 +7795,7 @@ var Agent = class {
 					};
 					replies.push(conversation.add({
 						role: "tool",
-						content: outcome.success ? renderToolValue(outcome.value) : outcome.error,
+						content,
 						call: call.id
 					}));
 				}
@@ -7023,6 +7811,13 @@ var Agent = class {
 				});
 				continue;
 			}
+			if (schema !== void 0 && result.truncated !== true && !abort.signal.aborted) {
+				const answered = attempt(() => requireAnswer(result.content, schema));
+				if (!answered.success) {
+					if (this.#strict) throw answered.error;
+					this.#emitter.emit("fault", answered.error);
+				}
+			}
 			conversation.add({
 				role: "assistant",
 				content: result.content,
@@ -7046,7 +7841,7 @@ var Agent = class {
 				entry.usage,
 				...turns.map((turn) => turn.spent)
 			].reduce((total, one) => one === void 0 ? total : sumUsage(total, one), void 0),
-			partial: final?.partial ?? cancelled,
+			partial: final?.partial ?? abort.signal.aborted,
 			exhausted: final?.outcome === "tools" && !abort.signal.aborted,
 			stop: inferStop(abort.signal.reason, allowance, budget, this.#provider.id, final)
 		};
@@ -7058,8 +7853,7 @@ var Agent = class {
 		const thinking = surfaced !== void 0 && surfaced.length > 0 ? surfaced : void 0;
 		const content = streamed.join("");
 		const estimate = estimateTokens(content);
-		const reported = provided.success ? provided.value.usage : partial?.usage;
-		const usage = reported === void 0 ? void 0 : sanitizeUsage(reported);
+		const usage = provided.success ? provided.value.usage : partial?.usage === void 0 ? void 0 : sanitizeUsage(partial.usage);
 		const charged = allowance === budget ? meter?.charged ?? 0 : 0;
 		const billed = usage ?? (allowance === budget ? void 0 : {
 			prompt: 0,
@@ -7258,6 +8052,11 @@ var Agent = class {
 			return failure(denial);
 		}
 		const authority = this.#authority;
+		if (authority === void 0) {
+			const denial = denyCall(call, void 0);
+			this.#emitter.emit("deny", call, "no authority is set", void 0);
+			return failure(denial);
+		}
 		const evaluated = attempt(() => {
 			const decision = authority.evaluate({ call });
 			if (!isObject(decision)) return void 0;
@@ -7289,7 +8088,7 @@ var Agent = class {
 			this.#emitter.emit("ask", call, decision);
 			if (signal.aborted) return;
 			const answer = new Promise((resolve) => {
-				const ask = authority.ask;
+				const ask = authority?.ask;
 				resolve(ask === void 0 ? {
 					approved: false,
 					reason: void 0,
@@ -7323,21 +8122,33 @@ var Agent = class {
 			}
 		}
 	}
-	#confirm(tools, authorization) {
+	#changed(tools, call, tool, advertised) {
+		const same = attempt(() => {
+			const current = tools.tool(call.name);
+			const definition = advertised.find((entry) => entry.name === call.name);
+			return current === tool && current?.annotations?.consequential === true === (definition?.annotations?.consequential === true);
+		});
+		return !same.success || !same.value;
+	}
+	#confirm(tools, authorization, advertised) {
 		for (const [index, { call, tool }] of authorization.allowed) {
-			if (tools.tool(call.name) === tool) continue;
+			if (!this.#changed(tools, call, tool, advertised)) continue;
 			authorization.allowed.delete(index);
 			authorization.denials.set(index, denyCall(call, AUTHORITY_NOTES.denied));
 			this.#emitter.emit("deny", call, `${call.name} changed after its decision`, void 0);
-			this.#confirm(tools, authorization);
+			this.#confirm(tools, authorization, advertised);
 			return;
 		}
 	}
-	async #dispatch(tools, calls, signal, authorization) {
+	async #dispatch(tools, calls, signal, authorization, advertised) {
 		const { allowed, denials } = authorization;
 		const entries = [...allowed].sort(([left], [right]) => left - right);
-		const batch = entries.map(([, { call }]) => call);
-		const executed = batch.length > 0 ? await tools.execute(batch, { signal }) : [];
+		const started = entries.map(([, { call, tool }]) => {
+			if (!this.#changed(tools, call, tool, advertised)) return tools.execute(call, { signal });
+			this.#emitter.emit("deny", call, `${call.name} changed after its decision`, void 0);
+			return denyCall(call, AUTHORITY_NOTES.denied);
+		});
+		const executed = started.length > 0 ? await Promise.all(started) : [];
 		const results = new Map([...denials, ...entries.flatMap(([index], offset) => {
 			const result = executed[offset];
 			return result === void 0 ? [] : [[index, result]];
@@ -7351,9 +8162,13 @@ var Agent = class {
 				const next = await generator.next();
 				if (next.done === true) {
 					const result = next.value;
-					return attempt(() => result);
+					return attempt(() => requireProviderResult(result));
+				}
+				const delta = readProviderDelta(next.value);
+				if (delta === void 0) {
+					generator.return({ content: "" }).catch(() => {});
+					throw new ProviderError("PROTOCOL", `provider error: a delta must carry a channel of 'content' or 'thinking' and string text; received ${preview(next.value)}`);
 				}
-				const delta = next.value;
 				if (delta.channel === "content") {
 					streamed.push(delta.text);
 					meter?.charge(delta.text);
@@ -7443,6 +8258,67 @@ var AgentFanout = class {
 		return settleAgentJob(this.#registry.build(controller.input, controller.signal), this.#partial);
 	}
 };
+// src/core/agents/Authority.ts
+/**
+* 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 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, 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`
+*   chunk + a tool message) instead of being executed — no tool execution —
+*   so the model receives the denial and can react.
+* - **Approver.** `ask` answers an `ask` verdict through the `ask` option's
+*   {@link AuthorityHandler}, as a promise for a synchronous or an async handler; a handler
+*   throw rejects it. With no handler it rejects with an `AgentError` coded `'APPROVER'`, which
+*   the loop reads as an unanswered ask. It never throws synchronously.
+* - **Synchronous.** `evaluate` returns the verdict directly; only `ask` is async.
+* - **Event-free.** A purely functional gate — no Emitter, no events.
+*
+* @example
+* ```ts
+* // 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' }
+* ```
+*/
+var Authority = class {
+	#rules;
+	#fallback;
+	#handler;
+	constructor(options) {
+		this.#fallback = requireFallback(options);
+		this.#rules = requireRules(options.rules);
+		this.#handler = options.ask;
+	}
+	evaluate(context) {
+		for (const rule of this.#rules) if (rule.match(context)) return {
+			zone: rule.zone,
+			verdict: rule.verdict,
+			...rule.reason === void 0 ? {} : { reason: rule.reason }
+		};
+		return this.#fallback;
+	}
+	async ask(context, decision, signal) {
+		if (this.#handler === void 0) throw new AgentError("APPROVER", "an asked call needs an approver and none is set", { context: { tool: context.call.name } });
+		return this.#handler(context, decision, signal);
+	}
+};
 // src/core/agents/Approver.ts
 /**
 * Holds a server's waiting asks between the run that asked them and the page that answers them — an
@@ -7464,7 +8340,11 @@ var AgentFanout = class {
 * @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
 * ```
 */
@@ -7546,13 +8426,14 @@ var Approver = class {
 *   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.
 *
@@ -7590,14 +8471,18 @@ var AgentRegistry = class {
 		return requireEntry(this.#schedulers, "scheduler", name);
 	}
 	build(input, signal) {
+		const faults = agentJobContract.audit(input);
+		if (faults.length > 0) throw new AgentError("REGISTRY", `a job must hold only the declared members of AgentJobInput\n${describeFaults(faults, agentJobContract.schema)}`, { context: { faults } });
 		const agent = new Agent(this.provider(input.provider), this.#buildOptions(input, signal));
-		for (const message of input.messages) agent.context.messages.add(message);
+		for (const message of input.messages ?? []) agent.context.messages.add(message);
 		return agent;
 	}
 	#buildOptions(input, signal) {
+		const names = input.tools ?? [];
+		if (names.length > 0 && input.authority === void 0) throw new AgentError("REGISTRY", "a job that names tools and no authority cannot run them; add authority: 'NAME' to the job and register that NAME under authorities", { context: { tools: names } });
 		const budget = input.budget === void 0 ? void 0 : createTokenBudget({ max: input.budget });
 		return {
-			tools: this.#buildToolManager(input.tools),
+			...names.length === 0 ? {} : { tools: this.#buildToolManager(names) },
 			...input.system === void 0 ? {} : { system: input.system },
 			...input.limit === void 0 ? {} : { limit: input.limit },
 			...input.timeout === void 0 ? {} : { timeout: input.timeout },
@@ -7610,7 +8495,7 @@ var AgentRegistry = class {
 	}
 	#buildToolManager(names) {
 		const manager = new ToolManager();
-		if (names !== void 0) for (const name of names) manager.add(this.tool(name));
+		for (const name of names) manager.add(this.tool(name));
 		return manager;
 	}
 };
@@ -7692,20 +8577,20 @@ function createChannel() {
 /**
 * 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
@@ -7714,6 +8599,7 @@ function createChannel() {
 * // 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 })
 * ```
@@ -7735,7 +8621,11 @@ function createAuthority(options) {
 * @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)) {
@@ -7764,16 +8654,29 @@ function createApprover() {
 *
 * @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.' }] })
 * ```
 */
 function createAgentRegistry(options) {
@@ -7902,6 +8805,11 @@ var PLACED_CATEGORIES = Object.freeze(["rule", "correction"]);
 var LEDGER_RULES_KEY = "rules";
 /** Prefixes the key of an owner's record, which the owner's id follows. */
 var LEDGER_OWNER_PREFIX = "owner:";
+/** Labels recalled conversation text by its origin. */
+var LEDGER_RECALL_LABELS = Object.freeze({
+	request: "Earlier request:",
+	reply: "Earlier reply:"
+});
 /**
 * Supplies the wording of every question the ledger asks its judge.
 *
@@ -7998,10 +8906,10 @@ var DETERMINISTIC_JUDGE_ERROR = /invalid or duplicate top logprob token/;
 * 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.
@@ -8009,40 +8917,147 @@ var DETERMINISTIC_JUDGE_ERROR = /invalid or duplicate top logprob token/;
 var LedgerError = class extends Error {
 	/** Names the machine-readable condition; the {@link LedgerErrorCode} union describes each code. */
 	code;
+	/** Holds the values that locate the failure, such as the `faults` of a refused snapshot, or `undefined` when none were supplied. */
+	context;
 	/**
 	* 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, message) {
-		super(message);
+	constructor(code, message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
 		this.name = "LedgerError";
 		INTRINSICS.define(this, Symbol.for("@orkestrel/agent.LedgerError"), { value: this });
 		this.code = code;
+		this.context = options?.context;
 	}
 };
 /**
-* Narrows an unknown caught value to a {@link LedgerError} through its identity brand and declared members, so a `catch` can
-* branch on its `code`.
-*
-* @param value - The value to test (typically a `catch` binding)
-* @returns True if `value` is a {@link LedgerError}; false otherwise
-*
+* Narrows an unknown caught value to a {@link LedgerError} through its identity brand and declared members, so a `catch` can
+* branch on its `code`.
+*
+* @param value - The value to test (typically a `catch` binding)
+* @returns True if `value` is a {@link LedgerError}; false otherwise
+*
+* @example
+* ```ts
+* isLedgerError(new LedgerError('GAUGE', 'calibration reported no prompt usage')) // true
+* ```
+*/
+function isLedgerError(value) {
+	return holds(() => {
+		if (!(value instanceof Error && INTRINSICS.prototype(value) !== Error.prototype && INTRINSICS.describe(value, Symbol.for("@orkestrel/agent.LedgerError"))?.value === value)) return false;
+		const code = INTRINSICS.reflect.read(value, "code");
+		if (!(code === "REQUEST" || code === "THRESHOLD" || code === "SHARE" || code === "CAPACITY" || code === "LIMIT" || code === "TOPIC" || code === "LOOKUP" || code === "GAUGE" || code === "REFERENCE" || code === "SNAPSHOT" || code === "QUESTION")) return false;
+		const context = INTRINSICS.reflect.read(value, "context");
+		return context === void 0 || isObject(context) || isFunction(context);
+	});
+}
+// src/core/ledgers/helpers.ts
+/**
+* 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
+* ```
+*/
+function digestLedgerWindow(exchanges, messages) {
+	const byId = new Map(messages.map((message) => [message.id, message]));
+	const held = [...new Set(exchanges.flatMap((entry) => [
+		entry.request,
+		entry.reply,
+		...entry.lines.map((line) => line.source)
+	]))].map((id) => byId.get(id));
+	const callers = messages.filter((message) => message.role === "tool" || message.calls !== void 0);
+	const encoded = attempt(() => {
+		const values = [...held, ...callers].map((message) => canonicalStringify(message));
+		return values.some((value) => value === void 0) ? void 0 : canonicalStringify([values, exchanges.map((entry) => [entry.copy ?? null, entry.lines])]);
+	});
+	if (!encoded.success || encoded.value === void 0) return void 0;
+	const hash = [...encoded.value].reduce((prior, character) => {
+		const code = character.codePointAt(0) ?? 0;
+		return {
+			first: Math.imul(prior.first ^ code, 16777619) >>> 0,
+			second: Math.imul(prior.second ^ code, 16777619) >>> 0
+		};
+	}, {
+		first: 2166136261,
+		second: 3335557771
+	});
+	return hash.first.toString(16).padStart(8, "0") + hash.second.toString(16).padStart(8, "0");
+}
+/**
+* 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
-* isLedgerError(new LedgerError('GAUGE', 'calibration reported no prompt usage')) // true
+* collectRecallMessages(input, new Set(), new Set()) // eligible stored messages
 * ```
 */
-function isLedgerError(value) {
-	return holds(() => {
-		if (!(value instanceof Error && INTRINSICS.prototype(value) !== Error.prototype && INTRINSICS.describe(value, Symbol.for("@orkestrel/agent.LedgerError"))?.value === value)) return false;
-		const code = INTRINSICS.reflect.read(value, "code");
-		if (!(code === "REQUEST" || code === "THRESHOLD" || code === "SHARE" || code === "CAPACITY" || code === "LIMIT" || code === "TOPIC" || code === "LOOKUP" || code === "GAUGE" || code === "REFERENCE" || code === "SNAPSHOT")) return false;
-		return true;
+function collectRecallMessages(input, requests, notes) {
+	const findings = new Set(input.findings.filter((finding) => finding.result !== void 0).map((finding) => finding.id));
+	return input.messages.filter((message) => !notes.has(message.id) && (requests.has(message.id) || message.role === "assistant" && !hasCalls(message) && message.content.trim() !== "" || message.role === "user" && !hasCalls(message) || message.role === "tool" && findings.has(message.id)));
+}
+/**
+* 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
+* ```
+*/
+function hasHiddenRecall(input, request, requests, notes, messages, lines) {
+	const start = input.messages.findIndex((message) => message.id === request);
+	const before = new Set(input.messages.slice(0, Math.max(0, start)).map((message) => message.id));
+	const present = new Map(messages.map((message) => [message.id, message]));
+	const receipts = Map.groupBy(lines, (line) => line.source);
+	return collectRecallMessages(input, requests, notes).some((message) => {
+		if (!before.has(message.id)) return false;
+		if (requests.has(message.id) || message.role === "assistant") return !present.has(message.id);
+		if (present.get(message.id)?.content === message.content) return false;
+		const finding = input.findings.find((one) => one.id === message.id);
+		return !(finding === void 0 ? [message.id] : input.findings.filter((one) => before.has(one.id) && matchesLookup(finding, one)).map((one) => one.id)).some((id) => {
+			if (present.get(id)?.content === message.content) return true;
+			const held = new Set((receipts.get(id) ?? []).map((line) => line.sentence));
+			return splitSentences(message.content).every((_, at) => held.has(at));
+		});
 	});
 }
-// src/core/ledgers/helpers.ts
+/**
+* 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
+* ```
+*/
+function matchesLookup(left, right) {
+	if (left.result === void 0 || right.result === void 0 || left.text !== right.text) return false;
+	if (left.id === right.id) return true;
+	const identity = identifyLookup(left.name, left.arguments);
+	return identity !== void 0 && identity === identifyLookup(right.name, right.arguments);
+}
 /**
 * Collects the live message ids placed in records or left without a record.
 * @param projection - The projected records and unplaced ids
@@ -8599,17 +9614,17 @@ function matchEntities(index, text, partial) {
 * 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,
@@ -8819,10 +9834,12 @@ function splitTopic(topic) {
 * @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
@@ -8830,7 +9847,7 @@ function splitTopic(topic) {
 * cutListing(['first entry', 'second entry'], 1) // 'first entry\n1 older item not shown; name a narrower topic to narrow the recall'
 * ```
 */
-function cutListing(entries, room) {
+function cutListing(entries, room, kind = "older") {
 	const stop = [...entries.keys()].findIndex((at) => at > 0 && estimateMessages([{
 		id: "recall",
 		role: "tool",
@@ -8838,7 +9855,7 @@ function cutListing(entries, room) {
 	}]) > room);
 	const kept = entries.slice(0, stop === -1 ? void 0 : stop);
 	const left = entries.length - kept.length;
-	return [...kept, ...left > 0 ? [`${left} older item${left === 1 ? "" : "s"} not shown; name a narrower topic to narrow the recall`] : []].join("\n");
+	return [...kept, ...left > 0 ? [`${left} ${kind} item${left === 1 ? "" : "s"} not shown; name a narrower topic to narrow the recall`] : []].join("\n");
 }
 /**
 * Checks whether a line is the cut line {@link cutListing} writes.
@@ -8852,7 +9869,7 @@ function cutListing(entries, room) {
 * ```
 */
 function matchesCutLine(line) {
-	return /^\d+ older items? not shown; /.test(line);
+	return /^\d+ (?:older|more) items? not shown; /.test(line);
 }
 /**
 * Renders the tail stub of a lookup result from an earlier request.
@@ -8913,11 +9930,12 @@ function fitSlope(groups) {
 * 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
@@ -8933,7 +9951,14 @@ function collectLive(input) {
 	const position = new Map(input.messages.map((message, at) => [message.id, at]));
 	const findings = input.findings.filter((finding) => position.has(finding.id));
 	const identities = new Map(findings.map((finding) => [finding.id, identifyLookup(finding.name, finding.arguments)]));
-	const current = new Set(findings.filter((finding) => finding.result !== void 0 && !findings.some((later) => identities.get(finding.id) !== void 0 && (position.get(later.id) ?? -1) > (position.get(finding.id) ?? -1) && identities.get(later.id) === identities.get(finding.id))).map((finding) => finding.id));
+	const current = new Set([...Map.groupBy(findings, (finding) => identities.get(finding.id) ?? finding).values()].flatMap((group) => {
+		const ordered = group.toSorted((left, right) => (position.get(left.id) ?? -1) - (position.get(right.id) ?? -1));
+		const last = ordered.at(-1);
+		if (last?.result === void 0) return [];
+		const boundary = ordered.findLastIndex((finding) => finding.result === void 0 || finding.text !== last.text);
+		const first = ordered.slice(boundary + 1).find((finding) => (classification.supersessions.get(finding.id) ?? []).length === 0) ?? ordered[boundary + 1];
+		return first === void 0 ? [] : [first.id];
+	}));
 	return [...new Map(input.messages.map((message) => [message.id, message])).values()].filter((message) => message.role === "user" || message.role === "tool" && current.has(message.id)).map((message) => message.id).filter((id) => !excluded.has(id) && !classification.quiet.has(id) && (classification.supersessions.get(id) ?? []).length === 0);
 }
 /**
@@ -8988,17 +10013,18 @@ function placeMember(input, links, amended, id, seen, settled) {
 	return keys;
 }
 /**
-* 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
@@ -9012,7 +10038,10 @@ function collectAmendments(input, byId, live) {
 	const ordered = [...new Set(input.messages.map((message) => message.id))];
 	const positions = new Map(ordered.map((id, index) => [id, index]));
 	const effective = /* @__PURE__ */ new Set([...live, ...[...byId.values()].filter((message) => message.role !== "assistant" && !excluded.has(message.id) && !classification.quiet.has(message.id) && (classification.supersessions.get(message.id) ?? []).length > 0).map((message) => message.id)]);
-	return ordered.filter((id) => living.has(id)).flatMap((earlier) => [...new Set(classification.amendments.get(earlier) ?? [])].filter((later) => effective.has(later) && positions.has(later)).sort((a, b) => (positions.get(a) ?? 0) - (positions.get(b) ?? 0)).map((later) => ({
+	return ordered.filter((id) => living.has(id)).flatMap((earlier) => [...new Set((classification.amendments.get(earlier) ?? []).filter((later) => effective.has(later) && positions.has(later)).map((later) => {
+		const successors = new Set(scanAmendments(classification.supersessions, later, () => true));
+		return ordered.findLast((id) => living.has(id) && successors.has(id)) ?? later;
+	}))].sort((a, b) => (positions.get(a) ?? 0) - (positions.get(b) ?? 0)).map((later) => ({
 		earlier,
 		later
 	})));
@@ -9058,6 +10087,83 @@ function buildLines(input, byId, id, holders, system) {
 		}];
 	});
 }
+/**
+* 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 })
+* ```
+*/
+function buildLedgerLineKey(line) {
+	return JSON.stringify([
+		line.key,
+		line.title,
+		line.source,
+		line.sentence
+	]);
+}
+/**
+* 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()) // []
+* ```
+*/
+function collectLedgerLines(record, held) {
+	return record.lines.map((line) => ({
+		...line,
+		key: record.key,
+		title: record.title
+	})).filter((line) => !held.has(buildLedgerLineKey(line)));
+}
+/**
+* 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
+* ```
+*/
+function collectLedgerReplies(messages, requests, notes) {
+	const positions = messages.flatMap((message, at) => requests.has(message.id) ? [at] : []);
+	return new Map(positions.flatMap((position, index) => {
+		const request = messages[position];
+		const turns = messages.slice(position + 1, positions[index + 1]);
+		const reply = turns.findLast((message) => message.role === "assistant" && !hasCalls(message));
+		const answers = turns.flatMap((message, at) => message.role === "assistant" && !hasCalls(message) && message.content.trim() !== "" ? [at] : []);
+		const certain = answers.every((at, offset) => offset === 0 || turns.slice((answers[offset - 1] ?? -1) + 1, at).some((message) => notes.has(message.id)));
+		return request !== void 0 && certain && reply !== void 0 && reply.content.trim() !== "" ? [[request.id, reply]] : [];
+	}));
+}
+/**
+* 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
+* ```
+*/
+function collectLedgerEvidence(messages, sources, amendments) {
+	return {
+		messages: new Set(messages.filter((message) => sources.has(message.id)).map((message) => JSON.stringify(["message", message]))),
+		amendments: new Map(amendments.filter((edge) => sources.has(edge.earlier) || sources.has(edge.later)).map((edge) => [JSON.stringify([
+			"edge",
+			edge.earlier,
+			edge.later
+		]), { ...edge }]))
+	};
+}
 // src/core/ledgers/Classifier.ts
 /**
 * Files messages through the conversation's judgment manager and reads their categories and corrections.
@@ -9084,23 +10190,25 @@ var Classifier = class {
 	* 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`
 	*/
 	async classify(requests, signal) {
 		const results = [];
 		const fault = await this.#gather(requests, signal, results).then(() => void 0, (error) => isError(error) ? error : new Error(errorToMessage(error)));
 		const usage = results.reduce((total, result) => result.usage === void 0 ? total : sumUsage(total, result.usage), void 0);
+		const failure = results.find((result) => result.failure !== void 0)?.failure;
 		return {
 			judgments: results.flatMap((result) => result.judgments),
 			attempts: results.flatMap((result) => result.attempts),
 			...fault === void 0 ? {} : { fault },
+			...failure === void 0 ? {} : { failure },
 			...usage === void 0 ? {} : { usage }
 		};
 	}
 	/**
 	* 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) {
 		const message = this.#options.conversation.message(id);
@@ -9109,25 +10217,29 @@ var Classifier = class {
 		if (assigned !== void 0) return assigned;
 		const answer = this.#readCategories(id);
 		const cutoff = this.#options.thresholds.category;
-		return LEDGER_CATEGORIES.flatMap((category) => {
+		const winner = LEDGER_CATEGORIES.flatMap((category) => {
 			const probability = answer?.probabilities[category];
 			return probability !== void 0 && probability >= cutoff ? [{
 				category,
 				probability
 			}] : [];
 		}).reduce((best, candidate) => best === void 0 || candidate.probability > best.probability ? candidate : best, void 0)?.category;
+		return winner !== void 0 && QUIET_CATEGORIES.includes(winner) && !this.quiet(id) ? void 0 : winner;
 	}
 	/**
 	* 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) {
 		const message = this.#options.conversation.message(id);
 		if (message === void 0) return false;
 		const assigned = this.#options.assign(message);
 		if (assigned !== void 0) return QUIET_CATEGORIES.includes(assigned);
-		return this.#weigh(id, QUIET_CATEGORIES) >= this.#options.thresholds.category;
+		if (this.#weigh(id, QUIET_CATEGORIES) < this.#options.thresholds.category) return false;
+		if (message.role !== "user") return true;
+		const literals = extractLiterals(message.content);
+		return literals.ids.size + literals.numbers.size === 0;
 	}
 	/**
 	* Reports whether a message files under a decisive category.
@@ -9166,7 +10278,7 @@ var Classifier = class {
 			if (head !== "amends" && head !== "supersedes" || !isString(earlier) || !isString(later)) return [];
 			const before = this.#options.conversation.message(earlier);
 			const after = this.#options.conversation.message(later);
-			if (before === void 0 || after === void 0 || (this.#readNoul(this.#buildPair(head, earlier, later)) ?? 0) < this.#options.thresholds[head]) return [];
+			if (before === void 0 || after === void 0 || (this.#readNoul(this.#buildPair(head, earlier, later)) ?? 0) < this.#options.thresholds[head] || this.quiet(later)) return [];
 			return head === "amends" && !this.#sharesLiteral(extractLiterals(before.content), extractLiterals(after.content)) ? [] : [{
 				head,
 				earlier,
@@ -9401,86 +10513,26 @@ var Classifier = class {
 				judgments: [],
 				attempts
 			});
-			if (isJudgeError(error) && error.code === "QUESTION" || DETERMINISTIC_JUDGE_ERROR.test(renderCauseChain(error))) this.#failed.add(fingerprint);
 			if (signal.aborted) throw error;
+			const failure = isError(error) ? error : new Error(errorToMessage(error));
+			if (this.#options.strict === false && (isJudgeError(error) && error.code === "QUESTION" || DETERMINISTIC_JUDGE_ERROR.test(renderCauseChain(error)))) this.#failed.add(fingerprint);
 			return {
 				judgments: [],
-				attempts: []
+				attempts: [],
+				failure
 			};
 		}
 	}
 };
-// src/core/ledgers/validators.ts
-/**
-* Checks whether a value is finite and lies in the interval (0, 1].
-* @param value - The value to inspect
-* @returns True if the value is a valid ledger fraction; false otherwise
-* @example
-* ```ts
-* isFraction(0.8) // true
-* ```
-*/
-function isFraction(value) {
-	return isFiniteNumber(value) && value > 0 && value <= 1;
-}
-/**
-* Checks whether a value is a positive safe integer.
-* @param value - The value to inspect
-* @returns True if the value is a positive safe integer; false otherwise
-* @example
-* ```ts
-* isPositiveSafeInteger(4096) // true
-* ```
-*/
-function isPositiveSafeInteger(value) {
-	return isFiniteNumber(value) && Number.isSafeInteger(value) && value > 0;
-}
-/**
-* Checks whether a value is a ledger snapshot whose marked ids name messages of its own conversation.
-*
-* @remarks
-* `conversation` must pass `isConversationSnapshot`, and `requests`, `notes`, and `failures` must be
-* 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
-* or a repeated id, which `requireConversationSnapshot` and the `Conversation` constructor then
-* refuse as the stored-data check a ledger's hydrate runs.
-*
-* @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
-* @example
-* ```ts
-* const conversation = { id: 'c1', sections: [], messages: [{ id: 'm1', role: 'user', content: 'Check FX-111.' }] }
-* isLedgerSnapshot({ conversation, requests: ['m1'], notes: [], failures: [] }) // true
-* isLedgerSnapshot({ conversation, requests: [], notes: [], failures: ['m1'] }) // false
-* ```
-*/
-function isLedgerSnapshot(value) {
-	return holds(() => {
-		if (!isRecord(value)) return false;
-		const { conversation, requests, notes, failures, gauge } = value;
-		if (!isConversationSnapshot(conversation)) return false;
-		const isIds = arrayOf(isString);
-		if (!isIds(requests) || !isIds(notes) || !isIds(failures)) return false;
-		if (gauge !== void 0) {
-			if (!isRecord(gauge)) return false;
-			const { scale, overhead } = gauge;
-			if (!isFiniteNumber(scale) || scale <= 0 || !isFiniteNumber(overhead) || overhead < 0) return false;
-		}
-		const roles = new Map(conversation.messages.map((message) => [message.id, message.role]));
-		return requests.every((id) => roles.get(id) === "user") && notes.every((id) => roles.get(id) === "user") && failures.every((id) => roles.get(id) === "tool");
-	});
-}
 // src/core/ledgers/Gauge.ts
 /**
 * Prices prompts in tokens from a measured scale and overhead cost, and measures the room a request
 * 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.
@@ -9538,7 +10590,7 @@ var Gauge = class {
 	}
 	remainder(calls) {
 		const call = calls.at(-1);
-		const used = isFiniteNumber(call?.prompt) ? call.prompt + (call.completion ?? 0) - (this.#replay === "none" ? call.thinking ?? 0 : 0) : this.#overhead + this.#scale * (call?.estimate ?? 0);
+		const used = isFiniteNumber(call?.prompt) ? call.prompt + (call.completion ?? 0) - (this.#replay === "none" ? call.thinking ?? 0 : 0) : Math.max(0, this.#overhead - (call?.spared ?? 0)) + this.#scale * (call?.estimate ?? 0);
 		return Math.max(0, this.#capacity - used);
 	}
 	reserve(calls, longest) {
@@ -9558,8 +10610,8 @@ var Gauge = class {
 	}
 	observe(calls, reply) {
 		const first = calls[0];
-		if (first !== void 0 && isFiniteNumber(first.prompt) && first.estimate > 0) {
-			const priced = first.prompt - this.#overhead;
+		if (first !== void 0 && isFiniteNumber(first.prompt) && first.estimate > 0 && ((first.spared ?? 0) === 0 || (first.spared ?? 0) >= this.#overhead)) {
+			const priced = first.prompt - Math.max(0, this.#overhead - (first.spared ?? 0));
 			if (priced > 0) this.#scale = priced / first.estimate;
 		}
 		this.#history = [...this.#history, [...calls]];
@@ -9733,8 +10785,12 @@ var LedgerPass = class {
 var LedgerRequest = class {
 	#content;
 	#limit;
+	#faults = /* @__PURE__ */ new Set();
 	#message;
 	#plan;
+	#scope;
+	#draft;
+	#sent;
 	#passes = [];
 	#attempts = [];
 	#admitted = /* @__PURE__ */ new Set();
@@ -9769,6 +10825,16 @@ var LedgerRequest = class {
 	get plan() {
 		return this.#plan;
 	}
+	get scope() {
+		return this.#scope;
+	}
+	apply(scope) {
+		this.#scope = scope;
+	}
+	/** Returns the copy and receipts adopted by the last provider turn. */
+	get sent() {
+		return this.#sent;
+	}
 	/**
 	* Returns the selection the current pass's run adopted last.
 	*
@@ -9824,6 +10890,8 @@ var LedgerRequest = class {
 		this.#passes.at(-1)?.adopt(selection, boundary);
 	}
 	observe(call, position) {
+		const draft = this.#draft;
+		this.#sent = draft !== void 0 && this.selection?.messages.some((message) => message.id === draft.copy.id && message.content === draft.copy.content) ? draft : void 0;
 		this.#passes.at(-1)?.observe(call, position);
 	}
 	spend(usage) {
@@ -9838,8 +10906,15 @@ var LedgerRequest = class {
 		if (message?.thinking === void 0) return;
 		pass.think(computeThinking(message, completion));
 	}
-	file(attempts, plan) {
+	fault(error) {
+		this.#faults.add(error);
+	}
+	faulted(error) {
+		return this.#faults.has(error);
+	}
+	file(attempts, plan, draft) {
 		this.#attempts = [...this.#attempts, ...attempts];
+		this.#draft = draft;
 		if (plan !== void 0) this.#plan = plan;
 	}
 	admit(name, args) {
@@ -9970,6 +11045,156 @@ var LedgerScan = class {
 		return this.#positions.get(id);
 	}
 };
+// src/core/ledgers/shapers.ts
+/** Describes the minimal serialized evidence of a nonempty exchange window. */
+var 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({
+				integer: true,
+				min: 0,
+				max: Number.MAX_SAFE_INTEGER
+			})
+		}))
+	}), { min: 1 }),
+	amendments: arrayShape(objectShape({
+		earlier: stringShape(),
+		later: stringShape()
+	}))
+});
+/**
+* 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.
+*/
+var ledgerSnapshotShape = objectShape({
+	conversation: conversationSnapshotShape,
+	requests: arrayShape(stringShape()),
+	notes: arrayShape(stringShape()),
+	failures: arrayShape(stringShape()),
+	gauge: optionalShape(objectShape({
+		scale: numberShape(),
+		overhead: numberShape()
+	})),
+	window: optionalShape(ledgerWindowShape)
+});
+// src/core/ledgers/contracts.ts
+/** Reads structural faults of a serialized exchange window. */
+var ledgerWindowContract = createContract(ledgerWindowShape);
+/** Reads structural faults of a ledger snapshot, including its optional held exchange window. */
+var ledgerSnapshotContract = createContract(ledgerSnapshotShape);
+// src/core/ledgers/validators.ts
+/**
+* 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
+* ```
+*/
+function isLedgerWindowSnapshot(value) {
+	return holds(() => {
+		if (!isRecord(value) || Object.keys(value).length !== 3 || !isString(value.digest)) return false;
+		const { exchanges, amendments } = value;
+		if (!arrayOf(isRecord)(exchanges) || exchanges.length === 0 || !arrayOf(isRecord)(amendments)) return false;
+		return exchanges.every((entry) => {
+			const { request, reply, copy, lines } = entry;
+			return Object.keys(entry).length === 3 + Number(copy !== void 0) && isString(request) && isString(reply) && (copy === void 0 || isString(copy)) && arrayOf(isRecord)(lines) && lines.every((line) => Object.keys(line).length === 4 && isString(line.key) && isString(line.title) && isString(line.source) && isNonNegativeSafeInteger(line.sentence));
+		}) && amendments.every((edge) => Object.keys(edge).length === 2 && isString(edge.earlier) && isString(edge.later));
+	});
+}
+/**
+* Checks whether a value is finite and lies in the interval (0, 1].
+* @param value - The value to inspect
+* @returns True if the value is a valid ledger fraction; false otherwise
+* @example
+* ```ts
+* isFraction(0.8) // true
+* ```
+*/
+function isFraction(value) {
+	return isFiniteNumber(value) && value > 0 && value <= 1;
+}
+/**
+* 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
+* ```
+*/
+function isLedgerQuestion(value) {
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		const { category, topic, amends, supersedes } = value;
+		if (!isJudgeQuestion(category) || category.form !== "choice") return false;
+		const { criteria } = category;
+		return LEDGER_CATEGORIES.every((one) => isJudgeEntry(criteria[one])) && isString(topic) && topic.trim() !== "" && isJudgeQuestion(amends) && amends.form === "noul" && isJudgeQuestion(supersedes) && supersedes.form === "noul";
+	});
+}
+/**
+* Checks whether a value is a ledger snapshot whose marked ids name messages of its own conversation.
+*
+* @remarks
+* `conversation` must pass `isConversationSnapshot`, and `requests`, `notes`, and `failures` must be
+* 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. 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
+* @example
+* ```ts
+* const conversation = { id: 'c1', sections: [], messages: [{ id: 'm1', role: 'user', content: 'Check FX-111.' }] }
+* isLedgerSnapshot({ conversation, requests: ['m1'], notes: [], failures: [] }) // true
+* isLedgerSnapshot({ conversation, requests: [], notes: [], failures: ['m1'] }) // false
+* ```
+*/
+function isLedgerSnapshot(value) {
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		const { conversation, requests, notes, failures, gauge, window } = value;
+		if (Object.keys(value).length !== 4 + Number(gauge !== void 0) + Number(window !== void 0)) return false;
+		if (!isConversationSnapshot(conversation)) return false;
+		const isIds = arrayOf(isString);
+		if (!isIds(requests) || !isIds(notes) || !isIds(failures)) return false;
+		if (gauge !== void 0) {
+			if (!isRecord(gauge) || Object.keys(gauge).length !== 2) return false;
+			const { scale, overhead } = gauge;
+			if (!isFiniteNumber(scale) || scale <= 0 || !isFiniteNumber(overhead) || overhead < 0) return false;
+		}
+		const roles = new Map(conversation.messages.map((message) => [message.id, message.role]));
+		return requests.every((id) => roles.get(id) === "user") && notes.every((id) => roles.get(id) === "user") && failures.every((id) => roles.get(id) === "tool") && (window === void 0 || isLedgerWindowSnapshot(window));
+	});
+}
 // src/core/ledgers/Ledger.ts
 /**
 * Serves one conversation through classified records, a bounded copy of each request turn that carries them, and a final answer pass.
@@ -9997,13 +11222,16 @@ var Ledger = class {
 	#scans = /* @__PURE__ */ new Set();
 	#calibrations = /* @__PURE__ */ new Set();
 	#gauge;
+	#window = [];
+	#evidence = collectLedgerEvidence([], /* @__PURE__ */ new Set(), []);
 	/**
 	* Composes the conversation, classifier, tools, and agent.
 	* @param provider - The provider that serves the conversation
 	* @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, options) {
@@ -10020,13 +11248,19 @@ var Ledger = class {
 		for (const value of Object.values(options.share ?? {})) if (!isFraction(value)) throw new LedgerError("SHARE", "shares must be finite and in (0, 1]");
 		if (!isPositiveSafeInteger(options.capacity)) throw new LedgerError("CAPACITY", "capacity must be a positive safe integer");
 		this.#predict = resolvePredict(options.predict, options.capacity);
-		for (const value of [options.recall?.limit, options.agent?.limit]) if (value !== void 0 && !isNonNegativeSafeInteger(value)) throw new LedgerError("LIMIT", "limits must be nonnegative safe integers");
+		if (options.recall?.limit !== void 0 && !isNonNegativeSafeInteger(options.recall.limit)) throw new LedgerError("LIMIT", "a recall limit must be a nonnegative safe integer");
+		if (options.agent?.limit !== void 0 && !isPositiveSafeInteger(options.agent.limit)) throw new LedgerError("LIMIT", "an agent limit must be a positive safe integer");
 		const topics = Array.from(options.topics, (topic) => topic.name);
 		if (topics.some((name) => name.trim() === "") || new Set(topics).size !== topics.length) throw new LedgerError("TOPIC", "topic names must be nonempty and unique");
 		const lookups = ["recall", ...Array.from(options.lookups ?? [], (lookup) => lookup.tool.name)];
 		if (new Set(lookups).size !== lookups.length) throw new LedgerError("LOOKUP", "lookup names must be unique and cannot be recall");
+		if (!isLedgerQuestion(options.questions)) throw new LedgerError("QUESTION", "questions must hold a choice category question whose criteria describe every category, a non-empty topic string, and noul amends and supersedes questions; pass the LEDGER_QUESTIONS constant for the measured wording");
 		const snapshot = options.snapshot;
-		if (snapshot !== void 0 && !isLedgerSnapshot(snapshot)) throw new LedgerError("SNAPSHOT", "snapshot must be well formed and mark only messages of its conversation; pass what snapshot() returned");
+		if (snapshot !== void 0 && !isLedgerSnapshot(snapshot)) {
+			const candidate = options.snapshot;
+			const faults = ledgerSnapshotContract.audit(candidate);
+			throw new LedgerError("SNAPSHOT", `snapshot must be well formed and mark only messages of its conversation; pass what snapshot() returned${faults.length === 0 ? "" : `\n${describeFaults(faults, ledgerSnapshotContract.schema)}`}`, { context: { faults } });
+		}
 		this.#provider = provider;
 		this.#replay = provider.replay ?? "none";
 		this.#options = options;
@@ -10057,7 +11291,8 @@ var Ledger = class {
 				return matchEntities(scan?.index ?? buildLedgerIndex(collectRegistry(this.#readLookups(this.#conversation.messages()))), text, partial);
 			},
 			...options.correction === void 0 ? {} : { correction: options.correction },
-			...options.agent?.scheduler === void 0 ? {} : { scheduler: options.agent.scheduler }
+			...options.agent?.scheduler === void 0 ? {} : { scheduler: options.agent.scheduler },
+			...options.agent?.strict === void 0 ? {} : { strict: options.agent.strict }
 		});
 		const tools = createToolManager();
 		for (const lookup of options.lookups ?? []) tools.add(createTool({
@@ -10071,15 +11306,11 @@ var Ledger = class {
 		}));
 		tools.add(createTool({
 			name: "recall",
-			description: `Recall what the full conversation record holds on a topic: an owner name, an id, or one of the topics ${renderTopicNames(options.topics)}. Returns source lines, newest first.`,
-			parameters: {
-				type: "object",
-				properties: { topic: {
-					type: "string",
-					description: "An owner name, an id, or a topic"
-				} },
-				required: ["topic"]
-			},
+			description: `Find something said earlier that isn't in the messages you can see, by an owner name, an id, or one of the topics ${renderTopicNames(options.topics)}. Returns statements and lookup findings first, then earlier requests and replies labeled by origin; newest first within each group.`,
+			contract: objectShape({ topic: stringShape({
+				min: 1,
+				description: "An owner name, an id, or a topic"
+			}) }),
 			execute: (args) => this.#recall(args)
 		}));
 		this.#agent = createAgent(provider, {
@@ -10087,8 +11318,19 @@ var Ledger = class {
 			conversations,
 			system: options.system,
 			tools,
+			authority: createAuthority({
+				rules: [{
+					match: (context) => lookups.includes(context.call.name),
+					zone: "ledger",
+					verdict: "allow"
+				}],
+				fallback: {
+					zone: "ledger",
+					verdict: "deny",
+					reason: "the ledger advertises no such tool"
+				}
+			}),
 			limit: options.agent?.limit ?? 8,
-			strict: false,
 			select: (conversation, request, signal) => this.#select(conversation, request, signal)
 		});
 		this.#agent.emitter.on("tool", (_call, result) => {
@@ -10103,6 +11345,7 @@ var Ledger = class {
 			if (isLedgerError(selection.fault) && selection.fault.code === "REQUEST") return;
 			this.#current()?.adopt(selection, this.#conversation.messages().length);
 		});
+		this.#agent.emitter.on("fault", (error) => this.#current()?.fault(error));
 		this.#agent.emitter.on("turn", () => this.#observeTurn());
 		this.#agent.emitter.on("usage", (usage) => this.#current()?.spend(usage));
 	}
@@ -10147,8 +11390,8 @@ var Ledger = class {
 		}
 	}
 	/**
-	* 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() {
@@ -10157,18 +11400,37 @@ var Ledger = class {
 		const conversation = this.#conversation.snapshot();
 		const ids = conversation.messages.map((message) => message.id);
 		const gauge = this.gauge;
+		const window = {
+			exchanges: this.#window.map((entry) => ({
+				request: entry.request.id,
+				...entry.request.content === this.#conversation.message(entry.request.id)?.content ? {} : { copy: entry.request.content },
+				reply: entry.reply.id,
+				lines: entry.lines.map(({ key, title, source, sentence }) => ({
+					key,
+					title,
+					source,
+					sentence
+				}))
+			})),
+			amendments: [...this.#evidence.amendments.values()].map((edge) => ({ ...edge }))
+		};
+		const digest = window.exchanges.length === 0 ? void 0 : digestLedgerWindow(window.exchanges, conversation.messages);
 		return {
 			conversation,
 			requests: ids.filter((id) => this.#requests.has(id)),
 			notes: ids.filter((id) => this.#annotations.has(id)),
 			failures: ids.filter((id) => this.#results.get(id)?.success === false),
-			...gauge === void 0 ? {} : { gauge }
+			...gauge === void 0 ? {} : { gauge },
+			...window.exchanges.length === 0 || digest === void 0 ? {} : { window: {
+				...window,
+				digest
+			} }
 		};
 	}
 	/**
 	* 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
@@ -10180,16 +11442,20 @@ var Ledger = class {
 		if (this.#busy()) throw new AgentError("CONCURRENCY", "a ledger request is already active");
 		const caller = createAbort({ ...signal === void 0 ? {} : { signal } }).signal;
 		const request = new LedgerRequest(content, this.#options.recall?.limit);
+		const scope = this.#agent.context.scope;
 		this.#live.add(request);
 		try {
 			if (this.#gauge === void 0) await this.#measureGauge(caller);
 			const entered = request.enter(this.#conversation);
 			this.#requests.add(entered.id);
-			const first = await this.#generatePass(request, caller, this.#options.think).catch(() => ({
-				content: "",
-				partial: true,
-				...request.usage === void 0 ? {} : { usage: request.usage }
-			}));
+			const first = await this.#generatePass(request, caller, this.#options.think).catch((error) => {
+				if (request.faulted(error)) throw error;
+				return {
+					content: "",
+					partial: true,
+					...request.usage === void 0 ? {} : { usage: request.usage }
+				};
+			});
 			const passes = [first];
 			if (!caller.aborted && (first.partial || first.content.trim() === "")) {
 				const digest = this.#buildDigest(request, entered);
@@ -10202,7 +11468,8 @@ var Ledger = class {
 					content: LEDGER_NOTES.cue
 				}).id);
 				const previous = this.#agent.context.scope;
-				this.#agent.context.apply(createScope({
+				const answer = createScope({
+					...previous,
 					name: "answer",
 					tools: [],
 					select: async (conversation, message, runSignal) => {
@@ -10213,11 +11480,12 @@ var Ledger = class {
 							messages: selection.messages.filter((one) => one.role !== "tool" && !hasCalls(one))
 						};
 					}
-				}));
+				});
+				this.#agent.context.apply(answer);
 				try {
 					passes.push(await this.#generatePass(request, caller, false));
 				} finally {
-					this.#agent.context.apply(previous);
+					if (this.#agent.context.scope === answer) this.#agent.context.apply(previous);
 				}
 			}
 			const last = passes.at(-1) ?? first;
@@ -10236,24 +11504,22 @@ var Ledger = class {
 				...last.stop === void 0 ? {} : { stop: last.stop }
 			};
 		} finally {
+			if (request.scope !== void 0 && this.#agent.context.scope === request.scope) this.#agent.context.apply(scope);
 			this.#flush();
+			this.#commitExchange(request);
 			this.#live.delete(request);
 		}
 	}
 	async #measureGauge(signal) {
 		try {
-			const messages = stripThinking([
-				...this.#agent.context.build({
-					messages: [],
-					judgments: []
-				}),
-				...this.#conversation.view(),
-				{
+			const messages = stripThinking(this.#agent.context.build({
+				messages: [...this.#conversation.view(), {
 					id: "calibration",
 					role: "user",
 					content: ""
-				}
-			], this.#replay).slice(0, -1);
+				}],
+				judgments: []
+			}), this.#replay).slice(0, -1);
 			const priced = await this.#provider.generate(messages, signal, this.#agent.context.tools.definitions(), { think: false });
 			const bare = await this.#provider.generate(messages, signal, void 0, { think: false });
 			if (!isFiniteNumber(priced.usage?.prompt) || priced.usage.prompt <= 0 || !isFiniteNumber(bare.usage?.prompt) || bare.usage.prompt <= 0) throw new LedgerError("GAUGE", "calibration requires prompt usage from both calls");
@@ -10303,6 +11569,37 @@ var Ledger = class {
 		for (const id of snapshot.requests) this.#requests.add(id);
 		for (const id of snapshot.notes) this.#annotations.add(id);
 		const messages = this.#conversation.messages();
+		if (snapshot.window !== void 0 && digestLedgerWindow(snapshot.window.exchanges, messages) === snapshot.window.digest) {
+			const window = snapshot.window.exchanges.map((entry) => {
+				const request = this.#conversation.message(entry.request);
+				const reply = this.#conversation.message(entry.reply);
+				if (request === void 0 || reply === void 0) throw new LedgerError("SNAPSHOT", "window pair must belong to its conversation");
+				const lines = entry.lines.map((line) => {
+					const source = this.#conversation.message(line.source);
+					if (source === void 0) throw new LedgerError("SNAPSHOT", "window source must belong to its conversation");
+					return {
+						...line,
+						text: splitSentences(source.content)[line.sentence] ?? "",
+						topics: [],
+						role: source.role
+					};
+				});
+				return {
+					request: {
+						...request,
+						content: entry.copy ?? request.content
+					},
+					reply,
+					lines
+				};
+			});
+			this.#window = window;
+			this.#evidence = collectLedgerEvidence(messages, new Set(this.#window.flatMap((entry) => [
+				entry.request.id,
+				entry.reply.id,
+				...entry.lines.map((line) => line.source)
+			])), snapshot.window.amendments);
+		}
 		const groups = collectToolGroups(messages);
 		for (const message of messages) {
 			if (!snapshot.failures.includes(message.id)) continue;
@@ -10430,22 +11727,29 @@ var Ledger = class {
 		return scan;
 	}
 	#file(classified, request, selected, message) {
-		const { attempts, ...filed } = classified;
+		const { attempts, failure, ...filed } = classified;
 		const planned = attempt(() => {
 			if (filed.fault !== void 0) throw filed.fault;
+			const { draft, ...plan } = this.#plan(selected, this.#rescan());
 			return {
-				...this.#plan(selected, this.#rescan()),
-				...filed
+				draft,
+				selection: {
+					...plan,
+					...filed,
+					...failure === void 0 ? {} : { fault: failure }
+				}
 			};
 		});
-		request.file(attempts, planned.success ? planned.value : void 0);
+		request.file(attempts, planned.success ? planned.value.selection : void 0, planned.success ? planned.value.draft : void 0);
 		if (!planned.success) return this.#refuse(planned.error, filed, this.#conversation);
+		const selection = planned.value.selection;
 		return this.#annotations.has(message.id) ? {
-			...planned.value,
-			messages: [...planned.value.messages, ...this.#collectAfter(selected)]
-		} : planned.value;
+			...selection,
+			messages: [...selection.messages, ...this.#collectAfter(selected)]
+		} : selection;
 	}
 	#refuse(error, filed, conversation) {
+		if (conversation === this.#conversation && !(isLedgerError(error) && error.code === "REQUEST")) this.#current()?.file([]);
 		return {
 			...filed,
 			messages: conversation.view(),
@@ -10472,7 +11776,11 @@ var Ledger = class {
 			topics: [...near]
 		});
 		const total = Math.max(0, (this.#options.capacity - this.#predict) * this.#share.prompt - (this.#gauge?.overhead ?? 0)) / (1 + LEDGER_SCALE_DRIFT);
-		const tail = this.#selectTail(request, total * this.#share.tail, input, scan);
+		const built = this.#agent.context.build({
+			messages: [request],
+			judgments: []
+		});
+		const tail = this.#selectTail(request, total, input, scan);
 		const tailIds = new Set(tail.map((message) => message.id));
 		const scoped = records.some((record) => record.key !== LEDGER_RULES_KEY);
 		const held = /* @__PURE__ */ new Set([...projection.records.filter((record) => scoped || record.key === "rules").flatMap((record) => record.members), ...records.length > 0 ? projection.records.flatMap((record) => record.members.filter((id) => this.#conversation.message(id)?.role === "user" && this.#classifier.category(id) === "rule" && this.#classifier.decisive(id))) : []]);
@@ -10520,25 +11828,121 @@ var Ledger = class {
 			source: unit.source,
 			record: this.#buildUnitRecord(unit.source, unit.category, input, projection, held)
 		}));
-		const trimmed = this.#trim(steps, records, mapped, new Set(ordered.map((unit) => unit.source)), request, tail, total, projection.amendments, scan);
-		const shown = /* @__PURE__ */ new Set([...trimmed.included, ...records.flatMap((record) => record.members.filter((source) => {
-			const full = record.lines.filter((line) => line.source === source);
-			const visible = trimmed.records.find((one) => one.key === record.key)?.lines.filter((line) => line.source === source) ?? [];
-			return full.length > 0 && full.length === visible.length;
-		}))]);
-		return { messages: [...tail.slice(0, -1).map((message) => message.role === "tool" ? this.#renderTailStub(message, scan, shown) : message), buildRequestMessage(request, trimmed.rendered)] };
-	}
-	#trim(steps, records, mapped, included, request, tail, total, amendments, scan) {
-		const built = this.#agent.context.build({
-			messages: [request],
-			judgments: []
+		const trimmed = this.#trim(steps, records, mapped, new Set(ordered.map((unit) => unit.source)), built, tail, total, projection.amendments, scan);
+		const replies = collectLedgerReplies(scan.messages, this.#requests, this.#annotations);
+		const sources = new Set(this.#window.flatMap((entry) => [
+			entry.request.id,
+			entry.reply.id,
+			...entry.lines.map((line) => line.source)
+		]));
+		const evidence = collectLedgerEvidence(scan.messages, sources, projection.amendments);
+		const prefix = this.#window.flatMap((entry) => entry.lines);
+		const prior = buildLedgerRenderContext(scan.messages, prefix, projection.amendments);
+		const combined = buildLedgerRenderContext(scan.messages, [...prefix, ...trimmed.rendered.lines], projection.amendments);
+		const stale = evidence.messages.size !== this.#evidence.messages.size || [...evidence.messages].some((receipt) => !this.#evidence.messages.has(receipt)) || evidence.amendments.size !== this.#evidence.amendments.size || [...evidence.amendments.keys()].some((receipt) => !this.#evidence.amendments.has(receipt)) || this.#window.some((entry) => replies.get(entry.request.id)?.id !== entry.reply.id || entry.lines.some((line) => !live.has(line.source))) || projection.amendments.some((edge) => prior.first.has(edge.earlier) && prior.complete.has(edge.later) !== combined.complete.has(edge.later) || prior.first.has(edge.later) && combined.complete.has(edge.later) && !prior.first.has(edge.earlier) && combined.first.has(edge.earlier));
+		const last = stale ? this.#window.at(-1) : void 0;
+		const retained = last === void 0 || replies.get(last.request.id)?.id !== last.reply.id ? void 0 : this.#conversation.message(last.request.id);
+		if (stale) this.#window = [];
+		const [previous, reply] = this.#window.length === 0 ? this.#selectExchange(request, input) : [];
+		const window = this.#window.length > 0 ? this.#window : previous !== void 0 && reply !== void 0 ? [{
+			request: previous,
+			reply,
+			lines: []
+		}] : retained !== void 0 && last !== void 0 ? [{
+			request: retained,
+			reply: last.reply,
+			lines: []
+		}] : [];
+		if (this.#window.length === 0) {
+			const derived = collectLedgerEvidence(scan.messages, new Set(window.flatMap((entry) => [entry.request.id, entry.reply.id])), projection.amendments);
+			this.#window = window;
+			this.#evidence = derived;
+		}
+		const carried = window.flatMap((entry) => entry.lines);
+		const delta = this.#render(trimmed.records, mapped, trimmed.included, projection.amendments, scan, new Set(carried.map(buildLedgerLineKey)), carried);
+		const newest = window.at(-1);
+		const plain = newest === void 0 ? void 0 : this.#conversation.message(newest.request.id);
+		const fallback = newest === void 0 || plain === void 0 ? [] : [{
+			request: plain,
+			reply: newest.reply,
+			lines: []
+		}];
+		const empty = {
+			window: [],
+			rendered: trimmed.rendered
+		};
+		const rungs = [
+			{
+				window,
+				rendered: delta
+			},
+			{
+				window: fallback,
+				rendered: trimmed.rendered
+			},
+			empty
+		];
+		const probes = rungs.map((rung) => [...built.slice(0, -1), ...stripThinking([
+			...tail.slice(0, -1),
+			...rung.window.flatMap((entry) => [entry.request, entry.reply]),
+			buildRequestMessage(built.at(-1) ?? request, rung.rendered.text)
+		], this.#replay)]);
+		const names = this.#agent.context.scope?.tools;
+		const definitions = this.#agent.context.tools.definitions();
+		const offered = rungs.map((rung) => hasHiddenRecall(input, request.id, this.#requests, this.#annotations, [...tail.slice(0, -1), ...rung.window.flatMap((entry) => [entry.request, entry.reply])], [...rung.window.flatMap((entry) => entry.lines), ...rung.rendered.lines]));
+		const longest = this.#findLongest();
+		const closed = probes.map((messages, at) => {
+			const tools = definitions.filter((tool) => (names === void 0 || names.includes(tool.name)) && (tool.name !== "recall" || offered[at]));
+			const calls = [{
+				estimate: estimateMessages(messages),
+				tools: tools.length,
+				spared: this.#spared(tools)
+			}];
+			return offered[at] === true && this.#gauge !== void 0 && this.#gauge.remainder(calls) - this.#predict < 2 * this.#gauge.reserve(calls, longest);
 		});
+		const prices = probes.map((messages) => this.#price(messages));
+		const admitted = rungs.find((_rung, at) => (prices[at] ?? Infinity) <= total && (closed[2] === true || closed[at] === false)) ?? empty;
+		if (offered[rungs.indexOf(admitted)] === false && (names === void 0 || names.includes("recall"))) {
+			const tools = definitions.filter((tool) => tool.name !== "recall").map((tool) => tool.name);
+			const narrowed = this.#agent.context.scope?.narrow({ tools }) ?? createScope({
+				name: "ledger",
+				tools
+			});
+			this.#current()?.apply(narrowed);
+			this.#agent.context.apply(narrowed);
+		}
+		const copy = buildRequestMessage(request, admitted.rendered.text);
+		const kept = admitted.window.flatMap((entry) => entry.lines);
+		const origins = /* @__PURE__ */ new Set([
+			request.id,
+			...admitted.window.flatMap((entry) => [entry.request.id, entry.reply.id]),
+			...kept.map((line) => line.source),
+			...admitted.rendered.lines.map((line) => line.source)
+		]);
+		const draft = {
+			copy,
+			lines: admitted.rendered.lines,
+			evidence: collectLedgerEvidence(scan.messages, origins, projection.amendments),
+			window: admitted.window
+		};
+		const shown = buildLedgerRenderContext(scan.messages, [...kept, ...admitted.rendered.lines], []).complete;
+		return {
+			draft,
+			messages: [
+				...tail.slice(0, -1).map((message) => message.role === "tool" ? this.#renderTailStub(message, scan, shown) : message),
+				...admitted.window.flatMap((entry) => [entry.request, entry.reply]),
+				copy
+			]
+		};
+	}
+	#trim(steps, records, mapped, included, built, tail, total, amendments, scan) {
 		const head = built.slice(0, -1);
-		const priced = built.at(-1) ?? request;
+		const priced = built.at(-1);
+		if (priced === void 0) throw new Error("a built plan holds its request");
 		const found = findLedgerCut(0, steps.length, (count) => {
 			const cut = buildLedgerCut(steps.slice(0, count), records, included);
 			const rendered = this.#render(cut.records, mapped, cut.included, amendments, scan);
-			const copy = buildRequestMessage(priced, rendered);
+			const copy = buildRequestMessage(priced, rendered.text);
 			return this.#price([...head, ...stripThinking([...tail.slice(0, -1), copy], this.#replay)]) <= total ? {
 				...cut,
 				rendered
@@ -10563,36 +11967,48 @@ var Ledger = class {
 		const live = collectProjectionIds(projection);
 		return scanAmendments(input.classification.amendments, source, (id) => id === source || !held.has(id) && live.has(id)).flatMap((id) => this.#projectLines(input, id));
 	}
-	#render(records, mapped, included, amendments, scan) {
-		const entries = mapped.filter((unit) => included.has(unit.source)).flatMap(({ record: unit }) => [...Map.groupBy(unit.lines, (line) => line.source)].map(([source, lines]) => ({
+	#render(records, mapped, included, amendments, scan, held = /* @__PURE__ */ new Set(), prefix = []) {
+		const population = records.map((record) => ({
+			...record,
+			lines: collectLedgerLines(record, held)
+		}));
+		const entries = mapped.filter((unit) => included.has(unit.source)).flatMap(({ record: unit }) => [...Map.groupBy(collectLedgerLines(unit, /* @__PURE__ */ new Set()), (line) => line.source)].map(([source, lines]) => ({
 			unit,
 			source,
 			lines
 		})));
 		const first = new Map(entries.toReversed().map((entry) => [entry.source, entry]));
-		const unique = entries.filter((entry) => first.get(entry.source) === entry);
-		const record = records.find((candidate) => candidate.key === "rules" && candidate.lines.length > 0);
-		const ownerRecords = records.filter((candidate) => candidate.key !== "rules" && candidate.lines.length > 0);
-		const context = buildLedgerRenderContext(this.#conversation.messages(), [
+		const unique = entries.filter((entry) => first.get(entry.source) === entry).map((entry) => ({
+			...entry,
+			lines: entry.lines.filter((line) => !prefix.some((prior) => prior.source === line.source && prior.sentence === line.sentence))
+		})).filter((entry) => entry.lines.length > 0);
+		const record = population.find((candidate) => candidate.key === "rules" && candidate.lines.length > 0);
+		const ownerRecords = population.filter((candidate) => candidate.key !== "rules" && candidate.lines.length > 0);
+		const lines = [
 			...ownerRecords.flatMap((candidate) => candidate.lines),
 			...unique.filter((entry) => entry.unit.key !== LEDGER_RULES_KEY).flatMap((entry) => entry.lines),
 			...record?.lines ?? [],
 			...unique.filter((entry) => entry.unit.key === LEDGER_RULES_KEY).flatMap((entry) => entry.lines)
-		], amendments);
+		];
+		const context = buildLedgerRenderContext(scan.messages, [...prefix, ...lines], amendments);
 		const owners = ownerRecords.map((owner) => renderLedgerPinned(owner, context)).join("\n\n");
-		const rendered = unique.map(({ unit, source, lines }) => {
+		const rendered = unique.map(({ unit, source, lines: retained }) => {
 			const sentences = splitSentences(this.#conversation.message(source)?.content ?? "");
 			return {
 				rules: unit.key === LEDGER_RULES_KEY,
-				texts: unit.key === "rules" && source === unit.members[0] ? lines.map((line) => this.#renderSource(source, sentences, [line], context, scan)) : [this.#renderSource(source, sentences, lines, context, scan)]
+				texts: unit.key === "rules" && source === unit.members[0] ? retained.map((line) => this.#renderSource(source, sentences, [line], context, scan)) : [this.#renderSource(source, sentences, retained, context, scan)]
 			};
 		});
 		const pinned = rendered.filter((one) => !one.rules).flatMap((one) => one.texts);
 		const rules = rendered.filter((one) => one.rules).flatMap((one) => one.texts);
 		const body = [owners, pinned.join("\n")].filter((text) => text !== "").join("\n\n");
-		return [body === "" ? "" : `## Records\n${body}`, record === void 0 ? rules.length === 0 ? "" : ["## Rules", ...rules].join("\n") : [renderLedgerRecord(record, context), ...rules].join("\n")].filter((text) => text !== "").join("\n\n");
+		return {
+			text: [body === "" ? "" : `## Records\n${body}`, record === void 0 ? rules.length === 0 ? "" : ["## Rules", ...rules].join("\n") : [renderLedgerRecord(record, context), ...rules].join("\n")].filter((part) => part !== "").join("\n\n"),
+			lines
+		};
 	}
-	#selectTail(request, cap, input, scan) {
+	#selectTail(request, total, input, scan) {
+		const cap = total * this.#share.tail;
 		const first = input.messages.findIndex((message) => this.#requests.has(message.id));
 		const seed = input.messages.slice(0, first < 0 ? input.messages.findIndex((message) => message.id === request.id) : first);
 		const groups = collectToolGroups(seed).flatMap((group) => {
@@ -10623,6 +12039,29 @@ var Ledger = class {
 		const stop = exchanges.findIndex((_exchange, index) => this.#price(stripThinking([...exchanges.slice(0, index + 1).toReversed().flat(), request], this.#replay)) > cap);
 		return [...exchanges.slice(0, stop === -1 ? exchanges.length : stop).toReversed().flat(), request];
 	}
+	#selectExchange(request, input) {
+		const before = input.messages.slice(0, input.messages.findIndex((message) => message.id === request.id));
+		const previous = before.findLast((message) => this.#requests.has(message.id));
+		const reply = previous === void 0 ? void 0 : collectLedgerReplies(before, this.#requests, this.#annotations).get(previous.id);
+		return previous !== void 0 && reply !== void 0 ? [previous, reply] : [];
+	}
+	#commitExchange(request) {
+		const draft = request.sent;
+		const message = request.message;
+		if (message === void 0) return;
+		const reply = collectLedgerReplies(this.#conversation.messages(), this.#requests, this.#annotations).get(message.id);
+		if (reply === void 0) return;
+		this.#window = [...draft?.window ?? this.#window, {
+			request: draft?.copy ?? message,
+			reply,
+			lines: draft?.lines ?? []
+		}];
+		const evidence = draft?.evidence ?? this.#evidence;
+		this.#evidence = {
+			messages: /* @__PURE__ */ new Set([...evidence.messages, ...collectLedgerEvidence([message, reply], /* @__PURE__ */ new Set([message.id, reply.id]), []).messages]),
+			amendments: evidence.amendments
+		};
+	}
 	#renderTailStub(message, scan, shown) {
 		const group = scan.group(message.id);
 		const call = group === void 0 ? void 0 : findLedgerCall(group, message);
@@ -10631,7 +12070,7 @@ var Ledger = class {
 		const visible = renderStub(call?.name ?? "tool", call?.arguments ?? {}, "shown");
 		return {
 			...message,
-			content: renderStub(call?.name ?? "tool", call?.arguments ?? {}, this.#results.get(message.id)?.success === false ? "failed" : finding?.result === void 0 ? "empty" : shown === void 0 ? hidden.length > visible.length ? "hidden" : "shown" : shown.has(message.id) ? "shown" : "hidden")
+			content: renderStub(call?.name ?? "tool", call?.arguments ?? {}, this.#results.get(message.id)?.success === false ? "failed" : finding?.result === void 0 ? "empty" : shown === void 0 ? hidden.length > visible.length ? "hidden" : "shown" : scan.findings.some((other) => shown.has(other.id) && matchesLookup(finding, other)) ? "shown" : "hidden")
 		};
 	}
 	#observeTurn() {
@@ -10642,11 +12081,19 @@ var Ledger = class {
 		const additions = this.#conversation.messages().slice(boundary);
 		const messages = this.#agent.context.build(request.selection);
 		const names = this.#agent.context.scope?.tools;
+		const tools = this.#agent.context.tools.definitions().filter((tool) => names === void 0 || names.includes(tool.name));
 		request.observe({
 			estimate: estimateMessages(stripThinking([...messages, ...additions], this.#replay)),
-			tools: this.#agent.context.tools.definitions().filter((tool) => names === void 0 || names.includes(tool.name)).length
+			tools: tools.length,
+			spared: this.#spared(tools)
 		}, this.#conversation.messages().length);
 	}
+	#spared(tools) {
+		const overhead = this.#gauge?.overhead ?? 0;
+		if (tools.length === 0) return overhead;
+		const missing = this.#agent.context.tools.definitions().filter((tool) => !tools.some((one) => one.name === tool.name));
+		return missing.length === 0 ? 0 : Math.min(overhead, estimateTokens(JSON.stringify(missing)) * (this.#gauge?.scale ?? 1));
+	}
 	#findLongest() {
 		return this.#conversation.messages().filter((message) => message.role === "assistant").reduce((longest, message) => message.content.length > longest.length ? message.content : longest, "");
 	}
@@ -10699,11 +12146,12 @@ var Ledger = class {
 					const source = listable.get(id);
 					if (source === void 0) return [];
 					const lookup = scan.finding(id);
-					const text = lookup === void 0 ? source.content : `${renderLookupCall(lookup.name, lookup.arguments)}: ${source.content}`;
+					const content = source.content.replace(/(^|[\n\v\f\r\u0085\u2028\u2029])(?=Earlier (?:request|reply):)/g, "$1  ");
+					const text = lookup === void 0 ? content : `${renderLookupCall(lookup.name, lookup.arguments)}: ${content}`;
 					return [{
 						id,
 						text,
-						stored: lookup === void 0 ? [] : [[splitResultLines(text)[0] ?? "", splitResultLines(source.content)[0] ?? ""]]
+						stored: lookup === void 0 ? [] : [[splitResultLines(text)[0] ?? "", splitResultLines(content)[0] ?? ""]]
 					}];
 				});
 				return {
@@ -10716,7 +12164,14 @@ var Ledger = class {
 				listed: [],
 				recalled: /* @__PURE__ */ new Map()
 			});
-			const result = gathered.listed.length === 0 ? `nothing on "${topic}"; recall ${guidance}` : cutListing(gathered.listed, room);
+			const earlier = input.messages.slice(0, Math.max(0, start)).reverse().flatMap((message) => {
+				if (gathered.done.has(message.id) || this.#annotations.has(message.id)) return [];
+				const label = this.#requests.has(message.id) ? LEDGER_RECALL_LABELS.request : message.role === "assistant" && !hasCalls(message) && message.content.trim() !== "" ? LEDGER_RECALL_LABELS.reply : void 0;
+				if (label === void 0 || !searches.some((search) => search.words.length > 0 && search.words.every((word) => message.content.toLowerCase().includes(word)))) return [];
+				return [`${label} ${message.content.replace(/[\n\v\f\r\u0085\u2028\u2029]+/g, "\n  ")}`];
+			});
+			const listed = [...gathered.listed, ...earlier];
+			const result = listed.length === 0 ? `nothing earlier on "${topic}"; answer from the messages you can see` : cutListing(listed, room, earlier.length > 0 ? "more" : "older");
 			request?.list(result, gathered.recalled);
 			return result;
 		} finally {
@@ -10729,7 +12184,7 @@ var Ledger = class {
 			const result = this.#results.get(message.id);
 			if (message.role !== "tool" || result?.success !== true) return [];
 			const recalled = result.name === "recall";
-			if (recalled && /^nothing on /.test(message.content)) return [];
+			if (recalled && /^nothing earlier on /.test(message.content)) return [];
 			const stored = recalled ? request.lines(message.content) : void 0;
 			return splitResultLines(message.content).filter((line) => !recalled || !matchesCutLine(line)).map((line) => stored?.get(line) ?? line);
 		}))];
@@ -10752,6 +12207,6 @@ var Ledger = class {
 function createLedger(provider, options) {
 	return new Ledger(provider, options);
 }
-export { AUTHORITY_NOTES, Agent, AgentContext, AgentError, AgentFanout, AgentJobError, AgentJudge, AgentProvider, AgentRegistry, Approver, Authority, CONVERSATION_RECAP_PREFIX, CONVERSATION_ROLES, Channel, Classifier, ContextError, Conversation, ConversationError, ConversationManager, DECISIVE_CATEGORIES, DEFAULT_AGENT_LIMIT, DEFAULT_AUTHORITY_ZONE, DEFAULT_CONVERSATION_KEEP, DEFAULT_LEDGER_LIMIT, DEFAULT_LEDGER_SHARE, DEFAULT_PROVIDER_TIMEOUT, DEFAULT_RECALL_LIMIT, DEFAULT_RELAY_LIMIT, DETERMINISTIC_JUDGE_ERROR, DatabaseConversationStore, DatabaseMemoStore, Gauge, IMAGE_TOKEN_ESTIMATE, INVALID_RELAY_STATUS, Instruction, InstructionManager, JudgeAbortError, JudgeError, JudgmentManager, LEDGER_CATEGORIES, LEDGER_NOTES, LEDGER_OWNER_PREFIX, LEDGER_QUESTIONS, LEDGER_RULES_KEY, LEDGER_SCALE_DRIFT, LEDGER_SLICE, LEDGER_WORD, Ledger, LedgerError, LedgerRequest, MAX_ERROR_BODY_LENGTH, MEMO_SECTION_HEADER, MESSAGE_ROLES, MESSAGE_TOKEN_OVERHEAD, MemoManager, MemoryConversationStore, MemoryMemoStore, OVERSIZED_RELAY_STATUS, PLACED_CATEGORIES, ProviderAbortError, ProviderError, QUIET_CATEGORIES, REFUSED_RELAY_CONTENT_TYPE, REFUSED_RELAY_STATUS, RELAY_CONTENT_TYPE, RELAY_PROVIDER_MESSAGE, RelayProvider, RelayStream, SCOPE_NOTE, SKILL_SECTION_HEADER, SYSTEM_ONE_PATH, Scope, ScopeManager, SkillManager, SystemOneJudge, THINK_CLOSE, THINK_OPEN, ThinkSplitter, UNAUTHORIZED_RELAY_STATUS, UPSTREAM_RELAY_STATUS, WORKSPACE_SECTION_HEADER, agentAnswerContract, agentAnswerShape, agentChunkToFrame, agentFrameContract, agentFrameShape, agentPromptContract, agentPromptShape, agentResultToFrame, agentResultToJSON, agentStreamToFrames, armReaderAbort, assembleResult, attachImages, attachUserImages, buildJudgeResult, buildJudgments, buildLedgerCut, buildLedgerIndex, buildLedgerRenderContext, buildLines, buildProviderHeaders, buildProviderResult, buildRecallMessage, buildRecapMessage, buildRecords, buildRelayRequest, buildRequestMessage, buildSummaryMessage, chargeUsage, collectAmendments, collectExchanges, collectImageData, collectLive, collectNames, collectProjectionIds, collectRegistry, collectToolGroups, computeThinking, copyJSON, createAgent, createAgentContext, createAgentQueue, createAgentRegistry, createAgentRunner, createApprover, createAuthority, createChannel, createConversation, createConversationManager, createDatabaseConversationStore, createDatabaseMemoStore, createInstruction, createInstructionManager, createLedger, createMemoManager, createMemoryConversationStore, createMemoryMemoStore, createRelay, createRelayProvider, createScope, createScopeManager, createSkillManager, createSystemOneJudge, createThinkSplitter, cutListing, denyCall, describeRelayRefusal, estimateMessages, estimateRequest, estimateTokens, extractLiterals, extractQueueOptions, extractSystemOneAnswer, extractSystemOneUsage, extractWords, filterAllowList, findLedgerCall, findLedgerCut, fitSlope, freezeJSON, handleAgentQueueJob, hasCalls, identifyLookup, inferStop, intersectKeys, isAgentError, isAgentJobError, isAuthorityDecision, isContextError, isConversation, isConversationError, isConversationSnapshot, isFraction, isJudgeAbortError, isJudgeEntry, isJudgeError, isJudgeQuestion, isJudgment, isLedgerError, isLedgerSnapshot, isMemo, isMemoSnapshot, isMessage, isNonNegativeSafeInteger, isPositiveSafeInteger, isProviderAbortError, isProviderError, isSection, isSystemOneAnswer, isSystemOneResponse, joinThinking, linkOwners, matchEntities, matchesCutLine, matchesJSON, matchesJudgment, measureAnswer, measureMessage, measureRequest, messageContract, messageShape, normalizeArgument, normalizeWord, placeMember, providerRequestContract, providerRequestShape, providerResultContract, providerResultShape, questionToSystemOne, raceSignal, rankLedgerCut, readBodyText, readChunks, readFailure, relayFrameContract, relayFrameShape, releaseReader, removeEntries, renderArguments, renderCauseChain, renderFencedFile, renderIndexEntry, renderJSON, renderLedgerAnnotation, renderLedgerPinned, renderLedgerRecord, renderLookupCall, renderSection, renderStub, renderToolValue, renderTopicNames, requestToRelay, requireBudget, requireConversation, requireConversationSnapshot, requireCumulative, requireEntry, requireJudgment, requireKeep, requireLimit, requireRole, requireSectionsCap, requireSummary, resolveDecision, resolvePredict, sanitizeToken, sanitizeUsage, scanAmendments, selectRecords, settleAgentJob, splitResultLines, splitSentences, splitTopic, splitWords, stripThinking, sumUsage, tokenUsageShape, tokenUsageToJSON, toolCallShape };
+export { AUTHORITY_NOTES, Agent, AgentContext, AgentError, AgentFanout, AgentJobError, AgentJudge, AgentProvider, AgentRegistry, Approver, Authority, CONVERSATION_RECAP_PREFIX, CONVERSATION_ROLES, Channel, Classifier, ContextError, Conversation, ConversationError, ConversationManager, DECISIVE_CATEGORIES, DEFAULT_AGENT_LIMIT, DEFAULT_CONVERSATION_KEEP, DEFAULT_LEDGER_LIMIT, DEFAULT_LEDGER_SHARE, DEFAULT_PROVIDER_TIMEOUT, DEFAULT_RECALL_LIMIT, DEFAULT_RELAY_LIMIT, DETERMINISTIC_JUDGE_ERROR, DatabaseConversationStore, DatabaseMemoStore, Gauge, IMAGE_TOKEN_ESTIMATE, INVALID_RELAY_STATUS, Instruction, InstructionManager, JudgeAbortError, JudgeError, JudgmentManager, LEDGER_CATEGORIES, LEDGER_NOTES, LEDGER_OWNER_PREFIX, LEDGER_QUESTIONS, LEDGER_RECALL_LABELS, LEDGER_RULES_KEY, LEDGER_SCALE_DRIFT, LEDGER_SLICE, LEDGER_WORD, Ledger, LedgerError, LedgerRequest, MAX_ERROR_BODY_LENGTH, MEMO_SECTION_HEADER, MESSAGE_ROLES, MESSAGE_TOKEN_OVERHEAD, MemoManager, MemoryConversationStore, MemoryMemoStore, OVERSIZED_RELAY_STATUS, PLACED_CATEGORIES, ProviderAbortError, ProviderError, QUIET_CATEGORIES, REFUSED_RELAY_CONTENT_TYPE, REFUSED_RELAY_STATUS, RELAY_CONTENT_TYPE, RELAY_PROVIDER_MESSAGE, RelayProvider, RelayStream, SCOPE_NOTE, SKILL_SECTION_HEADER, SYSTEM_ONE_PATH, Scope, ScopeManager, SkillManager, SystemOneJudge, THINK_CLOSE, THINK_OPEN, ThinkSplitter, UNAUTHORIZED_RELAY_STATUS, UPSTREAM_RELAY_STATUS, WORKSPACE_SECTION_HEADER, agentAnswerContract, agentAnswerShape, agentChunkToFrame, agentFrameContract, agentFrameShape, agentJobContract, agentJobShape, agentPromptContract, agentPromptShape, agentResultToFrame, agentResultToJSON, agentStreamToFrames, armReaderAbort, assembleResult, attachImages, attachUserImages, buildJudgeResult, buildJudgments, buildLedgerCut, buildLedgerIndex, buildLedgerLineKey, buildLedgerRenderContext, buildLines, buildProviderHeaders, buildProviderResult, buildRecallMessage, buildRecapMessage, buildRecords, buildRelayRequest, buildRequestMessage, buildSummaryMessage, chargeUsage, collectAmendments, collectExchanges, collectImageData, collectLedgerEvidence, collectLedgerLines, collectLedgerReplies, collectLive, collectNames, collectProjectionIds, collectRecallMessages, collectRegistry, collectToolGroups, computeThinking, conversationSnapshotContract, conversationSnapshotShape, copyJSON, createAgent, createAgentContext, createAgentQueue, createAgentRegistry, createAgentRunner, createApprover, createAuthority, createChannel, createConversation, createConversationManager, createDatabaseConversationStore, createDatabaseMemoStore, createInstruction, createInstructionManager, createLedger, createMemoManager, createMemoryConversationStore, createMemoryMemoStore, createRelay, createRelayProvider, createScope, createScopeManager, createSkillManager, createSystemOneJudge, createThinkSplitter, cutListing, denyCall, describeQuestionRefusal, describeRelayRefusal, describeSnapshotRefusal, digestLedgerWindow, estimateMessages, estimateRequest, estimateTokens, extractLiterals, extractQueueOptions, extractSystemOneAnswer, extractSystemOneUsage, extractWords, filterAllowList, findLedgerCall, findLedgerCut, fitSlope, freezeJSON, handleAgentQueueJob, hasCalls, hasHiddenRecall, identifyLookup, inferStop, intersectKeys, isAgentError, isAgentJobError, isAuthorityDecision, isAuthorityVerdict, isContextError, isConversation, isConversationError, isConversationSnapshot, isFraction, isJudgeAbortError, isJudgeAnswer, isJudgeEntry, isJudgeError, isJudgeQuestion, isJudgment, isLedgerError, isLedgerQuestion, isLedgerSnapshot, isLedgerWindowSnapshot, isMemo, isMemoOrigin, isMemoSnapshot, isMessage, isMessageInput, isNonNegativeSafeInteger, isPositiveSafeInteger, isProviderAbortError, isProviderError, isProviderResult, isSection, isSystemOneAnswer, isSystemOneResponse, joinThinking, judgeAnswerContract, judgeAnswerShape, judgeEntryShape, judgeQuestionContract, judgeQuestionShape, judgmentContract, judgmentShape, ledgerSnapshotContract, ledgerSnapshotShape, ledgerWindowContract, ledgerWindowShape, linkOwners, matchEntities, matchesCutLine, matchesJSON, matchesJudgment, matchesLookup, measureAnswer, measureMessage, measureRequest, memoContract, memoShape, memoSnapshotContract, memoSnapshotShape, messageContract, messageInputContract, messageInputShape, messageShape, normalizeArgument, normalizeWord, placeMember, providerRequestContract, providerRequestShape, providerResultContract, providerResultShape, questionToSystemOne, raceSignal, rankLedgerCut, readBodyText, readChunks, readFailure, readJudgeOutcome, readProviderDelta, relayFrameContract, relayFrameShape, releaseReader, removeEntries, renderArguments, renderCauseChain, renderFencedFile, renderIndexEntry, renderJSON, renderLedgerAnnotation, renderLedgerPinned, renderLedgerRecord, renderLookupCall, renderSection, renderStub, renderToolValue, renderTopicNames, requestToRelay, requireAnswer, requireBudget, requireConversation, requireConversationSnapshot, requireCumulative, requireEntry, requireFallback, requireJudgeResult, requireJudgment, requireKeep, requireLimit, requireMessageInput, requireProviderResult, requireRole, requireRules, requireSectionsCap, requireSummary, resolveDecision, resolvePredict, sanitizeToken, sanitizeUsage, scanAmendments, scanJudgmentTies, scanProbability, sectionContract, sectionShape, selectRecords, settleAgentJob, settleToolResult, splitResultLines, splitSentences, splitTopic, splitWords, stripThinking, sumUsage, tokenUsageShape, tokenUsageToJSON, toolCallShape };
 
 //# sourceMappingURL=index.js.map