@orkestrel/agent 0.0.36 → 0.0.37

package/dist/src/core/index.cjs

@@ -8806,6 +8806,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.
 *
@@ -8953,6 +8958,108 @@ function isLedgerError(value) {
 }
 // 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 = (0, _orkestrel_contract.attempt)(() => {
+		const values = [...held, ...callers].map((message) => (0, _orkestrel_contract.canonicalStringify)(message));
+		return values.some((value) => value === void 0) ? void 0 : (0, _orkestrel_contract.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
+* collectRecallMessages(input, new Set(), new Set()) // eligible stored messages
+* ```
+*/
+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));
+		});
+	});
+}
+/**
+* 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
 * @returns The distinct live message ids
@@ -9508,17 +9615,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,
@@ -9728,10 +9835,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
@@ -9739,7 +9848,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",
@@ -9747,7 +9856,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.
@@ -9761,7 +9870,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.
@@ -9822,11 +9931,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
@@ -9842,7 +9952,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);
 }
 /**
@@ -9897,17 +10014,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
@@ -9921,7 +10039,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
 	})));
@@ -9967,6 +10088,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.
@@ -10011,7 +10209,7 @@ var Classifier = class {
 	/**
 	* 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);
@@ -10020,25 +10218,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.
@@ -10077,7 +10279,7 @@ var Classifier = class {
 			if (head !== "amends" && head !== "supersedes" || !(0, _orkestrel_contract.isString)(earlier) || !(0, _orkestrel_contract.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,
@@ -10329,8 +10531,9 @@ var Classifier = class {
 * 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.
@@ -10388,7 +10591,7 @@ var Gauge = class {
 	}
 	remainder(calls) {
 		const call = calls.at(-1);
-		const used = (0, _orkestrel_contract.isFiniteNumber)(call?.prompt) ? call.prompt + (call.completion ?? 0) - (this.#replay === "none" ? call.thinking ?? 0 : 0) : this.#overhead + this.#scale * (call?.estimate ?? 0);
+		const used = (0, _orkestrel_contract.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) {
@@ -10408,8 +10611,8 @@ var Gauge = class {
 	}
 	observe(calls, reply) {
 		const first = calls[0];
-		if (first !== void 0 && (0, _orkestrel_contract.isFiniteNumber)(first.prompt) && first.estimate > 0) {
-			const priced = first.prompt - this.#overhead;
+		if (first !== void 0 && (0, _orkestrel_contract.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]];
@@ -10586,6 +10789,9 @@ var LedgerRequest = class {
 	#faults = /* @__PURE__ */ new Set();
 	#message;
 	#plan;
+	#scope;
+	#draft;
+	#sent;
 	#passes = [];
 	#attempts = [];
 	#admitted = /* @__PURE__ */ new Set();
@@ -10620,6 +10826,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.
 	*
@@ -10675,6 +10891,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) {
@@ -10695,8 +10913,9 @@ var LedgerRequest = class {
 	faulted(error) {
 		return this.#faults.has(error);
 	}
-	file(attempts, plan) {
+	file(attempts, plan, draft) {
 		this.#attempts = [...this.#attempts, ...attempts];
+		this.#draft = draft;
 		if (plan !== void 0) this.#plan = plan;
 	}
 	admit(name, args) {
@@ -10828,6 +11047,29 @@ var LedgerScan = class {
 	}
 };
 // src/core/ledgers/shapers.ts
+/** Describes the minimal serialized evidence of a nonempty exchange window. */
+var ledgerWindowShape = (0, _orkestrel_contract.objectShape)({
+	digest: (0, _orkestrel_contract.stringShape)(),
+	exchanges: (0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.objectShape)({
+		request: (0, _orkestrel_contract.stringShape)(),
+		copy: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)()),
+		reply: (0, _orkestrel_contract.stringShape)(),
+		lines: (0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.objectShape)({
+			key: (0, _orkestrel_contract.stringShape)(),
+			title: (0, _orkestrel_contract.stringShape)(),
+			source: (0, _orkestrel_contract.stringShape)(),
+			sentence: (0, _orkestrel_contract.numberShape)({
+				integer: true,
+				min: 0,
+				max: Number.MAX_SAFE_INTEGER
+			})
+		}))
+	}), { min: 1 }),
+	amendments: (0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.objectShape)({
+		earlier: (0, _orkestrel_contract.stringShape)(),
+		later: (0, _orkestrel_contract.stringShape)()
+	}))
+});
 /**
 * Describes a ledger snapshot exactly: an unknown key refuses, so a key a later version adds never reads
 * as absent.
@@ -10845,13 +11087,36 @@ var ledgerSnapshotShape = (0, _orkestrel_contract.objectShape)({
 	gauge: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.objectShape)({
 		scale: (0, _orkestrel_contract.numberShape)(),
 		overhead: (0, _orkestrel_contract.numberShape)()
-	}))
+	})),
+	window: (0, _orkestrel_contract.optionalShape)(ledgerWindowShape)
 });
 // src/core/ledgers/contracts.ts
-/** Reads the faults of a refused ledger snapshot. */
+/** Reads structural faults of a serialized exchange window. */
+var ledgerWindowContract = (0, _orkestrel_contract.createContract)(ledgerWindowShape);
+/** Reads structural faults of a ledger snapshot, including its optional held exchange window. */
 var ledgerSnapshotContract = (0, _orkestrel_contract.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 (0, _orkestrel_contract.holds)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(value) || Object.keys(value).length !== 3 || !(0, _orkestrel_contract.isString)(value.digest)) return false;
+		const { exchanges, amendments } = value;
+		if (!(0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isRecord)(exchanges) || exchanges.length === 0 || !(0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isRecord)(amendments)) return false;
+		return exchanges.every((entry) => {
+			const { request, reply, copy, lines } = entry;
+			return Object.keys(entry).length === 3 + Number(copy !== void 0) && (0, _orkestrel_contract.isString)(request) && (0, _orkestrel_contract.isString)(reply) && (copy === void 0 || (0, _orkestrel_contract.isString)(copy)) && (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isRecord)(lines) && lines.every((line) => Object.keys(line).length === 4 && (0, _orkestrel_contract.isString)(line.key) && (0, _orkestrel_contract.isString)(line.title) && (0, _orkestrel_contract.isString)(line.source) && isNonNegativeSafeInteger(line.sentence));
+		}) && amendments.every((edge) => Object.keys(edge).length === 2 && (0, _orkestrel_contract.isString)(edge.earlier) && (0, _orkestrel_contract.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
@@ -10902,6 +11167,8 @@ function isLedgerQuestion(value) {
 * 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
@@ -10915,8 +11182,8 @@ function isLedgerQuestion(value) {
 function isLedgerSnapshot(value) {
 	return (0, _orkestrel_contract.holds)(() => {
 		if (!(0, _orkestrel_contract.isRecord)(value)) return false;
-		const { conversation, requests, notes, failures, gauge } = value;
-		if (Object.keys(value).length !== (gauge === void 0 ? 4 : 5)) 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 = (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString);
 		if (!isIds(requests) || !isIds(notes) || !isIds(failures)) return false;
@@ -10926,7 +11193,7 @@ function isLedgerSnapshot(value) {
 			if (!(0, _orkestrel_contract.isFiniteNumber)(scale) || scale <= 0 || !(0, _orkestrel_contract.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");
+		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
@@ -10956,6 +11223,8 @@ 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
@@ -10989,7 +11258,8 @@ var Ledger = class {
 		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)) {
-			const faults = ledgerSnapshotContract.audit(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${(0, _orkestrel_contract.describeFaults)(faults, ledgerSnapshotContract.schema)}`}`, { context: { faults } });
 		}
 		this.#provider = provider;
@@ -11037,7 +11307,7 @@ var Ledger = class {
 		}));
 		tools.add((0, _orkestrel_tool.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.`,
