dsh-context-fold 0.0.0-stage → 0.1.1

package/lib/index.js

@@ -0,0 +1,1783 @@
+import z from "@deepseek-ai/schemastery";
+import { appendPluginRecord, pluginRecordOf } from "@deepseek-ai/dsh-session";
+import { freezeMessage } from "@deepseek-ai/dsh-llm";
+// src/config.ts
+/**
+* Configuration resolution for deterministic tool-result folding.
+*
+* Every knob is a plain integer or boolean, so the same content always yields
+* the same decision on the same log prefix (design §2 goal 3).
+*
+* @module dsh-context-fold/config
+*/
+/** Low-friction defaults from design §6.9. */
+const DEFAULT_CONFIG = deepFreeze({
+	minFoldChars: 1e3,
+	minBatchChars: 8e3,
+	keepRecentSteps: 6,
+	staleSteps: 12,
+	batchSpanSteps: 20,
+	foldReasoning: true,
+	foldPlainTurnReasoning: false,
+	enabled: true,
+	dryRun: false
+});
+/** Config schema shown in the settings UI. */
+const Config = z.object({
+	minFoldChars: z.number().step(1).min(300).default(DEFAULT_CONFIG.minFoldChars).description("Skip tool results smaller than this many characters. Never below 300."),
+	minBatchChars: z.number().step(1).min(1).default(DEFAULT_CONFIG.minBatchChars).description("Only fold a batch of candidates whose combined size reaches this many characters."),
+	keepRecentSteps: z.number().step(1).min(0).default(DEFAULT_CONFIG.keepRecentSteps).description("Never fold a result from the newest N steps."),
+	staleSteps: z.number().step(1).min(1).default(DEFAULT_CONFIG.staleSteps).description("Age (in steps) after which a result may fold inside one long turn."),
+	batchSpanSteps: z.number().step(1).min(1).default(DEFAULT_CONFIG.batchSpanSteps).description("Split a turn longer than this many steps into contiguous sub-batches."),
+	foldReasoning: z.boolean().default(DEFAULT_CONFIG.foldReasoning).description("Fold reasoning blocks on historical tool-call turns. Reasoning on plain turns is never re-sent, so it is not folded."),
+	foldPlainTurnReasoning: z.boolean().default(DEFAULT_CONFIG.foldPlainTurnReasoning).description("Also fold reasoning on plain turns. Enable when the route re-sends it (e.g. dsh-router-core); leave off for dsh-llm-deepseek, which drops it."),
+	enabled: z.boolean().default(DEFAULT_CONFIG.enabled).description("Turn folding on or off."),
+	dryRun: z.boolean().default(DEFAULT_CONFIG.dryRun).description("Compute and report candidates without mutating the session.")
+});
+/**
+* Resolve and validate a partly-specified configuration.
+*
+* @param config - raw plugin configuration.
+* @returns a detached, frozen configuration.
+* @throws when a budget is not a safe integer or `minFoldChars` is below 300.
+*/
+function resolveConfig(config = {}) {
+	const resolved = {
+		minFoldChars: config.minFoldChars ?? DEFAULT_CONFIG.minFoldChars,
+		minBatchChars: config.minBatchChars ?? DEFAULT_CONFIG.minBatchChars,
+		keepRecentSteps: config.keepRecentSteps ?? DEFAULT_CONFIG.keepRecentSteps,
+		staleSteps: config.staleSteps ?? DEFAULT_CONFIG.staleSteps,
+		batchSpanSteps: config.batchSpanSteps ?? DEFAULT_CONFIG.batchSpanSteps,
+		foldReasoning: config.foldReasoning ?? DEFAULT_CONFIG.foldReasoning,
+		foldPlainTurnReasoning: config.foldPlainTurnReasoning ?? DEFAULT_CONFIG.foldPlainTurnReasoning,
+		enabled: config.enabled ?? DEFAULT_CONFIG.enabled,
+		dryRun: config.dryRun ?? DEFAULT_CONFIG.dryRun
+	};
+	for (const [key, value] of Object.entries(resolved)) {
+		if (key === "enabled" || key === "dryRun" || key === "foldReasoning" || key === "foldPlainTurnReasoning") continue;
+		assertInteger(key, value, key === "minFoldChars" ? 300 : key === "minBatchChars" ? 1 : 0);
+	}
+	if (resolved.staleSteps < 1) throw new Error(`context-fold: staleSteps (${resolved.staleSteps}) must be at least 1`);
+	if (resolved.batchSpanSteps < 1) throw new Error(`context-fold: batchSpanSteps (${resolved.batchSpanSteps}) must be at least 1`);
+	return deepFreeze(resolved);
+}
+function assertInteger(name, value, minimum) {
+	if (!Number.isSafeInteger(value) || value < minimum) throw new Error(`context-fold: ${name} (${String(value)}) must be an integer of at least ${minimum}`);
+}
+/** Recursively freeze a configuration object. */
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null) {
+		for (const child of Object.values(value)) deepFreeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+// src/format.ts
+/** Fixed prefix identifying a folded node. A `startsWith` test is the idempotency check. */
+const FOLD_MARKER = "[context-fold]";
+/**
+* Whether already-folded content is being inspected.
+*
+* @param text - current model-visible text of a node.
+* @returns true when the node is a fold this plugin produced.
+*/
+function isFoldedText(text) {
+	return text.startsWith(FOLD_MARKER);
+}
+/**
+* Render one folded node.
+*
+* @param plan - the fold being rendered.
+* @param locator - where this node's full original now lives.
+* @param roster - the batch's other members with their locators (used on the head only).
+* @param total - total member count of the batch, including the head.
+* @returns the replacement content text.
+*/
+function renderFoldedText(plan, locator, roster, total) {
+	const lines = [
+		`${FOLD_MARKER} [tool: ${plan.facts.toolName}] ${formatNumber$2(plan.facts.chars)} chars folded at turn ${plan.turn}, step ${plan.step}.${plan.head ? " (batch head)" : ""}`,
+		`Conclusion: ${plan.conclusion}`,
+		`Full result: ${locator}`
+	];
+	if (plan.head && roster.length > 0) {
+		lines.push(`Same batch (${roster.length} more):`);
+		for (const entry of roster) lines.push(`  - ${entry.toolName} (callId ${entry.callId}): ${entry.locator}`);
+	}
+	if (!plan.head && plan.headCallId !== void 0) {
+		const others = Math.max(0, total - 1);
+		lines.push(`Batch head: ${plan.headCallId} (callId) — lists ${others} more result${others === 1 ? "" : "s"} from this batch.`);
+	}
+	return lines.join("\n");
+}
+/** Group digits for readability. */
+function formatNumber$2(value) {
+	return value.toLocaleString("en-US");
+}
+// src/rules.ts
+const NOTICE_LOCATION = " Full formatted result stored at: ";
+/** Longest conclusion line before ellipsis. */
+const LINE_BUDGET = 120;
+/** Longest total conclusion body. */
+const BODY_BUDGET = 320;
+const SHELL_TOOLS = /* @__PURE__ */ new Set([
+	"ops_bash",
+	"pwsh",
+	"bash",
+	"shell",
+	"ops_pwsh",
+	"wsl"
+]);
+const READ_TOOLS = /* @__PURE__ */ new Set([
+	"read",
+	"ops_read_files",
+	"ops_inspect_local_file",
+	"wsl-read",
+	"ops_read_pdf",
+	"ops_read_docx"
+]);
+const SEARCH_TOOLS = /* @__PURE__ */ new Set([
+	"grep",
+	"glob",
+	"ops_grep",
+	"ops_glob",
+	"ops_result",
+	"wsl-grep",
+	"ops_discover_tools"
+]);
+const WEB_TOOLS = /* @__PURE__ */ new Set([
+	"web_fetch",
+	"web_search",
+	"platform_search",
+	"domain_search",
+	"research",
+	"web_tools",
+	"video_search",
+	"multi_search",
+	"advanced_search"
+]);
+/**
+* Count Unicode code points without splitting surrogate pairs, matching the
+* pruner's measurement so sizes are comparable across plugins.
+*
+* @param text - text to measure.
+* @returns the code-point count.
+*/
+function codePointLength(text) {
+	return Array.from(text).length;
+}
+/**
+* Model-visible text of one result, including image/file placeholders.
+*
+* @param content - ordered result blocks.
+* @returns concatenated text with a stable placeholder for non-text blocks.
+*/
+function textOf(content) {
+	let text = "";
+	for (const block of content) if (block.type === "text") text += block.text;
+	else if (block.type === "image") text += `\n[image ${block.attachment.attachmentId}]\n`;
+	else if (block.type === "file") text += `\n[file ${block.attachment.attachmentId}]\n`;
+	return text;
+}
+/**
+* Whether a result can be folded without losing anything structural.
+*
+* Image and unknown blocks are never folded: their placeholder text is not the
+* content, and phase 1 must not trade an attachment for a sentence about it.
+*
+* @param content - ordered result blocks.
+* @returns true when every block is text.
+*/
+function isFoldableContent(content) {
+	return content.every((block) => block.type === "text");
+}
+/**
+* Find the spill notice an already-bounded result carries, so folding reuses
+* that locator instead of spilling the same text twice (design §6.5).
+*
+* @param text - result text.
+* @returns the parsed notice, or undefined when the result was never spilled.
+*/
+function parseSpillNotice(text) {
+	const at = text.indexOf(NOTICE_LOCATION);
+	if (at < 0) return void 0;
+	const rest = text.slice(at + 34);
+	const end = rest.indexOf(". ");
+	const locator = (end < 0 ? rest : rest.slice(0, end)).replace(/\)\s*$/, "").trim();
+	if (locator === "") return void 0;
+	const head = text.slice(0, at);
+	const bytes = /([\d,]+)\s+bytes\s+omitted/i.exec(head)?.[1];
+	return {
+		locator,
+		bytes: bytes === void 0 ? void 0 : Number(bytes.replaceAll(",", ""))
+	};
+}
+/**
+* Produce the one-line conclusion for a result.
+*
+* The rule is chosen by tool family, mirroring design §6.3, and falls back to
+* the first line plus a size for anything unlisted. A conclusion is always
+* shorter than the result it replaces; callers still compare sizes before
+* folding, because a pathological result can defeat any rule.
+*
+* @param facts - candidate facts.
+* @returns the conclusion body (without the fold header), or undefined when the
+*   result carries no foldable text.
+*/
+function conclude(facts) {
+	const text = textOf(facts.content);
+	if (text.trim() === "") return void 0;
+	const args = parseArgs(facts.args);
+	let body;
+	if (facts.toolName.startsWith("cordis_inspect")) body = inspectConclusion(text);
+	else if (SHELL_TOOLS.has(facts.toolName)) body = shellConclusion(text, facts);
+	else if (READ_TOOLS.has(facts.toolName)) body = readConclusion(text, args);
+	else if (SEARCH_TOOLS.has(facts.toolName)) body = searchConclusion(text, args);
+	else if (WEB_TOOLS.has(facts.toolName)) body = webConclusion(text, args);
+	else body = fallbackConclusion(text);
+	const capped = cap(body, BODY_BUDGET);
+	return capped === "" ? void 0 : capped;
+}
+/** Shell: exit code, first stdout line, last stderr line, line count. */
+function shellConclusion(text, facts) {
+	const parts = [];
+	const exit = /\[exit code:\s*(-?\d+)\s*\]/i.exec(text);
+	if (exit !== null) parts.push(`exit ${exit[1]}`);
+	const stderrAt = /^\[stderr\]$/m.exec(text);
+	const stdout = (stderrAt === null ? text : text.slice(0, stderrAt.index)).split("\n").map((line) => line.trim()).filter((line) => line !== "" && !/^\[cwd:/.test(line) && !/^\[exit code:/.test(line));
+	if (stdout[0] !== void 0) parts.push(`first ${quote(cap(stdout[0], LINE_BUDGET))}`);
+	if (stderrAt !== null) {
+		const tail = lastNonEmpty(text.slice(stderrAt.index + stderrAt[0].length).split("\n").filter((line) => !/^\[exit code:/.test(line.trim())).join("\n"));
+		if (tail !== "") parts.push(`stderr ${quote(cap(tail, LINE_BUDGET))}`);
+	}
+	parts.push(`${countLines(text)} lines, ${formatNumber$1(facts.chars)} chars`);
+	return parts.join("; ");
+}
+/** Read: path, line range, first content line. */
+function readConclusion(text, args) {
+	const parts = [];
+	const path = args.path ?? args.file_path ?? /^=== FILE:\s*(.+?)(?:\s+\(|$)/m.exec(text)?.[1];
+	if (path !== void 0) parts.push(`path ${quote(cap(path.trim(), LINE_BUDGET))}`);
+	const range = /\(Lines (\d+)-(\d+) of (\d+)\)/.exec(text);
+	if (range !== null) parts.push(`lines ${range[1]}-${range[2]} of ${range[3]}`);
+	const first = firstNonEmpty(text.split("\n").filter((line) => !/^=== FILE:/.test(line) && !/^\[Notice:/.test(line)));
+	if (first !== "") parts.push(`first ${quote(cap(first, LINE_BUDGET))}`);
+	parts.push(`${countLines(text)} lines total`);
+	return parts.join("; ");
+}
+/** Search: pattern, hit count, first few matched paths. */
+function searchConclusion(text, args) {
+	const parts = [];
+	const pattern = args.pattern ?? args.query;
+	if (pattern !== void 0) parts.push(`pattern ${quote(cap(pattern, LINE_BUDGET))}`);
+	const files = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(/^=== FILE:\s*(.+?)(?:\s+\(|$)/gm)) files.add(match[1].trim());
+	const hits = text.split("\n").filter((line) => line.trim() !== "" && !/^\[Notice:/.test(line)).length;
+	parts.push(`${hits} non-empty lines`);
+	if (files.size > 0) {
+		const shown = [...files].slice(0, 3);
+		parts.push(`${files.size} files: ${shown.join(", ")}`);
+	}
+	if (files.size === 0) {
+		const firstPath = text.split("\n").map((line) => line.trim()).find((line) => line !== "" && !/^\[Notice:/.test(line));
+		if (firstPath !== void 0) parts.push(`first ${quote(cap(firstPath, LINE_BUDGET))}`);
+	}
+	return parts.join("; ");
+}
+/** Inspect: section headings only, never the declaration bodies. */
+function inspectConclusion(text) {
+	const headings = [];
+	for (const match of text.matchAll(/^#{1,6}\s+(.+)$/gm)) {
+		const heading = match[1].trim();
+		if (heading !== "" && !headings.includes(heading)) headings.push(heading);
+		if (headings.length >= 5) break;
+	}
+	if (headings.length > 0) return `sections: ${headings.join(", ")}; ${countLines(text)} lines`;
+	return fallbackConclusion(text);
+}
+/** Web: URL or query, then the first meaningful line. */
+function webConclusion(text, args) {
+	const parts = [];
+	const url = args.url ?? args.query;
+	if (url !== void 0) parts.push(`url ${quote(cap(url, LINE_BUDGET))}`);
+	const first = firstNonEmpty(text.split("\n").filter((line) => !/^#{1,6}\s/.test(line)));
+	if (first !== "") parts.push(`first ${quote(cap(first, LINE_BUDGET))}`);
+	parts.push(`${countLines(text)} lines, ${formatNumber$1(codePointLength(text))} chars`);
+	return parts.join("; ");
+}
+/** Unknown tools: first line plus the measured size. */
+function fallbackConclusion(text) {
+	return `first ${quote(cap(firstNonEmpty(text.split("\n")), LINE_BUDGET))}; ${countLines(text)} lines, ${formatNumber$1(codePointLength(text))} chars`;
+}
+/** Parse the small argument subset the rules quote, tolerating malformed JSON. */
+function parseArgs(raw) {
+	if (raw === void 0 || raw.trim() === "") return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {};
+	}
+	if (typeof parsed !== "object" || parsed === null) return {};
+	const out = {};
+	for (const key of [
+		"path",
+		"file_path",
+		"pattern",
+		"query",
+		"url",
+		"command",
+		"description"
+	]) {
+		const value = parsed[key];
+		if (typeof value === "string" && value !== "") out[key] = value;
+	}
+	return out;
+}
+/** First non-empty line, trimmed. */
+function firstNonEmpty(lines) {
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed !== "") return trimmed;
+	}
+	return "";
+}
+/** Last non-empty line, trimmed. */
+function lastNonEmpty(text) {
+	const lines = text.split("\n");
+	for (let index = lines.length - 1; index >= 0; index--) {
+		const trimmed = lines[index].trim();
+		if (trimmed !== "") return trimmed;
+	}
+	return "";
+}
+/** Line count of a text. */
+function countLines(text) {
+	if (text === "") return 0;
+	return text.split("\n").length;
+}
+/** Cap by code point with a trailing ellipsis. */
+function cap(text, budget) {
+	const points = Array.from(text);
+	return points.length <= budget ? text : `${points.slice(0, budget - 1).join("")}…`;
+}
+/** Render a quoted, single-line excerpt. */
+function quote(text) {
+	return `"${text.replaceAll("\"", "'").replaceAll("\n", " ")}"`;
+}
+/** Group digits for readability; the value itself is unchanged. */
+function formatNumber$1(value) {
+	return value.toLocaleString("en-US");
+}
+// src/reasoning.ts
+/** Marker opening a folded reasoning block. Must be distinctive: `startsWith` is the idempotency test. */
+const REASONING_MARKER = `${FOLD_MARKER} [reasoning]`;
+/** Durable record type carrying one reasoning-fold decision. */
+const REASONING_EVENT = "plugin:context-fold/reasoning";
+/**
+* Prefix kept from the head of a folded reasoning block.
+*
+* Reasoning carries its conclusion at the end (the model reasons towards a
+* decision), but the opening line names the intent. Keeping a head and a tail
+* would double the per-block overhead for little added value, so the policy
+* keeps a head only and leaves the full text reachable through the spill path
+* recorded in the block itself. Zero is not allowed: a bare pointer with no
+* conclusion is the failure mode the design forbids.
+*/
+const HEAD_CHARS = 240;
+/** Smallest reasoning block worth folding. Below this the pointer costs as much as the text. */
+const MIN_REASONING_CHARS = 1200;
+/**
+* Whether a reasoning block is already folded.
+*
+* @param text - reasoning text.
+* @returns true for a block this plugin produced.
+*/
+function isFoldedReasoning(text) {
+	return text.startsWith(REASONING_MARKER);
+}
+/**
+* Whether a message is a tool-call turn, i.e. a turn that requested tool work.
+*
+* This is a **policy** filter, not a token-accounting claim. Reasoning is re-sent
+* differently per route:
+*
+* - `dsh-llm-deepseek`'s `serializeAssistant` emits `reasoning_content` only when
+*   `toolCalls.length > 0` ("it is ignored on plain turns, so we drop it there"),
+*   so a plain turn's reasoning is free on that route.
+* - `dsh-router-core`'s `wireMessages` — the route this profile actually runs —
+*   does **not** gate it: `...reasoning.length > 0 ? { reasoning_content } : {}`
+*   is unconditional, so plain-turn reasoning IS re-sent and does cost tokens.
+*
+* Restricting to tool-call turns therefore leaves real bytes on the table on the
+* router route. It stays the default only because the conservative shape matches
+* phase 1's "completed stage" intent and the measured tool-call share dominates;
+* `foldPlainTurnReasoning` widens it for routes that replay plain-turn reasoning.
+*
+* @param content - assistant content blocks.
+* @returns true when the message carries at least one tool call.
+*/
+function isToolCallTurn(content) {
+	return content.some((block) => block.type === "tool-call");
+}
+/**
+* Build the replacement text for one reasoning block.
+*
+* The head is preserved verbatim, so no information is invented and the
+* conclusion-like opening of the thought stays visible. The character count and
+* the full-length note make the omission visible, which is the difference
+* between a cautious model and a fluent one.
+*
+* When a `locator` is supplied the folded text inlines it, so the omission is
+* **recoverable**: `read`/`grep` on that path returns the original reasoning.
+* Without it the note is a pointer to nothing — it tells the model detail is
+* missing while offering no way to fetch it — which is why the fold path always
+* tries to spill first (design §12.7).
+*
+* @param text - original reasoning text.
+* @param locator - spill path holding the full original, when one was written.
+* @returns folded text, or undefined when folding would not shorten it.
+*/
+function foldReasoningText(text, locator) {
+	if (isFoldedReasoning(text)) return void 0;
+	const chars = codePointLength(text);
+	if (chars < MIN_REASONING_CHARS) return void 0;
+	const head = Array.from(text).slice(0, HEAD_CHARS).join("").trimEnd();
+	const omitted = `[… ${formatNumber(chars - codePointLength(head))} chars of earlier reasoning omitted]`;
+	const folded = [
+		`${REASONING_MARKER} ${formatNumber(chars)} chars folded.`,
+		head,
+		locator === void 0 ? omitted : `${omitted} Full text: ${locator} — use read (offset/limit) or grep on that path.`
+	].join("\n");
+	return codePointLength(folded) < chars ? folded : void 0;
+}
+/** Group digits for readability. */
+function formatNumber(value) {
+	return value.toLocaleString("en-US");
+}
+/**
+* Plan reasoning folds for one snapshot.
+*
+* A node qualifies when it is a tool-call turn (where reasoning is re-sent most,
+* and where the measurable win is), when it is old enough by the same age rules
+* phase 1 uses, and when at least one reasoning block is large enough to shrink.
+*
+* The plan itself does not spill: writing to the store is side-effectful, so it
+* happens in `recordReasoningFolds`, which fills in the locators and re-derives
+* the conclusion text with them.
+*
+* @param candidates - current assistant nodes, in surface order.
+* @param currentTurn - turn being evaluated.
+* @param currentStep - step being evaluated.
+* @param config - resolved configuration.
+* @returns plans in surface order.
+*/
+function planReasoningFolds(candidates, currentTurn, currentStep, config) {
+	const plans = [];
+	for (const node of candidates) {
+		if (!isToolCallTurn(node.content) && !config.foldPlainTurnReasoning) continue;
+		if (!(node.turn < currentTurn || currentStep - node.step >= config.staleSteps)) continue;
+		if (node.step > currentStep - config.keepRecentSteps) continue;
+		const indexes = [];
+		const chars = [];
+		let removed = 0;
+		for (const [index, block] of node.content.entries()) {
+			if (block.type !== "reasoning") continue;
+			const folded = foldReasoningText(block.text);
+			if (folded === void 0) continue;
+			indexes.push(index);
+			chars.push(codePointLength(block.text));
+			removed += codePointLength(block.text) - codePointLength(folded);
+		}
+		if (indexes.length === 0) continue;
+		plans.push({
+			seq: node.seq,
+			indexes,
+			chars,
+			charsRemoved: removed
+		});
+	}
+	return plans;
+}
+/**
+* Project one assistant message with selected reasoning blocks folded.
+*
+* Message identity and every other block are preserved verbatim, which is what
+* `replayedAssistant` and `foreignAssistant` both require: the block count and
+* block types are unchanged, so even a signed route would still validate.
+*
+* @param message - message to project.
+* @param indexes - reasoning block indexes to fold, strictly increasing.
+* @returns an immutable projected copy.
+* @throws when an index is out of range or does not name a reasoning block.
+*/
+function projectReasoning(message, indexes, locators) {
+	const content = message.content.map((block, index) => {
+		if (!indexes.includes(index)) return block;
+		if (block.type !== "reasoning") throw new Error(`context-fold: block ${index} is not reasoning`);
+		const locator = locators?.[indexes.indexOf(index)];
+		const folded = foldReasoningText(block.text, locator);
+		if (folded === void 0) throw new Error(`context-fold: block ${index} cannot be folded again`);
+		return {
+			...block,
+			text: folded
+		};
+	});
+	return freezeCopy({
+		...message,
+		content
+	});
+}
+/** Deep-freeze a detached copy, matching the host's immutability contract for projected messages. */
+function freezeCopy(value) {
+	const freeze = (node) => {
+		if (typeof node !== "object" || node === null) return;
+		for (const child of Object.values(node)) freeze(child);
+		Object.freeze(node);
+	};
+	const copy = structuredClone(value);
+	freeze(copy);
+	return copy;
+}
+/**
+* Collect the assistant nodes a decision event may target.
+*
+* @param session - session to read.
+* @returns candidates in surface order.
+*/
+function reasoningCandidates(session) {
+	const candidates = [];
+	for (const seq of [...session.surface.nodes]) {
+		const event = session.eventAt(seq);
+		if (event?.type !== "assistant/message") continue;
+		const message = session.deriveEventMessage(event);
+		if (message === null || message.role !== "assistant") continue;
+		candidates.push({
+			seq,
+			turn: event.data.turn,
+			step: event.data.step,
+			content: message.content
+		});
+	}
+	return candidates;
+}
+/**
+* Append one decision record covering the planned folds.
+*
+* The record is self-describing: it stores the exact content indexes it covers,
+* so replay never has to re-derive *which* blocks were chosen from a count. The
+* record is durable and pure — replaying the log through the registered
+* projection reproduces exactly the same request content.
+*
+* @param session - session to extend.
+* @param plans - folds to record.
+* @param spill - optional spill store; when supplied, every folded block's full
+*   text is written first and its locator is recorded so the projection can
+*   inline a real recovery path.
+* @returns the record's sequence number.
+*/
+async function recordReasoningFolds(session, plans, spill) {
+	const targets = [];
+	for (const plan of plans) {
+		const locators = [];
+		const event = session.eventAt(plan.seq);
+		const message = event === void 0 ? null : session.deriveEventMessage(event);
+		for (const [position, index] of plan.indexes.entries()) {
+			const block = message !== null && message.role === "assistant" ? message.content[index] : void 0;
+			const original = block !== void 0 && block.type === "reasoning" ? block.text : void 0;
+			if (spill === void 0 || original === void 0) {
+				locators.push(void 0);
+				continue;
+			}
+			try {
+				const saved = await spill.saveText({
+					owner: { sessionId: session.header.id },
+					source: {
+						kind: "tool",
+						toolName: "reasoning",
+						callId: `reasoning-${String(plan.seq)}-${String(index)}`,
+						label: "reasoning"
+					},
+					suggestedName: `reasoning-${String(plan.seq)}-${String(index)}.txt`,
+					content: original
+				});
+				locators.push(saved.locator);
+			} catch {
+				locators.push(void 0);
+			}
+		}
+		targets.push({
+			seq: plan.seq,
+			indexes: [...plan.indexes],
+			chars: [...plan.chars],
+			...locators.some((locator) => locator !== void 0) ? { locators } : {}
+		});
+	}
+	return appendPluginRecord(session, REASONING_EVENT, { targets });
+}
+/**
+* Read every decision record in a log.
+*
+* Records are read back through {@link pluginRecordOf}, which validates that the
+* type carries the `plugin:` prefix; the owner still validates `data` before use,
+* because a restored record carries whatever an earlier build wrote.
+*
+* @param session - session to inspect.
+* @returns decisions in log order, with unreadable payloads dropped.
+*/
+function reasoningDecisions(session) {
+	const decisions = [];
+	for (const event of session.snapshotEvents()) {
+		if (event.type !== "plugin:context-fold/reasoning") continue;
+		const record = pluginRecordOf(event);
+		if (record === void 0) continue;
+		const data = record.data;
+		if (typeof data !== "object" || data === null || !Array.isArray(data.targets)) continue;
+		decisions.push(data);
+	}
+	return decisions;
+}
+/**
+* The projection definition registered with `ctx.sessions`.
+*
+* It is deliberately **tolerant of stale targets** rather than strict: a
+* decision is durable, but the surface it referred to is not frozen — a
+* `compaction` replacement can remove a node the decision named. Throwing there
+* would make every later `deriveMessages()` fail and brick the session, which
+* violates the design's "a session never errors" anti-goal. A target whose node
+* is no longer current, or whose reasoning blocks are already folded, is
+* therefore skipped: the fold it described is simply no longer applicable.
+*
+* Each target's `chars` array is only a length hint — how many reasoning blocks
+* that decision intended to fold. The projection folds that many still-unfolded
+* reasoning blocks, which keeps replay correct even after a later decision has
+* already folded a sibling block.
+*/
+/**
+* The projection definition registered with `ctx.sessions`.
+*
+* **Why a cast is needed, and why it is correct:** `SessionMessageProjection<T>`
+* constrains `T extends keyof SessionEventMap`, so the host's *types* do not
+* admit a `plugin:` record type. The *runtime* does: `SurfaceManager` resolves a
+* projection with `projections.find(item => item.type === event.type)` **before**
+* it looks at `surfaceOp`, so any committed event type can drive one. The cast is
+* therefore only widening a compile-time parameter that the implementation
+* already accepts.
+*
+* A projection must **not** be registered for a surface event type
+* (`assistant/message`, `user/message`, `tool/result`): `planSurfaceEvent`
+* returns a `project` plan *instead of* an append/replace plan, and
+* `applySurfacePlan` only pushes nodes for `append`, so such a registration would
+* silently drop every message of that type off the surface. A non-surface
+* plugin-owned record is the only correct carrier.
+*
+* It is deliberately **tolerant of stale targets** rather than strict: a
+* decision is durable, but the surface it referred to is not frozen — a
+* `compaction` replacement can remove a node the decision named. Throwing there
+* would make every later derivation fail and brick the session, which violates
+* the design's "a session never errors" anti-goal.
+*/
+const reasoningProjection = {
+	type: REASONING_EVENT,
+	project(event, context) {
+		const data = event.data;
+		if (typeof data !== "object" || data === null || !Array.isArray(data.targets) || data.targets.length === 0) return /* @__PURE__ */ new Map();
+		const nodes = new Set(context.nodes);
+		const updates = /* @__PURE__ */ new Map();
+		for (const target of data.targets) {
+			if (typeof target !== "object" || target === null) continue;
+			if (!Number.isSafeInteger(target.seq) || !Array.isArray(target.indexes) || target.indexes.length === 0) continue;
+			if (!nodes.has(target.seq) || updates.has(target.seq)) continue;
+			const source = context.events[target.seq - context.baseSeq];
+			if (source?.type !== "assistant/message") continue;
+			const message = context.messages.get(target.seq) ?? source.data.message;
+			if (message.role !== "assistant") continue;
+			const indexes = [];
+			const locators = [];
+			for (const [position, index] of target.indexes.entries()) {
+				const block = message.content[index];
+				if (block === void 0 || block.type !== "reasoning") continue;
+				if (isFoldedReasoning(block.text)) continue;
+				if (foldReasoningText(block.text) === void 0) continue;
+				indexes.push(index);
+				locators.push(target.locators?.[position]);
+			}
+			if (indexes.length === 0) continue;
+			updates.set(target.seq, projectReasoning(message, indexes, locators));
+		}
+		return updates;
+	}
+};
+// src/plan.ts
+/**
+* Decide what to fold for one snapshot.
+*
+* Candidate rules, in the order they are checked (design §6.1): error results
+* never fold, recently-used results never fold, already-folded nodes never
+* fold, nodes still cited by a later event never fold, and a node folds only
+* when it is at least `minFoldChars` and a conclusion exists that is smaller
+* than the result.
+*
+* @param input - one detached snapshot plus configuration.
+* @returns the decision; an empty `batches` array means "do nothing".
+*/
+function planFolds(input) {
+	const { config } = input;
+	const skipped = [];
+	const candidates = [];
+	for (const node of input.nodes) {
+		const text = textOfContent(node.content);
+		const chars = codePointLength(text);
+		const skip = (reason) => {
+			skipped.push({
+				seq: node.seq,
+				toolName: node.toolName,
+				chars,
+				reason
+			});
+		};
+		if (node.isError) {
+			skip("error");
+			continue;
+		}
+		if (isFoldedText(text)) {
+			skip("folded");
+			continue;
+		}
+		if (!isFoldableContent(node.content)) {
+			skip("unfoldable");
+			continue;
+		}
+		if (!(node.turn < input.currentTurn || input.currentStep - node.step >= config.staleSteps)) {
+			skip("alive");
+			continue;
+		}
+		if (node.step > input.currentStep - config.keepRecentSteps) {
+			skip("recent");
+			continue;
+		}
+		if (isReferencedAfter(node.callId, node.seq, input.mentions)) {
+			skip("referenced");
+			continue;
+		}
+		if (chars < config.minFoldChars) {
+			skip("small");
+			continue;
+		}
+		if (conclude(factsOf(node)) === void 0) {
+			skip("no-conclusion");
+			continue;
+		}
+		candidates.push(node);
+	}
+	const candidateChars = candidates.reduce((total, node) => total + codePointLength(textOfContent(node.content)), 0);
+	const batches = [];
+	for (const group of groupByBatch(candidates, config.batchSpanSteps)) {
+		const chars = group.reduce((total, node) => total + codePointLength(textOfContent(node.content)), 0);
+		if (chars < config.minBatchChars) continue;
+		const ordered = [...group].sort((a, b) => {
+			const size = codePointLength(textOfContent(b.content)) - codePointLength(textOfContent(a.content));
+			return size !== 0 ? size : a.seq - b.seq;
+		});
+		const head = ordered[0];
+		if (head === void 0) continue;
+		batches.push({
+			key: `${group[0].turn}:${group[0].step}-${group[group.length - 1].step}`,
+			callId: head.callId,
+			members: ordered.map((node) => ({
+				seq: node.seq,
+				facts: factsOf(node),
+				turn: node.turn,
+				step: node.step,
+				conclusion: conclude(factsOf(node)) ?? "",
+				original: textOfContent(node.content),
+				head: node.seq === head.seq,
+				...node.seq === head.seq ? {} : { headCallId: head.callId }
+			})),
+			chars
+		});
+	}
+	return {
+		batches,
+		skipped,
+		candidateChars
+	};
+}
+/** Detect a node that a later event still cites (design §6.2). */
+function isReferencedAfter(callId, seq, mentions) {
+	for (const mention of mentions) if (mention.seq > seq && mention.text.includes(callId)) return true;
+	return false;
+}
+/** Group candidates into batches by turn, splitting long turns by step range. */
+function groupByBatch(nodes, batchSpanSteps) {
+	const byTurn = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const list = byTurn.get(node.turn);
+		if (list === void 0) byTurn.set(node.turn, [node]);
+		else list.push(node);
+	}
+	const groups = [];
+	for (const turn of [...byTurn.keys()].sort((a, b) => a - b)) {
+		const sorted = [...byTurn.get(turn)].sort((a, b) => a.step - b.step || a.seq - b.seq);
+		const first = sorted[0];
+		if (first === void 0) continue;
+		let bucket = [];
+		let bucketStart = first.step;
+		for (const node of sorted) {
+			if (node.step - bucketStart >= batchSpanSteps && bucket.length > 0) {
+				groups.push(bucket);
+				bucket = [];
+				bucketStart = node.step;
+			}
+			bucket.push(node);
+		}
+		if (bucket.length > 0) groups.push(bucket);
+	}
+	return groups;
+}
+/** Build facts from a snapshot. */
+function factsOf(node) {
+	return {
+		toolName: node.toolName,
+		callId: node.callId,
+		content: node.content,
+		chars: codePointLength(textOfContent(node.content)),
+		...node.args === void 0 ? {} : { args: node.args }
+	};
+}
+/** Concatenate text blocks of one result. */
+function textOfContent(content) {
+	let text = "";
+	for (const block of content) if (block.type === "text") text += block.text;
+	return text;
+}
+// src/session.ts
+/**
+* Read the current model-visible state of one node.
+*
+* @param session - session owning the node.
+* @param seq - a surface seq taken from `session.surface.nodes` at evaluation time.
+* @returns the node, or undefined when the seq no longer resolves to a tool result.
+*/
+function currentNode(session, seq) {
+	const event = session.eventAt(seq);
+	if (event === void 0) return void 0;
+	const message = session.deriveEventMessage(event);
+	if (message === null || message.role !== "tool") return void 0;
+	if (event.type !== "tool/result") return void 0;
+	return {
+		event,
+		message,
+		text: textOf$1(message.content)
+	};
+}
+/**
+* Build the detached evaluation input for one moment in the session.
+*
+* Surface seqs are always sourced fresh from `session.surface.nodes`, never
+* cached across evaluations (design §6.7), because a replacement splices the new
+* seq over the old one and the old seq leaves the surface.
+*
+* @param session - session to read.
+* @returns a snapshot that does not reference live session objects.
+*/
+function snapshotInput(session) {
+	const nodes = [];
+	const calls = /* @__PURE__ */ new Map();
+	const mentions = [];
+	for (const event of session.snapshotEvents()) switch (event.type) {
+		case "tool/call":
+			calls.set(event.data.callId, {
+				name: event.data.name,
+				args: event.data.arguments
+			});
+			mentions.push({
+				seq: event.seq,
+				text: `${event.data.callId} ${event.data.arguments}`
+			});
+			break;
+		case "assistant/message": {
+			let text = "";
+			for (const block of event.data.message.content) if (block.type === "text") text += block.text;
+			else if (block.type === "tool-call") {
+				text += `${block.id} ${block.name} ${block.arguments}`;
+				if (!calls.has(block.id)) calls.set(block.id, {
+					name: block.name,
+					args: block.arguments
+				});
+			}
+			if (text !== "") mentions.push({
+				seq: event.seq,
+				text
+			});
+			break;
+		}
+		case "user/message": {
+			const text = textOf$1(event.data.content);
+			if (text !== "") mentions.push({
+				seq: event.seq,
+				text
+			});
+			break;
+		}
+	}
+	for (const seq of [...session.surface.nodes]) {
+		const current = currentNode(session, seq);
+		if (current === void 0) continue;
+		const { event, message } = current;
+		if (event.type !== "tool/result") continue;
+		const call = calls.get(message.toolCallId);
+		nodes.push({
+			seq,
+			turn: event.data.turn,
+			step: event.data.step,
+			toolName: call?.name ?? "unknown",
+			callId: message.toolCallId,
+			...call === void 0 ? {} : { args: call.args },
+			content: message.content,
+			isError: message.isError === true
+		});
+	}
+	return {
+		nodes,
+		mentions
+	};
+}
+/**
+* Plan one evaluation without touching the session.
+*
+* @param session - session to read.
+* @param currentTurn - the turn being evaluated.
+* @param currentStep - the step being evaluated.
+* @param config - resolved configuration.
+* @returns the decision.
+*/
+function planFor(session, currentTurn, currentStep, config) {
+	const { nodes, mentions } = snapshotInput(session);
+	return planFolds({
+		nodes,
+		mentions,
+		currentTurn,
+		currentStep,
+		config
+	});
+}
+/**
+* Execute one planned batch.
+*
+* Per node (design §6.6): resolve the node's *current* message, spill the full
+* current text, append the shadow price, then append the replacement. A node
+* whose spill fails is left untouched — folding without a reachable original
+* would be lossy. A node whose replacement is rejected fails that node only;
+* earlier replacements stay durable and the batch is not retried.
+*
+* @param host - session, spill store, meter, and configuration.
+* @param batch - the batch to fold.
+* @returns landed folds, failures, and the characters removed.
+*/
+async function foldBatch(host, batch) {
+	const folded = [];
+	const failed = [];
+	const spilled = /* @__PURE__ */ new Map();
+	const roster = [];
+	for (const plan of batch.members) try {
+		const ref = await spillFor(host, plan);
+		spilled.set(plan.seq, ref);
+		roster.push({
+			toolName: plan.facts.toolName,
+			callId: plan.facts.callId,
+			locator: ref.locator
+		});
+	} catch (error) {
+		failed.push({
+			seq: plan.seq,
+			toolName: plan.facts.toolName,
+			reason: describe(error)
+		});
+	}
+	const landed = batch.members.filter((plan) => spilled.has(plan.seq));
+	for (const plan of landed) {
+		const ref = spilled.get(plan.seq);
+		const siblings = roster.filter((entry) => entry.callId !== plan.facts.callId);
+		try {
+			const text = renderFoldedText(plan, ref.locator, siblings, landed.length);
+			if (Array.from(text).length >= plan.facts.chars) {
+				failed.push({
+					seq: plan.seq,
+					toolName: plan.facts.toolName,
+					reason: "the folded node would not be smaller than the result"
+				});
+				continue;
+			}
+			folded.push(applyFold(host, plan, text, ref.locator, ref.bytes));
+		} catch (error) {
+			failed.push({
+				seq: plan.seq,
+				toolName: plan.facts.toolName,
+				reason: describe(error)
+			});
+		}
+	}
+	return {
+		folded,
+		failed,
+		charsRemoved: folded.reduce((total, fold) => total + (fold.charsBefore - fold.charsAfter), 0)
+	};
+}
+/**
+* Spill one node's full current text and return its locator.
+*
+* A result that already carries a spill notice is not spilled twice: its
+* existing locator is reused (design §6.5).
+*
+* @param host - host services.
+* @param plan - the node to spill.
+* @returns the locator to cite and the bytes this fold wrote.
+*/
+async function spillFor(host, plan) {
+	const current = currentNode(host.session, plan.seq);
+	if (current === void 0) throw new Error("the node left the surface before its fold landed");
+	const existing = parseSpillNotice(current.text);
+	if (existing !== void 0) return {
+		locator: existing.locator,
+		bytes: 0
+	};
+	const ref = await host.spillStore.saveText({
+		owner: { sessionId: host.session.header.id },
+		source: {
+			kind: "tool",
+			toolName: plan.facts.toolName,
+			callId: current.message.toolCallId,
+			label: "result"
+		},
+		suggestedName: `${plan.facts.toolName}.txt`,
+		content: current.text
+	});
+	return {
+		locator: ref.locator,
+		bytes: ref.bytes
+	};
+}
+/**
+* Apply one fold through the replace protocol.
+*
+* @param host - host services.
+* @param plan - the node to rewrite.
+* @param text - replacement content text.
+* @param locator - the spill locator cited in the text.
+* @param spillBytes - bytes written to reach that locator.
+* @returns the landed fold record.
+* @throws when the host rejects the replacement.
+*/
+function applyFold(host, plan, text, locator, spillBytes) {
+	const current = currentNode(host.session, plan.seq);
+	if (current === void 0) throw new Error("the node left the surface before its fold landed");
+	const content = [{
+		type: "text",
+		text
+	}];
+	const message = freezeMessage({
+		...current.message,
+		content
+	});
+	host.session.append("compaction/prune", {
+		shadowedRange: {
+			start: plan.seq,
+			end: plan.seq
+		},
+		shadowedSeqs: [plan.seq],
+		shadowedTokenCount: host.estimateMessage(current.message)
+	});
+	return {
+		replacementSeq: host.session.append("tool/result", {
+			...current.event.data,
+			message
+		}, {
+			surfaceOp: {
+				op: "replace",
+				startSeq: plan.seq,
+				endSeq: plan.seq
+			},
+			sourceEventSeqs: [plan.seq]
+		}).seq,
+		originalSeq: plan.seq,
+		callId: plan.facts.callId,
+		toolName: plan.facts.toolName,
+		charsBefore: plan.facts.chars,
+		charsAfter: Array.from(text).length,
+		locator,
+		spillBytes
+	};
+}
+/** Concatenate text blocks. */
+function textOf$1(content) {
+	let text = "";
+	for (const block of content) if (block.type === "text") text += block.text;
+	return text;
+}
+/** Human-readable error text. */
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+// src/measure.ts
+const MARKER_HEADER = /^\[context-fold\] \[tool: ([^\]]+)\] ([\d,]+) chars folded at turn (\d+), step (\d+)\.( \(batch head\))?/;
+/**
+* Derive a report from one session's current log.
+*
+* @param session - session to inspect.
+* @returns the fold report.
+*/
+function reportOf(session) {
+	const events = session.snapshotEvents();
+	const folds = [];
+	for (const seq of [...session.surface.nodes]) {
+		const current = currentNode(session, seq);
+		if (current === void 0) continue;
+		if (!isFoldedText(current.text)) continue;
+		const header = MARKER_HEADER.exec(current.text);
+		const charsAfter = codePointLength(current.text);
+		folds.push({
+			seq,
+			turn: header === null ? 0 : Number(header[3]),
+			step: header === null ? 0 : Number(header[4]),
+			toolName: header?.[1] ?? "unknown",
+			charsBefore: header === null ? charsAfter : Number(header[2].replaceAll(",", "")),
+			charsAfter,
+			reReads: countReReads(events, seq, current.text),
+			head: header?.[5] !== void 0
+		});
+	}
+	return {
+		folds,
+		charsRemoved: folds.reduce((total, fold) => total + Math.max(0, fold.charsBefore - fold.charsAfter), 0),
+		reReads: folds.reduce((total, fold) => total + fold.reReads, 0),
+		rereadNodes: folds.filter((fold) => fold.reReads > 0).length,
+		reasoningFolds: reasoningFoldsOf(session, events)
+	};
+}
+/**
+* Derive reasoning folds from their durable decision records.
+*
+* Only the folded blocks are measured, so a message that intentionally keeps a
+* short reasoning block does not have that block's characters attributed to the
+* fold. Rows are keyed by `seq` + block index: two decisions may legitimately
+* cover different blocks of one message, but a repeated decision for the same
+* block must not be counted twice.
+*
+* @param session - session to inspect.
+* @param events - the session's event log.
+* @returns one record per folded block, in decision order.
+*/
+function reasoningFoldsOf(session, events) {
+	const records = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (event.type !== "plugin:context-fold/reasoning") continue;
+		const data = event.data;
+		for (const target of data.targets ?? []) {
+			const indexes = target.indexes ?? [];
+			const message = session.eventAt(target.seq);
+			const derived = message === void 0 ? null : session.deriveEventMessage(message);
+			if (derived === null || derived.role !== "assistant") continue;
+			for (const [position, index] of indexes.entries()) {
+				const key = `${target.seq}:${index}`;
+				if (seen.has(key)) continue;
+				const block = derived.content[index];
+				if (block === void 0 || block.type !== "reasoning") continue;
+				seen.add(key);
+				records.push({
+					seq: target.seq,
+					blocks: 1,
+					charsBefore: target.chars?.[position] ?? codePointLength(block.text),
+					charsAfter: codePointLength(block.text)
+				});
+			}
+		}
+	}
+	return records;
+}
+/**
+* Count later tool calls that cite a folded node.
+*
+* Two signals, both cheap substring tests over a bounded window: the node's
+* call id, and its spill locator. Design §6.2 records the known limitation — a
+* model that re-runs the original tool with identical arguments is not
+* detected here; the argument-hash refinement is out of phase 1.
+*
+* @param events - the session's event log.
+* @param seq - the folded node's seq.
+* @param text - the folded node's text, source of the spill locator.
+* @returns the number of later citing events.
+*/
+function countReReads(events, seq, text) {
+	const headCallId = /Batch head: (\S+) \(callId\)/.exec(text)?.[1];
+	const locator = /^Full result: (.+)$/m.exec(text)?.[1];
+	const needles = [];
+	if (headCallId !== void 0) needles.push(headCallId);
+	if (locator !== void 0) needles.push(locator.trim());
+	if (needles.length === 0) return 0;
+	let count = 0;
+	for (const event of events) {
+		if (event.seq <= seq) continue;
+		const searched = searchableText(event);
+		if (searched === void 0) continue;
+		if (needles.some((needle) => searched.includes(needle))) count++;
+	}
+	return count;
+}
+/** Text one later event contributes to the re-read search. */
+function searchableText(event) {
+	switch (event.type) {
+		case "tool/call": return `${event.data.callId} ${event.data.name} ${event.data.arguments}`;
+		case "user/message": {
+			let text = "";
+			for (const block of event.data.content) if (block.type === "text") text += block.text;
+			return text;
+		}
+		case "assistant/message": {
+			let text = "";
+			for (const block of event.data.message.content) if (block.type === "text") text += block.text;
+			else if (block.type === "tool-call") text += `${block.id} ${block.name} ${block.arguments}`;
+			return text;
+		}
+		default: return;
+	}
+}
+/**
+* Render the `/context-fold` report.
+*
+* @param report - derived report.
+* @param dryRun - whether the plugin is configured to mutate nothing.
+* @returns markdown text for the command result.
+*/
+function renderReport(report, dryRun) {
+	const lines = [`${FOLD_MARKER} ${report.folds.length} folded node(s) on the surface.`];
+	if (report.reasoningFolds.length > 0) {
+		const removed = report.reasoningFolds.reduce((total, fold) => total + Math.max(0, fold.charsBefore - fold.charsAfter), 0);
+		lines.push(`Reasoning folded in ${report.reasoningFolds.length} message(s): ${removed.toLocaleString("en-US")} chars removed.`);
+	}
+	if (report.folds.length === 0) {
+		if (report.reasoningFolds.length > 0) {
+			if (dryRun) lines.push("dryRun is on: nothing is mutated; candidates are reported by the log line.");
+			return lines.join("\n");
+		}
+		lines.push(dryRun ? "dryRun is on: nothing is mutated; candidates are reported by the log line." : "Nothing has been folded in this session yet.");
+		return lines.join("\n");
+	}
+	lines.push(`Characters removed: ${report.charsRemoved.toLocaleString("en-US")}`);
+	lines.push(`Re-read signals: ${report.reReads} across ${report.rereadNodes} folded node(s)`);
+	lines.push("");
+	lines.push("| seq | turn.step | tool | before | after | re-reads |");
+	lines.push("| --- | --- | --- | ---: | ---: | ---: |");
+	for (const fold of report.folds) lines.push(`| ${fold.seq} | ${fold.turn}.${fold.step} | ${fold.toolName} | ${fold.charsBefore} | ${fold.charsAfter} | ${fold.reReads} |`);
+	if (dryRun) lines.push("", "dryRun is on: the numbers above describe folds landed earlier, not new mutations.");
+	return lines.join("\n");
+}
+// src/counterfactual.ts
+/**
+* DeepSeek's published relative pricing, normalised to uncached input = 1.
+*
+* Cache read is ~0.1×, cache write ~1× (a write and a plain read are priced
+* alike), output 4× but output is not affected by folding so it is not modelled.
+* These are *ratios*, so the result can be read as "token-equivalents" without
+* needing a currency.
+*/
+const DEFAULT_PRICE_MODEL = Object.freeze({
+	uncachedInput: 1,
+	cacheRead: .1,
+	cacheWrite: 1
+});
+/**
+* Extract per-step provider usage from a log.
+*
+* @param events - session events in seq order.
+* @returns one record per step that reported usage, in seq order.
+*/
+function usageOf(events) {
+	const steps = [];
+	for (const event of events) {
+		if (event.type !== "assistant/message") continue;
+		const data = event.data;
+		const usage = data?.usage;
+		if (usage === void 0 || usage === null) continue;
+		const read = (key) => {
+			const value = usage[key];
+			return typeof value === "number" && Number.isFinite(value) ? value : 0;
+		};
+		steps.push({
+			turn: typeof data?.turn === "number" ? data.turn : 0,
+			step: typeof data?.step === "number" ? data.step : 0,
+			input: read("inputTokens"),
+			cacheRead: read("cacheReadTokens"),
+			cacheWrite: read("cacheWriteTokens"),
+			seq: event.seq
+		});
+	}
+	return steps;
+}
+/**
+* Price one step's prompt under the model.
+*
+* @param usage - the step's observed billing.
+* @param price - price model.
+* @returns prompt cost in price units (uncached-input-equivalents).
+*/
+function promptCostOf(usage, price) {
+	return usage.input * price.uncachedInput + usage.cacheRead * price.cacheRead + usage.cacheWrite * price.cacheWrite;
+}
+/** Total tokens one step sent. */
+function promptTokensOf(usage) {
+	return usage.input + usage.cacheRead + usage.cacheWrite;
+}
+/**
+* Build the counterfactual comparison.
+*
+* @param folds - folded nodes present on the current surface.
+* @param steps - observed per-step usage, in seq order.
+* @param options - fold step numbers per fold, for the invalidation window, plus the price model.
+* @returns the comparison, with every assumption stated.
+*/
+function counterfactualOf(folds, steps, options = {}) {
+	const price = options.price ?? DEFAULT_PRICE_MODEL;
+	const tokensNow = folds.reduce((total, fold) => total + fold.tokensAfter, 0);
+	const tokensIfUnfolded = folds.reduce((total, fold) => total + fold.tokensBefore, 0);
+	const tokensSavedPerStep = Math.max(0, tokensIfUnfolded - tokensNow);
+	const hasRealUsage = steps.length > 0;
+	const totalPromptTokens = steps.reduce((total, step) => total + promptTokensOf(step), 0);
+	const totalCacheRead = steps.reduce((total, step) => total + step.cacheRead, 0);
+	const actualPromptCost = steps.reduce((total, step) => total + promptCostOf(step, price), 0);
+	const foldSteps = options.foldSteps;
+	const remainingSteps = foldSteps === void 0 || foldSteps.length === 0 ? steps.length : steps.filter((step) => foldSteps.some((foldStep) => step.step > foldStep)).length;
+	const cacheReadShare = totalPromptTokens === 0 ? void 0 : totalCacheRead / totalPromptTokens;
+	const savedTokenRate = cacheReadShare === void 0 ? price.uncachedInput : cacheReadShare * price.cacheRead + (1 - cacheReadShare) * price.uncachedInput;
+	const grossSaving = tokensSavedPerStep * remainingSteps * savedTokenRate;
+	let invalidationCost = 0;
+	if (foldSteps !== void 0) for (const foldStep of foldSteps) {
+		const at = steps.find((step) => step.step >= foldStep);
+		if (at === void 0) continue;
+		const prompt = promptTokensOf(at);
+		invalidationCost += prompt * (price.uncachedInput - price.cacheRead);
+	}
+	const counterfactualPromptCost = actualPromptCost + tokensSavedPerStep * remainingSteps * savedTokenRate;
+	const assumptions = [];
+	assumptions.push(hasRealUsage ? `Prices are DeepSeek ratios (cache read ${price.cacheRead}×, write ${price.cacheWrite}×, uncached ${price.uncachedInput}×), applied to this session's observed usage.` : "This session reported no provider usage, so even the \"actual\" figures are heuristic token counts, not billed amounts.");
+	if (cacheReadShare !== void 0) assumptions.push(`Saved tokens are priced at this session's observed cache-read share (${(cacheReadShare * 100).toFixed(1)}%), not at the uncached rate.`);
+	if (foldSteps === void 0 || foldSteps.length === 0) assumptions.push("Fold step numbers were unavailable, so every observed step is credited with the saving. Treat the figure as an upper bound.");
+	else assumptions.push(`Each fold is charged one prefix invalidation: the whole prompt after it re-billed from cache-read to uncached once.`);
+	assumptions.push("The counterfactual assumes the same number of steps and the same cache behaviour as the real session — a folded prompt might have hit cache differently.");
+	return {
+		tokensNow,
+		tokensIfUnfolded,
+		tokensSavedPerStep,
+		remainingSteps,
+		grossSaving,
+		invalidationCost,
+		netSaving: grossSaving - invalidationCost,
+		actualPromptCost,
+		counterfactualPromptCost,
+		hasRealUsage,
+		...cacheReadShare === void 0 ? {} : { cacheReadShare },
+		priceModel: price,
+		assumptions
+	};
+}
+// src/routes.ts
+/**
+* Extract the spill locator a folded node's text carries.
+*
+* Phase 1 writes `Full result: <path>`; phase 2 writes `Full text: <path> —`.
+*
+* @param text - folded node text.
+* @returns the locator, or undefined when the fold has no recovery path.
+*/
+function locatorOf(text) {
+	return /(?:Full result|Full text): (\S+)/.exec(text)?.[1];
+}
+/**
+* Build the `/report` payload for one session.
+*
+* @param session - session to inspect.
+* @param deps - token meter and spill access.
+* @returns the payload the tab renders.
+*/
+function buildReport(session, deps) {
+	const tool = reportOf(session);
+	const decisions = reasoningDecisions(session);
+	const folds = [];
+	for (const fold of tool.folds) {
+		const event = session.eventAt(fold.seq);
+		const message = event === void 0 ? null : session.deriveEventMessage(event);
+		const content = message !== null && message.role === "tool" ? message.content : void 0;
+		const tokensAfter = content === void 0 ? 0 : deps.estimateMessage(content);
+		const inline = inlineTextOf(content) ?? "";
+		const locator = locatorOf(inline);
+		folds.push({
+			seq: fold.seq,
+			kind: "tool-result",
+			turn: fold.turn,
+			step: fold.step,
+			toolName: fold.toolName,
+			charsBefore: fold.charsBefore,
+			charsAfter: fold.charsAfter,
+			tokensBefore: estimateFromChars(fold.charsBefore),
+			tokensAfter,
+			inline,
+			recoverable: locator !== void 0,
+			...locator === void 0 ? {} : { locator }
+		});
+	}
+	for (const decision of decisions) for (const target of decision.targets) {
+		const event = session.eventAt(target.seq);
+		const message = event === void 0 ? null : session.deriveEventMessage(event);
+		if (message === null || message.role !== "assistant") continue;
+		const assistantEvent = session.eventAt(target.seq);
+		const turn = assistantEvent?.type === "assistant/message" ? assistantEvent.data.turn : 0;
+		const step = assistantEvent?.type === "assistant/message" ? assistantEvent.data.step : 0;
+		for (const [position, index] of target.indexes.entries()) {
+			const block = message.content[index];
+			if (block === void 0 || block.type !== "reasoning") continue;
+			const locator = target.locators?.[position];
+			folds.push({
+				seq: target.seq,
+				kind: "reasoning",
+				turn,
+				step,
+				charsBefore: target.chars?.[position] ?? 0,
+				charsAfter: Array.from(block.text).length,
+				tokensBefore: estimateFromChars(target.chars?.[position] ?? 0),
+				tokensAfter: deps.estimateMessage([{
+					type: "text",
+					text: block.text
+				}]),
+				inline: block.text,
+				recoverable: locator !== void 0,
+				...locator === void 0 ? {} : { locator }
+			});
+		}
+	}
+	return {
+		folds,
+		counterfactual: counterfactualOf(folds.map((fold) => ({
+			seq: fold.seq,
+			kind: fold.kind,
+			charsBefore: fold.charsBefore,
+			charsAfter: fold.charsAfter,
+			tokensBefore: fold.tokensBefore,
+			tokensAfter: fold.tokensAfter
+		})), usageOf(session.snapshotEvents()), { foldSteps: folds.map((fold) => fold.step).filter((step) => step > 0) }),
+		reReads: tool.reReads
+	};
+}
+/** Text of a tool message's single result block. */
+function inlineTextOf(content) {
+	if (content === void 0) return void 0;
+	let text = "";
+	for (const block of content) if (block.type === "text" && typeof block.text === "string") text += block.text;
+	return text;
+}
+/**
+* Approximate tokens from a character count.
+*
+* Only used for the *before* side, where the text is gone. The ratio matches the
+* token meter's own CJK-aware heuristic closely enough for an estimate that is
+* already labelled as one.
+*/
+function estimateFromChars(chars) {
+	return Math.round(chars / 3.5);
+}
+/**
+* Read the full original behind one fold.
+*
+* @param deps - spill access.
+* @param locator - recovery path recorded on the fold.
+* @returns the text, or undefined when it cannot be read.
+*/
+async function readOriginal(deps, locator) {
+	if (deps.spillStore === void 0) return void 0;
+	const reader = deps.spillStore;
+	if (typeof reader.readText !== "function") return void 0;
+	try {
+		return await reader.readText(locator);
+	} catch {
+		return;
+	}
+}
+/** Box a successful value. */
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/** Box a failure. */
+function fail(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+/** JSON response matching the host's own convention. */
+function json(value, status = 200) {
+	return Response.json(value, {
+		status,
+		headers: { "cache-control": "no-store" }
+	});
+}
+/**
+* Register the two read-only routes the tab uses.
+*
+* @param register - the host route registrar.
+* @param deps - session and spill access.
+* @returns a disposer for both routes.
+*/
+function registerRoutes(register, deps) {
+	const report = register({
+		path: "/api/context-fold/report",
+		methods: ["POST"],
+		requestBody: "buffered",
+		async fetch(request) {
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return json(fail("body is not JSON"), 400);
+			}
+			const sessionId = typeof body.sessionId === "string" ? body.sessionId : "";
+			if (sessionId === "") return json(fail("missing sessionId"), 400);
+			const session = deps.sessionOf(sessionId);
+			if (session === void 0) return json(fail(`unknown session ${sessionId}`), 404);
+			try {
+				return json(ok(buildReport(session, deps)));
+			} catch (error) {
+				return json(fail(error instanceof Error ? error.message : String(error)), 500);
+			}
+		}
+	});
+	const original = register({
+		path: "/api/context-fold/original",
+		methods: ["POST"],
+		requestBody: "buffered",
+		async fetch(request) {
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return json(fail("body is not JSON"), 400);
+			}
+			const locator = typeof body.locator === "string" ? body.locator : "";
+			if (locator === "") return json(fail("missing locator"), 400);
+			try {
+				const text = await readOriginal(deps, locator);
+				return text === void 0 ? json(fail("original not readable"), 404) : json(ok({ text }));
+			} catch (error) {
+				return json(fail(error instanceof Error ? error.message : String(error)), 500);
+			}
+		}
+	});
+	return () => {
+		report();
+		original();
+	};
+}
+// src/index.ts
+/** Cordis plugin identity. */
+const name = "context-fold";
+/** The plugin needs a token meter; without a spill store it no-ops with a warning (design §6.5). */
+const inject = ["tokenMeter"];
+/**
+* Mount the fold policy.
+*
+* @param ctx - plugin context.
+* @param rawConfig - configuration from the settings row.
+*/
+function apply(ctx, rawConfig = {}) {
+	const config = resolveConfig(rawConfig);
+	if (!config.enabled) {
+		ctx.logger.info("context-fold: disabled by configuration");
+		return;
+	}
+	const states = /* @__PURE__ */ new Map();
+	let warnedMissingSpill = false;
+	let warnedMissingMeter = false;
+	/** Run one idempotent evaluation for an agent at a boundary. */
+	async function evaluate(agent, currentTurn, currentStep) {
+		const session = agent.session;
+		const sessionId = session.header.id;
+		let state = states.get(sessionId);
+		if (state === void 0) {
+			state = {
+				boundary: "",
+				running: false
+			};
+			states.set(sessionId, state);
+		}
+		const boundary = `${currentTurn}:${currentStep}:${session.surface.contentGeneration}`;
+		if (state.running || state.boundary === boundary) return void 0;
+		state.running = true;
+		state.boundary = boundary;
+		try {
+			const spillStore = ctx.get("spillStore");
+			if (spillStore === void 0) {
+				if (!warnedMissingSpill) {
+					warnedMissingSpill = true;
+					ctx.logger.warn("context-fold: no ctx.spillStore backend is loaded; folding is a no-op");
+				}
+				return;
+			}
+			const tokenMeter = ctx.get("tokenMeter");
+			if (tokenMeter === void 0) {
+				if (!warnedMissingMeter) {
+					warnedMissingMeter = true;
+					ctx.logger.warn("context-fold: no ctx.tokenMeter service; folding is a no-op");
+				}
+				return;
+			}
+			const decision = planFor(session, currentTurn, currentStep, config);
+			const reasoningPlans = config.foldReasoning ? planReasoningFolds(reasoningCandidates(session), currentTurn, currentStep, config) : [];
+			if (config.dryRun) {
+				ctx.logger.info(describeDecision("dryRun: would fold", decision, config));
+				if (reasoningPlans.length > 0) {
+					const chars = reasoningPlans.reduce((total, plan) => total + plan.charsRemoved, 0);
+					ctx.logger.info(`dryRun: would fold reasoning in ${reasoningPlans.length} message(s), removing ${chars} chars`);
+				}
+				return {
+					decision,
+					folded: [],
+					failed: [],
+					charsRemoved: 0
+				};
+			}
+			if (reasoningPlans.length > 0) try {
+				await recordReasoningFolds(session, reasoningPlans, spillStore);
+				const chars = reasoningPlans.reduce((total, plan) => total + plan.charsRemoved, 0);
+				ctx.logger.info(`context-fold: folded reasoning in ${reasoningPlans.length} message(s), removed ${chars} chars`);
+			} catch (error) {
+				ctx.logger.warn(`context-fold: reasoning fold failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (decision.batches.length === 0) return {
+				decision,
+				folded: [],
+				failed: [],
+				charsRemoved: 0
+			};
+			const folded = [];
+			const failed = [];
+			const host = {
+				session,
+				spillStore,
+				config,
+				estimateMessage: (message) => tokenMeter.estimateMessage(message)
+			};
+			for (const batch of decision.batches) {
+				const result = await foldBatch(host, batch);
+				folded.push(...result.folded);
+				failed.push(...result.failed);
+			}
+			const charsRemoved = folded.reduce((total, fold) => total + (fold.charsBefore - fold.charsAfter), 0);
+			if (folded.length > 0 || failed.length > 0) ctx.logger.info(`context-fold: folded ${folded.length} node(s), removed ${charsRemoved} chars, ${failed.length} failure(s)`);
+			return {
+				decision,
+				folded,
+				failed,
+				charsRemoved
+			};
+		} catch (error) {
+			state.boundary = "";
+			ctx.logger.warn(`context-fold: evaluation failed: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		} finally {
+			state.running = false;
+		}
+	}
+	ctx.on("agent/pre-step", async (payload, next) => {
+		const decision = await next();
+		await evaluate(payload.agent, payload.turn, payload.step);
+		return decision;
+	});
+	ctx.on("agent/turn-stopping", async (payload) => {
+		await evaluate(payload.agent, payload.turn, latestStep(payload.agent.session));
+	});
+	ctx.inject(["commands"], (scope) => {
+		scope.commands.register({
+			name: "context-fold",
+			description: "Report what dsh-context-fold has folded in this session, and how often the folded content was read again.",
+			handler: (invocation) => ({
+				kind: "success",
+				text: renderReport(reportOf(invocation.agent.session), config.dryRun)
+			})
+		});
+	});
+	ctx.inject(["sessions"], (scope) => {
+		const sessions = scope.sessions;
+		if (sessions === void 0 || typeof sessions.registerMessageProjection !== "function") {
+			ctx.logger.warn("context-fold: no ctx.sessions.registerMessageProjection; reasoning folds stay inactive");
+			return;
+		}
+		try {
+			sessions.registerMessageProjection(reasoningProjection);
+		} catch (error) {
+			ctx.logger.warn(`context-fold: reasoning projection not registered: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+	ctx.inject(["connection"], (scope) => {
+		const connection = scope.connection;
+		if (connection === void 0) {
+			ctx.logger.warn("context-fold: no ctx.connection service; the conversation tab has no data source");
+			return;
+		}
+		const tokenMeter = ctx.get("tokenMeter");
+		registerRoutes(connection, {
+			sessionOf: (id) => {
+				return ctx.get("sessions")?.get(id);
+			},
+			estimateMessage: (message) => tokenMeter === void 0 ? 0 : tokenMeter.estimateMessage(message),
+			...ctx.get("spillStore") === void 0 ? {} : { spillStore: ctx.get("spillStore") }
+		});
+	});
+	ctx.on("session/disposed", (session) => {
+		states.delete(session.header.id);
+	});
+	if (ctx.get("spillStore") === void 0) ctx.logger.warn("context-fold: no ctx.spillStore backend at mount; folding stays inert until one is loaded");
+	ctx.logger.info(`context-fold: enabled (minFoldChars ${config.minFoldChars}, minBatchChars ${config.minBatchChars}, keepRecentSteps ${config.keepRecentSteps}, staleSteps ${config.staleSteps}, batchSpanSteps ${config.batchSpanSteps}, dryRun ${config.dryRun})`);
+}
+/**
+* Highest step number recorded in a session log, used at the turn boundary.
+*
+* @param session - session to scan.
+* @returns the highest step, or 0 for a session without steps.
+*/
+function latestStep(session) {
+	let step = 0;
+	for (const event of session.snapshotEvents()) {
+		const value = stepOf(event);
+		if (value !== void 0 && value > step) step = value;
+	}
+	return step;
+}
+/** The step of any step-carrying event. */
+function stepOf(event) {
+	if (event.type !== "tool/result" && event.type !== "tool/call" && event.type !== "assistant/message") return void 0;
+	const data = event.data;
+	return typeof data.step === "number" ? data.step : void 0;
+}
+/**
+* One-line summary of a decision for the log during `dryRun`.
+*
+* @param prefix - leading phrase.
+* @param decision - the decision to describe.
+* @param config - resolved configuration.
+* @returns a single log line.
+*/
+function describeDecision(prefix, decision, config) {
+	const nodes = decision.batches.reduce((total, batch) => total + batch.members.length, 0);
+	const reasons = /* @__PURE__ */ new Map();
+	for (const skip of decision.skipped) reasons.set(skip.reason, (reasons.get(skip.reason) ?? 0) + 1);
+	const detail = [...reasons].map(([reason, count]) => `${reason}=${count}`).join(" ");
+	return `context-fold: ${prefix} ${nodes} node(s) in ${decision.batches.length} batch(es); candidate chars ${decision.candidateChars}; skipped ${detail === "" ? "none" : detail}; thresholds minFoldChars=${config.minFoldChars} minBatchChars=${config.minBatchChars}`;
+}
+var src_default = {
+	name,
+	inject,
+	Config,
+	apply
+};
+export { Config, DEFAULT_CONFIG, FOLD_MARKER, REASONING_EVENT, REASONING_MARKER, apply, codePointLength, conclude, src_default as default, describeDecision, foldReasoningText, inject, isFoldableContent, isFoldedReasoning, isFoldedText, isToolCallTurn, name, parseSpillNotice, planFolds, planFor, planReasoningFolds, projectReasoning, reasoningCandidates, reasoningProjection, recordReasoningFolds, renderReport, reportOf, resolveConfig, snapshotInput, textOf };