dsh-context-compression-improved 0.4.0-beta.1 → 0.5.0

package/packages/selector/lib/pruner.js

@@ -1,4 +1,4 @@
-import { _ as COMPRESSION_PROFILES, a as PRUNE_MARKER, c as isValidAutoCompactThresholdPercent, d as resolvePolicy, f as CustomCompressionPolicySchema, g as deepFreeze, h as assertNever, i as DEFAULTS, l as parseContextCompressionSettings, m as resolveCustomPolicy, n as CONTEXT_COMPRESSION_SETTINGS_NAMESPACE, o as codePointLength, p as DEFAULT_CUSTOM_COMPRESSION_POLICY, r as ContextCompressionSettingsSchema, s as isCompressionProfile, t as AUTO_COMPACT_THRESHOLD_LIMITS, u as resolveConfig } from "./config.js";
+import { C as DEFAULT_CUSTOM_COMPRESSION_POLICY, D as COMPRESSION_PROFILES, E as deepFreeze, S as CustomCompressionPolicySchema, T as assertNever, _ as isCompressionProfile, a as registerReviewPruner, b as resolveConfig, c as ReviewQueue, d as ContextCompressionSettingsSchema, f as DEFAULTS, g as codePointLength, h as charsToTokens, i as recordScore, l as AUTO_COMPACT_THRESHOLD_LIMITS, m as charsForTokens, n as invalidateOnTaskChange, p as PRUNE_MARKER, r as recordRecertified, s as sharedReviewStore, t as getAdvisorState, u as CONTEXT_COMPRESSION_SETTINGS_NAMESPACE, v as isValidAutoCompactThresholdPercent, w as resolveCustomPolicy, x as resolvePolicy, y as parseContextCompressionSettings } from "./advisor-state.js";
 import { a as validatePublishedTailTrim, i as tailTrimStub, n as tailTrimMessage, o as eventBySeq, r as tailTrimRef, s as sessionEvents, t as parseTailTrimRef } from "./tail-trim.js";
 import z from "@deepseek-ai/schemastery";
 import { createHash } from "node:crypto";
@@ -355,8 +355,135 @@ function countExactCanonicalTextFields(fields, counter, subject) {
 		tokens
 	});
 }
+/** Count the lines present in the original but absent from the replacement. */
+function countOmittedLines(original, replacement) {
+	const omitted = original.split("\n").length - replacement.split("\n").length;
+	return omitted > 0 ? omitted : void 0;
+}
+/** Routed-context utilization required before capacity-pressure History may age sent history. */
+const CAPACITY_PRESSURE_RATIO = .7;
+//#endregion
+//#region src/pruner/content.ts
+function onlyTextBlock(blocks) {
+	return blocks.length === 1 && blocks[0]?.type === "text" ? blocks[0] : null;
+}
+function onlyTextBlocks(blocks) {
+	return blocks.every((block) => block.type === "text") ? blocks : null;
+}
+function countToolContent(blocks, view) {
+	const text = onlyTextBlocks(blocks);
+	if (text === null) return unavailableCount("tool result contains unsupported rich content");
+	return countExactCanonicalTextFields(text.map((block) => block.text), (candidate) => view.countCanonicalText(candidate), "tool result replacement");
+}
+function sameProviderMeasurementKey(left, right) {
+	return left.provider === right.provider && left.baseUrlClass === right.baseUrlClass && left.apiRoute === right.apiRoute && left.modelId === right.modelId && left.requestTemplateRevision === right.requestTemplateRevision && left.tokenizerRevision === right.tokenizerRevision && left.modality === right.modality;
+}
+function unavailableCount(reason) {
+	return Object.freeze({
+		kind: "unavailable",
+		reason
+	});
+}
+function recoveryMarker(sourceRef, label, startLine) {
+	return `\n\n[... ${label}; source=${sourceRef}; ${startLine === void 0 ? "use context_compression_retrieve if needed" : `retrieve with context_compression_retrieve({"ref":"${sourceRef}","start_line":${String(startLine)},"max_lines":80})`} ...]\n\n`;
+}
+/**
+* Measure text content in Unicode code points; non-text blocks cost zero.
+* @param blocks - tool-result content to measure.
+* @returns total Unicode code points across text blocks.
+*/
+function measureContent(blocks) {
+	let chars = 0;
+	for (const block of blocks) if (block.type === "text") chars += codePointLength(block.text);
+	return chars;
+}
+function pressureCost(blocks) {
+	let cost = 0;
+	for (const block of blocks) switch (block.type) {
+		case "text":
+		case "reasoning":
+			cost += codePointLength(block.text);
+			break;
+		case "tool-call":
+			cost += 256 + codePointLength(block.name) + codePointLength(block.arguments);
+			break;
+		case "tool-result":
+			cost += 256 + pressureCost(block.content);
+			break;
+		default: {
+			const serialized = JSON.stringify(block);
+			cost += Math.max(256, codePointLength(serialized));
+		}
+	}
+	return cost;
+}
+function nativePruneContent(blocks, thresholdChars, headChars, tailChars, marker = PRUNE_MARKER) {
+	const totalChars = measureContent(blocks);
+	if (totalChars <= thresholdChars) return null;
+	const markerChars = codePointLength(typeof marker === "function" ? marker(1) : marker);
+	const safeHead = Math.max(0, Math.min(headChars, thresholdChars - markerChars));
+	const safeTail = Math.max(0, Math.min(tailChars, thresholdChars - markerChars - safeHead));
+	const removedStart = safeHead;
+	const removedEnd = totalChars - safeTail;
+	const pruned = [];
+	let consumed = 0;
+	let markerInserted = false;
+	let newlinesBefore = 0;
+	for (const block of blocks) {
+		if (block.type !== "text") {
+			pruned.push(block);
+			newlinesBefore += 1;
+			continue;
+		}
+		const points = Array.from(block.text);
+		const blockStart = consumed;
+		const blockEnd = blockStart + points.length;
+		const headEnd = Math.min(points.length, Math.max(0, removedStart - blockStart));
+		const tailStart = Math.min(points.length, Math.max(0, removedEnd - blockStart));
+		const intersectsRemoved = blockStart < removedEnd && blockEnd > removedStart;
+		const headText = points.slice(0, headEnd).join("");
+		const insertion = intersectsRemoved && !markerInserted && typeof marker === "function" ? marker(1 + newlinesBefore + headText.split("\n").length - 1) : intersectsRemoved && !markerInserted ? marker : "";
+		if (insertion !== "") markerInserted = true;
+		const text = points.slice(0, headEnd).join("") + insertion + points.slice(tailStart).join("");
+		if (text !== "") pruned.push({
+			...block,
+			text
+		});
+		newlinesBefore += block.text.split("\n").length - 1 + 1;
+		consumed = blockEnd;
+	}
+	if (!markerInserted) return null;
+	const charsAfter = measureContent(pruned);
+	return charsAfter <= thresholdChars && charsAfter < totalChars ? pruned : null;
+}
+function summarize(entries) {
+	return {
+		pruned: entries,
+		charsRemoved: entries.reduce((sum, entry) => sum + entry.charsBefore - entry.charsAfter, 0),
+		tokensRemoved: entries.reduce((sum, entry) => sum + entry.tokensBefore - entry.tokensAfter, 0)
+	};
+}
+function emptyResult() {
+	return {
+		pruned: [],
+		charsRemoved: 0,
+		tokensRemoved: 0
+	};
+}
 //#endregion
 //#region src/runtime/measurement.ts
+/**
+* Character pressure of one model-visible content array, measured on the same
+* level `SnapshotCandidate.characterPressure` uses: a tool/result message is
+* measured by its inner tool-result content, never by the wrapper block, so the
+* node-level and candidate-level figures stay directly comparable.
+* @param content - the node's model-visible content blocks.
+* @returns character pressure in Unicode code points, plus rich-block costs.
+*/
+function nodeCharacterPressure(content) {
+	const only = content.length === 1 ? content[0] : void 0;
+	return pressureCost(only?.type === "tool-result" ? only.content : content);
+}
 const VISION_MODEL_ID = DEEPSEEK_VISION_TOKENIZER_ARTIFACT.modelIds[0];
 /**
 * Capture one route-bound view without calling patched Harness methods.
@@ -374,22 +501,26 @@ function measureForCompaction(ctx, session) {
 		const event = eventsBySeq.get(Number(node.seq));
 		if (event === void 0) return {
 			seq: node.seq,
-			count: unavailableTokenCount(`surface node ${String(node.seq)} is missing`)
+			count: unavailableTokenCount(`surface node ${String(node.seq)} is missing`),
+			characterPressure: 0
 		};
 		const message = deriveEventMessage(event);
 		if (message === null) return {
 			seq: node.seq,
-			count: unavailableTokenCount(`surface node ${String(node.seq)} is not model-visible`)
+			count: unavailableTokenCount(`surface node ${String(node.seq)} is not model-visible`),
+			characterPressure: 0
 		};
 		const count = countCanonicalContent(message.content, counter, `surface node ${String(node.seq)}`);
 		const intrinsicImageBlockEstimate = count.kind === "tokenizer-estimate" ? intrinsicImageDiagnostic(message.content, target) : void 0;
 		return {
 			seq: node.seq,
 			count,
+			characterPressure: nodeCharacterPressure(message.content),
 			...intrinsicImageBlockEstimate === void 0 ? {} : { intrinsicImageBlockEstimate }
 		};
 	});
 	const currentSurface = countSurfaceCounts(measuredNodes.map((node) => node.count), "current surface");
+	const currentSurfaceChars = measuredNodes.reduce((sum, node) => sum + node.characterPressure, 0);
 	const intrinsicImageBlockEstimateTokens = measuredNodes.reduce((sum, node) => sum + (node.intrinsicImageBlockEstimate?.paddingMinimumTokens ?? 0), 0);
 	return Object.freeze({
 		...measurement,
@@ -399,6 +530,7 @@ function measureForCompaction(ctx, session) {
 		},
 		measuredNodes: Object.freeze(measuredNodes),
 		currentSurface,
+		currentSurfaceChars,
 		intrinsicImageBlockEstimateTokens,
 		countCanonicalText: counter.countText
 	});
@@ -922,119 +1054,6 @@ function codePointLength$1(text) {
 	for (const _point of text) count++;
 	return count;
 }
-/** Count the lines present in the original but absent from the replacement. */
-function countOmittedLines(original, replacement) {
-	const omitted = original.split("\n").length - replacement.split("\n").length;
-	return omitted > 0 ? omitted : void 0;
-}
-/** Routed-context utilization required before capacity-pressure History may age sent history. */
-const CAPACITY_PRESSURE_RATIO = .7;
-//#endregion
-//#region src/pruner/content.ts
-function onlyTextBlock(blocks) {
-	return blocks.length === 1 && blocks[0]?.type === "text" ? blocks[0] : null;
-}
-function onlyTextBlocks(blocks) {
-	return blocks.every((block) => block.type === "text") ? blocks : null;
-}
-function countToolContent(blocks, view) {
-	const text = onlyTextBlocks(blocks);
-	if (text === null) return unavailableCount("tool result contains unsupported rich content");
-	return countExactCanonicalTextFields(text.map((block) => block.text), (candidate) => view.countCanonicalText(candidate), "tool result replacement");
-}
-function exactTokens(count) {
-	return count.kind === "exact-tokenizer" ? count.tokens : void 0;
-}
-function sameProviderMeasurementKey(left, right) {
-	return left.provider === right.provider && left.baseUrlClass === right.baseUrlClass && left.apiRoute === right.apiRoute && left.modelId === right.modelId && left.requestTemplateRevision === right.requestTemplateRevision && left.tokenizerRevision === right.tokenizerRevision && left.modality === right.modality;
-}
-function unavailableCount(reason) {
-	return Object.freeze({
-		kind: "unavailable",
-		reason
-	});
-}
-function recoveryMarker(sourceRef, label) {
-	return `\n\n[... ${label}; source=${sourceRef}; use context_compression_retrieve if needed ...]\n\n`;
-}
-/**
-* Measure text content in Unicode code points; non-text blocks cost zero.
-* @param blocks - tool-result content to measure.
-* @returns total Unicode code points across text blocks.
-*/
-function measureContent(blocks) {
-	let chars = 0;
-	for (const block of blocks) if (block.type === "text") chars += codePointLength(block.text);
-	return chars;
-}
-function pressureCost(blocks) {
-	let cost = 0;
-	for (const block of blocks) switch (block.type) {
-		case "text":
-		case "reasoning":
-			cost += codePointLength(block.text);
-			break;
-		case "tool-call":
-			cost += 256 + codePointLength(block.name) + codePointLength(block.arguments);
-			break;
-		case "tool-result":
-			cost += 256 + pressureCost(block.content);
-			break;
-		default: {
-			const serialized = JSON.stringify(block);
-			cost += Math.max(256, codePointLength(serialized));
-		}
-	}
-	return cost;
-}
-function nativePruneContent(blocks, thresholdChars, headChars, tailChars, marker = PRUNE_MARKER) {
-	const totalChars = measureContent(blocks);
-	if (totalChars <= thresholdChars) return null;
-	const markerChars = codePointLength(marker);
-	const safeHead = Math.max(0, Math.min(headChars, thresholdChars - markerChars));
-	const safeTail = Math.max(0, Math.min(tailChars, thresholdChars - markerChars - safeHead));
-	const removedStart = safeHead;
-	const removedEnd = totalChars - safeTail;
-	const pruned = [];
-	let consumed = 0;
-	let markerInserted = false;
-	for (const block of blocks) {
-		if (block.type !== "text") {
-			pruned.push(block);
-			continue;
-		}
-		const points = Array.from(block.text);
-		const blockStart = consumed;
-		const blockEnd = blockStart + points.length;
-		const headEnd = Math.min(points.length, Math.max(0, removedStart - blockStart));
-		const tailStart = Math.min(points.length, Math.max(0, removedEnd - blockStart));
-		const insertion = blockStart < removedEnd && blockEnd > removedStart && !markerInserted ? marker : "";
-		if (insertion !== "") markerInserted = true;
-		const text = points.slice(0, headEnd).join("") + insertion + points.slice(tailStart).join("");
-		if (text !== "") pruned.push({
-			...block,
-			text
-		});
-		consumed = blockEnd;
-	}
-	if (!markerInserted) return null;
-	const charsAfter = measureContent(pruned);
-	return charsAfter <= thresholdChars && charsAfter < totalChars ? pruned : null;
-}
-function summarize(entries) {
-	return {
-		pruned: entries,
-		charsRemoved: entries.reduce((sum, entry) => sum + entry.charsBefore - entry.charsAfter, 0),
-		tokensRemoved: entries.reduce((sum, entry) => sum + entry.tokensBefore - entry.tokensAfter, 0)
-	};
-}
-function emptyResult() {
-	return {
-		pruned: [],
-		charsRemoved: 0,
-		tokensRemoved: 0
-	};
-}
 //#endregion
 //#region src/pruner/session.ts
 /** Check whether the session currently has an open (unterminated) turn. */
@@ -1177,1274 +1196,2590 @@ function buildLocatorBlock(events, shadowedRange) {
 			`- seq range: ${String(shadowedRange.start)}-${String(shadowedRange.end)}`,
 			...[...spillFiles].map((path) => `- spill file: ${path}`),
 			...[...touchedFiles].map((path) => `- file touched: ${path}`),
-			"(Use `read <spill file>` or `context_compression_retrieve` with a `session://` source to restore exact text.)"
+			"(Use `read <spill file>` or `context_compression_retrieve` with a `session://` source — pass start_line/max_lines to window the text — to restore exact text.)"
 		].join("\n"),
 		spillFiles: spillFiles.size,
 		touchedFiles: touchedFiles.size
 	};
 }
 //#endregion
-//#region src/runtime/tokenpilot/read-state.ts
-/** Write-style tool names whose success supersedes earlier reads. */
-const WRITE_TOOLS = /(?:^|[-_])?(?:write|edit|apply_patch|file_write|file_edit|str_replace|replace|multiedit)(?:$|[-_])/i;
-const PATH_KEYS = ["path", "file_path"];
-/** Parse one path out of a tool-call arguments JSON blob. */
-function toolCallPath(argumentsText) {
-	let parsed;
-	try {
-		parsed = JSON.parse(argumentsText);
-	} catch {
-		return;
-	}
-	if (typeof parsed !== "object" || parsed === null) return void 0;
-	const record = parsed;
-	for (const key of PATH_KEYS) {
-		const value = record[key];
-		if (typeof value === "string" && value.length > 0) return value;
-	}
-}
+//#region src/runtime/toolclass.ts
+/** task_11 (AD3): exact-token matching, no substring hits. */
+const TOKEN_SEPARATOR = /[-_/]+/;
+/** Multi-token names that must match as a whole word, not as a token. */
+const READ_NAMES = /* @__PURE__ */ new Set(["open_file"]);
+const READ_TOKENS = /* @__PURE__ */ new Set([
+	"read",
+	"cat",
+	"view"
+]);
+const SHELL_TOKENS = /* @__PURE__ */ new Set([
+	"shell",
+	"bash",
+	"pwsh",
+	"powershell",
+	"terminal",
+	"exec",
+	"command"
+]);
+const SEARCH_TOKENS = /* @__PURE__ */ new Set([
+	"grep",
+	"rg",
+	"ripgrep"
+]);
+const PATH_LISTING_TOKENS = /* @__PURE__ */ new Set([
+	"glob",
+	"tree",
+	"ls",
+	"fd",
+	"find"
+]);
+const SEARCH_COMMAND_PATTERN = /(?:^|\s)(?:rg|grep|ripgrep)\s/;
+const PATH_COMMAND_PATTERN = /(?:^|\s)(?:find|fd|ls|tree)\s/;
+/** grep-style hit line: `path:line[:column][: content]`. */
+const PATH_LINE_CONTENT_PATTERN = /^(.*?):(\d+)(?::\d+)?(?::|\s+-\s+)(.*)$/;
 /**
-* Decide whether an oversized read result was superseded by a later mutation
-* of the same file. `readPath` is the read call's target path; events after
-* `readSeq` are scanned for a write-style call on it.
+* Classify a tool result's source.
+* @param name - raw tool name (case-insensitive).
+* @param command - extracted command argument, '' when absent.
+* @param text - result text; enables the C13/C14 content fallback for names
+*   that no whitelist (and no command hit) claims.
+* @returns the tool source class.
 */