+			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: (0, _orkestrel_contract.objectShape)({ topic: (0, _orkestrel_contract.stringShape)({
 				min: 1,
 				description: "An owner name, an id, or a topic"
@@ -11121,8 +11391,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() {
@@ -11131,12 +11401,31 @@ 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
+			} }
 		};
 	}
 	/**
@@ -11154,6 +11443,7 @@ var Ledger = class {
 		if (this.#busy()) throw new AgentError("CONCURRENCY", "a ledger request is already active");
 		const caller = (0, _orkestrel_abort.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);
@@ -11179,7 +11469,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) => {
@@ -11190,11 +11481,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;
@@ -11213,7 +11505,9 @@ 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);
 		}
 	}
@@ -11276,6 +11570,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;
@@ -11406,20 +11731,26 @@ var Ledger = class {
 		const { attempts, failure, ...filed } = classified;
 		const planned = (0, _orkestrel_contract.attempt)(() => {
 			if (filed.fault !== void 0) throw filed.fault;
+			const { draft, ...plan } = this.#plan(selected, this.#rescan());
 			return {
-				...this.#plan(selected, this.#rescan()),
-				...filed,
-				...failure === void 0 ? {} : { fault: failure }
+				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(),
@@ -11446,7 +11777,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))) : []]);
@@ -11494,25 +11829,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
@@ -11537,36 +11968,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) => {
@@ -11597,6 +12040,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);
@@ -11605,7 +12071,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() {
@@ -11616,11 +12082,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, "");
 	}
@@ -11673,11 +12147,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 {
@@ -11690,7 +12165,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 {
@@ -11703,7 +12185,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);
 		}))];
@@ -11768,6 +12250,7 @@ exports.LEDGER_CATEGORIES = LEDGER_CATEGORIES;
 exports.LEDGER_NOTES = LEDGER_NOTES;
 exports.LEDGER_OWNER_PREFIX = LEDGER_OWNER_PREFIX;
 exports.LEDGER_QUESTIONS = LEDGER_QUESTIONS;
+exports.LEDGER_RECALL_LABELS = LEDGER_RECALL_LABELS;
 exports.LEDGER_RULES_KEY = LEDGER_RULES_KEY;
 exports.LEDGER_SCALE_DRIFT = LEDGER_SCALE_DRIFT;
 exports.LEDGER_SLICE = LEDGER_SLICE;
@@ -11826,6 +12309,7 @@ exports.buildJudgeResult = buildJudgeResult;
 exports.buildJudgments = buildJudgments;
 exports.buildLedgerCut = buildLedgerCut;
 exports.buildLedgerIndex = buildLedgerIndex;
+exports.buildLedgerLineKey = buildLedgerLineKey;
 exports.buildLedgerRenderContext = buildLedgerRenderContext;
 exports.buildLines = buildLines;
 exports.buildProviderHeaders = buildProviderHeaders;
@@ -11840,9 +12324,13 @@ exports.chargeUsage = chargeUsage;
 exports.collectAmendments = collectAmendments;
 exports.collectExchanges = collectExchanges;
 exports.collectImageData = collectImageData;
+exports.collectLedgerEvidence = collectLedgerEvidence;
+exports.collectLedgerLines = collectLedgerLines;
+exports.collectLedgerReplies = collectLedgerReplies;
 exports.collectLive = collectLive;
 exports.collectNames = collectNames;
 exports.collectProjectionIds = collectProjectionIds;
+exports.collectRecallMessages = collectRecallMessages;
 exports.collectRegistry = collectRegistry;
 exports.collectToolGroups = collectToolGroups;
 exports.computeThinking = computeThinking;
@@ -11879,6 +12367,7 @@ exports.denyCall = denyCall;
 exports.describeQuestionRefusal = describeQuestionRefusal;
 exports.describeRelayRefusal = describeRelayRefusal;
 exports.describeSnapshotRefusal = describeSnapshotRefusal;
+exports.digestLedgerWindow = digestLedgerWindow;
 exports.estimateMessages = estimateMessages;
 exports.estimateRequest = estimateRequest;
 exports.estimateTokens = estimateTokens;
@@ -11894,6 +12383,7 @@ exports.fitSlope = fitSlope;
 exports.freezeJSON = freezeJSON;
 exports.handleAgentQueueJob = handleAgentQueueJob;
 exports.hasCalls = hasCalls;
+exports.hasHiddenRecall = hasHiddenRecall;
 exports.identifyLookup = identifyLookup;
 exports.inferStop = inferStop;
 exports.intersectKeys = intersectKeys;
@@ -11915,6 +12405,7 @@ exports.isJudgment = isJudgment;
 exports.isLedgerError = isLedgerError;
 exports.isLedgerQuestion = isLedgerQuestion;
 exports.isLedgerSnapshot = isLedgerSnapshot;
+exports.isLedgerWindowSnapshot = isLedgerWindowSnapshot;
 exports.isMemo = isMemo;
 exports.isMemoOrigin = isMemoOrigin;
 exports.isMemoSnapshot = isMemoSnapshot;
@@ -11938,11 +12429,14 @@ exports.judgmentContract = judgmentContract;
 exports.judgmentShape = judgmentShape;
 exports.ledgerSnapshotContract = ledgerSnapshotContract;
 exports.ledgerSnapshotShape = ledgerSnapshotShape;
+exports.ledgerWindowContract = ledgerWindowContract;
+exports.ledgerWindowShape = ledgerWindowShape;
 exports.linkOwners = linkOwners;
 exports.matchEntities = matchEntities;
 exports.matchesCutLine = matchesCutLine;
 exports.matchesJSON = matchesJSON;
 exports.matchesJudgment = matchesJudgment;
+exports.matchesLookup = matchesLookup;
 exports.measureAnswer = measureAnswer;
 exports.measureMessage = measureMessage;
 exports.measureRequest = measureRequest;