-function isSupersededRead(events, readSeq, readPath) {
-	if (readPath === void 0) return false;
-	for (let seq = readSeq + 1; seq < events.length; seq += 1) {
-		const event = events[seq];
-		if (event?.type !== "tool/call") continue;
-		if (!WRITE_TOOLS.test(event.data.name)) continue;
-		if (toolCallPath(event.data.arguments) === readPath) return true;
-	}
-	return false;
+function classifyToolSource(name, command, text) {
+	const lowered = name.toLowerCase();
+	const tokens = lowered.split(TOKEN_SEPARATOR).filter((token) => token !== "");
+	if (tokens.includes("mcp")) return "generic";
+	const byName = classifyByName(lowered, tokens);
+	if (byName !== "generic") return byName;
+	const byCommand = classifyByCommand(command);
+	if (byCommand !== "generic") return byCommand;
+	return text === void 0 ? "generic" : classifyByContent(text);
+}
+function classifyByName(lowered, tokens) {
+	if (READ_NAMES.has(lowered) || tokens.some((token) => READ_TOKENS.has(token))) return "read";
+	if (tokens.some((token) => SHELL_TOKENS.has(token))) return "shell";
+	if (tokens.some((token) => SEARCH_TOKENS.has(token))) return "search";
+	if (tokens.some((token) => PATH_LISTING_TOKENS.has(token))) return "path-listing";
+	return "generic";
+}
+function classifyByCommand(command) {
+	if (command === "") return "generic";
+	if (SEARCH_COMMAND_PATTERN.test(command)) return "search";
+	if (PATH_COMMAND_PATTERN.test(command)) return "path-listing";
+	return "generic";
+}
+/** A path-shaped hit locator needs a path-looking prefix, not just `:digits`. */
+function looksLikeFilePath(prefix) {
+	if (prefix.includes("://")) return false;
+	return prefix.includes("/") || prefix.includes("\\") || /\.[A-Za-z0-9]{1,8}$/.test(prefix);
+}
+/** A bare path: no whitespace, no URL scheme, with a separator or an extension. */
+function isPurePathLine(line) {
+	if (/\s/.test(line) || line.includes("://")) return false;
+	return line.includes("/") || line.includes("\\") || /\.[A-Za-z0-9]{1,8}$/.test(line);
 }
-/** Error/warning/info line classifiers used by the omission summary. */
-const ERROR_LINE = /\b(error|failed|failure|fatal|exception|traceback|cannot|unable|denied)\b/i;
-const WARN_LINE = /\b(warn|warning|deprecated)\b/i;
 /**
-* Cluster one omitted line-count into an error/warn/info census appended to a
-* placeholder marker, giving the model meta-knowledge about what was dropped.
+* Content fallback (C13/C14) for unknown names: one path-plausible
+* `path:line:content` line reads as grep output; a body of ≥80% pure paths
+* reads as a directory listing. Both require file-path evidence so prose
+* (`Note: 2024 - ...`) and URLs (`https://host:8080 - ...`) stay generic.
 */
-function clusterOmittedLines(text, omittedLines) {
-	if (omittedLines <= 0) return void 0;
-	let errors = 0;
-	let warns = 0;
-	let infos = 0;
-	for (const line of text.split("\n")) if (ERROR_LINE.test(line)) errors += 1;
-	else if (WARN_LINE.test(line)) warns += 1;
-	else infos += 1;
-	const parts = [];
-	if (errors > 0) parts.push(`${String(errors)} error`);
-	if (warns > 0) parts.push(`${String(warns)} warn`);
-	if (infos > 0) parts.push(`${String(infos)} info`);
-	if (parts.length === 0) return void 0;
-	return `${String(omittedLines)} lines omitted (${parts.join(", ")})`;
+function classifyByContent(text) {
+	let nonEmpty = 0;
+	let purePaths = 0;
+	let pathLineHits = 0;
+	for (const line of text.split("\n")) {
+		if (line.trim() === "") continue;
+		nonEmpty += 1;
+		const match = PATH_LINE_CONTENT_PATTERN.exec(line);
+		if (match !== null && looksLikeFilePath(match[1] ?? "")) pathLineHits += 1;
+		if (isPurePathLine(line)) purePaths += 1;
+	}
+	if (pathLineHits >= 1) return "search";
+	if (nonEmpty >= 4 && purePaths / nonEmpty >= .8) return "path-listing";
+	return "generic";
 }
 //#endregion
-//#region src/runtime/tokenpilot/estimator.ts
-/** Exponential backoff with a 5-minute cap: 1s, 2s, 4s, … */
-function backoffCooldownMs(failures) {
-	return Math.min(3e5, 1e3 * 2 ** Math.max(0, failures - 1));
+//#region src/runtime/reducers.ts
+/** Deterministic, evidence-backed reducers for fresh tool results. */
+/** Ranked-first ordering: ranked ids keep their rank, the rest append in order. */
+function rankedFirst(items, ranking) {
+	if (ranking === void 0 || ranking.length === 0) return items;
+	const ranked = /* @__PURE__ */ new Map();
+	for (const id of ranking) {
+		const found = items.find((item) => item.id === id);
+		if (found !== void 0 && !ranked.has(id)) ranked.set(id, found);
+	}
+	return [...ranked.values(), ...items.filter((item) => !ranked.has(item.id))];
 }
-function isCoolingDown(state, now) {
-	return state !== void 0 && state.cooldownUntil > now;
+const ANSI_PATTERN = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/gu;
+const IMPORTANT_PATTERN = new RegExp([
+	String.raw`\b(?:error|failed|failure|fatal|panic|exception|warning|warn|conflict|denied|forbidden|`,
+	String.raw`timeout|timed out|not found|cannot|unable|invalid|exit(?:ed)?\s+(?:code|status)|traceback|`,
+	String.raw`assert(?:ion)?|segmentation fault|oom|out of memory)\b`
+].join(""), "i");
+const STATUS_PATTERN = new RegExp([String.raw`\b(?:success|succeeded|passed|installed|added|removed|updated|built|compiled|`, String.raw`tests?\s+(?:passed|failed)|exit(?:ed)?\s+(?:code|status))\b`].join(""), "i");
+const PATH_LINE_PATTERN = /^(.*?):(\d+)(?::\d+)?(?::|\s+-\s+)(.*)$/;
+const GIT_STATUS_PATTERN = new RegExp([String.raw`^(?:On branch|Your branch|HEAD detached|Changes |Untracked |Unmerged |\s*(?:modified|deleted|`, String.raw`new file|renamed|both modified):)`].join(""), "i");
+const CODE_IMPORT_PATTERN = new RegExp([String.raw`^\s*(?:import\b|from\s+[\w.]+\s+import\b|use\s+\w|package\s+|#include\b|`, String.raw`using\s+[\w.]+;|require\s*\(|extern\s+crate\b)`].join(""));
+const CODE_STRUCTURE_PATTERN = new RegExp([
+	String.raw`^\s*(?:@[\w.]+|export\s+|default\s+|declare\s+|abstract\s+|public\s+|private\s+|protected\s+|`,
+	String.raw`internal\s+|static\s+|final\s+|sealed\s+|override\s+|pub(?:\([^)]*\))?\s+|async\s+|unsafe\s+)*`,
+	String.raw`(?:function\b|class\b|interface\b|enum\b|struct\b|impl\b|trait\b|type\s+\w|fn\s|func\b|`,
+	String.raw`def\s|module\b|namespace\b|sub\s)`
+].join(""));
+const PYTHON_STRUCTURE_PATTERN = /^\s*(?:async\s+)?def\s|^\s*class\s/;
+const CODE_DECORATOR_PATTERN = /^\s*@[\w.]+/;
+const CODE_COMMENT_PATTERN = /^\s*(?:\/\/|#|\/\*|\*)/;
+const MARKDOWN_HEADING_PATTERN = /^#{1,6}\s+\S/;
+const LIST_ITEM_PATTERN = /^\s*(?:[-*+]|\d+[.)])\s+\S/;
+const TABLE_ROW_PATTERN = /^\s*\|/;
+const FENCE_PATTERN = /^\s*(?:```|~~~)/;
+const UUID_PATTERN = /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g;
+const LONG_HEX_PATTERN = /\b[0-9a-fA-F]{64,}\b/g;
+const LONG_BASE64_PATTERN = /[A-Za-z0-9+/]{200,}={0,2}/g;
+const HTML_TAG_PATTERN = /<!DOCTYPE html|<html\b|<head\b|<div\b|<span\b|<script\b|<style\b|<body\b|<p>|<table\b|<a\s/i;
+const HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
+const HTML_DROPPED_ELEMENTS = /<(script|style|noscript|svg|head)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+const HTML_DATA_URI_PATTERN = /\s(?:src|href)="data:[^"]*"/gi;
+const HTML_TAG_PATTERN_FULL = /<([a-z][a-z0-9]*)((?:\s[^<>]*?)?)\/?>/gi;
+const HTML_INLINE_TAG_PATTERN = /<\/?(?:em|strong|b|i|u|s|code|small|sub|sup|span|br)\b[^<>]*>/gi;
+const HTML_WHITELISTED_ATTRIBUTES = /\s(?:href|src|alt|title|id)="[^"]*"/gi;
+const ADJACENT_REPEAT_MARKER = "[previous line repeated";
+/** Non-adjacent folding only pays off once a line recurs enough to beat the marker cost. */
+const NON_ADJACENT_FOLD_THRESHOLD = 3;
+/** Read-output line-number gutter added unconditionally by the host's `formatReadOutput`. */
+const READ_GUTTER_PATTERN = /^(\d+): ?/;
+/**
+* Block-level read-gutter detection (GF-1). The host prefixes read output with
+* `N: ` line numbers unconditionally and cannot be configured off. The gutter
+* is only recognized when the block as a whole reads like a numbered listing —
+* enough non-empty lines, a large majority guttered, and the numbers strictly
+* increasing — so prose like `12:30 pm` (one stray gutter-looking line) is
+* never stripped. The stripping happens on the CONTENT view only; the output
+* view keeps the gutter because it is the model's only inline locator into the
+* original file (and its measured cost, 9.16% of read bodies, never gets
+* retrieved anyway).
+*/
+function hasReadGutter(lines) {
+	let nonEmpty = 0;
+	let guttered = 0;
+	let previousNumber = 0;
+	for (const line of lines) {
+		if (line.trim() === "") continue;
+		nonEmpty += 1;
+		const match = READ_GUTTER_PATTERN.exec(line);
+		if (match === null) continue;
+		const number = Number(match[1]);
+		if (number <= previousNumber) return false;
+		previousNumber = number;
+		guttered += 1;
+	}
+	return nonEmpty >= 4 && guttered / nonEmpty >= .75;
 }
-function buildEstimatorSystemPrompt() {
-	return [
-		"You are a session residual-utility estimator.",
-		"For each numbered historical file read, decide whether the live agent is likely to",
-		"reference that exact file state again later in the session. Reads whose file was",
-		"already rewritten, or whose task has visibly moved on, are expired.",
-		"Answer with ONLY a JSON array: [{\"seq\":<number>,\"expired\":<boolean>}].",
-		"Optionally, if you can estimate how many user turns remain in this session, answer",
-		"with {\"expectedRemainingTurns\":<number>,\"items\":[{\"seq\":<number>,\"expired\":<boolean>}]}",
-		"instead; omit the field when you cannot estimate it."
-	].join(" ");
+/**
+* Replace long opaque literals with length summaries (R12). Data URIs, base64
+* blobs, and long hex dumps are pure noise in a compressed view; the prefix is
+* kept so the model can still recognize the value. Short strings are never
+* touched, and replacements never span lines, so the line mapping survives.
+*/
+function placeholderizeLongStrings(line) {
+	if (!/[0-9a-zA-Z+/]{32}/.test(line) && !/\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-/.test(line)) return line;
+	let result = line.replace(UUID_PATTERN, "[uuid]");
+	result = result.replace(LONG_HEX_PATTERN, (match) => `[hex ${String(match.length)} chars: ${match.slice(0, 16)}…]`);
+	result = result.replace(LONG_BASE64_PATTERN, (match) => `[base64 ${String(match.length)} chars: ${match.slice(0, 16)}…]`);
+	return result;
 }
-function buildEstimatorUserPrompt(samples) {
-	return samples.map((sample) => `{"seq":${String(sample.seq)},"path":${JSON.stringify(sample.path)},"turn":${String(sample.turn)}}`).join("\n");
+/**
+* Select a reducer from verified tool, command, and content evidence.
+* @param input - original result text, recovery source, and output budget.
+* @returns a verified candidate, or `null` when every reducer fails open.
+*/
+function reduceFreshToolResult(input, ranking) {
+	const normalized = normalizeTerminalLines(input.text);
+	const prepared = {
+		...input,
+		text: normalized.text,
+		lines: normalized.folded,
+		contentText: normalized.contentText
+	};
+	const command = extractCommand(input.argumentsText);
+	const name = input.toolName.toLowerCase();
+	const toolClass = classifyToolSource(input.toolName, command, normalized.contentText);
+	const readTocFirst = toolClass === "read" && codePointLength(normalized.contentText) >= READ_TOC_MIN_CHARS;
+	const candidates = [];
+	if (looksLikeJson(normalized.contentText)) candidates.push(() => reduceJson(prepared));
+	if (looksLikeMinified(normalized.contentText)) candidates.push(() => reduceBundledJs(prepared));
+	if (toolClass === "search") candidates.push(() => reduceSearch(prepared, ranking?.files));
+	if (isGitCommand(name, command)) candidates.push(() => reduceGit(prepared, command));
+	if (isPackageCommand(command)) candidates.push(() => reducePatternLog(prepared, "hypa-package", packagePattern()));
+	if (isBuildOrTestCommand(command)) candidates.push(() => reducePatternLog(prepared, "hypa-build-test", buildPattern()));
+	if (looksLikeSourceCode(normalized.contentText)) {
+		if (input.codeSkeleton === true) candidates.push(() => reduceCodeSkeleton(prepared));
+		else if (readTocFirst) candidates.push(() => tocGuardedCodeSkeleton(prepared));
+	}
+	if (looksLikeHtml(normalized.contentText)) candidates.push(() => reduceHtml(prepared));
+	if (looksLikeDocument(normalized.contentText)) candidates.push(() => reduceDocSkeleton(prepared, ranking?.sections));
+	if (toolClass === "shell" || command !== "") candidates.push(() => reduceShell(prepared));
+	candidates.push(() => reduceProseKeep(prepared));
+	if (toolClass === "read") candidates.push(() => reduceHead(prepared, "pi-head"));
+	candidates.push(() => reduceSalient(prepared, "generic-salience"));
+	for (const make of candidates) {
+		const candidate = make();
+		if (candidate !== null && verifyReduction(input, candidate)) return candidate;
+	}
+	return null;
 }
-function parseVerdictArray(value) {
-	if (!Array.isArray(value)) return [];
-	const verdicts = [];
-	for (const entry of value) {
-		if (typeof entry !== "object" || entry === null) continue;
-		const record = entry;
-		if (typeof record.seq !== "number" || typeof record.expired !== "boolean") continue;
-		verdicts.push({
-			seq: record.seq,
-			expired: record.expired
+/**
+* Build a recoverable placeholder for an old tool result.
+* @param input - tool identity, source reference, size, status, and retained evidence.
+* @returns a lossy placeholder that cites the immutable source event.
+*/
+function historicalPlaceholder(input) {
+	const anchor = input.compact ? "" : importantAnchor(input.text, 360);
+	const normalized = normalizeTerminalLines(input.text);
+	const lastFolded = normalized.folded.at(-1);
+	const elidedLines = lastFolded === void 0 ? void 0 : lastFolded.originalLineEnd ?? lastFolded.originalLine;
+	const anchorLine = input.compact ? void 0 : (normalized.folded.find((line) => IMPORTANT_PATTERN.test(line.text)) ?? void 0)?.originalLine;
+	const retrieveHint = anchorLine === void 0 ? `retrieve: context_compression_retrieve({"ref":"${input.sourceRef}"})` : `retrieve: context_compression_retrieve({"ref":"${input.sourceRef}","start_line":${String(anchorLine)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}})`;
+	const lines = [
+		"[Old tool result content cleared from active context]",
+		`tool: ${input.toolName || "unknown"}`,
+		`status: ${input.isError ? "error" : "completed"}`,
+		`original_chars: ${String(input.charsBefore)}`,
+		`source: ${input.sourceRef}`,
+		retrieveHint
+	];
+	if (anchor !== "") lines.push(`retained_anchor: ${anchor}`);
+	return {
+		text: lines.join("\n"),
+		reducer: input.compact ? "pair-preserving-tail-aging" : "historical-tool-result-aging",
+		lossy: true,
+		...elidedLines === void 0 ? {} : { elidedLines }
+	};
+}
+/**
+* Validate shrinkage, budget, recovery, and error retention.
+* @param input - original reducer input and its safety requirements.
+* @param output - candidate reduced text and reducer metadata.
+* @returns whether the candidate is safe to land.
+*/
+function verifyReduction(input, output) {
+	const before = codePointLength(input.text);
+	const after = codePointLength(output.text);
+	if (after <= 0 || after >= before || after > input.budgetChars) return false;
+	if (output.lossy && !output.text.includes(input.sourceRef)) return false;
+	if ((input.isError || IMPORTANT_PATTERN.test(input.text)) && !IMPORTANT_PATTERN.test(output.text) && !output.text.includes("status: error")) return false;
+	return true;
+}
+/**
+* Strip ANSI, collapse carriage-return progress redraws, and fold exact repeats.
+* @param text - raw terminal output.
+* @returns normalized terminal text.
+*/
+function normalizeTerminalText(text) {
+	return normalizeTerminalLines(text).text;
+}
+/**
+* Structured normalization (R9a): `retrieve` reads the original event, so any
+* line number a reducer prints must resolve against the ORIGINAL text, not the
+* normalized surface. ANSI stripping and `\r` redraw collapse never change the
+* line count (logical lines are 1:1 with original lines); only the adjacent
+* duplicate fold drops lines, so every folded entry carries the original line
+* (range) it was kept from.
+*/
+function normalizeTerminalLines(text) {
+	const logical = text.replace(ANSI_PATTERN, "").split("\n").map((line) => {
+		return placeholderizeLongStrings(line.split("\r").filter((part) => part !== "").at(-1) ?? "");
+	});
+	const stripGutter = hasReadGutter(logical);
+	const folded = [];
+	let previous;
+	let firstText = "";
+	let count = 0;
+	let firstOriginal = 0;
+	const flush = (nextOriginal) => {
+		if (previous === void 0) return;
+		folded.push({
+			text: firstText,
+			content: previous,
+			originalLine: firstOriginal
 		});
-	}
-	return verdicts;
+		if (count > 1) {
+			const marker = `[previous line repeated ${String(count - 1)} more times]`;
+			folded.push({
+				text: marker,
+				content: marker,
+				originalLine: firstOriginal + 1,
+				originalLineEnd: nextOriginal - 1
+			});
+		}
+	};
+	logical.forEach((line, index) => {
+		const originalLine = index + 1;
+		const content = stripGutter ? line.replace(READ_GUTTER_PATTERN, "") : line;
+		if (content === previous) {
+			count++;
+			return;
+		}
+		flush(originalLine);
+		previous = content;
+		firstText = line;
+		count = 1;
+		firstOriginal = originalLine;
+	});
+	flush(logical.length + 1);
+	const result = foldNonAdjacentRepeats(folded);
+	return {
+		folded: result,
+		text: result.map((line) => line.text).join("\n"),
+		contentText: result.map((line) => line.content).join("\n")
+	};
 }
 /**
-* Parse the estimator answer including the optional session-level
-* `expectedRemainingTurns`. Accepts both the legacy bare verdict array and the
-* extended object form; anything malformed yields no verdicts and no Ŝ.
+* Fold non-adjacent exact repeats (R11). Adjacent folding runs FIRST and only
+* handles consecutive runs (0.03–0.32% of real duplicate content); separated
+* repeats reached 8.37% in large results. Each surviving occurrence — a kept
+* line plus its optional adjacent-repeat marker — is one unit; once a text
+* recurs ≥ threshold times, the first unit is kept and every later unit is
+* replaced by ONE counted marker citing the original-event span it covers.
+* A pure consecutive run forms a single unit, so this pass is a no-op on it
+* and can never double-fold the adjacent marker.
 */
-function parseEstimatorAnswerDetailed(text) {
-	const objectStart = text.indexOf("{");
-	const objectEnd = text.lastIndexOf("}");
-	if (objectStart >= 0 && objectEnd > objectStart) try {
-		const parsed = JSON.parse(text.slice(objectStart, objectEnd + 1));
-		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-			const record = parsed;
-			const verdicts = parseVerdictArray(record.verdicts ?? record.items);
-			if (verdicts.length > 0) {
-				const turns = record.expectedRemainingTurns;
-				if (typeof turns === "number" && Number.isFinite(turns) && turns >= 0) return {
-					verdicts,
-					expectedRemainingTurns: Math.floor(turns)
-				};
-				return { verdicts };
-			}
+function foldNonAdjacentRepeats(folded) {
+	const units = [];
+	for (const entry of folded) if (entry.text.startsWith(ADJACENT_REPEAT_MARKER) && units.length > 0) units[units.length - 1].repeat = entry;
+	else units.push({ lead: entry });
+	const totals = /* @__PURE__ */ new Map();
+	for (const unit of units) totals.set(unit.lead.content, (totals.get(unit.lead.content) ?? 0) + 1);
+	if (totals.size === units.length) return [...folded];
+	const firstOriginal = /* @__PURE__ */ new Map();
+	const lastOriginalEnd = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		const content = unit.lead.content;
+		if (totals.get(content) < NON_ADJACENT_FOLD_THRESHOLD) continue;
+		if (!firstOriginal.has(content)) firstOriginal.set(content, unit.lead.originalLine);
+		const end = unit.repeat?.originalLineEnd ?? unit.lead.originalLineEnd ?? unit.lead.originalLine;
+		lastOriginalEnd.set(content, end);
+	}
+	const seen = /* @__PURE__ */ new Map();
+	const result = [];
+	for (const unit of units) {
+		const content = unit.lead.content;
+		const total = totals.get(content);
+		if (total < NON_ADJACENT_FOLD_THRESHOLD) {
+			result.push(unit.lead);
+			if (unit.repeat !== void 0) result.push(unit.repeat);
+			continue;
 		}
-	} catch {}
-	const start = text.indexOf("[");
-	const end = text.lastIndexOf("]");
-	if (start < 0 || end <= start) return { verdicts: [] };
-	try {
-		return { verdicts: parseVerdictArray(JSON.parse(text.slice(start, end + 1))) };
-	} catch {
-		return { verdicts: [] };
+		if (!seen.has(content)) {
+			seen.set(content, 1);
+			result.push(unit.lead);
+			if (unit.repeat !== void 0) result.push(unit.repeat);
+			continue;
+		}
+		const ordinal = (seen.get(content) ?? 1) + 1;
+		seen.set(content, ordinal);
+		if (ordinal > 2) continue;
+		const end = lastOriginalEnd.get(content);
+		const marker = `[× ${String(total)} total: same as line ${String(firstOriginal.get(content))}; original lines ${String(unit.lead.originalLine)}-${String(end)}]`;
+		result.push({
+			text: marker,
+			content: marker,
+			originalLine: unit.lead.originalLine,
+			originalLineEnd: end
+		});
 	}
+	return result;
 }
-/** One channel-bound estimator. `ask` resolves undefined on any failure. */
-var Estimator = class {
-	ctx;
-	options;
-	constructor(ctx, options) {
-		this.ctx = ctx;
-		this.options = options;
-	}
-	get enabled() {
-		return this.options.estimatorMode === "host" || this.options.estimatorMode === "direct";
+/** Default line window a retrieve hint suggests the model paste. */
+const RETRIEVE_HINT_MAX_LINES = 80;
+/**
+* TOC-first (G6): read-class results at or above this size let the code
+* skeleton compete before head/tail truncation. The 14,000-char boundary is
+* the studied real-read cohort (findings §7), well above p90 of actual reads
+* so ordinary results keep their existing dispatch.
+*/
+const READ_TOC_MIN_CHARS = 14e3;
+/**
+* A skeleton whose output is dominated by elision markers is worse than
+* head/tail for the model (task_4b risk: structure-poor files degenerate into
+* "almost all markers") — above this marker-char share the TOC candidate fails
+* open to the prose reducers.
+*/
+const TOC_MARKER_RATIO_LIMIT = .5;
+/**
+* Fail-open wrapper for the TOC-first code-skeleton candidate: a skeleton that
+* degenerates into mostly-elision markers (minified bundles, generated files)
+* returns null so the prose head/tail pair takes over.
+*/
+function tocGuardedCodeSkeleton(input) {
+	const output = reduceCodeSkeleton(input);
+	if (output === null) return null;
+	const total = codePointLength(output.text);
+	return output.text.split("\n").filter((line) => line.startsWith("[...")).reduce((sum, line) => sum + codePointLength(line) + 1, 0) / total > TOC_MARKER_RATIO_LIMIT ? null : output;
+}
+/** R10a thresholds: one giant line, uniformly fat lines, or very few fat lines. */
+const MINIFIED_MAX_LINE_CHARS = 2e3;
+const MINIFIED_AVG_LINE_CHARS = 300;
+const MINIFIED_FEW_LINES = 40;
+const MINIFIED_FEW_LINES_TOTAL_CHARS = 2e4;
+/**
+* Require form evidence of a bundled/minified module (R10a): line-anchored
+* reducers cannot see inside a 135k-character line, and R9 line ranges on a
+* 53-line bundle cannot address anything smaller than the whole file.
+* @param text - normalized result text.
+* @returns whether the text reads as a bundled/minified module.
+*/
+function looksLikeMinified(text) {
+	const lines = splitLines(text);
+	if (lines.length === 0) return false;
+	let total = 0;
+	let max = 0;
+	for (const line of lines) {
+		const length = line.length;
+		total += length;
+		if (length > max) max = length;
 	}
-	async ask(system, user, signal) {
-		const timeoutMs = this.options.estimatorTimeoutMs ?? 3e3;
-		const timeout = AbortSignal.timeout(timeoutMs);
-		const signal2 = typeof AbortSignal.any === "function" ? AbortSignal.any([signal, timeout]) : timeout;
-		try {
-			if (this.options.estimatorMode === "host") return await this.askHost(system, user, signal2);
-			if (this.options.estimatorMode === "direct") return await this.askDirect(system, user, signal2);
-			return;
-		} catch {
-			return;
+	if (max > MINIFIED_MAX_LINE_CHARS) return true;
+	if (total / lines.length > MINIFIED_AVG_LINE_CHARS) return true;
+	return lines.length < MINIFIED_FEW_LINES && total > MINIFIED_FEW_LINES_TOTAL_CHARS;
+}
+/**
+* Statement-level declaration patterns scanned GLOBALLY per line: a bundle's
+* statements are separated by `;` / `},{` / `);` inside one physical line, so
+* line-anchored matching is useless here. Reserved-name traces (`exports.*`,
+* `module.exports`) are extracted first and called out in the header because
+* minifiers rename local symbols.
+*/
+const BUNDLED_DECLARATION_PATTERNS = [
+	/\bexports\.([A-Za-z_$][\w$]*)\s*=/g,
+	/\bmodule\.exports\s*=\s*([A-Za-z_$][\w$]*)/g,
+	/\b(?:function|class)\s+([A-Za-z_$][\w$]*)/g,
+	/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g,
+	/\b([A-Za-z_$][\w$]*)\s*:\s*function\b/g
+];
+const SOURCEMAP_DIRECTIVE = "//# sourceMappingURL=";
+/**
+* Bundled/minified JS directory (R10-B). The useful first answer is the
+* declaration/export directory — WHAT the bundle exposes — plus one honest
+* whole-span marker: the host's continuation is line-addressed, so a
+* line-range retrieve on a 53-line bundle hands back the whole file (R10d:
+* character-range retrieval is a separate, undecided extension).
+*/
+function reduceBundledJs(input) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const line of input.lines) for (const pattern of BUNDLED_DECLARATION_PATTERNS) {
+		pattern.lastIndex = 0;
+		let match = pattern.exec(line.content);
+		while (match !== null) {
+			const symbol = match[1];
+			if (symbol !== void 0 && !declarations.has(symbol)) declarations.set(symbol, line.originalLine);
+			match = pattern.exec(line.content);
 		}
 	}
-	/**
-	* Resolve the host LLM route. Explicit estimator provider/model win; with
-	* them empty, reuse the route the harness already has configured via the
-	* optional `agentDefaultModel` service's current selection (same seam as
-	* dsh-prime-memory's resolveModelRoute) — the user must not re-enter a
-	* provider/model the host already knows.
-	*/
-	resolveHostRoute() {
-		const provider = this.options.estimatorProvider ?? "";
-		const model = this.options.estimatorModel ?? "";
-		if (provider.length > 0 && model.length > 0) return {
-			provider,
-			model
+	if (declarations.size === 0) return null;
+	const hasSourceMap = input.contentText.includes(SOURCEMAP_DIRECTIVE);
+	const entries = [...declarations.entries()].sort((a, b) => a[1] - b[1]);
+	const kept = [`[bundled/minified JS detected; ${String(entries.length)} declarations; minified symbols may be renamed — exports.*/module.exports traces are the reliable ones;${hasSourceMap ? " source map present, prefer reading the original source;" : ""} source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}"}) (line-addressed: single-line bundles come back whole)]`, ...entries.slice(0, 400).map(([symbol, line]) => `${symbol}  (line ${String(line)})`)];
+	const start = input.lines[0]?.originalLine ?? 1;
+	const end = originalEnd(input.lines, input.lines.length - 1);
+	if (end > start) kept.push(elidedRangeMarker(start, end));
+	const text = fitLines(kept, input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer: "bundled-js-directory",
+		lossy: true
+	};
+}
+/**
+* Continuous-mask marker (R9b): cites the ORIGINAL-event line range it elides
+* and carries a pasteable retrieve hint starting at the first elided line.
+* Falls back to the compact plain marker when the hint would not fit.
+*/
+function reduceHead(input, reducer) {
+	const marker = omissionMarker(input, reducer);
+	const available = input.budgetChars - codePointLength(marker) - 1;
+	if (available <= 0) return null;
+	const head = takeWholeLinesFromHead(input.text, available);
+	if (head === input.text || head === "") return null;
+	const keptCount = head.split("\n").length;
+	const firstElided = input.lines[keptCount];
+	if (firstElided !== void 0) {
+		const elidedEnd = originalEnd(input.lines, input.lines.length - 1);
+		const ranged = rangeOmissionMarker(input, reducer, firstElided.originalLine, elidedEnd);
+		if (codePointLength(head) + codePointLength(ranged) + 1 <= input.budgetChars) return {
+			text: `${head}\n${ranged}`,
+			reducer,
+			lossy: true
 		};
-		try {
-			const selected = this.ctx.get("agentDefaultModel")?.currentSelection?.();
-			const selectedProvider = selected?.provider ?? "";
-			const selectedModel = selected?.model ?? "";
-			if (selectedProvider.length > 0 && selectedModel.length > 0) return {
-				provider: provider.length > 0 ? provider : selectedProvider,
-				model: model.length > 0 ? model : selectedModel
-			};
-		} catch {}
 	}
-	async askHost(system, user, signal) {
-		let llm;
-		try {
-			llm = this.ctx.get("llm");
-		} catch {
-			return;
-		}
-		if (llm?.stream === void 0) return void 0;
-		const route = this.resolveHostRoute();
-		if (route === void 0) return void 0;
-		const provider = route.provider;
-		const model = route.model;
-		let text = "";
-		const stream = llm.stream({
-			provider,
-			model,
-			messages: [{
-				role: "user",
-				content: [{
-					type: "text",
-					text: user
-				}]
-			}],
-			system,
-			temperature: 0,
-			reasoningEffort: "off",
-			maxTokens: 256,
-			signal
-		});
-		for await (const chunk of stream) if ((chunk.type === "text-delta" || chunk.type === "reasoning-delta") && typeof chunk.text === "string") text += chunk.text;
-		else if (chunk.type === "finish" && chunk.text === void 0) break;
-		return text.trim().length > 0 ? text : void 0;
+	return {
+		text: `${head}\n${marker}`,
+		reducer,
+		lossy: true
+	};
+}
+function reduceTail(input, reducer) {
+	const marker = omissionMarker(input, reducer);
+	const available = input.budgetChars - codePointLength(marker) - 1;
+	if (available <= 0) return null;
+	const tail = takeWholeLinesFromTail(input.text, available);
+	if (tail === input.text || tail === "") return null;
+	const firstKept = input.lines.length - tail.split("\n").length;
+	if (firstKept > 0) {
+		const elidedEnd = originalEnd(input.lines, firstKept - 1);
+		const ranged = rangeOmissionMarker(input, reducer, input.lines[0].originalLine, elidedEnd);
+		if (codePointLength(ranged) + codePointLength(tail) + 1 <= input.budgetChars) return {
+			text: `${ranged}\n${tail}`,
+			reducer,
+			lossy: true
+		};
 	}
-	async askDirect(system, user, signal) {
-		const baseUrl = this.options.estimatorBaseUrl;
-		if (baseUrl === void 0 || baseUrl.length === 0) return void 0;
-		const headers = { "content-type": "application/json" };
-		if (this.options.estimatorApiKey !== void 0 && this.options.estimatorApiKey.length > 0) headers.authorization = `Bearer ${this.options.estimatorApiKey}`;
-		const model = this.options.estimatorModel ?? "";
-		if (model.length === 0) return void 0;
-		const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify({
-				model,
-				messages: [{
-					role: "system",
-					content: system
-				}, {
-					role: "user",
-					content: user
-				}],
-				temperature: 0,
-				max_tokens: 256
-			}),
-			signal
-		});
-		if (!response.ok) return void 0;
-		const text = (await response.json()).choices?.[0]?.message?.content;
-		return typeof text === "string" && text.trim().length > 0 ? text : void 0;
+	return {
+		text: `${marker}\n${tail}`,
+		reducer,
+		lossy: true
+	};
+}
+function reduceJson(input) {
+	let value;
+	try {
+		value = JSON.parse(input.text);
+	} catch {
+		return null;
 	}
-};
-//#endregion
-//#region src/runtime/tokenpilot/dedup.ts
-/**
-* TokenPilot-inspired A1: byte-identical repeated tool-result dedup.
-*
-* Pure helpers behind the ToolResultPruner fresh pass. The per-session table
-* maps a canonical-content SHA-256 to the first surface seq that produced it;
-* later identical results may be replaced with a pointer placeholder that the
-* recovery tool can resolve back to the original full text via the append-only
-* session log. Only hash+seq metadata is stored — never content.
-*/
-/** Per-session dedup index with insertion-order eviction. */
-var DedupeTable = class {
-	maxEntries;
-	entries = /* @__PURE__ */ new Map();
-	constructor(maxEntries = 2048) {
-		this.maxEntries = maxEntries;
+	const minified = JSON.stringify(value);
+	if (codePointLength(minified) < codePointLength(input.text) && codePointLength(minified) <= input.budgetChars) return {
+		text: minified,
+		reducer: "json-minify",
+		lossy: false
+	};
+	const envelope = {
+		$dsh_compression: {
+			kind: "json-preview",
+			source: input.sourceRef,
+			original_chars: codePointLength(input.text)
+		},
+		value: shrinkJson(value, 0)
+	};
+	const text = JSON.stringify(envelope, null, 2);
+	if (codePointLength(text) <= input.budgetChars) return {
+		text,
+		reducer: "json-structure-preview",
+		lossy: true
+	};
+	return null;
+}
+function shrinkJson(value, depth) {
+	if (depth >= 5) {
+		if (Array.isArray(value)) return `[array length=${String(value.length)} omitted]`;
+		if (typeof value === "object" && value !== null) return "[object omitted]";
+		return value;
 	}
-	/** Look up the first occurrence for one canonical hash, if any. */
-	get(hash) {
-		return this.entries.get(hash);
+	if (Array.isArray(value)) {
+		if (value.length <= 8) return value.map((entry) => shrinkJson(entry, depth + 1));
+		return [
+			...value.slice(0, 3).map((entry) => shrinkJson(entry, depth + 1)),
+			{ $dsh_omitted_items: value.length - 5 },
+			...value.slice(-2).map((entry) => shrinkJson(entry, depth + 1))
+		];
 	}
-	/** Record a first occurrence; existing hashes only refresh insertion order. */
-	record(hash, entry) {
-		if (this.entries.has(hash)) return;
-		while (this.entries.size >= this.maxEntries) {
-			const oldest = this.entries.keys().next().value;
-			if (oldest === void 0) break;
-			this.entries.delete(oldest);
+	if (typeof value !== "object" || value === null) {
+		if (typeof value === "string" && codePointLength(value) > 800) return `${Array.from(value).slice(0, 500).join("")}…[${String(codePointLength(value) - 700)} chars omitted]…${Array.from(value).slice(-200).join("")}`;
+		return value;
+	}
+	const entries = Object.entries(value);
+	const important = entries.filter(([key]) => /error|warn|status|code|message|path|file|line|summary/i.test(key));
+	const selected = entries.length <= 18 ? entries : [
+		...entries.slice(0, 10),
+		...important.filter((entry) => !entries.slice(0, 10).includes(entry)).slice(0, 6),
+		...entries.slice(-2)
+	];
+	const result = {};
+	for (const [key, entry] of selected) result[key] = shrinkJson(entry, depth + 1);
+	if (selected.length < entries.length) result.$dsh_omitted_keys = entries.length - selected.length;
+	return result;
+}
+/**
+* Two-tier search folding (R10). L1 is a LOSSLESS per-file locator —
+* `## <path> (<N> matches)  L12,L15,…` — one line number per hit, taken from
+* the hit's own `path:line` prefix (falling back to the original-event line).
+* L2 is the content quota, water-filled round-robin so no file vanishes and
+* no file runs more than one row ahead of another; the budget is reserved for
+* L1 first. When L1 itself cannot fit, the shortfall is ANNOUNCED
+* (withheld file/match counts) — never silently truncated. Outputs without
+* any `path:line` form fail open to salience.
+*/
+function reduceSearch(input, fileRanking) {
+	const groups = /* @__PURE__ */ new Map();
+	const ungrouped = [];
+	input.lines.forEach((line) => {
+		const match = PATH_LINE_PATTERN.exec(line.text);
+		const row = {
+			text: line.text,
+			fileLine: match !== null ? Number(match[2]) : line.originalLine,
+			important: IMPORTANT_PATTERN.test(line.text)
+		};
+		if (match === null) {
+			ungrouped.push(row);
+			return;
 		}
-		this.entries.set(hash, entry);
+		const path = match[1] ?? "<unknown>";
+		const bucket = groups.get(path) ?? [];
+		bucket.push(row);
+		groups.set(path, bucket);
+	});
+	if (groups.size === 0) return reduceSalient(input, "search-salience");
+	const totalMatches = [...groups.values()].reduce((sum, rows) => sum + rows.length, 0);
+	const locatorFor = (path, rows) => `## ${path} (${String(rows.length)} matches)  ${rows.map((row) => `L${String(row.fileLine)}`).join(",")}`;
+	const perFile = /* @__PURE__ */ new Map();
+	for (const entry of rankedFirst([...groups.entries()].map(([id, rows]) => ({
+		id,
+		rows
+	})), fileRanking)) perFile.set(entry.id, [...entry.rows].sort((a, b) => a.important === b.important ? a.fileLine - b.fileLine : a.important ? -1 : 1));
+	const allLocators = [...perFile.keys()].map((path) => locatorFor(path, groups.get(path)));
+	const headerFor = (l2Rows, omitted) => `[search results compressed; ${String(groups.size)} files, ${String(totalMatches)} matches; ${String(l2Rows)} content rows shown, ${String(omitted)} matches omitted; source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}"})]`;
+	const fillL2 = (output, quotaChars) => {
+		let used = 0;
+		let shown = 0;
+		let round = 0;
+		let progress = true;
+		while (progress && round < 512) {
+			progress = false;
+			for (const rows of perFile.values()) {
+				if (round >= rows.length) continue;
+				const row = rows[round];
+				const cost = codePointLength(row.text) + 1;
+				if (used + cost > quotaChars) continue;
+				output.push(row.text);
+				used += cost;
+				shown += 1;
+				progress = true;
+			}
+			round += 1;
+		}
+		for (const row of ungrouped.filter((entry) => entry.important).slice(0, 12)) {
+			const cost = codePointLength(row.text) + 1;
+			if (used + cost > quotaChars) break;
+			output.push(row.text);
+			used += cost;
+			shown += 1;
+		}
+		return {
+			shown,
+			omitted: totalMatches - shown
+		};
+	};
+	const finish = (output) => {
+		const text = output.join("\n");
+		return text.includes(input.sourceRef) ? {
+			text,
+			reducer: "search-by-file",
+			lossy: true
+		} : null;
+	};
+	const headerProbe = headerFor(0, 0);
+	const budget = input.budgetChars - codePointLength(headerProbe) - 2;
+	if (budget <= 0) return null;
+	const locatorCost = allLocators.reduce((sum, line) => sum + codePointLength(line) + 1, 0);
+	if (locatorCost > budget) {
+		const announcementReserve = 160;
+		const output = [];
+		let used = 0;
+		let withheldFiles = 0;
+		let withheldMatches = 0;
+		for (let index = 0; index < allLocators.length; index++) {
+			const cost = codePointLength(allLocators[index]) + 1 + announcementReserve;
+			if (used + cost > budget) {
+				withheldFiles = allLocators.length - index;
+				withheldMatches = totalMatches - [...groups.values()].slice(0, index).reduce((sum, rows) => sum + rows.length, 0);
+				break;
+			}
+			output.push(allLocators[index]);
+			used += cost - announcementReserve;
+		}
+		if (withheldFiles > 0) output.push(`[L1 locator partially withheld: ${String(withheldFiles)} file(s) / ${String(withheldMatches)} matches' line lists did not fit the budget; retrieve for the full hit list]`);
+		const { shown, omitted } = fillL2(output, Math.max(0, budget - used - (withheldFiles > 0 ? announcementReserve : 0)));
+		output.unshift(headerFor(shown, omitted + withheldMatches));
+		return finish(output);
 	}
-};
-/** Canonicalize tool-result text for hashing. */
-function canonicalizeForDedupe(text, mode) {
-	if (mode === "exact") return text;
-	return text.replace(/[ \t]+\r?\n/g, "\n").replace(/(^\s+)|(\s+$)/g, "");
+	const output = [...allLocators];
+	const { shown, omitted } = fillL2(output, budget - locatorCost);
+	output.unshift(headerFor(shown, omitted));
+	return finish(output);
 }
-/** SHA-256 hex of the canonicalized text. */
-function dedupeHash(text, mode) {
-	return createHash("sha256").update(canonicalizeForDedupe(text, mode), "utf8").digest("hex");
+function reduceGit(input, command) {
+	const lines = input.lines;
+	const lower = command.toLowerCase();
+	let keep;
+	let reducer;
+	if (/\bgit\s+(?:diff|show)\b/.test(lower)) {
+		reducer = "hypa-git-diff";
+		keep = lines.map((line) => line.text).filter((line) => /^(?:diff --git|index |--- |\+\+\+ |@@ |[+-](?![+-]))/.test(line) || IMPORTANT_PATTERN.test(line));
+	} else if (/\bgit\s+(?:status|switch|checkout|merge|rebase|cherry-pick)\b/.test(lower)) {
+		reducer = "hypa-git-status";
+		keep = lines.map((line) => line.text).filter((line) => GIT_STATUS_PATTERN.test(line) || IMPORTANT_PATTERN.test(line));
+	} else {
+		reducer = "hypa-git-log";
+		keep = lines.map((line) => line.text).filter((line) => /^(?:commit\s+[0-9a-f]+|Author:|Date:|[0-9a-f]{7,}\s)/i.test(line) || IMPORTANT_PATTERN.test(line));
+	}
+	if (keep.length === 0) return reduceSalient(input, reducer);
+	const text = fitLines([
+		`[git output compressed; ${scannedTotals(input, keep.length)}; source: ${input.sourceRef}; scatter-masked: retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","query":"<keyword>"}) for missed rows]`,
+		...keep,
+		...lines.slice(-8).map((line) => line.text)
+	], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer,
+		lossy: true
+	};
 }
-/** Concatenated text of an all-text content block list; null when rich. */
-function flattenPlainText(content) {
-	let text = "";
-	for (const block of content) {
-		if (block.type !== "text") return void 0;
-		text += block.text;
+function reducePatternLog(input, reducer, pattern) {
+	const lines = input.lines;
+	const kept = lines.filter((line) => pattern.test(line.text) || IMPORTANT_PATTERN.test(line.text) || STATUS_PATTERN.test(line.text));
+	const text = fitLines([
+		`[command output compressed by ${reducer}; ${scannedTotals(input, kept.length)}; source: ${input.sourceRef}; scatter-masked: retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","query":"<keyword>"}) for missed rows]`,
+		...kept.map((line) => line.text),
+		...lines.slice(-20).map((line) => line.text)
+	], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer,
+		lossy: true
+	};
+}
+function reduceShell(input) {
+	const lines = input.lines;
+	const important = lines.filter((line) => IMPORTANT_PATTERN.test(line.text));
+	if (important.length === 0) return reduceTail(input, "pi-tail");
+	const text = fitLines([
+		`[shell/log output compressed; ${scannedTotals(input, important.length)}; source: ${input.sourceRef}; scatter-masked: retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","query":"<keyword>"}) for missed rows]`,
+		...important.map((line) => line.text),
+		"--- final output ---",
+		...lines.slice(-40).map((line) => line.text)
+	], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer: "shell-salience-tail",
+		lossy: true
+	};
+}
+function reduceSalient(input, reducer) {
+	const lines = input.lines;
+	if (lines.length < 3) return reduceHead(input, reducer);
+	const marker = omissionMarker(input, reducer);
+	const headBudget = Math.max(1, Math.floor((input.budgetChars - codePointLength(marker)) * .34));
+	const tailBudget = headBudget;
+	const head = takeWholeLinesFromHead(input.text, headBudget);
+	const tail = takeWholeLinesFromTail(input.text, tailBudget);
+	const salient = lines.filter((line) => IMPORTANT_PATTERN.test(line.text) || STATUS_PATTERN.test(line.text)).slice(0, 24);
+	const keptCount = head.split("\n").length + salient.length + tail.split("\n").length;
+	const text = fitLines([
+		head,
+		...salient.map((line) => line.text),
+		`${marker} [${scannedTotals(input, keptCount)}]`,
+		tail
+	], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer,
+		lossy: true
+	};
+}
+/**
+* Require content evidence of a structured document: enough Markdown heading
+* lines among a bounded prefix. Pure form evidence — tool names, path
+* extensions, and commands are never read (MCP output has no predictable
+* identity). Real logs and build output carry no `#`-heading lines, which is
+* the misjudgment guard.
+* @param text - normalized result text.
+* @returns whether the text qualifies as a structured document.
+*/
+function looksLikeDocument(text) {
+	const lines = splitLines(text);
+	let headings = 0;
+	for (const line of lines.slice(0, 600)) if (MARKDOWN_HEADING_PATTERN.test(line)) {
+		headings += 1;
+		if (headings >= 3) return true;
 	}
-	return text;
+	return false;
 }
-/** Pointer placeholder pointing at the first occurrence's original event. */
-function dedupePlaceholder(entry, originalChars) {
-	return [
-		`[... identical to the earlier ${entry.toolName} result; first seen at ${entry.sourceRef};`,
-		`original_chars=${String(originalChars)};`,
-		"use context_compression_retrieve with this source if the omitted evidence is necessary.]"
-	].join(" ");
+/** One R9-spec elision marker: an original-event line range plus its count. */
+function elidedRangeMarker(start, end) {
+	return `[... lines ${String(start)}-${String(end)} elided (${String(end - start + 1)} lines) ...]`;
 }
-//#endregion
-//#region src/runtime/tokenpilot/proposal.ts
 /**
-* TokenPilot-inspired R4: benefit model for the human-gated review pipeline.
-*
-* Pure functions only: the classifier needs no I/O, no session state, and no
-* host services, so every decision is unit-testable and audit-replayable.
-*
-* The cost model follows the TokenPilot paper's cache-accounting view: one
-* merged mutation pays a one-time tail KV-cache refill penalty of
-* `(1−α)·tailTokens`, and every later turn recovers the reclaimed tokens at
-* the cache-hit discount `α`:
-*
-* ```
-* R              = Σ(tokensBefore − tokensAfter)   // net reclaimed tokens
-* paybackTurns   = (1−α)·tailTokens / (α·R)        // one-time refill / per-turn saving
-* expectedSaving = α·R·max(0, Ŝ − paybackTurns)    // Ŝ = estimated remaining turns
-* ```
-*
-* `expectedSaving` is only produced when Ŝ is known (the estimator answered
-* with `expectedRemainingTurns`); it is never fabricated from a guess.
-*/
-/**
-* Aggregate the batch-level benefit of a set of reduction candidates.
-*
-* Individual candidates whose replacement would grow the context contribute
-* zero recovery (they never make a batch look better than dropping them).
-*/
-function computeBenefit(candidates, input) {
-	const { alpha, tailTokens, remainingTurns } = input;
-	let recoveredTokens = 0;
-	for (const candidate of candidates) recoveredTokens += Math.max(0, candidate.tokensBefore - candidate.tokensAfter);
-	const penaltyTokens = (1 - alpha) * tailTokens;
-	const perTurnSaving = alpha * recoveredTokens;
-	if (perTurnSaving <= 0) return remainingTurns === void 0 ? {
-		recoveredTokens,
-		penaltyTokens
-	} : {
-		recoveredTokens,
-		penaltyTokens,
-		expectedSaving: -penaltyTokens
-	};
-	const paybackTurns = penaltyTokens / perTurnSaving;
-	if (remainingTurns === void 0) return {
-		recoveredTokens,
-		penaltyTokens,
-		paybackTurns
-	};
-	return {
-		recoveredTokens,
-		penaltyTokens,
-		paybackTurns,
-		expectedSaving: perTurnSaving * Math.max(0, remainingTurns - paybackTurns)
-	};
-}
-/**
-* Stable proposal identity: the sha-256 of the serialized item digests, cut to
-* 12 hex chars. Stable across re-enqueues of the same content so a repeated
-* classification cannot duplicate a pending proposal.
+* Require content evidence of HTML: enough lines carrying real markup tags
+* among a bounded prefix. Angle-bracket prose (TS generics, comparisons) does
+* not match the tag list, which is the misjudgment guard.
 */
-function proposalId(itemDigests) {
-	const hash = createHash("sha256");
-	for (const digest of itemDigests) hash.update(digest);
-	hash.update(String(itemDigests.length));
-	return hash.digest("hex").slice(0, 12);
+function looksLikeHtml(text) {
+	const lines = splitLines(text);
+	let tags = 0;
+	for (const line of lines.slice(0, 400)) if (HTML_TAG_PATTERN.test(line)) {
+		tags += 1;
+		if (tags >= 3) return true;
+	}
+	return false;
 }
+const HTML_DROPPED_OPEN = /<(script|style|noscript|svg|head)\b[^>]*>/i;
+const HTML_BLOCK_MIN_LINES = 2;
+const HTML_BLOCK_MAX_LINES = 8;
+const HTML_BLOCK_MIN_OCCURRENCES = 3;
+const HTML_TABLE_TAG_PATTERN = /<table\b|<tr\b|<th\b|<\/tr\b|<\/table\b/i;
 /**
-* Canonical content digest reused from the dedup hash: plain-text results hash
-* through the dedupe canonicalization; rich blocks fall back to canonical JSON
-* so every candidate is freezable.
+* Deterministic repeated-block folding for slimmed HTML (R4/RK-3): contiguous
+* runs of 2–8 non-table lines whose digit-normalized signature recurs ≥3 times
+* keep their first occurrence; every later occurrence becomes ONE counted
+* marker. Tables never fold, and different copy never shares a signature —
+* only counter/number drift does.
 */
-function contentDigest(content) {
-	return dedupeHash(flattenPlainText(content) ?? JSON.stringify(content), "trim-eol");
-}
-function proposalKindFor(candidate, estimatorSeqs) {
-	if (estimatorSeqs?.has(candidate.sourceSeq) === true) return "estimator";
-	if (candidate.reducer === "dedupe-pointer") return "dedup";
-	return "read-state";
+function foldRepeatedHtmlBlocks(slim, originalLineFor) {
+	const signatureOf = (from, length) => {
+		let signature = `${String(length)}|`;
+		for (let position = from; position < from + length; position++) {
+			const text = slim[position].text;
+			if (HTML_TABLE_TAG_PATTERN.test(text)) return null;
+			signature += `${text.replace(/\d+/g, "#").replace(/\s+/g, " ").trim()}\n`;
+		}
+		return signature;
+	};
+	const counts = /* @__PURE__ */ new Map();
+	for (let length = HTML_BLOCK_MIN_LINES; length <= HTML_BLOCK_MAX_LINES; length++) for (let start = 0; start + length <= slim.length; start++) {
+		const signature = signatureOf(start, length);
+		if (signature === null) continue;
+		const bucket = counts.get(signature);
+		if (bucket === void 0) counts.set(signature, {
+			count: 1,
+			first: start
+		});
+		else bucket.count += 1;
+	}
+	const result = [];
+	let position = 0;
+	while (position < slim.length) {
+		let foldedLength = 0;
+		let matched;
+		for (let length = HTML_BLOCK_MAX_LINES; length >= HTML_BLOCK_MIN_LINES; length--) {
+			if (position + length > slim.length) continue;
+			const signature = signatureOf(position, length);
+			const bucket = signature === null ? void 0 : counts.get(signature);
+			if (bucket !== void 0 && bucket.count >= HTML_BLOCK_MIN_OCCURRENCES) {
+				foldedLength = length;
+				matched = bucket;
+				break;
+			}
+		}
+		if (matched === void 0) {
+			result.push({
+				text: slim[position].text,
+				index: slim[position].index
+			});
+			position += 1;
+			continue;
+		}
+		if (matched.first === position) for (let offset = 0; offset < foldedLength; offset++) result.push({
+			text: slim[position + offset].text,
+			index: slim[position + offset].index
+		});
+		else {
+			const firstLine = originalLineFor(slim[matched.first].index);
+			result.push({
+				text: `[×${String(matched.count)} repeated block, first at line ${String(firstLine)}]`,
+				index: slim[position].index,
+				marker: true
+			});
+		}
+		position += foldedLength;
+	}
+	return result;
 }
 /**
-* Triage planned replacements into the three review-mode buckets.
+* Two-stage HTML reduction (R13). HTML previously fell into `pi-head`, which
+* keeps exactly the useless `<head>` metadata and drops the body.
 *
-* Per candidate (R is per candidate, never cross-credited):
-* - `tokensAfter ≥ tokensBefore` → drop (nothing to recover);
-* - `tokensBefore ≥ reviewHighImpactTokens` → review ("直接送审": high impact
-*   always waits for a human, even when the payback band would pass it);
-* - `paybackTurns ≤ 1`, or Ŝ known and `paybackTurns ≤ 0.25·Ŝ` → auto;
-* - Ŝ known and `paybackTurns ∈ (1, 3]` → review;
-* - everything else (Ŝ unknown with a slow payback) → drop.
+* Stage 1 (`html-slim`) is a deterministic, line-aligned slimming pass:
+* comments, script/style/noscript/svg/head elements (single- or multi-line),
+* data URIs, non-whitelisted attributes, and inline-tag markup disappear;
+* every surviving line keeps its original-event position for the R9 ranges.
+* Stage 2 (`html-skeleton`) runs only when the slim output still exceeds the
+* budget: heading hierarchy, each section's first line, and table header rows
+* survive; the rest is elided with original-event line ranges.
 */
-function classifyCandidates(candidates, input) {
-	const auto = [];
-	const review = [];
-	const drop = [];
-	for (const candidate of candidates) {
-		const benefit = computeBenefit([candidate], input);
-		if (benefit.recoveredTokens <= 0) {
-			drop.push(candidate);
-			continue;
+function reduceHtml(input) {
+	const slim = [];
+	let dropping = null;
+	input.lines.forEach((line, index) => {
+		let text = line.content;
+		if (dropping !== null) {
+			const close = new RegExp(`</${dropping}\\s*>`, "i").exec(text);
+			if (close === null) return;
+			text = text.slice(close.index + close[0].length);
+			dropping = null;
 		}
-		const highImpact = candidate.tokensBefore >= input.reviewHighImpactTokens;
-		const payback = benefit.paybackTurns;
-		if (!highImpact && payback !== void 0) {
-			if (payback <= 1 || input.remainingTurns !== void 0 && payback <= .25 * input.remainingTurns) {
-				auto.push(candidate);
-				continue;
-			}
-			if (!(input.remainingTurns !== void 0 && payback <= 3)) {
-				drop.push(candidate);
-				continue;
+		text = text.replace(HTML_COMMENT_PATTERN, "");
+		text = text.replace(HTML_DROPPED_ELEMENTS, "");
+		const open = HTML_DROPPED_OPEN.exec(text);
+		if (open !== null) {
+			const close = new RegExp(`</${open[1] ?? ""}\\s*>`, "i").exec(text.slice(open.index));
+			if (close !== null) {
+				const end = open.index + open[0].length + close.index + close[0].length;
+				text = text.slice(0, open.index) + text.slice(end);
+			} else {
+				dropping = open[1] ?? null;
+				text = text.slice(0, open.index);
 			}
 		}
-		const item = {
-			seq: candidate.sourceSeq,
-			component: candidate.component,
-			kind: proposalKindFor(candidate, input.estimatorSeqs),
-			tokensBefore: candidate.tokensBefore,
-			tokensAfter: candidate.tokensAfter,
-			digest: contentDigest(candidate.content)
-		};
-		review.push({
-			id: proposalId([item.digest]),
-			kind: item.kind,
-			items: [item],
-			benefit
+		text = text.replace(HTML_DATA_URI_PATTERN, "");
+		text = text.replace(HTML_TAG_PATTERN_FULL, (match, name, attrs) => `<${name}${attrs.match(HTML_WHITELISTED_ATTRIBUTES)?.join("") ?? ""}>`);
+		text = text.replace(HTML_INLINE_TAG_PATTERN, "");
+		text = text.trim();
+		if (text !== "") slim.push({
+			text,
+			index
 		});
-	}
-	return {
-		auto,
-		review,
-		drop
+	});
+	if (slim.length === 0) return null;
+	const buildHeader = (reducer, firstElided) => {
+		const startLine = firstElided === void 0 ? "" : `,"start_line":${String(firstElided.start)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}`;
+		return `[html compressed by ${reducer}; source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}"${startLine}})]`;
 	};
-}
-//#endregion
-//#region src/runtime/tokenpilot/review-queue.ts
-/** In-memory store: the fail-open fallback when no durable seam is available. */
-var MemoryReviewStore = class {
-	sessions = /* @__PURE__ */ new Map();
-	load(sessionId) {
-		return this.sessions.get(sessionId);
-	}
-	save(sessionId, record) {
-		this.sessions.set(sessionId, record);
-	}
-	ids() {
-		return [...this.sessions.keys()];
-	}
-};
-var ReviewQueue = class {
-	store;
-	options;
-	constructor(store, options) {
-		this.store = store;
-		this.options = options;
-	}
-	/**
-	* Fail-open store access: a throwing seam must never break the compression
-	* pipeline. Reads degrade to "no stored record"; writes degrade to losing
-	* durability for that call (the store itself is expected to warn).
-	*/
-	safeLoad(sessionId) {
-		try {
-			return this.store.load(sessionId);
-		} catch {
-			return;
-		}
-	}
-	safeSave(sessionId, record) {
-		try {
-			this.store.save(sessionId, record);
-		} catch {}
-	}
-	sessionRecord(sessionId) {
-		return this.safeLoad(sessionId) ?? {
-			version: 1,
-			proposals: []
+	const foldedSlim = foldRepeatedHtmlBlocks(slim, (index) => input.lines[index]?.originalLine ?? 1);
+	if (foldedSlim.reduce((sum, line) => sum + codePointLength(line.text) + 1, 0) + 160 <= input.budgetChars) {
+		const text = fitLines([buildHeader("html-slim"), ...foldedSlim.map((line) => line.text)], input.budgetChars, input.sourceRef);
+		if (text !== null) return {
+			text,
+			reducer: "html-slim",
+			lossy: true
 		};
 	}
-	/**
-	* Queue one classified proposal. A repeated classification of the same
-	* content re-does nothing but refresh the patience clock, so re-enqueue
-	* cannot duplicate a live proposal.
-	* @returns `false` when an identical live proposal already exists.
-	*/
-	enqueue(sessionId, skeleton, turnIndex) {
-		const record = this.sessionRecord(sessionId);
-		const existing = record.proposals.find((entry) => entry.id === skeleton.id);
-		if (existing !== void 0 && existing.status !== "expired") {
-			existing.lastTurnIndex = turnIndex;
-			this.safeSave(sessionId, record);
-			return false;
+	const keep = new Array(foldedSlim.length).fill(false);
+	let tableRows = 0;
+	let lastHeading = -2;
+	for (let position = 0; position < foldedSlim.length; position++) {
+		const text = foldedSlim[position].text;
+		if (foldedSlim[position].marker === true) {
+			keep[position] = true;
+			continue;
 		}
-		const proposal = {
-			id: skeleton.id,
-			sessionId,
-			kind: skeleton.kind,
-			items: skeleton.items.map((item) => ({ ...item })),
-			benefit: { ...skeleton.benefit },
-			status: "pending",
-			enqueuedTurn: turnIndex,
-			lastTurnIndex: turnIndex
-		};
-		this.safeSave(sessionId, {
-			version: 1,
-			proposals: [...record.proposals.filter((entry) => entry.id !== skeleton.id), proposal]
-		});
-		return true;
-	}
-	/** Live pending proposals of one session, oldest enqueue first. */
-	listPending(sessionId) {
-		return this.sessionRecord(sessionId).proposals.filter((entry) => entry.status === "pending").sort((left, right) => left.enqueuedTurn - right.enqueuedTurn);
-	}
-	/** Approved proposals waiting for the next turn-boundary batch. */
-	listApproved(sessionId) {
-		return this.sessionRecord(sessionId).proposals.filter((entry) => entry.status === "approved").sort((left, right) => left.enqueuedTurn - right.enqueuedTurn);
+		if (/<h[1-6]\b/i.test(text)) {
+			keep[position] = true;
+			lastHeading = position;
+			continue;
+		}
+		if (lastHeading === position - 1) {
+			keep[position] = true;
+			continue;
+		}
+		if (/<table\b|<tr\b|<th\b/i.test(text)) {
+			if (tableRows < 2) keep[position] = true;
+			tableRows += 1;
+			continue;
+		}
+		if (!/<\/(tr|table)\b/i.test(text)) tableRows = 0;
+		if (IMPORTANT_PATTERN.test(text)) keep[position] = true;
 	}
-	/**
-	* Transition one pending proposal. Idempotent: deciding an unknown id or a
-	* non-pending proposal changes nothing and reports the miss.
-	*/
-	decide(sessionId, id, decision) {
-		const record = this.sessionRecord(sessionId);
-		const proposal = record.proposals.find((entry) => entry.id === id);
-		if (proposal === void 0) return {
-			ok: false,
-			reason: "unknown-proposal"
-		};
-		if (proposal.status !== "pending") return {
-			ok: false,
-			reason: "not-pending"
-		};
-		proposal.status = decision;
-		this.safeSave(sessionId, record);
-		return { ok: true };
+	const kept = [];
+	let position = 0;
+	let firstElided;
+	let elidedLines = 0;
+	while (position < foldedSlim.length) {
+		if (keep[position]) {
+			kept.push(foldedSlim[position].text);
+			position += 1;
+			continue;
+		}
+		const runStart = position;
+		while (position < foldedSlim.length && !keep[position]) position += 1;
+		const start = input.lines[foldedSlim[runStart].index].originalLine;
+		const end = originalEnd(input.lines, foldedSlim[position - 1].index);
+		if (firstElided === void 0) firstElided = start;
+		elidedLines += end - start + 1;
+		kept.push(elidedRangeMarker(start, end));
+	}
+	const text = fitLines([buildHeader("html-skeleton", firstElided === void 0 ? void 0 : { start: firstElided }), ...kept], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer: "html-skeleton",
+		lossy: true,
+		elidedLines
+	};
+}
+/** Original-event end line of folded entry `lines[index]`. */
+function originalEnd(lines, index) {
+	const line = lines[index];
+	return line?.originalLineEnd ?? line?.originalLine ?? 0;
+}
+/**
+* Keep a document skeleton: the heading hierarchy, each section's first and
+* last content line, list-item starts, table headers, and fence markers,
+* eliding the remaining bodies with R9 line-range markers. Fails open (null)
+* when nothing is elidable or the budget cannot be met, so the next candidate
+* takes over.
+*/
+function reduceDocSkeleton(input, sectionRanking) {
+	const lines = input.lines;
+	const keep = new Array(lines.length).fill(false);
+	const headingIndex = [];
+	let inFence = false;
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index].content;
+		if (FENCE_PATTERN.test(line)) {
+			inFence = !inFence;
+			keep[index] = true;
+			continue;
+		}
+		if (!inFence && MARKDOWN_HEADING_PATTERN.test(line)) {
+			headingIndex.push(index);
+			keep[index] = true;
+			continue;
+		}
+		if (IMPORTANT_PATTERN.test(line)) keep[index] = true;
+		else if (!inFence && LIST_ITEM_PATTERN.test(line)) keep[index] = true;
 	}
-	/**
-	* Expire every pending proposal whose patience has run out at this turn
-	* boundary. Expired proposals are removed from the store (the summary view
-	* aggregates them from the audit log instead).
-	* @returns the expired proposals, for the caller's audit emission.
-	*/
-	expireTurn(sessionId, turnIndex) {
-		const record = this.sessionRecord(sessionId);
-		const keep = [];
-		const expired = [];
-		for (const proposal of record.proposals) {
-			if (proposal.status === "pending" && turnIndex - proposal.lastTurnIndex > this.options.timeoutTurns) {
-				expired.push({
-					...proposal,
-					status: "expired"
-				});
+	let tableRows = 0;
+	let fenceOpen = false;
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index].content;
+		if (FENCE_PATTERN.test(line)) {
+			fenceOpen = !fenceOpen;
+			tableRows = 0;
+			continue;
+		}
+		if (fenceOpen || line.trim() === "") continue;
+		if (TABLE_ROW_PATTERN.test(line)) {
+			if (tableRows < 2) keep[index] = true;
+			tableRows += 1;
+			continue;
+		}
+		tableRows = 0;
+	}
+	const sectionStarts = [-1, ...headingIndex];
+	const sectionEnds = [...headingIndex, lines.length];
+	const sections = headingIndex.map((heading, position) => ({
+		id: lines[heading].content.replace(/^#+\s*/, "").trim(),
+		heading,
+		from: heading + 1,
+		to: position + 1 < headingIndex.length ? headingIndex[position + 1] : lines.length
+	}));
+	const floorKeep = new Array(lines.length).fill(false);
+	for (let section = 0; section < sectionStarts.length; section++) {
+		const from = sectionStarts[section] + 1;
+		const to = sectionEnds[section];
+		let first = -1;
+		let last = -1;
+		for (let index = from; index < to; index++) {
+			if (lines[index].content.trim() === "") continue;
+			if (first === -1) first = index;
+			last = index;
+		}
+		if (first !== -1) floorKeep[first] = true;
+		if (last !== -1) floorKeep[last] = true;
+	}
+	/** Emit the skeleton for one keep-set: header, kept lines, R9 range markers. */
+	const assemble = (flags, budget) => {
+		const kept = [];
+		let index = 0;
+		let firstElided;
+		let elidedLines = 0;
+		while (index < lines.length) {
+			if (flags[index]) {
+				kept.push(lines[index].text);
+				index += 1;
 				continue;
 			}
-			keep.push(proposal);
+			const runStart = index;
+			while (index < lines.length && !flags[index]) index += 1;
+			const start = lines[runStart].originalLine;
+			const end = originalEnd(lines, index - 1);
+			if (firstElided === void 0) firstElided = start;
+			elidedLines += end - start + 1;
+			kept.push(elidedRangeMarker(start, end));
 		}
-		if (expired.length > 0) this.safeSave(sessionId, {
-			version: 1,
-			proposals: keep
-		});
-		return expired;
-	}
-	/**
-	* Settle an approved proposal with its execution receipt and retire it from
-	* the live store. The caller is responsible for auditing the receipt; the
-	* queue only records which proposal left and why.
-	*/
-	recordReceipt(sessionId, id, receipt) {
-		const record = this.sessionRecord(sessionId);
-		const proposal = record.proposals.find((entry) => entry.id === id);
-		if (proposal === void 0 || proposal.status !== "approved") return void 0;
-		this.safeSave(sessionId, {
-			version: 1,
-			proposals: record.proposals.filter((entry) => entry.id !== id)
-		});
+		const hint = firstElided === void 0 ? "" : `,"start_line":${String(firstElided)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}`;
+		kept.unshift(`[document compressed by doc-skeleton; source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}"${hint}})]`);
 		return {
-			...proposal,
-			receipt
+			text: fitLines(kept, budget, input.sourceRef),
+			...firstElided === void 0 ? {} : { firstElided },
+			elidedLines
 		};
-	}
-};
-//#endregion
-//#region src/runtime/tokenpilot/review-storage.ts
-/** Domain name — `UNIT_NAME_RE` (`/^[a-z][a-z0-9_]*$/`) allows no hyphens. */
-const REVIEW_STORAGE_DOMAIN = "context_compression_review";
-/** The one declared table: one record per session id. */
-const REVIEW_STORAGE_TABLE = "sessions";
-/** Structural validator: accepts exactly the shape this module persists. */
-function reviewSessionRecordValidator() {
-	return { safeParse(value) {
-		if (typeof value !== "object" || value === null) return { success: false };
-		const record = value;
-		if (record.version !== 1 || !Array.isArray(record.proposals)) return { success: false };
-		for (const proposal of record.proposals) {
-			if (typeof proposal !== "object" || proposal === null) return { success: false };
-			const entry = proposal;
-			if (typeof entry.id !== "string" || typeof entry.sessionId !== "string") return { success: false };
-			if (entry.kind !== "estimator" && entry.kind !== "dedup" && entry.kind !== "read-state") return { success: false };
-			if (entry.status !== "pending" && entry.status !== "approved") return { success: false };
-			if (!Number.isSafeInteger(entry.enqueuedTurn) || !Number.isSafeInteger(entry.lastTurnIndex)) return { success: false };
-			if (!Array.isArray(entry.items) || typeof entry.benefit !== "object" || entry.benefit === null) return { success: false };
-			for (const item of entry.items) {
-				if (typeof item !== "object" || item === null) return { success: false };
-				const one = item;
-				if (!Number.isSafeInteger(one.seq) || typeof one.digest !== "string") return { success: false };
+	};
+	const combine = (base, overlay) => lines.map((_, index) => (base[index] ?? false) || (overlay[index] ?? false));
+	const mechanical = assemble(combine(keep, floorKeep), input.budgetChars);
+	if (mechanical.text === null) return null;
+	if (sectionRanking === void 0 || sectionRanking.length === 0) return {
+		text: mechanical.text,
+		reducer: "doc-skeleton",
+		lossy: true,
+		elidedLines: mechanical.elidedLines
+	};
+	const cap = Math.min(input.budgetChars, codePointLength(input.text) - 1);
+	const rankedFloor = new Array(lines.length).fill(false);
+	for (const section of sections) for (let index = section.from; index < section.to; index++) {
+		if (lines[index].content.trim() === "") continue;
+		rankedFloor[index] = true;
+		break;
+	}
+	/** Exact packed-output size of a keep-set: header + kept lines + markers. */
+	const packedSize = (flags) => {
+		let size = 180;
+		let index = 0;
+		while (index < lines.length) {
+			if (flags[index]) {
+				size += codePointLength(lines[index].text) + 1;
+				index += 1;
+				continue;
 			}
+			const runStart = index;
+			while (index < lines.length && !flags[index]) index += 1;
+			size += codePointLength(elidedRangeMarker(lines[runStart].originalLine, originalEnd(lines, index - 1))) + 1;
 		}
-		return {
-			success: true,
-			data: value
-		};
-	} };
+		return size;
+	};
+	const fill = new Array(lines.length).fill(false);
+	for (const section of rankedFirst(sections, sectionRanking)) for (let index = section.from; index < section.to; index++) {
+		if (rankedFloor[index] || fill[index] || lines[index].content.trim() === "") continue;
+		fill[index] = true;
+		if (packedSize(combine(combine(keep, rankedFloor), fill)) > cap) {
+			fill[index] = false;
+			break;
+		}
+	}
+	const ranked = assemble(combine(combine(keep, rankedFloor), fill), cap);
+	return ranked.text === null ? null : {
+		text: ranked.text,
+		reducer: "doc-skeleton",
+		lossy: true,
+		elidedLines: ranked.elidedLines
+	};
 }
-function reviewStorageSpec() {
+/**
+* Universal prose fallback (R8b, the main force): keep the head AND the tail
+* of any non-code text and one R9 line-range marker for everything elided in
+* between. Unstructured prose (85%+ of large results) previously landed on
+* head-only truncation; a tail keep preserves conclusions and closing state.
+* Fails open for code-like text and when the budget cannot hold both ends.
+*/
+function reduceProseKeep(input) {
+	const lines = input.lines;
+	if (lines.length < 8) return null;
+	if (looksLikeSourceCode(input.contentText)) return null;
+	const first = lines[0];
+	const last = lines[lines.length - 1];
+	const tailLine = last.originalLineEnd ?? last.originalLine;
+	const markerTemplate = elidedRangeMarker(first.originalLine, tailLine);
+	const sourceNoteTemplate = `; source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}"})`;
+	const reserved = codePointLength(markerTemplate) + codePointLength(sourceNoteTemplate) + 2;
+	const bodyBudget = input.budgetChars - reserved;
+	if (bodyBudget <= 0) return null;
+	const headBudget = Math.floor(bodyBudget / 2);
+	const tailBudget = bodyBudget - headBudget;
+	let headCount = 0;
+	let used = 0;
+	while (headCount < lines.length) {
+		const cost = codePointLength(lines[headCount].text) + (headCount === 0 ? 0 : 1);
+		if (used + cost > headBudget) break;
+		used += cost;
+		headCount += 1;
+	}
+	let tailCount = 0;
+	used = 0;
+	while (tailCount < lines.length - headCount) {
+		const index = lines.length - 1 - tailCount;
+		const cost = codePointLength(lines[index].text) + (tailCount === 0 ? 0 : 1);
+		if (used + cost > tailBudget) break;
+		used += cost;
+		tailCount += 1;
+	}
+	if (headCount === 0 || tailCount === 0 || headCount + tailCount >= lines.length) return null;
+	const elidedStart = lines[headCount].originalLine;
+	const elidedEnd = originalEnd(lines, lines.length - tailCount - 1);
+	if (elidedEnd < elidedStart) return null;
+	const sourceNote = `; source: ${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","start_line":${String(elidedStart)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}})`;
 	return {
-		name: REVIEW_STORAGE_DOMAIN,
-		version: 1,
-		layout: "per-record",
-		tables: { [REVIEW_STORAGE_TABLE]: { valueSchema: reviewSessionRecordValidator() } }
+		text: [
+			...lines.slice(0, headCount).map((line) => line.text),
+			elidedRangeMarker(elidedStart, elidedEnd) + sourceNote,
+			...lines.slice(lines.length - tailCount).map((line) => line.text)
+		].join("\n"),
+		reducer: "prose-keep",
+		lossy: true,
+		elidedLines: elidedEnd - elidedStart + 1
 	};
 }
-/** Adapter presenting the sync KV face the queue expects over the domain table. */
-var StorageDomainReviewStore = class {
-	table;
-	constructor(table) {
-		this.table = table;
-	}
-	load(sessionId) {
-		const value = this.table.get(sessionId);
-		return typeof value === "object" && value !== null ? value : void 0;
-	}
-	save(sessionId, record) {
-		this.table.put(sessionId, record).catch(() => void 0);
-	}
-	ids() {
-		return [...this.table.keys()];
-	}
-};
-/**
-* Attempt to open the review storage domain through the optional
-* `storageDomain` seam.
-* @param getService - resolved once with the seam name; `undefined` means the
-* host lacks the service.
-* @returns the durable store, or `undefined` when the seam is absent or fails
-* (the caller falls back to the in-memory store and logs one warning).
-*/
-async function openReviewStorage(getService) {
-	let service;
-	try {
-		service = getService("storageDomain");
-	} catch {
-		return;
-	}
-	if (service === void 0 || service === null) return void 0;
-	return new StorageDomainReviewStore((await service.open(reviewStorageSpec())).table(REVIEW_STORAGE_TABLE));
-}
-//#endregion
-//#region src/runtime/reducers.ts
-/** Deterministic, evidence-backed reducers for fresh tool results. */
-const ANSI_PATTERN = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/gu;
-const IMPORTANT_PATTERN = new RegExp([
-	String.raw`\b(?:error|failed|failure|fatal|panic|exception|warning|warn|conflict|denied|forbidden|`,
-	String.raw`timeout|timed out|not found|cannot|unable|invalid|exit(?:ed)?\s+(?:code|status)|traceback|`,
-	String.raw`assert(?:ion)?|segmentation fault|oom|out of memory)\b`
-].join(""), "i");
-const STATUS_PATTERN = new RegExp([String.raw`\b(?:success|succeeded|passed|installed|added|removed|updated|built|compiled|`, String.raw`tests?\s+(?:passed|failed)|exit(?:ed)?\s+(?:code|status))\b`].join(""), "i");
-const PATH_LINE_PATTERN = /^(.*?):(\d+)(?::\d+)?(?::|\s+-\s+)(.*)$/;
-const GIT_STATUS_PATTERN = new RegExp([String.raw`^(?:On branch|Your branch|HEAD detached|Changes |Untracked |Unmerged |\s*(?:modified|deleted|`, String.raw`new file|renamed|both modified):)`].join(""), "i");
-const CODE_IMPORT_PATTERN = new RegExp([String.raw`^\s*(?:import\b|from\s+[\w.]+\s+import\b|use\s+\w|package\s+|#include\b|`, String.raw`using\s+[\w.]+;|require\s*\(|extern\s+crate\b)`].join(""));
-const CODE_STRUCTURE_PATTERN = new RegExp([
-	String.raw`^\s*(?:@[\w.]+|export\s+|default\s+|declare\s+|abstract\s+|public\s+|private\s+|protected\s+|`,
-	String.raw`internal\s+|static\s+|final\s+|sealed\s+|override\s+|pub(?:\([^)]*\))?\s+|async\s+|unsafe\s+)*`,
-	String.raw`(?:function\b|class\b|interface\b|enum\b|struct\b|impl\b|trait\b|type\s+\w|fn\s|func\b|`,
-	String.raw`def\s|module\b|namespace\b|sub\s)`
-].join(""));
-const PYTHON_STRUCTURE_PATTERN = /^\s*(?:async\s+)?def\s|^\s*class\s/;
-const CODE_DECORATOR_PATTERN = /^\s*@[\w.]+/;
-const CODE_COMMENT_PATTERN = /^\s*(?:\/\/|#|\/\*|\*)/;
 /**
-* Select a reducer from verified tool, command, and content evidence.
+* Keep a source-file skeleton: imports, decorators, declaration signatures,
+* comments at brace depth zero, and every error-signalling line, eliding the
+* remaining bodies with counted markers. Covers brace languages (TS/JS, Rust,
+* Go, Java, C family) and indent blocks (Python); unknown syntax fails open to
+* the next candidate. Output is compressed evidence, not required to parse.
 * @param input - original result text, recovery source, and output budget.
-* @returns a verified candidate, or `null` when every reducer fails open.
+* @returns a verified candidate, or `null` when the text is not code-like.
 */
-function reduceFreshToolResult(input) {
-	const normalized = normalizeTerminalText(input.text);
-	const prepared = {
-		...input,
-		text: normalized
+function reduceCodeSkeleton(input) {
+	const lines = input.lines.map((line) => line.content);
+	const kept = [];
+	let elided = 0;
+	let elidedTotal = 0;
+	let firstElided;
+	const flushElided = () => {
+		if (elided > 0) {
+			const start = input.lines[index - elided]?.originalLine ?? 0;
+			const end = originalEnd(input.lines, index - 1);
+			if (firstElided === void 0) firstElided = {
+				start,
+				end
+			};
+			kept.push(elidedRangeMarker(start, end));
+			elidedTotal += elided;
+		}
+		elided = 0;
 	};
-	const command = extractCommand(input.argumentsText);
-	const name = input.toolName.toLowerCase();
-	const candidates = [];
-	if (looksLikeJson(normalized)) candidates.push(() => reduceJson(prepared));
-	if (isSearchTool(name, command)) candidates.push(() => reduceSearch(prepared));
-	if (isGitCommand(name, command)) candidates.push(() => reduceGit(prepared, command));
-	if (isPackageCommand(command)) candidates.push(() => reducePatternLog(prepared, "hypa-package", packagePattern()));
-	if (isBuildOrTestCommand(command)) candidates.push(() => reducePatternLog(prepared, "hypa-build-test", buildPattern()));
-	if (input.codeSkeleton === true && looksLikeSourceCode(normalized)) candidates.push(() => reduceCodeSkeleton(prepared));
-	if (isReadTool(name)) candidates.push(() => reduceHead(prepared, "pi-head"));
-	if (isShellTool(name) || command !== "") candidates.push(() => reduceShell(prepared));
-	candidates.push(() => reduceSalient(prepared, "generic-salience"));
-	for (const make of candidates) {
-		const candidate = make();
-		if (candidate !== null && verifyReduction(input, candidate)) return candidate;
-	}
-	return null;
-}
-/**
-* Build a recoverable placeholder for an old tool result.
-* @param input - tool identity, source reference, size, status, and retained evidence.
-* @returns a lossy placeholder that cites the immutable source event.
-*/
-function historicalPlaceholder(input) {
-	const anchor = input.compact ? "" : importantAnchor(input.text, 360);
-	const lines = [
-		"[Old tool result content cleared from active context]",
-		`tool: ${input.toolName || "unknown"}`,
-		`status: ${input.isError ? "error" : "completed"}`,
-		`original_chars: ${String(input.charsBefore)}`,
-		`source: ${input.sourceRef}`,
-		"retrieve: context_compression_retrieve({\"ref\":\"" + input.sourceRef + "\"})"
-	];
-	if (anchor !== "") lines.push(`retained_anchor: ${anchor}`);
-	return {
-		text: lines.join("\n"),
-		reducer: input.compact ? "pair-preserving-tail-aging" : "historical-tool-result-aging",
-		lossy: true
+	let depth = 0;
+	let index = 0;
+	const elideBraceBody = () => {
+		const startDepth = depth;
+		index += 1;
+		while (index < lines.length && depth > startDepth) {
+			const body = lines[index];
+			if (body === void 0) break;
+			if (IMPORTANT_PATTERN.test(body)) {
+				flushElided();
+				kept.push(body);
+			} else elided += 1;
+			depth += braceDelta(body);
+			index += 1;
+		}
+		flushElided();
 	};
-}
-/**
-* Validate shrinkage, budget, recovery, and error retention.
-* @param input - original reducer input and its safety requirements.
-* @param output - candidate reduced text and reducer metadata.
-* @returns whether the candidate is safe to land.
-*/
-function verifyReduction(input, output) {
-	const before = codePointLength(input.text);
-	const after = codePointLength(output.text);
-	if (after <= 0 || after >= before || after > input.budgetChars) return false;
-	if (output.lossy && !output.text.includes(input.sourceRef)) return false;
-	if ((input.isError || IMPORTANT_PATTERN.test(input.text)) && !IMPORTANT_PATTERN.test(output.text) && !output.text.includes("status: error")) return false;
-	return true;
-}
-/**
-* Strip ANSI, collapse carriage-return progress redraws, and fold exact repeats.
-* @param text - raw terminal output.
-* @returns normalized terminal text.
-*/
-function normalizeTerminalText(text) {
-	const logical = text.replace(ANSI_PATTERN, "").split("\n").map((line) => {
-		return line.split("\r").filter((part) => part !== "").at(-1) ?? "";
-	});
-	const folded = [];
-	let previous;
-	let count = 0;
-	const flush = () => {
-		if (previous === void 0) return;
-		folded.push(previous);
-		if (count > 1) folded.push(`[previous line repeated ${String(count - 1)} more times]`);
+	const keepPythonSignature = (signatureLine) => {
+		index += 1;
+		if (/:\s*$/.test(signatureLine)) {
+			elideIndentedBody(leadingIndent(signatureLine));
+			return;
+		}
+		for (let guard = 0; guard < 6 && index < lines.length; guard += 1) {
+			const next = lines[index];
+			if (next === void 0) break;
+			if (next.trim() !== "" && leadingIndent(next) <= leadingIndent(signatureLine)) break;
+			flushElided();
+			kept.push(next);
+			index += 1;
+			if (/:\s*$/.test(next)) {
+				elideIndentedBody(leadingIndent(next));
+				return;
+			}
+			if (next.trim() !== "" && !/[:,(]\s*$/.test(next)) break;
+		}
 	};
-	for (const line of logical) {
-		if (line === previous) {
-			count++;
+	const elideIndentedBody = (indent) => {
+		while (index < lines.length) {
+			const body = lines[index];
+			if (body === void 0) break;
+			if (body.trim() !== "" && leadingIndent(body) <= indent) break;
+			if (IMPORTANT_PATTERN.test(body)) {
+				flushElided();
+				kept.push(body);
+				index += 1;
+				continue;
+			}
+			if (isCodeStructureLine(body) || CODE_DECORATOR_PATTERN.test(body)) {
+				flushElided();
+				kept.push(body);
+				keepPythonSignature(body);
+				continue;
+			}
+			elided += 1;
+			index += 1;
+		}
+		flushElided();
+	};
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line === void 0) break;
+		const delta = braceDelta(line);
+		if (IMPORTANT_PATTERN.test(line)) {
+			flushElided();
+			kept.push(line);
+			depth += delta;
+			index += 1;
 			continue;
 		}
-		flush();
-		previous = line;
-		count = 1;
+		if (isCodeStructureLine(line) || CODE_IMPORT_PATTERN.test(line) || CODE_DECORATOR_PATTERN.test(line)) {
+			flushElided();
+			kept.push(line);
+			depth += delta;
+			if (delta > 0) {
+				elideBraceBody();
+				continue;
+			}
+			if (PYTHON_STRUCTURE_PATTERN.test(line)) {
+				keepPythonSignature(line);
+				continue;
+			}
+			let opened = false;
+			for (let guard = 0; guard < 6 && index + 1 < lines.length; guard += 1) {
+				const next = lines[index + 1];
+				if (next === void 0) break;
+				const nextDelta = braceDelta(next);
+				if (nextDelta === 0 && next.trim() !== "" && !/[:,(]\s*$/.test(next)) break;
+				flushElided();
+				kept.push(next);
+				depth += nextDelta;
+				index += 1;
+				if (nextDelta > 0) {
+					opened = true;
+					break;
+				}
+			}
+			if (opened) elideBraceBody();
+			else index += 1;
+			continue;
+		}
+		if (depth === 0 && CODE_COMMENT_PATTERN.test(line)) {
+			flushElided();
+			kept.push(line);
+		} else elided += 1;
+		depth += delta;
+		index += 1;
 	}
-	flush();
-	return folded.join("\n");
+	flushElided();
+	return finishSkeleton(kept, lines, input, firstElided, elidedTotal);
 }
-function reduceHead(input, reducer) {
-	const marker = omissionMarker(input, reducer);
-	const available = input.budgetChars - codePointLength(marker) - 1;
-	if (available <= 0) return null;
-	const head = takeWholeLinesFromHead(input.text, available);
-	if (head === input.text || head === "") return null;
-	return {
-		text: `${head}\n${marker}`,
-		reducer,
-		lossy: true
+function finishSkeleton(kept, lines, input, firstElided, elidedLines) {
+	const hint = firstElided === void 0 ? "" : `; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","start_line":${String(firstElided.start)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}})`;
+	const text = fitLines([
+		`[code output compressed by hypa-code-skeleton; source: ${input.sourceRef}${hint}]`,
+		...kept,
+		...lines.slice(-4)
+	], input.budgetChars, input.sourceRef);
+	return text === null ? null : {
+		text,
+		reducer: "hypa-code-skeleton",
+		lossy: true,
+		elidedLines
 	};
 }
-function reduceTail(input, reducer) {
-	const marker = omissionMarker(input, reducer);
-	const available = input.budgetChars - codePointLength(marker) - 1;
-	if (available <= 0) return null;
-	const tail = takeWholeLinesFromTail(input.text, available);
-	if (tail === input.text || tail === "") return null;
-	return {
-		text: `${marker}\n${tail}`,
-		reducer,
-		lossy: true
-	};
+/** Net brace delta of one line, ignoring braces inside string literals. */
+function braceDelta(line) {
+	let delta = 0;
+	let quote = null;
+	for (let position = 0; position < line.length; position += 1) {
+		const char = line[position];
+		if (quote !== null) {
+			if (char === "\\") position += 1;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") delta += 1;
+		else if (char === "}") delta -= 1;
+	}
+	return delta;
 }
-function reduceJson(input) {
-	let value;
-	try {
-		value = JSON.parse(input.text);
-	} catch {
-		return null;
+function leadingIndent(line) {
+	return codePointLength(line) - codePointLength(line.trimStart());
+}
+function isCodeStructureLine(line) {
+	return CODE_STRUCTURE_PATTERN.test(line) || PYTHON_STRUCTURE_PATTERN.test(line);
+}
+/**
+* Require content evidence of source code: enough declaration, import, or
+* decorator lines among a bounded prefix. Failing this keeps prose, logs, and
+* data on their existing reducers.
+* @param text - normalized result text.
+* @returns whether the text qualifies as source code.
+*/
+function looksLikeSourceCode(text) {
+	const lines = splitLines(text);
+	if (lines.length < 12) return false;
+	let evidence = 0;
+	for (const line of lines.slice(0, 400)) if (isCodeStructureLine(line) || CODE_IMPORT_PATTERN.test(line) || CODE_DECORATOR_PATTERN.test(line)) {
+		evidence += 1;
+		if (evidence >= 3) return true;
 	}
-	const minified = JSON.stringify(value);
-	if (codePointLength(minified) < codePointLength(input.text) && codePointLength(minified) <= input.budgetChars) return {
-		text: minified,
-		reducer: "json-minify",
-		lossy: false
-	};
-	const envelope = {
-		$dsh_compression: {
-			kind: "json-preview",
-			source: input.sourceRef,
-			original_chars: codePointLength(input.text)
-		},
-		value: shrinkJson(value, 0)
-	};
-	const text = JSON.stringify(envelope, null, 2);
-	if (codePointLength(text) <= input.budgetChars) return {
-		text,
-		reducer: "json-structure-preview",
-		lossy: true
-	};
-	return null;
+	return false;
 }
-function shrinkJson(value, depth) {
-	if (depth >= 5) {
-		if (Array.isArray(value)) return `[array length=${String(value.length)} omitted]`;
-		if (typeof value === "object" && value !== null) return "[object omitted]";
-		return value;
+function omissionMarker(input, reducer) {
+	return `[... ${reducer} omitted content; original_chars=${String(codePointLength(input.text))}; source=${input.sourceRef}; retrieve with context_compression_retrieve ...]`;
+}
+/**
+* Continuous-mask marker (R9b): an original-event line range plus a pasteable
+* retrieve hint whose start_line is the first elided line. Line numbers point
+* at the RAW event because retrieve reads raw events (D8).
+*/
+function rangeOmissionMarker(input, reducer, elidedStart, elidedEnd) {
+	return `[... lines ${String(elidedStart)}-${String(elidedEnd)} elided (${String(elidedEnd - elidedStart + 1)} lines); ${reducer}; original_chars=${String(codePointLength(input.text))}; source=${input.sourceRef}; retrieve with context_compression_retrieve({"ref":"${input.sourceRef}","start_line":${String(elidedStart)},"max_lines":${String(RETRIEVE_HINT_MAX_LINES)}}) ...]`;
+}
+/** Scatter-mask note (R9b): totals instead of fragmented per-run ranges. */
+function scannedTotals(input, kept) {
+	const last = input.lines[input.lines.length - 1];
+	const lastLine = Math.max(last?.originalLineEnd ?? 0, last?.originalLine ?? 0, input.lines.length);
+	return `lines 1-${String(lastLine)} scanned, ${String(kept)} kept`;
+}
+function importantAnchor(text, maxChars) {
+	const lines = splitLines(normalizeTerminalText(text));
+	const chosen = lines.find((line) => IMPORTANT_PATTERN.test(line)) ?? lines.at(-1) ?? "";
+	return Array.from(chosen.trim()).slice(0, maxChars).join("");
+}
+function fitLines(lines, budgetChars, requiredRef) {
+	const unique = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const line of lines) {
+		if (line === "" || seen.has(line)) continue;
+		seen.add(line);
+		unique.push(line);
 	}
-	if (Array.isArray(value)) {
-		if (value.length <= 8) return value.map((entry) => shrinkJson(entry, depth + 1));
-		return [
-			...value.slice(0, 3).map((entry) => shrinkJson(entry, depth + 1)),
-			{ $dsh_omitted_items: value.length - 5 },
-			...value.slice(-2).map((entry) => shrinkJson(entry, depth + 1))
-		];
+	const output = [];
+	let used = 0;
+	for (const line of unique) {
+		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
+		if (used + cost > budgetChars) continue;
+		output.push(line);
+		used += cost;
 	}
-	if (typeof value !== "object" || value === null) {
-		if (typeof value === "string" && codePointLength(value) > 800) return `${Array.from(value).slice(0, 500).join("")}…[${String(codePointLength(value) - 700)} chars omitted]…${Array.from(value).slice(-200).join("")}`;
-		return value;
+	const text = output.join("\n");
+	return text.includes(requiredRef) ? text : null;
+}
+function takeWholeLinesFromHead(text, budgetChars) {
+	const output = [];
+	let used = 0;
+	for (const line of splitLines(text)) {
+		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
+		if (used + cost > budgetChars) break;
+		output.push(line);
+		used += cost;
 	}
-	const entries = Object.entries(value);
-	const important = entries.filter(([key]) => /error|warn|status|code|message|path|file|line|summary/i.test(key));
-	const selected = entries.length <= 18 ? entries : [
-		...entries.slice(0, 10),
-		...important.filter((entry) => !entries.slice(0, 10).includes(entry)).slice(0, 6),
-		...entries.slice(-2)
-	];
-	const result = {};
-	for (const [key, entry] of selected) result[key] = shrinkJson(entry, depth + 1);
-	if (selected.length < entries.length) result.$dsh_omitted_keys = entries.length - selected.length;
-	return result;
+	if (output.length === 0) return Array.from(text).slice(0, budgetChars).join("");
+	return output.join("\n");
 }
-function reduceSearch(input) {
-	const lines = splitLines(input.text);
-	const groups = /* @__PURE__ */ new Map();
-	const ungrouped = [];
-	for (const line of lines) {
-		const match = PATH_LINE_PATTERN.exec(line);
-		const row = {
-			line,
-			important: IMPORTANT_PATTERN.test(line)
-		};
-		if (match === null) {
-			ungrouped.push(row);
-			continue;
-		}
-		const path = match[1] ?? "<unknown>";
-		const bucket = groups.get(path) ?? [];
-		bucket.push(row);
-		groups.set(path, bucket);
+function takeWholeLinesFromTail(text, budgetChars) {
+	const lines = splitLines(text);
+	const output = [];
+	let used = 0;
+	for (let index = lines.length - 1; index >= 0; index--) {
+		const line = lines[index];
+		if (line === void 0) continue;
+		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
+		if (used + cost > budgetChars) break;
+		output.unshift(line);
+		used += cost;
 	}
-	if (groups.size === 0) return reduceSalient(input, "search-salience");
-	const selected = [];
-	let omitted = 0;
-	for (const [path, rows] of groups) {
-		const keep = /* @__PURE__ */ new Set([0, rows.length - 1]);
-		rows.forEach((row, index) => {
-			if (row.important) keep.add(index);
-		});
-		for (let index = 0; index < rows.length && keep.size < 5; index++) keep.add(index);
-		const indexes = [...keep].filter((index) => index >= 0).sort((a, b) => a - b);
-		selected.push(`## ${path} (${String(rows.length)} matches)`);
-		for (const index of indexes) {
-			const row = rows[index];
-			if (row !== void 0) selected.push(row.line);
+	if (output.length === 0) return Array.from(text).slice(-budgetChars).join("");
+	return output.join("\n");
+}
+function splitLines(text) {
+	const lines = text.split("\n");
+	if (text.endsWith("\n")) lines.pop();
+	return lines;
+}
+/**
+* Extract the command argument from a tool call's arguments (task_10/AD2):
+* ONLY `command` / `cmd` / `script` are command keys. `input` was removed —
+* any MCP tool with a non-empty `input` string parameter would otherwise be
+* misrouted into the shell reducer, the single largest misroute source.
+* @param argumentsText - raw JSON arguments of the tool call.
+* @returns the command string, or '' when absent.
+*/
+function extractCommand(argumentsText) {
+	try {
+		const parsed = JSON.parse(argumentsText);
+		if (typeof parsed !== "object" || parsed === null) return "";
+		const record = parsed;
+		for (const key of [
+			"command",
+			"cmd",
+			"script"
+		]) {
+			const value = record[key];
+			if (typeof value === "string") return value;
 		}
-		omitted += rows.length - indexes.length;
+	} catch {
+		return "";
 	}
-	for (const row of ungrouped.filter((row) => row.important).slice(0, 12)) selected.push(row.line);
-	const text = fitLines([`[search results compressed; ${String(omitted)} matches omitted; source: ${input.sourceRef}]`, ...selected], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer: "search-by-file",
-		lossy: true
-	};
+	return "";
 }
-function reduceGit(input, command) {
-	const lines = splitLines(input.text);
-	const lower = command.toLowerCase();
-	let keep;
-	let reducer;
-	if (/\bgit\s+(?:diff|show)\b/.test(lower)) {
-		reducer = "hypa-git-diff";
-		keep = lines.filter((line) => /^(?:diff --git|index |--- |\+\+\+ |@@ |[+-](?![+-]))/.test(line) || IMPORTANT_PATTERN.test(line));
-	} else if (/\bgit\s+(?:status|switch|checkout|merge|rebase|cherry-pick)\b/.test(lower)) {
-		reducer = "hypa-git-status";
-		keep = lines.filter((line) => GIT_STATUS_PATTERN.test(line) || IMPORTANT_PATTERN.test(line));
-	} else {
-		reducer = "hypa-git-log";
-		keep = lines.filter((line) => /^(?:commit\s+[0-9a-f]+|Author:|Date:|[0-9a-f]{7,}\s)/i.test(line) || IMPORTANT_PATTERN.test(line));
-	}
-	if (keep.length === 0) return reduceSalient(input, reducer);
-	const text = fitLines([
-		`[git output compressed; source: ${input.sourceRef}]`,
-		...keep,
-		...lines.slice(-8)
-	], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer,
-		lossy: true
-	};
+function looksLikeJson(text) {
+	const trimmed = text.trim();
+	return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
 }
-function reducePatternLog(input, reducer, pattern) {
-	const lines = splitLines(input.text);
-	const important = lines.filter((line) => pattern.test(line) || IMPORTANT_PATTERN.test(line) || STATUS_PATTERN.test(line));
-	const text = fitLines([
-		`[command output compressed by ${reducer}; source: ${input.sourceRef}]`,
-		...important,
-		...lines.slice(-20)
-	], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer,
-		lossy: true
-	};
+function isGitCommand(name, command) {
+	return name.includes("git") || /(?:^|\s)git\s/.test(command);
 }
-function reduceShell(input) {
-	const lines = splitLines(input.text);
-	const important = lines.filter((line) => IMPORTANT_PATTERN.test(line));
-	if (important.length === 0) return reduceTail(input, "pi-tail");
-	const text = fitLines([
-		`[shell/log output compressed; source: ${input.sourceRef}]`,
-		...important,
-		"--- final output ---",
-		...lines.slice(-40)
-	], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer: "shell-salience-tail",
-		lossy: true
-	};
+function isPackageCommand(command) {
+	return /(?:^|\s)(?:npm|pnpm|yarn|bun|pip|pip3|uv|poetry)\s/.test(command);
 }
-function reduceSalient(input, reducer) {
-	const lines = splitLines(input.text);
-	if (lines.length < 3) return reduceHead(input, reducer);
-	const marker = omissionMarker(input, reducer);
-	const headBudget = Math.max(1, Math.floor((input.budgetChars - codePointLength(marker)) * .34));
-	const tailBudget = headBudget;
-	const head = takeWholeLinesFromHead(input.text, headBudget);
-	const tail = takeWholeLinesFromTail(input.text, tailBudget);
-	const text = fitLines([
-		head,
-		...lines.filter((line) => IMPORTANT_PATTERN.test(line) || STATUS_PATTERN.test(line)).slice(0, 24),
-		marker,
-		tail
-	], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer,
-		lossy: true
-	};
+function isBuildOrTestCommand(command) {
+	return new RegExp([String.raw`(?:^|\s)(?:tsc|dotnet\s+(?:build|test)|pytest|cargo\s+(?:build|test|check)|go\s+test|mvn\s+test|`, String.raw`gradle|npm\s+(?:test|run\s+build)|pnpm\s+(?:test|build|lint)|yarn\s+(?:test|build|lint))\b`].join("")).test(command);
 }
-/**
-* Keep a source-file skeleton: imports, decorators, declaration signatures,
-* comments at brace depth zero, and every error-signalling line, eliding the
-* remaining bodies with counted markers. Covers brace languages (TS/JS, Rust,
-* Go, Java, C family) and indent blocks (Python); unknown syntax fails open to
-* the next candidate. Output is compressed evidence, not required to parse.
-* @param input - original result text, recovery source, and output budget.
-* @returns a verified candidate, or `null` when the text is not code-like.
+function packagePattern() {
+	return new RegExp([String.raw`(?:ERR!|WARN|warning|error|failed|conflict|peer dep|added\s+\d+|removed\s+\d+|installed|success|`, String.raw`up to date|packages?\s+(?:added|removed|changed)|resolution|No matching distribution|Could not find a version)`].join(""), "i");
+}
+function buildPattern() {
+	return new RegExp([
+		String.raw`(?:error\s+TS\d+|warning\s+TS\d+|FAILED|FAIL\b|AssertionError|expected|actual|`,
+		String.raw`tests?\s+(?:run|passed|failed|skipped)|Build\s+(?:succeeded|FAILED)|\d+\s+Error\(s\)|`,
+		String.raw`\d+\s+Warning\(s\)|Finished\s+test|compilation failed)`
+	].join(""), "i");
+}
+//#endregion
+//#region src/runtime/tokenpilot/read-state.ts
+/** Write-style tool names whose success supersedes earlier reads. */
+const WRITE_TOOLS = /(?:^|[-_])?(?:write|edit|apply_patch|file_write|file_edit|str_replace|replace|multiedit)(?:$|[-_])/i;
+const PATH_KEYS = ["path", "file_path"];
+/** Parse one path out of a tool-call arguments JSON blob. */
+function toolCallPath(argumentsText) {
+	let parsed;
+	try {
+		parsed = JSON.parse(argumentsText);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const record = parsed;
+	for (const key of PATH_KEYS) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+/**
+* Decide whether an oversized read result was superseded by a later mutation
+* of the same file. `readPath` is the read call's target path; events after
+* `readSeq` are scanned for a write-style call on it.
 */
-function reduceCodeSkeleton(input) {
-	const lines = splitLines(input.text);
-	const kept = [];
-	let elided = 0;
-	const flushElided = () => {
-		if (elided > 0) kept.push(`[... ${String(elided)} lines elided ...]`);
-		elided = 0;
+function isSupersededRead(events, readSeq, readPath) {
+	if (readPath === void 0) return false;
+	for (let seq = readSeq + 1; seq < events.length; seq += 1) {
+		const event = events[seq];
+		if (event?.type !== "tool/call") continue;
+		if (!WRITE_TOOLS.test(event.data.name)) continue;
+		if (toolCallPath(event.data.arguments) === readPath) return true;
+	}
+	return false;
+}
+/** Error/warning/info line classifiers used by the omission summary. */
+const ERROR_LINE = /\b(error|failed|failure|fatal|exception|traceback|cannot|unable|denied)\b/i;
+const WARN_LINE = /\b(warn|warning|deprecated)\b/i;
+const SECTION_HEADING = /^#{1,3}\s+(.{1,80})/;
+/**
+* Cluster one omitted line-count into a summary appended to a placeholder
+* marker, giving the model meta-knowledge about what was dropped. Document
+* content (R8) swaps the error/warn/info census for a section-heading list —
+* `0 error, 0 warn, N info` carries no information about a dropped document,
+* while its heading list does.
+*/
+function clusterOmittedLines(text, omittedLines) {
+	if (omittedLines <= 0) return void 0;
+	if (looksLikeDocument(text)) return documentCensus(text, omittedLines);
+	let errors = 0;
+	let warns = 0;
+	let infos = 0;
+	for (const line of text.split("\n")) if (ERROR_LINE.test(line)) errors += 1;
+	else if (WARN_LINE.test(line)) warns += 1;
+	else infos += 1;
+	const parts = [];
+	if (errors > 0) parts.push(`${String(errors)} error`);
+	if (warns > 0) parts.push(`${String(warns)} warn`);
+	if (infos > 0) parts.push(`${String(infos)} info`);
+	if (parts.length === 0) return void 0;
+	return `${String(omittedLines)} lines omitted (${parts.join(", ")})`;
+}
+/** Bounded section-heading list for an omitted document (R8 census). */
+function documentCensus(text, omittedLines) {
+	const titles = [];
+	for (const line of text.split("\n")) {
+		const match = SECTION_HEADING.exec(line);
+		if (match === null) continue;
+		titles.push(match[1].trim());
+		if (titles.length >= 8) break;
+	}
+	if (titles.length === 0) return `${String(omittedLines)} lines omitted (document content)`;
+	let summary = titles.join(" · ");
+	if (summary.length > 240) summary = `${summary.slice(0, 240)}…`;
+	return `${String(omittedLines)} lines omitted (sections: ${summary})`;
+}
+//#endregion
+//#region src/runtime/tokenpilot/sidechannel.ts
+/** One bound side channel. `ask` resolves `undefined` on ANY failure. */
+var SideChannel = class {
+	ctx;
+	options;
+	overrides;
+	/**
+	* @param overrides - per-consumer overrides of the estimator-named options.
+	* The estimator itself never passes them (byte-identical behavior); the
+	* advisory advisor passes its own mode/timeout/output budget so both
+	* consumers share one transport without sharing one configuration.
+	*/
+	constructor(ctx, options, overrides) {
+		this.ctx = ctx;
+		this.options = options;
+		this.overrides = overrides;
+	}
+	get mode() {
+		return this.overrides?.mode ?? this.options.estimatorMode ?? "";
+	}
+	get enabled() {
+		return this.mode === "host" || this.mode === "direct";
+	}
+	async ask(request) {
+		const timeoutMs = this.overrides?.timeoutMs ?? this.options.estimatorTimeoutMs ?? 3e3;
+		const timeout = AbortSignal.timeout(timeoutMs);
+		const signal = typeof AbortSignal.any === "function" ? AbortSignal.any([request.signal, timeout]) : timeout;
+		try {
+			if (this.mode === "host") return await this.askHost(request.system, request.user, signal);
+			if (this.mode === "direct") return await this.askDirect(request.system, request.user, signal);
+			return;
+		} catch {
+			return;
+		}
+	}
+	/** Failure-open wrapper that also records one audit record per call. */
+	async askAudited(request) {
+		const now = Date.now();
+		const text = await this.ask(request);
+		const audit = {
+			ok: text !== void 0,
+			latencyMs: Date.now() - now,
+			...this.identity() !== void 0 ? { channel: this.identity() } : {},
+			...text === void 0 ? { reason: "channel returned no content (timeout, non-2xx, parse failure, or reasoning ate the output-token budget)" } : {}
+		};
+		return {
+			...text === void 0 ? {} : { text },
+			audit
+		};
+	}
+	identity() {
+		if (this.mode === "direct") return `direct:${this.options.estimatorModel ?? ""}`;
+		if (this.mode === "host") {
+			const route = this.resolveHostRoute();
+			return route === void 0 ? "host" : `host:${route.provider}/${route.model}`;
+		}
+	}
+	/** Same host-route resolution as the estimator: explicit, then host default. */
+	resolveHostRoute() {
+		const provider = this.options.estimatorProvider ?? "";
+		const model = this.options.estimatorModel ?? "";
+		if (provider.length > 0 && model.length > 0) return {
+			provider,
+			model
+		};
+		try {
+			const selected = this.ctx.get("agentDefaultModel")?.currentSelection?.();
+			const selectedProvider = selected?.provider ?? "";
+			const selectedModel = selected?.model ?? "";
+			if (selectedProvider.length > 0 && selectedModel.length > 0) return {
+				provider: provider.length > 0 ? provider : selectedProvider,
+				model: model.length > 0 ? model : selectedModel
+			};
+		} catch {}
+	}
+	async askHost(system, user, signal) {
+		let llm;
+		try {
+			llm = this.ctx.get("llm");
+		} catch {
+			return;
+		}
+		if (llm?.stream === void 0) return void 0;
+		const route = this.resolveHostRoute();
+		if (route === void 0) return void 0;
+		let text = "";
+		const stream = llm.stream({
+			provider: route.provider,
+			model: route.model,
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: user
+				}]
+			}],
+			system,
+			temperature: 0,
+			reasoningEffort: "off",
+			maxTokens: this.overrides?.maxTokens ?? 256,
+			signal
+		});
+		for await (const chunk of stream) if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+		else if (chunk.type === "finish" && chunk.text === void 0) break;
+		return text.trim().length > 0 ? text : void 0;
+	}
+	async askDirect(system, user, signal) {
+		const baseUrl = this.options.estimatorBaseUrl;
+		if (baseUrl === void 0 || baseUrl.length === 0) return void 0;
+		const headers = { "content-type": "application/json" };
+		if (this.options.estimatorApiKey !== void 0 && this.options.estimatorApiKey.length > 0) headers.authorization = `Bearer ${this.options.estimatorApiKey}`;
+		const model = this.options.estimatorModel ?? "";
+		if (model.length === 0) return void 0;
+		const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				model,
+				messages: [{
+					role: "system",
+					content: system
+				}, {
+					role: "user",
+					content: user
+				}],
+				temperature: 0,
+				max_tokens: this.overrides?.maxTokens ?? 256
+			}),
+			signal
+		});
+		if (!response.ok) return void 0;
+		const text = (await response.json()).choices?.[0]?.message?.content;
+		return typeof text === "string" && text.trim().length > 0 ? text : void 0;
+	}
+};
+//#endregion
+//#region src/runtime/tokenpilot/estimator.ts
+/** Exponential backoff with a 5-minute cap: 1s, 2s, 4s, … */
+function backoffCooldownMs(failures) {
+	return Math.min(3e5, 1e3 * 2 ** Math.max(0, failures - 1));
+}
+function isCoolingDown(state, now) {
+	return state !== void 0 && state.cooldownUntil > now;
+}
+function buildEstimatorSystemPrompt() {
+	return [
+		"You are a session residual-utility estimator.",
+		"For each numbered historical file read, decide whether the live agent is likely to",
+		"reference that exact file state again later in the session. Reads whose file was",
+		"already rewritten, or whose task has visibly moved on, are expired.",
+		"Answer with ONLY a JSON array: [{\"seq\":<number>,\"expired\":<boolean>}].",
+		"Optionally, if you can estimate how many user turns remain in this session, answer",
+		"with {\"expectedRemainingTurns\":<number>,\"items\":[{\"seq\":<number>,\"expired\":<boolean>}]}",
+		"instead; omit the field when you cannot estimate it."
+	].join(" ");
+}
+function buildEstimatorUserPrompt(samples) {
+	return samples.map((sample) => `{"seq":${String(sample.seq)},"path":${JSON.stringify(sample.path)},"turn":${String(sample.turn)}}`).join("\n");
+}
+function parseVerdictArray(value) {
+	if (!Array.isArray(value)) return [];
+	const verdicts = [];
+	for (const entry of value) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		if (typeof record.seq !== "number" || typeof record.expired !== "boolean") continue;
+		verdicts.push({
+			seq: record.seq,
+			expired: record.expired
+		});
+	}
+	return verdicts;
+}
+/**
+* Parse the estimator answer including the optional session-level
+* `expectedRemainingTurns`. Accepts both the legacy bare verdict array and the
+* extended object form; anything malformed yields no verdicts and no Ŝ.
+*/
+function parseEstimatorAnswerDetailed(text) {
+	const objectStart = text.indexOf("{");
+	const objectEnd = text.lastIndexOf("}");
+	if (objectStart >= 0 && objectEnd > objectStart) try {
+		const parsed = JSON.parse(text.slice(objectStart, objectEnd + 1));
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+			const record = parsed;
+			const verdicts = parseVerdictArray(record.verdicts ?? record.items);
+			if (verdicts.length > 0) {
+				const turns = record.expectedRemainingTurns;
+				if (typeof turns === "number" && Number.isFinite(turns) && turns >= 0) return {
+					verdicts,
+					expectedRemainingTurns: Math.floor(turns)
+				};
+				return { verdicts };
+			}
+		}
+	} catch {}
+	const start = text.indexOf("[");
+	const end = text.lastIndexOf("]");
+	if (start < 0 || end <= start) return { verdicts: [] };
+	try {
+		return { verdicts: parseVerdictArray(JSON.parse(text.slice(start, end + 1))) };
+	} catch {
+		return { verdicts: [] };
+	}
+}
+/** One channel-bound estimator. `ask` resolves undefined on any failure. */
+var Estimator = class {
+	ctx;
+	options;
+	channel;
+	constructor(ctx, options) {
+		this.ctx = ctx;
+		this.options = options;
+		this.channel = new SideChannel(ctx, options);
+	}
+	get enabled() {
+		return this.options.estimatorMode === "host" || this.options.estimatorMode === "direct";
+	}
+	async ask(system, user, signal) {
+		return this.channel.ask({
+			system,
+			user,
+			signal
+		});
+	}
+};
+//#endregion
+//#region src/runtime/tokenpilot/dedup.ts
+/**
+* TokenPilot-inspired A1: byte-identical repeated tool-result dedup.
+*
+* Pure helpers behind the ToolResultPruner fresh pass. The per-session table
+* maps a canonical-content SHA-256 to the first surface seq that produced it;
+* later identical results may be replaced with a pointer placeholder that the
+* recovery tool can resolve back to the original full text via the append-only
+* session log. Only hash+seq metadata is stored — never content.
+*/
+/** Per-session dedup index with insertion-order eviction. */
+var DedupeTable = class {
+	maxEntries;
+	entries = /* @__PURE__ */ new Map();
+	constructor(maxEntries = 2048) {
+		this.maxEntries = maxEntries;
+	}
+	/** Look up the first occurrence for one canonical hash, if any. */
+	get(hash) {
+		return this.entries.get(hash);
+	}
+	/** Record a first occurrence; existing hashes only refresh insertion order. */
+	record(hash, entry) {
+		if (this.entries.has(hash)) return;
+		while (this.entries.size >= this.maxEntries) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) break;
+			this.entries.delete(oldest);
+		}
+		this.entries.set(hash, entry);
+	}
+};
+/** Canonicalize tool-result text for hashing. */
+function canonicalizeForDedupe(text, mode) {
+	if (mode === "exact") return text;
+	return text.replace(/[ \t]+\r?\n/g, "\n").replace(/(^\s+)|(\s+$)/g, "");
+}
+/** SHA-256 hex of the canonicalized text. */
+function dedupeHash(text, mode) {
+	return createHash("sha256").update(canonicalizeForDedupe(text, mode), "utf8").digest("hex");
+}
+/** Concatenated text of an all-text content block list; null when rich. */
+function flattenPlainText(content) {
+	let text = "";
+	for (const block of content) {
+		if (block.type !== "text") return void 0;
+		text += block.text;
+	}
+	return text;
+}
+/** Pointer placeholder pointing at the first occurrence's original event. */
+function dedupePlaceholder(entry, originalChars) {
+	return [
+		`[... identical to the earlier ${entry.toolName} result; first seen at ${entry.sourceRef};`,
+		`original_chars=${String(originalChars)};`,
+		"retrieve with context_compression_retrieve({\"ref\":\"" + entry.sourceRef + "\",\"start_line\":1}) if the omitted evidence is necessary.]"
+	].join(" ");
+}
+//#endregion
+//#region src/runtime/tokenpilot/proposal.ts
+/**
+* TokenPilot-inspired R4: benefit model for the human-gated review pipeline.
+*
+* Pure functions only: the classifier needs no I/O, no session state, and no
+* host services, so every decision is unit-testable and audit-replayable.
+*
+* The cost model follows the TokenPilot paper's cache-accounting view: one
+* merged mutation pays a one-time tail KV-cache refill penalty of
+* `(1−α)·tailTokens`, and every later turn recovers the reclaimed tokens at
+* the cache-hit discount `α`:
+*
+* ```
+* R              = Σ(tokensBefore − tokensAfter)   // net reclaimed tokens
+* paybackTurns   = (1−α)·tailTokens / (α·R)        // one-time refill / per-turn saving
+* expectedSaving = α·R·max(0, Ŝ − paybackTurns)    // Ŝ = estimated remaining turns
+* ```
+*
+* The refill penalty only models mutations of already-cached context. A
+* fresh-stage batch (shaped before its first request) is exempt via
+* `refillPenaltyExempt`: payback is 0 and every reclaimed token saves from
+* the very first turn.
+*
+* `expectedSaving` is only produced when Ŝ is known (the estimator answered
+* with `expectedRemainingTurns`); it is never fabricated from a guess.
+*/
+/**
+* Aggregate the batch-level benefit of a set of reduction candidates.
+*
+* Individual candidates whose replacement would grow the context contribute
+* zero recovery (they never make a batch look better than dropping them).
+*/
+function computeBenefit(candidates, input) {
+	const { alpha, tailTokens, remainingTurns } = input;
+	let recoveredTokens = 0;
+	for (const candidate of candidates) recoveredTokens += Math.max(0, candidate.tokensBefore - candidate.tokensAfter);
+	const penaltyTokens = input.refillPenaltyExempt === true ? 0 : (1 - alpha) * tailTokens;
+	const perTurnSaving = alpha * recoveredTokens;
+	if (perTurnSaving <= 0) return remainingTurns === void 0 ? {
+		recoveredTokens,
+		penaltyTokens
+	} : {
+		recoveredTokens,
+		penaltyTokens,
+		expectedSaving: -penaltyTokens
 	};
-	let depth = 0;
-	let index = 0;
-	const elideBraceBody = () => {
-		const startDepth = depth;
-		index += 1;
-		while (index < lines.length && depth > startDepth) {
-			const body = lines[index];
-			if (body === void 0) break;
-			if (IMPORTANT_PATTERN.test(body)) {
-				flushElided();
-				kept.push(body);
-			} else elided += 1;
-			depth += braceDelta(body);
-			index += 1;
-		}
-		flushElided();
+	const paybackTurns = penaltyTokens / perTurnSaving;
+	if (remainingTurns === void 0) return {
+		recoveredTokens,
+		penaltyTokens,
+		paybackTurns
 	};
-	const keepPythonSignature = (signatureLine) => {
-		index += 1;
-		if (/:\s*$/.test(signatureLine)) {
-			elideIndentedBody(leadingIndent(signatureLine));
-			return;
-		}
-		for (let guard = 0; guard < 6 && index < lines.length; guard += 1) {
-			const next = lines[index];
-			if (next === void 0) break;
-			if (next.trim() !== "" && leadingIndent(next) <= leadingIndent(signatureLine)) break;
-			flushElided();
-			kept.push(next);
-			index += 1;
-			if (/:\s*$/.test(next)) {
-				elideIndentedBody(leadingIndent(next));
-				return;
-			}
-			if (next.trim() !== "" && !/[:,(]\s*$/.test(next)) break;
+	return {
+		recoveredTokens,
+		penaltyTokens,
+		paybackTurns,
+		expectedSaving: perTurnSaving * Math.max(0, remainingTurns - paybackTurns)
+	};
+}
+/**
+* Stable proposal identity: the sha-256 of the serialized item digests, cut to
+* 12 hex chars. Stable across re-enqueues of the same content so a repeated
+* classification cannot duplicate a pending proposal.
+*/
+function proposalId(itemDigests) {
+	const hash = createHash("sha256");
+	for (const digest of itemDigests) hash.update(digest);
+	hash.update(String(itemDigests.length));
+	return hash.digest("hex").slice(0, 12);
+}
+/**
+* Canonical content digest reused from the dedup hash: plain-text results hash
+* through the dedupe canonicalization; rich blocks fall back to canonical JSON
+* so every candidate is freezable.
+*/
+function contentDigest(content) {
+	return dedupeHash(flattenPlainText(content) ?? JSON.stringify(content), "trim-eol");
+}
+function proposalKindFor(candidate, estimatorSeqs) {
+	if (estimatorSeqs?.has(candidate.sourceSeq) === true) return "estimator";
+	if (candidate.reducer === "dedupe-pointer") return "dedup";
+	return "read-state";
+}
+/**
+* Triage planned replacements into the three review-mode buckets, pricing the
+* pass as ONE merged mutation (R1): the tail KV-cache refill penalty is a
+* property of the landing event, not of any single candidate, so it must be
+* paid exactly once per batch. Pricing per candidate overstates the payback
+* N-fold and starves every real batch out of the auto path.
+*
+* Pipeline: zero/negative-recovery candidates are priced out first (they never
+* make a batch look better), the surviving batch is priced once through
+* `computeBenefit`, the verdict is a batch decision, and any high-impact
+* candidate (`tokensBefore ≥ reviewHighImpactTokens`) covers the whole batch
+* into review — splitting the batch would pay a second cache break that the
+* accounting does not model. Review skeletons are grouped one proposal per
+* kind; a proposal id covers every item digest.
+*
+* Batch verdict bands (identical thresholds to the per-candidate model):
+* - any high-impact candidate, or α too small to price a payback → review;
+* - `paybackTurns ≤ 1`, or Ŝ known and `paybackTurns ≤ 0.25·Ŝ` → auto;
+* - Ŝ known and `paybackTurns ∈ (1, 3]` → review;
+* - everything else (Ŝ unknown with a slow payback) → drop.
+*
+* Stage asymmetry: a `'fresh'` batch is exempt from the tail-refill penalty
+* (`refillPenaltyExempt`) — its content was never served, so compressing it
+* breaks no cache and payback is 0 — while a `'history'` batch mutates
+* already-cached context and pays `(1−α)·tailTokens` in full. Without this
+* exemption every realistic fresh batch prices into the drop band and the
+* auto bucket stays structurally unreachable.
+*/
+function classifyCandidates(candidates, input) {
+	const drop = [];
+	const usable = [];
+	for (const candidate of candidates) {
+		if (Math.max(0, candidate.tokensBefore - candidate.tokensAfter) <= 0) {
+			drop.push(candidate);
+			continue;
 		}
+		usable.push(candidate);
+	}
+	if (usable.length === 0) return {
+		auto: [],
+		review: [],
+		drop
 	};
-	const elideIndentedBody = (indent) => {
-		while (index < lines.length) {
-			const body = lines[index];
-			if (body === void 0) break;
-			if (body.trim() !== "" && leadingIndent(body) <= indent) break;
-			if (IMPORTANT_PATTERN.test(body)) {
-				flushElided();
-				kept.push(body);
-				index += 1;
-				continue;
-			}
-			if (isCodeStructureLine(body) || CODE_DECORATOR_PATTERN.test(body)) {
-				flushElided();
-				kept.push(body);
-				keepPythonSignature(body);
-				continue;
+	const benefit = computeBenefit(usable, {
+		alpha: input.alpha,
+		tailTokens: input.tailTokens,
+		...input.remainingTurns !== void 0 ? { remainingTurns: input.remainingTurns } : {},
+		refillPenaltyExempt: input.stage === "fresh"
+	});
+	const payback = benefit.paybackTurns;
+	const highImpact = usable.some((candidate) => candidate.tokensBefore >= input.reviewHighImpactTokens);
+	let verdict;
+	if (highImpact || payback === void 0) verdict = "review";
+	else if (payback <= 1 || input.remainingTurns !== void 0 && payback <= .25 * input.remainingTurns) verdict = "auto";
+	else if (input.remainingTurns !== void 0 && payback <= 3) verdict = "review";
+	else verdict = "drop";
+	if (verdict === "auto") return {
+		auto: usable,
+		review: [],
+		drop
+	};
+	if (verdict === "drop") return {
+		auto: [],
+		review: [],
+		drop: [...drop, ...usable]
+	};
+	const itemsByKind = /* @__PURE__ */ new Map();
+	for (const candidate of usable) {
+		const item = {
+			seq: candidate.sourceSeq,
+			component: candidate.component,
+			kind: proposalKindFor(candidate, input.estimatorSeqs),
+			tokensBefore: candidate.tokensBefore,
+			tokensAfter: candidate.tokensAfter,
+			digest: contentDigest(candidate.content)
+		};
+		const bucket = itemsByKind.get(item.kind) ?? [];
+		bucket.push(item);
+		itemsByKind.set(item.kind, bucket);
+	}
+	const review = [];
+	for (const [kind, items] of itemsByKind) review.push({
+		id: proposalId(items.map((item) => item.digest)),
+		kind,
+		items,
+		benefit
+	});
+	return {
+		auto: [],
+		review,
+		drop
+	};
+}
+//#endregion
+//#region src/runtime/tokenpilot/review-storage.ts
+/** Domain name — `UNIT_NAME_RE` (`/^[a-z][a-z0-9_]*$/`) allows no hyphens. */
+const REVIEW_STORAGE_DOMAIN = "context_compression_review";
+/** The one declared table: one record per session id. */
+const REVIEW_STORAGE_TABLE = "sessions";
+/** Structural validator: accepts exactly the shape this module persists. */
+function reviewSessionRecordValidator() {
+	return { safeParse(value) {
+		if (typeof value !== "object" || value === null) return { success: false };
+		const record = value;
+		if (record.version !== 1 || !Array.isArray(record.proposals)) return { success: false };
+		for (const proposal of record.proposals) {
+			if (typeof proposal !== "object" || proposal === null) return { success: false };
+			const entry = proposal;
+			if (typeof entry.id !== "string" || typeof entry.sessionId !== "string") return { success: false };
+			if (entry.kind !== "estimator" && entry.kind !== "dedup" && entry.kind !== "read-state") return { success: false };
+			if (entry.status !== "pending" && entry.status !== "approved") return { success: false };
+			if (!Number.isSafeInteger(entry.enqueuedTurn) || !Number.isSafeInteger(entry.lastTurnIndex)) return { success: false };
+			if (!Array.isArray(entry.items) || typeof entry.benefit !== "object" || entry.benefit === null) return { success: false };
+			for (const item of entry.items) {
+				if (typeof item !== "object" || item === null) return { success: false };
+				const one = item;
+				if (!Number.isSafeInteger(one.seq) || typeof one.digest !== "string") return { success: false };
 			}
-			elided += 1;
-			index += 1;
 		}
-		flushElided();
+		return {
+			success: true,
+			data: value
+		};
+	} };
+}
+function reviewStorageSpec() {
+	return {
+		name: REVIEW_STORAGE_DOMAIN,
+		version: 1,
+		layout: "per-record",
+		tables: { [REVIEW_STORAGE_TABLE]: { valueSchema: reviewSessionRecordValidator() } }
 	};
-	while (index < lines.length) {
-		const line = lines[index];
-		if (line === void 0) break;
-		const delta = braceDelta(line);
-		if (IMPORTANT_PATTERN.test(line)) {
-			flushElided();
-			kept.push(line);
-			depth += delta;
-			index += 1;
-			continue;
-		}
-		if (isCodeStructureLine(line) || CODE_IMPORT_PATTERN.test(line) || CODE_DECORATOR_PATTERN.test(line)) {
-			flushElided();
-			kept.push(line);
-			depth += delta;
-			if (delta > 0) {
-				elideBraceBody();
-				continue;
-			}
-			if (PYTHON_STRUCTURE_PATTERN.test(line)) {
-				keepPythonSignature(line);
-				continue;
-			}
-			let opened = false;
-			for (let guard = 0; guard < 6 && index + 1 < lines.length; guard += 1) {
-				const next = lines[index + 1];
-				if (next === void 0) break;
-				const nextDelta = braceDelta(next);
-				if (nextDelta === 0 && next.trim() !== "" && !/[:,(]\s*$/.test(next)) break;
-				flushElided();
-				kept.push(next);
-				depth += nextDelta;
-				index += 1;
-				if (nextDelta > 0) {
-					opened = true;
-					break;
-				}
-			}
-			if (opened) elideBraceBody();
-			else index += 1;
+}
+/** Adapter presenting the sync KV face the queue expects over the domain table. */
+var StorageDomainReviewStore = class {
+	table;
+	constructor(table) {
+		this.table = table;
+	}
+	load(sessionId) {
+		const value = this.table.get(sessionId);
+		return typeof value === "object" && value !== null ? value : void 0;
+	}
+	save(sessionId, record) {
+		this.table.put(sessionId, record).catch(() => void 0);
+	}
+	ids() {
+		return [...this.table.keys()];
+	}
+};
+/**
+* Attempt to open the review storage domain through the optional
+* `storageDomain` seam.
+* @param getService - resolved once with the seam name; `undefined` means the
+* host lacks the service.
+* @returns the durable store, or `undefined` when the seam is absent or fails
+* (the caller falls back to the in-memory store and logs one warning).
+*/
+async function openReviewStorage(getService) {
+	let service;
+	try {
+		service = getService("storageDomain");
+	} catch {
+		return;
+	}
+	if (service === void 0 || service === null) return void 0;
+	return new StorageDomainReviewStore((await service.open(reviewStorageSpec())).table(REVIEW_STORAGE_TABLE));
+}
+//#endregion
+//#region src/runtime/tokenpilot/advisor-prompt.ts
+function buildAdvisorSummarySystemPrompt() {
+	return [
+		"You summarize what an agent session is working on, for relevance statistics only.",
+		"Input: the session todolist snapshot and a recent tail of assistant narration.",
+		"Answer with ONLY one JSON object:",
+		"{\"overallTask\":\"<one sentence>\",\"activeSubtasks\":[\"<subtask>\"],\"keywords\":[\"<task keyword>\"]}.",
+		"keywords must be 3-10 short distinctive words describing the CURRENT task.",
+		"Never add commentary; never invent tasks that the input does not support."
+	].join(" ");
+}
+function buildAdvisorSummaryUserPrompt(taskText, tailText) {
+	return [`todolist:\n${taskText}`, tailText.trim().length > 0 ? `recent tail:\n${tailText.trim()}` : "recent tail: (none)"].join("\n\n");
+}
+function buildAdvisorScoringSystemPrompt() {
+	return [
+		"You score how relevant each historical session artifact is to the current task,",
+		"for statistics only. Relevance covers both the artifact content and its comments",
+		"(comment semantics count too). 0 means unrelated, 1 means the live agent will",
+		"very likely need this exact content again.",
+		"Answer with ONLY one JSON object per input line:",
+		"{\"seq\":<number>,\"score\":<number between 0 and 1>,\"reason\":\"<short>\"}",
+		"one per line, same order as the input. Never invent seq values; never add commentary."
+	].join(" ");
+}
+function buildAdvisorScoringUserPrompt(taskText, activeSubtasks, candidates) {
+	return [
+		`task: ${taskText.replace(/\s+/gu, " ").slice(0, 600)}`,
+		activeSubtasks.length > 0 ? `active subtasks: ${activeSubtasks.join("; ").slice(0, 300)}` : "active subtasks: (none)",
+		"",
+		...candidates.map((candidate) => `seq=${String(candidate.seq)} | ${candidate.preview.replace(/\s+/gu, " ")}`)
+	].join("\n");
+}
+/** Pull the first balanced JSON object out of a possibly chatty answer. */
+function firstJsonObject(text) {
+	const start = text.indexOf("{");
+	if (start < 0) return void 0;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let index = start; index < text.length; index += 1) {
+		const char = text[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
 			continue;
 		}
-		if (depth === 0 && CODE_COMMENT_PATTERN.test(line)) {
-			flushElided();
-			kept.push(line);
-		} else elided += 1;
-		depth += delta;
-		index += 1;
+		if (char === "\"") inString = true;
+		else if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) try {
+				const parsed = JSON.parse(text.slice(start, index + 1));
+				return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+			} catch {
+				return;
+			}
+		}
 	}
-	flushElided();
-	return finishSkeleton(kept, lines, input);
 }
-function finishSkeleton(kept, lines, input) {
-	const text = fitLines([
-		`[code output compressed by hypa-code-skeleton; source: ${input.sourceRef}]`,
-		...kept,
-		...lines.slice(-4)
-	], input.budgetChars, input.sourceRef);
-	return text === null ? null : {
-		text,
-		reducer: "hypa-code-skeleton",
-		lossy: true
+function stringList(value, limit) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).slice(0, limit).map((entry) => entry.trim());
+}
+/**
+* Parse one summary answer. Fail-open: `undefined` on any malformed or
+* missing field, so a broken channel can never poison the cached summary.
+*/
+function parseAdvisorSummary(text) {
+	if (text === void 0 || text.trim().length === 0) return void 0;
+	const object = firstJsonObject(text);
+	if (object === void 0) return void 0;
+	const overallTask = object.overallTask;
+	if (typeof overallTask !== "string" || overallTask.trim().length === 0) return void 0;
+	const activeSubtasks = stringList(object.activeSubtasks, 12);
+	const keywords = stringList(object.keywords, 12);
+	if (keywords.length === 0 && activeSubtasks.length === 0) return void 0;
+	return {
+		overallTask: overallTask.trim(),
+		activeSubtasks,
+		keywords
 	};
 }
-/** Net brace delta of one line, ignoring braces inside string literals. */
-function braceDelta(line) {
-	let delta = 0;
-	let quote = null;
-	for (let position = 0; position < line.length; position += 1) {
-		const char = line[position];
-		if (quote !== null) {
-			if (char === "\\") position += 1;
-			else if (char === quote) quote = null;
+/** Extract every balanced JSON object from a JSON-lines or chatty answer. */
+function jsonObjects(text) {
+	const objects = [];
+	let depth = 0;
+	let start = -1;
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
 			continue;
 		}
-		if (char === "\"" || char === "'" || char === "`") {
-			quote = char;
-			continue;
+		if (char === "\"") inString = true;
+		else if (char === "{") {
+			if (depth === 0) start = index;
+			depth += 1;
+		} else if (char === "}") {
+			depth -= 1;
+			if (depth === 0 && start >= 0) {
+				try {
+					const parsed = JSON.parse(text.slice(start, index + 1));
+					if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) objects.push(parsed);
+				} catch {}
+				start = -1;
+			}
 		}
-		if (char === "{") delta += 1;
-		else if (char === "}") delta -= 1;
 	}
-	return delta;
-}
-function leadingIndent(line) {
-	return codePointLength(line) - codePointLength(line.trimStart());
-}
-function isCodeStructureLine(line) {
-	return CODE_STRUCTURE_PATTERN.test(line) || PYTHON_STRUCTURE_PATTERN.test(line);
+	return objects;
 }
 /**
-* Require content evidence of source code: enough declaration, import, or
-* decorator lines among a bounded prefix. Failing this keeps prose, logs, and
-* data on their existing reducers.
-* @param text - normalized result text.
-* @returns whether the text qualifies as source code.
+* Parse one scoring answer. Fail-open: returns the valid rows it could read
+* (`undefined` when nothing valid remains) — a partially garbage answer still
+* contributes its good rows, mirroring the estimator's per-item tolerance.
 */
-function looksLikeSourceCode(text) {
-	const lines = splitLines(text);
-	if (lines.length < 12) return false;
-	let evidence = 0;
-	for (const line of lines.slice(0, 400)) if (isCodeStructureLine(line) || CODE_IMPORT_PATTERN.test(line) || CODE_DECORATOR_PATTERN.test(line)) {
-		evidence += 1;
-		if (evidence >= 3) return true;
-	}
-	return false;
-}
-function omissionMarker(input, reducer) {
-	return `[... ${reducer} omitted content; original_chars=${String(codePointLength(input.text))}; source=${input.sourceRef}; retrieve with context_compression_retrieve ...]`;
-}
-function importantAnchor(text, maxChars) {
-	const lines = splitLines(normalizeTerminalText(text));
-	const chosen = lines.find((line) => IMPORTANT_PATTERN.test(line)) ?? lines.at(-1) ?? "";
-	return Array.from(chosen.trim()).slice(0, maxChars).join("");
-}
-function fitLines(lines, budgetChars, requiredRef) {
-	const unique = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const line of lines) {
-		if (line === "" || seen.has(line)) continue;
-		seen.add(line);
-		unique.push(line);
-	}
-	const output = [];
-	let used = 0;
-	for (const line of unique) {
-		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
-		if (used + cost > budgetChars) continue;
-		output.push(line);
-		used += cost;
+function parseAdvisorScores(text, validSeqs) {
+	if (text === void 0 || text.trim().length === 0) return void 0;
+	const scores = /* @__PURE__ */ new Map();
+	for (const object of jsonObjects(text)) {
+		const seq = object.seq;
+		const score = object.score;
+		if (typeof seq !== "number" || !Number.isSafeInteger(seq) || !validSeqs.has(seq)) continue;
+		if (typeof score !== "number" || !Number.isFinite(score) || score < 0 || score > 1) continue;
+		const reason = typeof object.reason === "string" && object.reason.trim().length > 0 ? object.reason.trim() : void 0;
+		scores.set(seq, {
+			seq,
+			score,
+			...reason !== void 0 ? { reason } : {}
+		});
 	}
-	const text = output.join("\n");
-	return text.includes(requiredRef) ? text : null;
+	return scores.size > 0 ? scores : void 0;
 }
-function takeWholeLinesFromHead(text, budgetChars) {
-	const output = [];
-	let used = 0;
-	for (const line of splitLines(text)) {
-		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
-		if (used + cost > budgetChars) break;
-		output.push(line);
-		used += cost;
-	}
-	if (output.length === 0) return Array.from(text).slice(0, budgetChars).join("");
-	return output.join("\n");
+//#endregion
+//#region src/runtime/tokenpilot/advisor.ts
+/** Character cap for the recent-text fallback and the tail-text summary input. */
+const TAIL_TEXT_CHAR_BUDGET = 4e3;
+/** Score the advisor assigns to candidates it has no answer for. */
+const NEUTRAL_RELEVANCE = .5;
+/** Deterministic djb2-derived hex digest for task-semantics versioning. */
+function versionDigest(text) {
+	let hash = 5381;
+	for (let index = 0; index < text.length; index += 1) hash = (hash * 33 ^ text.charCodeAt(index)) >>> 0;
+	return hash.toString(16).padStart(8, "0");
+}
+/** Truncate on the character basis (Unicode code points), never UTF-16 units. */
+function truncateChars(text, budget) {
+	if (codePointLength(text) <= budget) return text;
+	return Array.from(text).slice(0, budget).join("");
+}
+/** Character cap of one candidate preview line offered to the scoring prompt. */
+const PREVIEW_CHAR_BUDGET = 200;
+/**
+* One candidate face for the scoring prompt: tool-call name plus the head of
+* the result text. Pure and shape-defensive.
+*/
+function advisorCandidatePreview(callName, blocks) {
+	return truncateChars(`${callName} ${textBlocks(blocks)}`.trim(), PREVIEW_CHAR_BUDGET);
 }
-function takeWholeLinesFromTail(text, budgetChars) {
-	const lines = splitLines(text);
-	const output = [];
-	let used = 0;
-	for (let index = lines.length - 1; index >= 0; index--) {
-		const line = lines[index];
-		if (line === void 0) continue;
-		const cost = codePointLength(line) + (output.length === 0 ? 0 : 1);
-		if (used + cost > budgetChars) break;
-		output.unshift(line);
-		used += cost;
+/**
+* Collect the recent assistant narration tail (bounded, oldest-first join) as
+* summary-prompt context. Pure.
+*/
+function collectTailText(events, budget = TAIL_TEXT_CHAR_BUDGET) {
+	const parts = [];
+	let size = 0;
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event?.type !== "assistant/message") continue;
+		const text = textBlocks(event.data).trim();
+		if (text.length === 0) continue;
+		parts.unshift(text);
+		size += codePointLength(text);
+		if (size >= budget) break;
+	}
+	return truncateChars(parts.join("\n"), budget);
+}
+function textBlocks(data) {
+	const content = data?.content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const block of content) if (block?.type === "text" && typeof block.text === "string") parts.push(block.text);
+	return parts.join("\n");
+}
+/** Structured probe of one `todo/write` payload: the list of task strings, or undefined. */
+function extractTodoItems(data) {
+	const todos = data?.todos;
+	const list = Array.isArray(todos) ? todos : Array.isArray(data) ? data : void 0;
+	if (list === void 0 || list.length === 0) return void 0;
+	const items = [];
+	for (const entry of list) {
+		if (typeof entry === "string") {
+			if (entry.trim().length > 0) items.push(entry.trim());
+			continue;
+		}
+		if (entry !== null && typeof entry === "object") {
+			const record = entry;
+			const text = [
+				record.content,
+				record.text,
+				record.title,
+				record.name
+			].find((candidate) => typeof candidate === "string" && candidate.trim().length > 0);
+			if (typeof text === "string") {
+				items.push(text.trim());
+				continue;
+			}
+			items.push(JSON.stringify(record));
+		}
 	}
-	if (output.length === 0) return Array.from(text).slice(-budgetChars).join("");
-	return output.join("\n");
-}
-function splitLines(text) {
-	const lines = text.split("\n");
-	if (text.endsWith("\n")) lines.pop();
-	return lines;
+	return items.length > 0 ? items : void 0;
 }
-function extractCommand(argumentsText) {
-	try {
-		const parsed = JSON.parse(argumentsText);
-		if (typeof parsed !== "object" || parsed === null) return "";
-		const record = parsed;
-		for (const key of [
-			"command",
-			"cmd",
-			"script",
-			"input"
-		]) {
-			const value = record[key];
-			if (typeof value === "string") return value;
+/**
+* Harvest task semantics for the summary/scoring prompts: the most recent
+* `todo/write` event (structured probe first, then the raw JSON string),
+* falling back to recent user/message text. Pure — log in, semantics out.
+*/
+function collectTaskSemantics(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event === void 0 || event.type !== "todo/write") continue;
+		const data = event.data;
+		const items = extractTodoItems(data);
+		if (items !== void 0) {
+			const taskText = truncateChars(items.join("\n"), TAIL_TEXT_CHAR_BUDGET);
+			return {
+				source: "todos",
+				todoVersion: versionDigest(taskText),
+				taskText
+			};
 		}
-	} catch {
-		return "";
+		const raw = truncateChars(JSON.stringify(event.data) ?? "", TAIL_TEXT_CHAR_BUDGET);
+		if (raw.length > 2) return {
+			source: "raw-todo",
+			todoVersion: versionDigest(raw),
+			taskText: raw
+		};
+	}
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event?.type !== "user/message") continue;
+		const text = truncateChars(textBlocks(event.data).trim(), TAIL_TEXT_CHAR_BUDGET);
+		if (text.length === 0) continue;
+		return {
+			source: "messages",
+			todoVersion: versionDigest(text),
+			taskText: text
+		};
 	}
-	return "";
-}
-function looksLikeJson(text) {
-	const trimmed = text.trim();
-	return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
-}
-function isReadTool(name) {
-	return /(?:^|[-_/])(?:read|cat|view|open_file)(?:$|[-_/])/.test(name);
 }
-function isSearchTool(name, command) {
-	return /(?:grep|search|glob|find|ripgrep|rg)/.test(name) || /(?:^|\s)(?:rg|grep|find|fd)\s/.test(command);
+/**
+* Prefix-decay figure: 1 minus the character-pressure-weighted mean relevance
+* of the prefix candidates. Unscored candidates count as neutral 0.5. Pure,
+* deterministic, no LLM and no I/O.
+*/
+function prefixDecay(candidates, scores) {
+	let totalWeight = 0;
+	let weightedRelevance = 0;
+	for (const candidate of candidates) {
+		const weight = candidate.characterPressure > 0 ? candidate.characterPressure : 0;
+		if (weight === 0) continue;
+		totalWeight += weight;
+		weightedRelevance += weight * (scores.get(candidate.seq)?.score ?? NEUTRAL_RELEVANCE);
+	}
+	if (totalWeight === 0) return {
+		decay: 0,
+		weightedChars: 0
+	};
+	return {
+		decay: 1 - weightedRelevance / totalWeight,
+		weightedChars: totalWeight
+	};
 }
-function isShellTool(name) {
-	return /(?:bash|shell|terminal|powershell|pwsh|exec|command)/.test(name);
+/** Lowercase word tokens used by the local keyword-overlap prescreen. */
+function keywordsOf(text) {
+	const matches = text.toLowerCase().match(/[\p{L}\p{N}_-]{3,}/gu) ?? [];
+	return new Set(matches);
 }
-function isGitCommand(name, command) {
-	return name.includes("git") || /(?:^|\s)git\s/.test(command);
+function overlapCount(left, right) {
+	let count = 0;
+	for (const token of right) if (left.has(token)) count += 1;
+	return count;
 }
-function isPackageCommand(command) {
-	return /(?:^|\s)(?:npm|pnpm|yarn|bun|pip|pip3|uv|poetry)\s/.test(command);
+/**
+* Incremental scoring selection: candidates newer than the watermark whose
+* character pressure reaches the token-named floor, ranked by local keyword
+* overlap with the task semantics and cut at the sample limit. When the task
+* semantics changed, the watermark is ignored so every eligible candidate can
+* rescore. Pure.
+*/
+function selectScoringCandidates(candidates, state, input) {
+	const eligible = [];
+	for (const candidate of candidates) {
+		if (!input.taskChanged && candidate.seq <= state.watermarkSeq) continue;
+		if (candidate.characterPressure < input.minChars) continue;
+		eligible.push({
+			...candidate,
+			overlap: overlapCount(input.taskKeywords, keywordsOf(candidate.preview))
+		});
+	}
+	eligible.sort((left, right) => right.overlap - left.overlap || right.characterPressure - left.characterPressure);
+	return eligible.slice(0, input.sampleLimit).map(({ overlap: _overlap, ...candidate }) => candidate);
 }
-function isBuildOrTestCommand(command) {
-	return new RegExp([String.raw`(?:^|\s)(?:tsc|dotnet\s+(?:build|test)|pytest|cargo\s+(?:build|test|check)|go\s+test|mvn\s+test|`, String.raw`gradle|npm\s+(?:test|run\s+build)|pnpm\s+(?:test|build|lint)|yarn\s+(?:test|build|lint))\b`].join("")).test(command);
+function advisorAudit(input, phase, fields) {
+	return {
+		schemaVersion: 1,
+		kind: "advisor-outcome",
+		sessionId: input.sessionId,
+		phase,
+		turnIndex: input.turn,
+		...fields
+	};
 }
-function packagePattern() {
-	return new RegExp([String.raw`(?:ERR!|WARN|warning|error|failed|conflict|peer dep|added\s+\d+|removed\s+\d+|installed|success|`, String.raw`up to date|packages?\s+(?:added|removed|changed)|resolution|No matching distribution|Could not find a version)`].join(""), "i");
+/**
+* One full advisor pass: summary refresh (todo change or every refreshTurns),
+* incremental batch scoring with recertification marks, then the decay
+* figure. State is written only on success; any failure leaves state
+* untouched, emits ok:false audits with reason codes, and never throws.
+*/
+async function runAdvisorPass(state, channel, emit, input) {
+	if (input.task === void 0) return void 0;
+	const taskChanged = invalidateOnTaskChange(state, input.task.todoVersion);
+	const turn = input.turn;
+	if (state.summary === void 0 || turn - state.lastSummaryTurn >= input.advisor.refreshTurns) {
+		const summaryStarted = Date.now();
+		const summaryText = await channel.ask({
+			system: buildAdvisorSummarySystemPrompt(),
+			user: buildAdvisorSummaryUserPrompt(input.task.taskText, input.tailText),
+			signal: input.signal
+		});
+		const summaryLatencyMs = Date.now() - summaryStarted;
+		const summary = input.signal.aborted ? void 0 : parseAdvisorSummary(summaryText);
+		if (summary === void 0) {
+			emit(advisorAudit(input, "summary", {
+				ok: false,
+				latencyMs: summaryLatencyMs,
+				...input.signal.aborted ? { reason: "aborted" } : summaryText === void 0 ? { reason: "channel-empty" } : { reason: "parse-failed" }
+			}));
+			return;
+		}
+		state.summary = {
+			...summary,
+			todoVersion: input.task.todoVersion,
+			turn
+		};
+		state.lastSummaryTurn = turn;
+		emit(advisorAudit(input, "summary", {
+			ok: true,
+			latencyMs: summaryLatencyMs
+		}));
+	}
+	const summary = state.summary;
+	if (summary === void 0) return void 0;
+	const sampled = selectScoringCandidates(input.candidates, state, {
+		taskKeywords: keywordsOf(`${input.task.taskText}\n${summary.keywords.join(" ")}`),
+		minChars: charsForTokens(input.advisor.minTokens),
+		sampleLimit: input.advisor.sampleLimit,
+		taskChanged
+	});
+	let scored = 0;
+	let highestScored = 0;
+	if (sampled.length > 0) {
+		const scoringStarted = Date.now();
+		const scoresText = await channel.ask({
+			system: buildAdvisorScoringSystemPrompt(),
+			user: buildAdvisorScoringUserPrompt(input.task.taskText, summary.activeSubtasks, sampled),
+			signal: input.signal
+		});
+		const scoringLatencyMs = Date.now() - scoringStarted;
+		const scores = input.signal.aborted ? void 0 : parseAdvisorScores(scoresText, new Set(sampled.map((item) => item.seq)));
+		if (scores === void 0 || scores.size === 0) {
+			emit(advisorAudit(input, "scoring", {
+				ok: false,
+				sampledCount: sampled.length,
+				latencyMs: scoringLatencyMs,
+				...input.signal.aborted ? { reason: "aborted" } : scoresText === void 0 ? { reason: "channel-empty" } : { reason: "parse-failed" }
+			}));
+			return;
+		}
+		for (const candidate of sampled) {
+			const answer = scores.get(candidate.seq);
+			if (answer === void 0) continue;
+			recordScore(state, candidate.seq, {
+				score: answer.score,
+				turn
+			});
+			scored += 1;
+			if (candidate.seq > highestScored) highestScored = candidate.seq;
+			if (answer.score < input.advisor.scoreThreshold) recordRecertified(state, candidate.seq, turn);
+		}
+		emit(advisorAudit(input, "scoring", {
+			ok: true,
+			sampledCount: sampled.length,
+			latencyMs: scoringLatencyMs
+		}));
+		if (highestScored > state.watermarkSeq) state.watermarkSeq = highestScored;
+	}
+	const decay = prefixDecay(input.candidates, state.scores);
+	state.lastDecay = {
+		decay: decay.decay,
+		weightedChars: decay.weightedChars,
+		turn
+	};
+	emit(advisorAudit(input, "decay", {
+		ok: true,
+		sampledCount: scored,
+		decay: decay.decay,
+		weightedChars: decay.weightedChars,
+		latencyMs: 0
+	}));
+	return {
+		decay: decay.decay,
+		weightedChars: decay.weightedChars,
+		sampled: sampled.length
+	};
 }
-function buildPattern() {
-	return new RegExp([
-		String.raw`(?:error\s+TS\d+|warning\s+TS\d+|FAILED|FAIL\b|AssertionError|expected|actual|`,
-		String.raw`tests?\s+(?:run|passed|failed|skipped)|Build\s+(?:succeeded|FAILED)|\d+\s+Error\(s\)|`,
-		String.raw`\d+\s+Warning\(s\)|Finished\s+test|compilation failed)`
-	].join(""), "i");
+/**
+* Convenience entry used by the pruner: fetch-or-create the session state and
+* run one pass against it.
+*/
+async function runSessionAdvisorPass(session, channel, emit, input) {
+	const state = getAdvisorState(session);
+	if (state.inFlight) return void 0;
+	state.inFlight = true;
+	try {
+		return await runAdvisorPass(state, channel, emit, {
+			...input,
+			sessionId: input.sessionId ?? String(session.id)
+		});
+	} finally {
+		state.inFlight = false;
+	}
 }
 //#endregion
 //#region src/runtime/deepseek-official-pricing.ts
@@ -2727,18 +4062,25 @@ function deriveAdaptiveTokenBounds(input) {
 	if (reclaimedLowerBoundTokens === 0) return unknown("reclaim-not-positive-after-margin");
 	let identity;
 	let exactPrefixLowerBoundTokens = 0;
+	let characterDerivedPrefix = false;
 	const seen = /* @__PURE__ */ new Set();
 	for (const node of input.measuredNodes) {
 		if (!isCount(node.seq) || seen.has(node.seq)) return unknown("invalid-measured-node-sequence");
 		seen.add(node.seq);
-		if (node.seq >= input.earliestChangedSeq || node.count.kind !== "exact-tokenizer") continue;
-		if (!isCount(node.count.tokens)) return unknown("invalid-exact-prefix-count");
-		if (node.count.tokenizerRevision !== input.expectedTokenizerRevision) return unknown("exact-prefix-tokenizer-revision-mismatch");
-		if (identity !== void 0 && (identity.tokenizerId !== node.count.tokenizerId || identity.tokenizerRevision !== node.count.tokenizerRevision)) return unknown("exact-prefix-tokenizer-identity-mismatch");
-		identity ??= node.count;
-		exactPrefixLowerBoundTokens += node.count.tokens;
+		if (node.seq >= input.earliestChangedSeq) continue;
+		if (node.count.kind === "exact-tokenizer") {
+			if (!isCount(node.count.tokens)) return unknown("invalid-exact-prefix-count");
+			if (node.count.tokenizerRevision !== input.expectedTokenizerRevision) return unknown("exact-prefix-tokenizer-revision-mismatch");
+			if (identity !== void 0 && (identity.tokenizerId !== node.count.tokenizerId || identity.tokenizerRevision !== node.count.tokenizerRevision)) return unknown("exact-prefix-tokenizer-identity-mismatch");
+			identity ??= node.count;
+			exactPrefixLowerBoundTokens += node.count.tokens;
+		} else {
+			exactPrefixLowerBoundTokens += charsToTokens(node.characterPressure);
+			characterDerivedPrefix = true;
+		}
 		if (!isCount(exactPrefixLowerBoundTokens)) return unknown("exact-prefix-overflow");
 	}
+	if (characterDerivedPrefix) measurementKind = "characters";
 	const accounted = exactPrefixLowerBoundTokens + reclaimedLowerBoundTokens;
 	if (!isCount(accounted) || accounted > input.previousPromptTokens) return unknown("adaptive-bounds-exceed-previous-prompt");
 	return {
@@ -2870,12 +4212,14 @@ var ToolResultPruner = class extends Service {
 			activeRequestBoundaries: /* @__PURE__ */ new WeakMap(),
 			tailTrimBoundaryAttempts: /* @__PURE__ */ new WeakMap(),
 			policyResolutionAudits: /* @__PURE__ */ new WeakMap(),
-			reviewStore: new MemoryReviewStore(),
+			reviewStore: sharedReviewStore(),
 			reviewQueues: /* @__PURE__ */ new WeakMap(),
 			reviewClocks: /* @__PURE__ */ new WeakMap(),
 			estimatorRemainingTurns: /* @__PURE__ */ new WeakMap(),
+			advisorChannels: /* @__PURE__ */ new WeakMap(),
 			reviewSummaries: /* @__PURE__ */ new WeakMap()
 		};
+		ctx.effect(() => registerReviewPruner(this), "contextCompressionSelector.reviewRegistry()");
 		openReviewStorage((name) => this.ctx.get(name)).then((store) => {
 			if (store !== void 0) this.state.reviewStore = store;
 		}).catch(() => {
@@ -2928,6 +4272,7 @@ var ToolResultPruner = class extends Service {
 				ctx.logger.warn("context-compression review turn-boundary pass failed open: %o", error);
 			}
 			this.postflightEstimatorPass(agent.session, signal).catch(() => void 0);
+			this.postflightAdvisorPass(agent.session, turn, signal).catch(() => void 0);
 		});
 	}
 	/**
@@ -2964,15 +4309,14 @@ var ToolResultPruner = class extends Service {
 		const landed = [];
 		if (policy.nativeToolResultEnabled) {
 			const eligible = this.snapshot(session, view).filter((candidate) => !this.isRecoveryExempt(session, candidate));
-			const exactUnavailable = eligible.some((candidate) => candidate.count.kind !== "exact-tokenizer");
-			if (exactUnavailable) this.warnExactUnavailable(session, view, "native");
+			if (eligible.some((candidate) => candidate.count.kind !== "exact-tokenizer")) this.warnExactUnavailable(session, view, "native");
 			const planned = eligible.map((candidate) => this.planNative(candidate, session, stage, policy, view)).filter((entry) => entry !== null);
-			landed.push(...this.landAll(session, this.triageForReview(session, policy, planned)));
+			landed.push(...this.landAll(session, this.triageForReview(session, policy, planned, "history")));
 			if (landed.length === 0) {
-				const exact = eligible.flatMap((candidate) => candidate.count.kind === "exact-tokenizer" ? [candidate.count.tokens] : []);
-				this.auditComponent(session, policy, "native-tool-result", "pressure", "skipped", exactUnavailable ? "exact-tokenizer-unavailable" : exact.length === 0 ? "no-tool-result-candidates" : Math.max(...exact) <= policy.nativeTriggerTokens ? "at-or-below-trigger" : planned.length === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
-					measurementKind: exactUnavailable ? "unavailable" : "exact-tokenizer",
-					...exact.length === 0 ? {} : { currentTokens: Math.max(...exact) },
+				const chars = eligible.map((candidate) => candidate.characterPressure);
+				this.auditComponent(session, policy, "native-tool-result", "pressure", "skipped", chars.length === 0 ? "no-tool-result-candidates" : Math.max(...chars) <= charsForTokens(policy.nativeTriggerTokens) ? "at-or-below-trigger" : planned.length === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
+					measurementKind: "characters",
+					...chars.length === 0 ? {} : { currentTokens: charsToTokens(Math.max(...chars)) },
 					triggerTokens: policy.nativeTriggerTokens,
 					targetTokens: policy.nativeTargetTokens
 				});
@@ -2989,13 +4333,13 @@ var ToolResultPruner = class extends Service {
 			if (historyOutcome.kind === "planned") {
 				const capacityPressure = this.capacityPressureActive(session, view, policy);
 				historyAllowed = this.adaptiveHistoryAllowed(session, view, historyOutcome.plans, capacityPressure);
-				if (historyAllowed) landed.push(...this.landAll(session, this.triageForReview(session, policy, historyOutcome.plans)));
+				if (historyAllowed) landed.push(...this.landAll(session, this.triageForReview(session, policy, historyOutcome.plans, "history")));
 			}
 		} else {
 			historyAllowed = this.historyAllowed(session, policy, view);
 			if (historyAllowed) {
 				historyOutcome = this.planHistoricalAging(session, policy, view);
-				if (historyOutcome.kind === "planned") landed.push(...this.landAll(session, this.triageForReview(session, policy, historyOutcome.plans)));
+				if (historyOutcome.kind === "planned") landed.push(...this.landAll(session, this.triageForReview(session, policy, historyOutcome.plans, "history")));
 			}
 		}
 		if (!landed.some((entry) => entry.stage === "pressure")) this.auditHistoryEvaluation(session, policy, view, historyAllowed, historyOutcome);
@@ -3127,8 +4471,7 @@ var ToolResultPruner = class extends Service {
 		for (const candidate of this.snapshot(session, measureForCompaction(this.ctx, session))) {
 			if (samples.length >= 3) break;
 			if (candidate.event.data.turn === void 0) continue;
-			const tokens = exactTokens(candidate.count);
-			if (tokens === void 0 || tokens <= policy.freshTriggerTokens) continue;
+			if (candidate.characterPressure <= charsForTokens(policy.freshTriggerTokens)) continue;
 			const path = toolCallPath(candidate.call.arguments);
 			if (path === void 0) continue;
 			if (isSupersededRead(events, candidate.seq, path)) continue;
@@ -3177,6 +4520,88 @@ var ToolResultPruner = class extends Service {
 		});
 	}
 	/**
+	* Advisory advisor pass at the turn boundary, strictly fire-and-forget.
+	* Produces todolist-bound tail-task summaries, incremental relevance
+	* scores, and a prefix-decay figure — all observational. Every short
+	* circuit below (mode off, re-entry, cooldown, no task semantics, no
+	* direct endpoint) returns without touching any state the pruning chain
+	* reads, so the default configuration adds exactly zero behavior.
+	*/
+	async postflightAdvisorPass(session, turn, signal) {
+		const policy = this.activePolicy(session);
+		const presetOptions = policy?.presetOptions;
+		const advisor = presetOptions?.advisor;
+		if (policy === void 0 || presetOptions === void 0 || advisor === void 0 || advisor.mode === "") return;
+		const advisorState = getAdvisorState(session);
+		if (advisorState.inFlight) return;
+		if (isCoolingDown(advisorState.failures, Date.now())) return;
+		const events = sessionEvents(session);
+		const task = collectTaskSemantics(events);
+		if (task === void 0) return;
+		const settings = this.activeSettings(session).presetOptions ?? {};
+		if (advisor.mode === "direct" && (settings.estimatorBaseUrl === void 0 || settings.estimatorBaseUrl.length === 0 || settings.estimatorModel === void 0 || settings.estimatorModel.length === 0)) {
+			emitCompressionAudit(this.ctx.logger, {
+				schemaVersion: 1,
+				kind: "advisor-outcome",
+				sessionId: String(session.id),
+				phase: "summary",
+				channel: "direct",
+				ok: false,
+				turnIndex: turn,
+				reason: "no-direct-endpoint",
+				latencyMs: 0
+			});
+			advisorState.failures = {
+				failures: (advisorState.failures?.failures ?? 0) + 1,
+				cooldownUntil: Date.now() + backoffCooldownMs((advisorState.failures?.failures ?? 0) + 1)
+			};
+			return;
+		}
+		let channel = this.state.advisorChannels.get(session);
+		if (channel === void 0) {
+			channel = new SideChannel(this.ctx, settings, {
+				mode: advisor.mode,
+				timeoutMs: advisor.timeoutMs,
+				maxTokens: 512
+			});
+			this.state.advisorChannels.set(session, channel);
+		}
+		const view = measureForCompaction(this.ctx, session);
+		const candidates = this.snapshot(session, view).filter((candidate) => !this.isRecoveryExempt(session, candidate)).map((candidate) => ({
+			seq: candidate.seq,
+			characterPressure: candidate.characterPressure,
+			preview: advisorCandidatePreview(candidate.call.name, candidate.event.data.message.content)
+		}));
+		let sawFailure = false;
+		const outcome = await runSessionAdvisorPass(session, channel, (record) => {
+			if (record.ok === false) sawFailure = true;
+			emitCompressionAudit(this.ctx.logger, record);
+		}, {
+			profile: policy.profile,
+			sessionId: String(session.id),
+			turn,
+			candidates,
+			task: {
+				source: task.source,
+				todoVersion: task.todoVersion,
+				taskText: task.taskText
+			},
+			advisor: {
+				refreshTurns: advisor.refreshTurns,
+				scoreThreshold: advisor.scoreThreshold,
+				sampleLimit: advisor.sampleLimit,
+				minTokens: advisor.minTokens
+			},
+			tailText: collectTailText(events),
+			signal
+		});
+		if (outcome === void 0 && sawFailure && signal.aborted === false) advisorState.failures = {
+			failures: (advisorState.failures?.failures ?? 0) + 1,
+			cooldownUntil: Date.now() + backoffCooldownMs((advisorState.failures?.failures ?? 0) + 1)
+		};
+		else if (outcome !== void 0) advisorState.failures = void 0;
+	}
+	/**
 	* The per-session review queue, or `undefined` while review mode is off
 	* (every review path must then behave exactly like before).
 	*/
@@ -3228,7 +4653,7 @@ var ToolResultPruner = class extends Service {
 	* The digest freezes each candidate's ORIGINAL surface content, so the apply
 	* point can prove "what is removed now is what was approved then".
 	*/
-	triageForReview(session, policy, plans) {
+	triageForReview(session, policy, plans, stage = "history") {
 		const queue = this.reviewQueueFor(session, policy);
 		if (queue === void 0 || plans.length === 0) return plans;
 		const presetOptions = policy.presetOptions;
@@ -3239,7 +4664,8 @@ var ToolResultPruner = class extends Service {
 			tailTokens: Math.max(1, policy.historyKeepRecentTokens),
 			reviewHighImpactTokens: presetOptions.reviewHighImpactTokens,
 			...this.state.estimatorRemainingTurns.get(session) === void 0 ? {} : { remainingTurns: this.state.estimatorRemainingTurns.get(session) },
-			estimatorSeqs
+			estimatorSeqs,
+			stage
 		};
 		const classified = classifyCandidates(plans.map((plan) => ({
 			sourceSeq: plan.sourceSeq,
@@ -3744,9 +5170,8 @@ var ToolResultPruner = class extends Service {
 		const plans = /* @__PURE__ */ new Map();
 		let freshPlanned = 0;
 		const dedupeEnabled = policy.presetOptions?.dedupeToolResults === true;
-		const exactCandidateTokens = candidates.map((candidate) => exactTokens(candidate.count));
-		const exactAvailable = exactCandidateTokens.every((tokens) => tokens !== void 0);
-		const maxCandidateTokens = exactAvailable ? Math.max(...exactCandidateTokens) : void 0;
+		const candidateChars = candidates.map((candidate) => candidate.characterPressure);
+		const maxCandidateChars = candidateChars.length === 0 ? void 0 : Math.max(...candidateChars);
 		if (policy.freshEnabled) {
 			if (candidates.some((candidate) => candidate.call.name !== "context_compression_retrieve" && candidate.count.kind !== "exact-tokenizer")) this.warnExactUnavailable(session, view, "fresh");
 			for (const candidate of candidates) {
@@ -3765,41 +5190,39 @@ var ToolResultPruner = class extends Service {
 				}
 			}
 		}
-		let aggregateInputTokens;
+		let aggregateInputChars;
 		let aggregatePlanned = 0;
 		if (policy.aggregateEnabled) {
-			const aggregateAvailable = exactAvailable;
-			if (!aggregateAvailable) this.warnExactUnavailable(session, view, "aggregate");
-			let total = aggregateAvailable ? candidates.reduce((sum, candidate) => sum + (plans.get(candidate.seq)?.tokensAfter ?? exactTokens(candidate.count) ?? 0), 0) : 0;
-			if (aggregateAvailable) aggregateInputTokens = total;
-			if (aggregateAvailable && total > policy.aggregateTriggerTokens) {
-				const remaining = candidates.filter((candidate) => !this.isRecoveryExempt(session, candidate)).sort((a, b) => Number(isError(a)) - Number(isError(b)) || (plans.get(b.seq)?.tokensAfter ?? exactTokens(b.count) ?? 0) - (plans.get(a.seq)?.tokensAfter ?? exactTokens(a.count) ?? 0));
+			let total = candidates.reduce((sum, candidate) => sum + (plans.get(candidate.seq)?.charsAfter ?? candidate.characterPressure), 0);
+			aggregateInputChars = total;
+			if (total > charsForTokens(policy.aggregateTriggerTokens)) {
+				const remaining = candidates.filter((candidate) => !this.isRecoveryExempt(session, candidate)).sort((a, b) => Number(isError(a)) - Number(isError(b)) || (plans.get(b.seq)?.charsAfter ?? b.characterPressure) - (plans.get(a.seq)?.charsAfter ?? a.characterPressure));
 				for (const candidate of remaining) {
 					const previous = plans.get(candidate.seq);
 					const plan = this.planAggregate(candidate, session, view);
-					const previousTokens = previous?.tokensAfter ?? exactTokens(candidate.count) ?? 0;
-					if (plan === null || plan.tokensAfter >= previousTokens) continue;
+					const previousChars = previous?.charsAfter ?? candidate.characterPressure;
+					if (plan === null || plan.charsAfter >= previousChars) continue;
 					plans.set(candidate.seq, plan);
 					aggregatePlanned += 1;
-					total -= previousTokens - plan.tokensAfter;
-					if (total <= policy.aggregateTargetTokens) break;
+					total -= previousChars - plan.charsAfter;
+					if (total <= charsForTokens(policy.aggregateTargetTokens)) break;
 				}
-				if (total > policy.aggregateTargetTokens) this.ctx.logger.warn("context-compression fresh aggregate residual: %d tokens exceed target %d", total, policy.aggregateTargetTokens);
+				if (total > charsForTokens(policy.aggregateTargetTokens)) this.ctx.logger.warn("context-compression fresh aggregate residual: %d characters exceed target %d", total, charsForTokens(policy.aggregateTargetTokens));
 			}
 		}
 		const freshCandidates = candidates.map((candidate) => plans.get(candidate.seq)).filter((plan) => plan !== void 0);
-		const landed = this.landAll(session, this.triageForReview(session, policy, freshCandidates));
+		const landed = this.landAll(session, this.triageForReview(session, policy, freshCandidates, "fresh"));
 		const freshLanded = landed.some((entry) => entry.stage === "fresh" && plans.get(entry.originalSeq)?.component === "fresh");
 		const aggregateLanded = landed.some((entry) => entry.stage === "fresh" && plans.get(entry.originalSeq)?.component === "aggregate");
-		if (!freshLanded) this.auditComponent(session, policy, "fresh", "fresh", policy.freshEnabled ? "skipped" : "disabled", !policy.freshEnabled ? "profile-policy" : !exactAvailable ? "exact-tokenizer-unavailable" : (maxCandidateTokens ?? 0) <= policy.freshTriggerTokens ? "at-or-below-trigger" : freshPlanned > 0 && aggregatePlanned > 0 ? "superseded-by-aggregate" : freshPlanned === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
-			measurementKind: exactAvailable ? "exact-tokenizer" : "unavailable",
-			...maxCandidateTokens === void 0 ? {} : { currentTokens: maxCandidateTokens },
+		if (!freshLanded) this.auditComponent(session, policy, "fresh", "fresh", policy.freshEnabled ? "skipped" : "disabled", !policy.freshEnabled ? "profile-policy" : (maxCandidateChars ?? 0) <= charsForTokens(policy.freshTriggerTokens) ? "at-or-below-trigger" : freshPlanned > 0 && aggregatePlanned > 0 ? "superseded-by-aggregate" : freshPlanned === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
+			measurementKind: "characters",
+			...maxCandidateChars === void 0 ? {} : { currentTokens: charsToTokens(maxCandidateChars) },
 			triggerTokens: policy.freshTriggerTokens,
 			targetTokens: policy.freshTargetTokens
 		});
-		if (!aggregateLanded) this.auditComponent(session, policy, "aggregate", "fresh", policy.aggregateEnabled ? "skipped" : "disabled", !policy.aggregateEnabled ? "profile-policy" : !exactAvailable ? "exact-tokenizer-unavailable" : (aggregateInputTokens ?? 0) <= policy.aggregateTriggerTokens ? "at-or-below-trigger" : aggregatePlanned === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
-			measurementKind: exactAvailable ? "exact-tokenizer" : "unavailable",
-			...aggregateInputTokens === void 0 ? {} : { currentTokens: aggregateInputTokens },
+		if (!aggregateLanded) this.auditComponent(session, policy, "aggregate", "fresh", policy.aggregateEnabled ? "skipped" : "disabled", !policy.aggregateEnabled ? "profile-policy" : (aggregateInputChars ?? 0) <= charsForTokens(policy.aggregateTriggerTokens) ? "at-or-below-trigger" : aggregatePlanned === 0 ? "no-valid-reduction" : "recovery-tool-unavailable", {
+			measurementKind: "characters",
+			...aggregateInputChars === void 0 ? {} : { currentTokens: charsToTokens(aggregateInputChars) },
 			triggerTokens: policy.aggregateTriggerTokens,
 			targetTokens: policy.aggregateTargetTokens
 		});
@@ -3838,16 +5261,15 @@ var ToolResultPruner = class extends Service {
 	}
 	planNative(candidate, session, stage, policy, view) {
 		if (this.isRecoveryExempt(session, candidate)) return null;
-		const tokensBefore = exactTokens(candidate.count);
-		if (tokensBefore === void 0 || tokensBefore <= policy.nativeTriggerTokens) return null;
+		if (candidate.characterPressure <= charsForTokens(policy.nativeTriggerTokens)) return null;
 		const result = candidate.event.data.message.content[0];
 		if (onlyTextBlocks(result.content) === null) return null;
 		const sourceSeq = rootToolResultSeq(session, candidate.seq);
-		const marker = recoveryMarker(sourceRef(session, sourceSeq), "tool result middle pruned");
+		const marker = (startLine) => recoveryMarker(sourceRef(session, sourceSeq), "tool result middle pruned", startLine);
 		let head = this.state.config.headChars;
 		let tail = this.state.config.tailChars;
 		for (let attempt = 0; attempt < 10; attempt += 1) {
-			const threshold = head + codePointLength(marker) + tail;
+			const threshold = head + codePointLength(marker(1)) + tail;
 			const content = nativePruneContent(result.content, threshold, head, tail, marker);
 			if (content !== null) {
 				const plan = this.plan(candidate, content, sourceSeq, "native-head-tail", stage, "native-tool-result", void 0, view);
@@ -3870,8 +5292,7 @@ var ToolResultPruner = class extends Service {
 		const result = candidate.event.data.message.content[0];
 		const text = flattenPlainText(result.content);
 		if (text === void 0) return null;
-		const tokensBefore = exactTokens(candidate.count);
-		if (tokensBefore === void 0 || tokensBefore <= policy.freshTriggerTokens) return null;
+		if (candidate.characterPressure <= charsForTokens(policy.freshTriggerTokens)) return null;
 		let table = this.state.dedupeTables.get(session);
 		if (table === void 0) {
 			table = new DedupeTable();
@@ -3899,8 +5320,7 @@ var ToolResultPruner = class extends Service {
 	planFresh(candidate, session, policy, view) {
 		if (typeof candidate.event.surfaceOp === "object") return null;
 		const result = candidate.event.data.message.content[0];
-		const tokensBefore = exactTokens(candidate.count);
-		if (tokensBefore === void 0 || tokensBefore <= policy.freshTriggerTokens) return null;
+		if (candidate.characterPressure <= charsForTokens(policy.freshTriggerTokens)) return null;
 		const sourceSeq = candidate.seq;
 		const sourceRef$1 = sourceRef(session, sourceSeq);
 		const textBlock = onlyTextBlock(result.content);
@@ -3921,8 +5341,11 @@ var ToolResultPruner = class extends Service {
 					const plan = this.plan(candidate, [{
 						...textBlock,
 						text: output.text
-					}], sourceSeq, output.reducer, "fresh", "fresh", void 0, view, { noNetSavingsGuard: policy.presetOptions?.noNetSavingsGuard === true });
-					if (plan !== null && plan.tokensAfter <= policy.freshTargetTokens) return plan;
+					}], sourceSeq, output.reducer, "fresh", "fresh", void 0, view, {
+						noNetSavingsGuard: policy.presetOptions?.noNetSavingsGuard === true,
+						...output.elidedLines === void 0 ? {} : { elidedLines: output.elidedLines }
+					});
+					if (plan !== null && plan.charsAfter <= charsForTokens(policy.freshTargetTokens)) return plan;
 				}
 				if (budgetChars === 1) break;
 				budgetChars = Math.max(1, Math.floor(budgetChars / 2));
@@ -3934,6 +5357,8 @@ var ToolResultPruner = class extends Service {
 		if (isError(candidate)) return this.planErrorEvidence(candidate, session, view, stage, targetTokens, component, historyMode);
 		const sourceSeq = rootToolResultSeq(session, candidate.seq);
 		const sourceRef$2 = sourceRef(session, sourceSeq);
+		const redacted = candidate.event.data.message.content[0];
+		if (onlyTextBlocks(redacted.content) === null) return null;
 		const text = [
 			"[Tool result reduced to satisfy the completed-step aggregate budget]",
 			`tool: ${candidate.call.name}`,
@@ -3980,17 +5405,8 @@ var ToolResultPruner = class extends Service {
 	planHistoricalAging(session, policy, view) {
 		const candidates = this.snapshot(session, view);
 		const events = sessionEvents(session);
-		const exact = [];
-		for (const candidate of candidates) {
-			const tokens = exactTokens(candidate.count);
-			if (tokens === void 0) {
-				this.warnExactUnavailable(session, view, "history");
-				return { kind: "exact-tokenizer-unavailable" };
-			}
-			exact.push(tokens);
-		}
-		const total = exact.reduce((sum, tokens) => sum + tokens, 0);
-		const trigger = policy.historyTriggerTokens;
+		const total = candidates.map((candidate) => candidate.characterPressure).reduce((sum, charsOfNode) => sum + charsOfNode, 0);
+		const trigger = charsForTokens(policy.historyTriggerTokens);
 		const deadline = policy.microDeadlineTokens;
 		const lastChance = deadline !== void 0 && view.totalTokens >= deadline;
 		if (total <= trigger && !lastChance) return { kind: "below-profile-trigger" };
@@ -4005,9 +5421,10 @@ var ToolResultPruner = class extends Service {
 		if (eligible.length === 0) return safe.length === 0 ? { kind: "no-safe-candidates" } : { kind: "protected-working-set" };
 		const planned = [];
 		let reclaim = 0;
-		const microTarget = deadline === void 0 ? void 0 : Math.max(0, deadline - policy.historyMinReclaimTokens);
-		const required = Math.max(policy.historyMinReclaimTokens, total - trigger, ...microTarget === void 0 ? [] : [view.totalTokens - microTarget]);
-		const batchTarget = microTarget === void 0 ? policy.historyMinReclaimTokens : required;
+		const minReclaimChars = charsForTokens(policy.historyMinReclaimTokens);
+		const microTarget = deadline === void 0 ? void 0 : Math.max(0, charsForTokens(deadline) - minReclaimChars);
+		const required = Math.max(minReclaimChars, total - trigger, ...microTarget === void 0 ? [] : [charsForTokens(view.totalTokens) - microTarget]);
+		const batchTarget = microTarget === void 0 ? minReclaimChars : required;
 		for (const candidate of eligible) {
 			const result = candidate.event.data.message.content[0];
 			const block = onlyTextBlock(result.content);
@@ -4018,7 +5435,7 @@ var ToolResultPruner = class extends Service {
 					const plan = this.planAggregate(candidate, session, view, "superseded-read-whole-result", "pressure", void 0, "history", policy.historyMode);
 					if (plan === null) continue;
 					planned.push(plan);
-					reclaim += plan.tokensBefore - plan.tokensAfter;
+					reclaim += plan.charsBefore - plan.charsAfter;
 					if (reclaim >= required) break;
 					continue;
 				}
@@ -4028,7 +5445,7 @@ var ToolResultPruner = class extends Service {
 				const plan = this.planAggregate(candidate, session, view, "historical-rich-whole-result", "pressure", void 0, "history", policy.historyMode);
 				if (plan === null) continue;
 				planned.push(plan);
-				reclaim += plan.tokensBefore - plan.tokensAfter;
+				reclaim += plan.charsBefore - plan.charsAfter;
 				if (reclaim >= required) break;
 				continue;
 			}
@@ -4058,10 +5475,10 @@ var ToolResultPruner = class extends Service {
 			const plan = this.plan(candidate, [{
 				...block,
 				text: replacementText
-			}], sourceSeq, output.reducer, "pressure", "history", policy.historyMode, view);
+			}], sourceSeq, output.reducer, "pressure", "history", policy.historyMode, view, { ...output.elidedLines === void 0 ? {} : { elidedLines: output.elidedLines } });
 			if (plan === null) continue;
 			planned.push(plan);
-			reclaim += plan.tokensBefore - plan.tokensAfter;
+			reclaim += plan.charsBefore - plan.charsAfter;
 			if (reclaim >= required) break;
 		}
 		if (reclaim >= batchTarget && planned.length > 0) return historyOutcome(planned);
@@ -4077,7 +5494,6 @@ var ToolResultPruner = class extends Service {
 	}
 	protectedHistoryResultSeqs(session, policy, view) {
 		const candidates = this.snapshot(session, view);
-		if (candidates.some((candidate) => exactTokens(candidate.count) === void 0)) return null;
 		return this.protectedHistoryCandidateSeqs(candidates, policy);
 	}
 	/** Select the newest completed tool calls and token tail for History-derived stages. */
@@ -4087,12 +5503,12 @@ var ToolResultPruner = class extends Service {
 			const candidate = candidates[index];
 			if (candidate !== void 0) protectedSeqs.add(candidate.seq);
 		}
-		let recentTokens = 0;
-		for (let index = candidates.length - 1; index >= 0 && recentTokens < policy.historyKeepRecentTokens; index--) {
+		let recentChars = 0;
+		for (let index = candidates.length - 1; index >= 0 && recentChars < charsForTokens(policy.historyKeepRecentTokens); index--) {
 			const candidate = candidates[index];
 			if (candidate === void 0) continue;
 			protectedSeqs.add(candidate.seq);
-			recentTokens += exactTokens(candidate.count) ?? 0;
+			recentChars += candidate.characterPressure;
 		}
 		return protectedSeqs;
 	}
@@ -4101,42 +5517,35 @@ var ToolResultPruner = class extends Service {
 		const tailTrim = policy.tailTrim;
 		if (tailTrim?.enabled !== true) return;
 		const events = sessionEvents(session);
-		if (view.currentSurface.kind !== "exact-tokenizer" || view.currentSurface.tokens <= tailTrim.triggerTokens) {
-			if (view.currentSurface.kind !== "exact-tokenizer") this.warnExactUnavailable(session, view, "tailtrim");
-			this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", view.currentSurface.kind !== "exact-tokenizer" ? "exact-tokenizer-unavailable" : "at-or-below-trigger", {
-				measurementKind: view.currentSurface.kind,
-				...view.currentSurface.kind === "exact-tokenizer" ? { currentTokens: view.currentSurface.tokens } : {},
+		if (view.currentSurfaceChars <= charsForTokens(tailTrim.triggerTokens)) {
+			this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "at-or-below-trigger", {
+				measurementKind: "characters",
+				currentTokens: charsToTokens(view.currentSurfaceChars),
 				triggerTokens: tailTrim.triggerTokens
 			});
 			return;
 		}
 		const surfaceCount = view.currentSurface;
+		const exactSurface = surfaceCount.kind === "exact-tokenizer" ? surfaceCount : void 0;
 		if (!this.hasRecoveryTool(session)) {
 			this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "recovery-tool-unavailable", {
-				measurementKind: "exact-tokenizer",
-				currentTokens: surfaceCount.tokens,
+				measurementKind: "characters",
+				currentTokens: charsToTokens(view.currentSurfaceChars),
 				triggerTokens: tailTrim.triggerTokens
 			});
 			return;
 		}
 		if (!hasOpenTurn(session)) {
 			this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "no-open-turn", {
-				measurementKind: "exact-tokenizer",
-				currentTokens: surfaceCount.tokens,
+				measurementKind: "characters",
+				currentTokens: charsToTokens(view.currentSurfaceChars),
 				triggerTokens: tailTrim.triggerTokens
 			});
 			return;
 		}
 		const protectedResults = this.protectedHistoryResultSeqs(session, policy, view);
-		if (protectedResults === null) {
-			this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "exact-tokenizer-unavailable-in-protected-set", {
-				measurementKind: "unavailable",
-				currentTokens: surfaceCount.tokens,
-				triggerTokens: tailTrim.triggerTokens
-			});
-			return;
-		}
 		const measured = new Map(view.measuredNodes.map((node) => [node.seq, node.count]));
+		const nodeChars = new Map(view.measuredNodes.map((node) => [node.seq, node.characterPressure]));
 		const heuristic = new Map(view.nodes.map((node) => [node.seq, node.tokens]));
 		const completedTurns = /* @__PURE__ */ new Set();
 		const completedSteps = /* @__PURE__ */ new Set();
@@ -4171,17 +5580,35 @@ var ToolResultPruner = class extends Service {
 			if (roots.some((root) => root === null)) continue;
 			const sourceEventSeqs = roots;
 			if (new Set(sourceEventSeqs).size !== sourceEventSeqs.length) continue;
-			const counts = shadowedSeqs.map((seq) => measured.get(seq));
-			if (counts.some((count) => count?.kind !== "exact-tokenizer")) continue;
-			const exactCounts = counts;
-			if (exactCounts.some((count) => count.tokenizerId !== surfaceCount.tokenizerId || count.tokenizerRevision !== surfaceCount.tokenizerRevision)) continue;
-			const tokensBefore = exactCounts.reduce((sum, count) => sum + count.tokens, 0);
+			let exactTokensBefore;
+			if (exactSurface !== void 0) {
+				let sum = 0;
+				let allExact = true;
+				for (const seq of shadowedSeqs) {
+					const count = measured.get(seq);
+					if (count?.kind !== "exact-tokenizer" || count.tokenizerId !== exactSurface.tokenizerId || count.tokenizerRevision !== exactSurface.tokenizerRevision) {
+						allExact = false;
+						break;
+					}
+					sum += count.tokens;
+				}
+				if (allExact) exactTokensBefore = sum;
+			}
+			const charsBefore = shadowedSeqs.reduce((sum, seq) => sum + (nodeChars.get(seq) ?? 0), 0);
 			const manifestSeq = events.length;
 			const ref = tailTrimRef(String(session.id), manifestSeq);
 			const stub = tailTrimStub(ref, calls.map((call) => call.name), sourceEventSeqs);
 			if (stub === null) continue;
-			const stubCount = countExactCanonicalTextFields([stub], (candidate) => view.countCanonicalText(candidate), "TailTrim group stub");
-			if (stubCount.kind !== "exact-tokenizer" || stubCount.tokenizerId !== surfaceCount.tokenizerId || stubCount.tokenizerRevision !== surfaceCount.tokenizerRevision || stubCount.tokens <= 0 || tokensBefore - stubCount.tokens < policy.historyMinReclaimTokens) continue;
+			const stubChars = codePointLength(stub);
+			if (stubChars <= 0 || charsBefore - stubChars < charsForTokens(policy.historyMinReclaimTokens)) continue;
+			let exactTokensAfter;
+			if (exactTokensBefore !== void 0 && exactSurface !== void 0) {
+				const stubCount = countExactCanonicalTextFields([stub], (candidate) => view.countCanonicalText(candidate), "TailTrim group stub");
+				if (stubCount.kind === "exact-tokenizer" && stubCount.tokenizerId === exactSurface.tokenizerId && stubCount.tokenizerRevision === exactSurface.tokenizerRevision) exactTokensAfter = stubCount.tokens;
+			}
+			const exact = exactTokensBefore !== void 0 && exactTokensAfter !== void 0;
+			const tokensBefore = exactTokensBefore ?? charsToTokens(charsBefore);
+			const tokensAfter = exactTokensAfter ?? charsToTokens(stubChars);
 			const heuristicTokens = shadowedSeqs.reduce((sum, seq) => sum + (heuristic.get(seq) ?? 0), 0);
 			const range = {
 				start: SessionSeq(assistantSeq),
@@ -4194,8 +5621,8 @@ var ToolResultPruner = class extends Service {
 			};
 			if (!this.reserveTailTrimBoundaryAttempt(session)) {
 				this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "already-attempted-at-request-boundary", {
-					measurementKind: "exact-tokenizer",
-					currentTokens: surfaceCount.tokens,
+					measurementKind: "characters",
+					currentTokens: charsToTokens(view.currentSurfaceChars),
 					triggerTokens: tailTrim.triggerTokens
 				});
 				return;
@@ -4228,16 +5655,17 @@ var ToolResultPruner = class extends Service {
 				replacementSeq: replacement.seq,
 				sourceSeqs: sourceEventSeqs,
 				tokensBefore,
-				tokensAfter: stubCount.tokens,
-				tokensRemoved: tokensBefore - stubCount.tokens,
-				tokenizerId: stubCount.tokenizerId,
-				tokenizerRevision: stubCount.tokenizerRevision
+				tokensAfter,
+				tokensRemoved: tokensBefore - tokensAfter,
+				measurementBasis: exact ? "exact-tokenizer" : "characters",
+				tokenizerId: exact === true && exactSurface !== void 0 ? exactSurface.tokenizerId : "characters",
+				tokenizerRevision: exact === true && exactSurface !== void 0 ? exactSurface.tokenizerRevision : "chars-per-token-4.0"
 			});
 			return;
 		}
 		this.auditComponent(session, policy, "tail-trim", "pressure", "skipped", "no-safe-eligible-tool-group", {
-			measurementKind: "exact-tokenizer",
-			currentTokens: surfaceCount.tokens,
+			measurementKind: "characters",
+			currentTokens: charsToTokens(view.currentSurfaceChars),
 			triggerTokens: tailTrim.triggerTokens
 		});
 	}
@@ -4277,13 +5705,14 @@ var ToolResultPruner = class extends Service {
 		return roots.size === 1 ? [...roots][0] ?? null : null;
 	}
 	plan(candidate, content, sourceSeq, reducer, stage, component, historyMode, view, options = {}) {
+		const charsBefore = candidate.characterPressure;
+		const charsAfter = pressureCost(content);
+		if (charsAfter <= 0 || charsAfter >= charsBefore) return null;
 		const countBefore = candidate.count;
-		if (countBefore.kind !== "exact-tokenizer") return null;
 		const countAfter = countToolContent(content, view);
-		if (countAfter.kind !== "exact-tokenizer" || countAfter.tokenizerId !== countBefore.tokenizerId || countAfter.tokenizerRevision !== countBefore.tokenizerRevision) return null;
-		const tokensBefore = countBefore.tokens;
-		const tokensAfter = countAfter.tokens;
-		if (tokensAfter <= 0 || tokensAfter >= tokensBefore) return null;
+		const exact = countBefore.kind === "exact-tokenizer" && countAfter.kind === "exact-tokenizer" && countAfter.tokenizerId === countBefore.tokenizerId && countAfter.tokenizerRevision === countBefore.tokenizerRevision;
+		const tokensBefore = exact ? countBefore.tokens : charsToTokens(charsBefore);
+		const tokensAfter = exact ? countAfter.tokens : charsToTokens(charsAfter);
 		if (options.noNetSavingsGuard === true) {
 			const originalBlocks = onlyTextBlocks(candidate.event.data.message.content[0].content);
 			const replacementBlocks = onlyTextBlocks(content);
@@ -4292,8 +5721,6 @@ var ToolResultPruner = class extends Service {
 				if (replacementBlocks.reduce((sum, block) => sum + codePointLength(block.text), 0) >= originalChars) return null;
 			}
 		}
-		const charsBefore = candidate.characterPressure;
-		const charsAfter = pressureCost(content);
 		return {
 			candidate,
 			content,
@@ -4306,8 +5733,10 @@ var ToolResultPruner = class extends Service {
 			charsAfter,
 			tokensBefore,
 			tokensAfter,
-			tokenizerId: countBefore.tokenizerId,
-			tokenizerRevision: countBefore.tokenizerRevision
+			measurementBasis: exact ? "exact-tokenizer" : "characters",
+			tokenizerId: exact ? countBefore.tokenizerId : "characters",
+			tokenizerRevision: exact ? countBefore.tokenizerRevision : "chars-per-token-4.0",
+			...options.elidedLines === void 0 ? {} : { elidedLines: options.elidedLines }
 		};
 	}
 	land(session, plan) {
@@ -4361,8 +5790,10 @@ var ToolResultPruner = class extends Service {
 			tokensBefore: plan.tokensBefore,
 			tokensAfter: plan.tokensAfter,
 			tokensRemoved: plan.tokensBefore - plan.tokensAfter,
+			measurementBasis: plan.measurementBasis,
 			tokenizerId: plan.tokenizerId,
-			tokenizerRevision: plan.tokenizerRevision
+			tokenizerRevision: plan.tokenizerRevision,
+			...plan.elidedLines === void 0 ? {} : { elidedLines: plan.elidedLines }
 		});
 		if (plan.reducer !== "review-approved-whole-result") this.reviewSummaryFor(session).autoApplied += 1;
 		return {
@@ -4410,7 +5841,7 @@ var ToolResultPruner = class extends Service {
 			const capacityTrigger = deadlineTrigger !== void 0 ? deadlineTrigger : Number.isSafeInteger(capacity) && capacity !== void 0 && capacity > 0 ? Math.floor(capacity * CAPACITY_PRESSURE_RATIO) : void 0;
 			this.auditComponent(session, policy, "history", "pressure", "skipped", policy.historyMode === "capacity-pressure" ? "below-micro-deadline" : "adaptive-cost-rejected", {
 				historyMode: policy.historyMode,
-				measurementKind: view.currentSurface.kind,
+				measurementKind: "characters",
 				currentTokens: view.totalTokens,
 				...capacityTrigger === void 0 ? {} : { triggerTokens: capacityTrigger }
 			});
@@ -4420,7 +5851,7 @@ var ToolResultPruner = class extends Service {
 		const lastChance = deadline !== void 0 && view.totalTokens >= deadline;
 		const detail = (extra = {}) => ({
 			historyMode: policy.historyMode,
-			measurementKind: outcome.kind === "exact-tokenizer-unavailable" ? "unavailable" : "exact-tokenizer",
+			measurementKind: "characters",
 			currentTokens: view.totalTokens,
 			...outcome.kind === "insufficient-reclaim" || outcome.kind === "cannot-reach-deadline-target" ? {
 				reclaimTokens: outcome.reclaim,
@@ -4429,9 +5860,6 @@ var ToolResultPruner = class extends Service {
 			...extra
 		});
 		switch (outcome.kind) {
-			case "exact-tokenizer-unavailable":
-				this.auditComponent(session, policy, "history", "pressure", "skipped", "exact-tokenizer-unavailable", detail({ triggerTokens: policy.historyTriggerTokens }));
-				return;
 			case "below-profile-trigger":
 				this.auditComponent(session, policy, "history", "pressure", "skipped", "below-profile-trigger", detail({ triggerTokens: policy.historyTriggerTokens }));
 				return;
@@ -4524,7 +5952,7 @@ var ToolResultPruner = class extends Service {
 	warnExactUnavailable(session, view, gate) {
 		const provider = view.providerRoute ?? "unbound-provider";
 		const model = view.modelId ?? "unbound-model";
-		this.warnOnce(session, `exact-tokenizer:${gate}:${provider}\0${model}`, "context-compression %s kept original tool results because exact tokenizer counts are unavailable for %s/%s", gate, provider, model);
+		this.warnOnce(session, `exact-tokenizer:${gate}:${provider}\0${model}`, "context-compression %s is measuring on the character basis: exact tokenizer counts are unavailable for %s/%s", gate, provider, model);
 	}
 	warnOnce(session, key, message, ...args) {
 		let warned = this.state.warnedFailures.get(session);