@shanepadgett/tau-agent 0.20.2 → 0.21.0

package/shared/context-pruning-state.ts

@@ -1,40 +1,38 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 
 const CONTEXT_PRUNE_TOOL = "context_prune";
-const AUTOREAD_MESSAGE_TYPE = "tau.autoread";
 
-export interface ContextPruneRefreshedFileV1 {
+export interface ContextPruneRefreshedFileV2 {
 	path: string;
 	rowId: string;
 	servedHash: string;
+	autoreadDetails: Record<string, unknown>;
 }
 
-export interface ContextPruneDeferredFileV1 {
+export interface ContextPruneDeferredFileV2 {
 	path: string;
 	reason: string;
 	relevantWhen: string;
 }
 
-export interface ContextPruneDetailsV1 {
-	v: 1;
-	status: "applied" | "skipped";
+export interface ContextPruneDetailsV2 {
+	v: 2;
 	anchorToolCallId: string;
-	newlyPrunedToolCallIds: string[];
-	newlyPrunedAutoreadRowIds: string[];
+	prunedToolCallIds: string[];
+	prunedAutoreadRowIds: string[];
 	retainedToolCallIds: string[];
 	retainedAutoreadRowIds: string[];
-	refreshedFiles: ContextPruneRefreshedFileV1[];
-	deferredFiles: ContextPruneDeferredFileV1[];
-	tokensBefore: number;
-	tokensAfter: number;
-	tokensReclaimed: number;
+	refreshedFiles: ContextPruneRefreshedFileV2[];
+	deferredFiles: ContextPruneDeferredFileV2[];
+	warnings: string[];
 }
 
 export interface ActiveContextPruningState {
 	latestAnchorToolCallId: string | undefined;
+	retainedToolCallIds: ReadonlySet<string>;
 	prunedToolCallIds: ReadonlySet<string>;
 	prunedAutoreadRowIds: ReadonlySet<string>;
-	deferredFiles: readonly ContextPruneDeferredFileV1[];
+	deferredFiles: readonly ContextPruneDeferredFileV2[];
 }
 
 const RUNTIME_ENABLED_KEY = Symbol.for("@earendil-works/tau-agent/context-pruning-enabled");
@@ -48,67 +46,35 @@ function isContextPruningEnabled(): boolean {
 	return runtimeState[RUNTIME_ENABLED_KEY] === true;
 }
 
-export function parseContextPruneDetailsV1(value: unknown): ContextPruneDetailsV1 | undefined {
-	if (
-		!hasExactKeys(value, [
-			"v",
-			"status",
-			"anchorToolCallId",
-			"newlyPrunedToolCallIds",
-			"newlyPrunedAutoreadRowIds",
-			"retainedToolCallIds",
-			"retainedAutoreadRowIds",
-			"refreshedFiles",
-			"deferredFiles",
-			"tokensBefore",
-			"tokensAfter",
-			"tokensReclaimed",
-		])
-	)
-		return undefined;
-	if (value.v !== 1 || (value.status !== "applied" && value.status !== "skipped")) return undefined;
-	if (!isNonEmptyString(value.anchorToolCallId)) return undefined;
-
-	const newlyPrunedToolCallIds = parseUniqueStrings(value.newlyPrunedToolCallIds);
-	const newlyPrunedAutoreadRowIds = parseUniqueStrings(value.newlyPrunedAutoreadRowIds);
-	const retainedToolCallIds = parseUniqueStrings(value.retainedToolCallIds);
+export function parseContextPruneDetailsV2(value: unknown): ContextPruneDetailsV2 | undefined {
+	if (!isRecord(value) || value.v !== 2 || !isNonEmptyString(value.anchorToolCallId)) return undefined;
+	const prunedToolCallIds = parseUniqueStrings(value.prunedToolCallIds);
+	const prunedAutoreadRowIds = parseUniqueStrings(value.prunedAutoreadRowIds);
+	const retainedToolCallIds = parseUniqueStrings(value.retainedToolCallIds, true);
 	const retainedAutoreadRowIds = parseUniqueStrings(value.retainedAutoreadRowIds);
 	const refreshedFiles = parseRefreshedFiles(value.refreshedFiles);
 	const deferredFiles = parseDeferredFiles(value.deferredFiles);
+	const warnings = parseStrings(value.warnings, true);
 	if (
-		!newlyPrunedToolCallIds ||
-		!newlyPrunedAutoreadRowIds ||
+		!prunedToolCallIds ||
+		!prunedAutoreadRowIds ||
 		!retainedToolCallIds ||
 		!retainedAutoreadRowIds ||
 		!refreshedFiles ||
-		!deferredFiles
-	)
-		return undefined;
-	if (
-		!isNonNegativeFinite(value.tokensBefore) ||
-		!isNonNegativeFinite(value.tokensAfter) ||
-		!isFiniteNumber(value.tokensReclaimed) ||
-		value.tokensBefore - value.tokensAfter !== value.tokensReclaimed
+		!deferredFiles ||
+		!warnings
 	)
 		return undefined;
-	if (hasOverlap(newlyPrunedToolCallIds, retainedToolCallIds)) return undefined;
-	if (hasOverlap(newlyPrunedAutoreadRowIds, retainedAutoreadRowIds)) return undefined;
-	if (value.status === "skipped" && (newlyPrunedToolCallIds.length > 0 || newlyPrunedAutoreadRowIds.length > 0))
-		return undefined;
-
 	return {
-		v: 1,
-		status: value.status,
+		v: 2,
 		anchorToolCallId: value.anchorToolCallId,
-		newlyPrunedToolCallIds,
-		newlyPrunedAutoreadRowIds,
+		prunedToolCallIds,
+		prunedAutoreadRowIds,
 		retainedToolCallIds,
 		retainedAutoreadRowIds,
 		refreshedFiles,
 		deferredFiles,
-		tokensBefore: value.tokensBefore,
-		tokensAfter: value.tokensAfter,
-		tokensReclaimed: value.tokensReclaimed,
+		warnings,
 	};
 }
 
@@ -118,233 +84,71 @@ export function replayContextPruningState(
 ): ActiveContextPruningState {
 	const prunedToolCallIds = new Set<string>();
 	const prunedAutoreadRowIds = new Set<string>();
-	const state: ActiveContextPruningState = {
-		latestAnchorToolCallId: undefined,
+	let latestAnchorToolCallId: string | undefined;
+	let retainedToolCallIds = new Set<string>();
+	let deferredFiles: readonly ContextPruneDeferredFileV2[] = [];
+	if (enabled) {
+		for (const entry of branch) {
+			if (entry.type !== "message" || entry.message.role !== "toolResult") continue;
+			const result = entry.message;
+			if (result.toolName !== CONTEXT_PRUNE_TOOL) continue;
+			const details = parseContextPruneDetailsV2(result.details);
+			if (!details || details.anchorToolCallId !== result.toolCallId) continue;
+			for (const id of details.prunedToolCallIds) prunedToolCallIds.add(id);
+			for (const id of details.prunedAutoreadRowIds) prunedAutoreadRowIds.add(id);
+			latestAnchorToolCallId = details.anchorToolCallId;
+			retainedToolCallIds = new Set(details.retainedToolCallIds);
+			deferredFiles = details.deferredFiles;
+		}
+		for (const id of retainedToolCallIds) prunedToolCallIds.delete(id);
+	}
+	return {
+		latestAnchorToolCallId,
+		retainedToolCallIds,
 		prunedToolCallIds,
 		prunedAutoreadRowIds,
-		deferredFiles: [],
+		deferredFiles,
 	};
-	if (!enabled) return state;
-
-	const toolCalls = new Map<string, { count: number; name: string; index: number }>();
-	const toolResults = new Map<string, { count: number; name: string; index: number }>();
-	const autoreads = new Map<
-		string,
-		{ count: number; path: string; servedHash: string; source: string; batchId: string; index: number }
-	>();
-	for (let index = 0; index < branch.length; index += 1) {
-		const entry = branch[index];
-		if (entry.type === "message") {
-			const message = entry.message;
-			if (message.role === "assistant") {
-				for (const block of message.content) {
-					if (block.type !== "toolCall") continue;
-					const current = toolCalls.get(block.id);
-					toolCalls.set(block.id, { count: (current?.count ?? 0) + 1, name: block.name, index });
-				}
-			} else if (message.role === "toolResult") {
-				const current = toolResults.get(message.toolCallId);
-				toolResults.set(message.toolCallId, {
-					count: (current?.count ?? 0) + 1,
-					name: message.toolName,
-					index,
-				});
-			}
-			continue;
-		}
-		if (entry.type !== "custom_message" || entry.customType !== AUTOREAD_MESSAGE_TYPE) continue;
-		const autoread = parseAutoreadReference(entry.details);
-		if (!autoread) continue;
-		const current = autoreads.get(autoread.rowId);
-		autoreads.set(autoread.rowId, {
-			count: (current?.count ?? 0) + 1,
-			path: autoread.path,
-			servedHash: autoread.servedHash,
-			source: autoread.source,
-			batchId: autoread.batchId,
-			index,
-		});
-	}
-
-	for (let resultIndex = 0; resultIndex < branch.length; resultIndex += 1) {
-		const entry = branch[resultIndex];
-		if (entry.type !== "message" || entry.message.role !== "toolResult") continue;
-		const result = entry.message;
-		if (result.toolName !== CONTEXT_PRUNE_TOOL) continue;
-		const details = parseContextPruneDetailsV1(result.details);
-		if (!details || details.status !== "applied" || details.anchorToolCallId !== result.toolCallId) continue;
-		if (!isCompleteExchange(details.anchorToolCallId, CONTEXT_PRUNE_TOOL, toolCalls, toolResults)) continue;
-		const anchorCallIndex = toolCalls.get(details.anchorToolCallId)?.index;
-		if (anchorCallIndex === undefined || anchorCallIndex >= resultIndex) continue;
-		if (details.newlyPrunedToolCallIds.includes(details.anchorToolCallId)) continue;
-		if (details.retainedToolCallIds.includes(details.anchorToolCallId)) continue;
-		if (
-			!allCompleteExchanges(details.newlyPrunedToolCallIds, toolCalls, toolResults) ||
-			!allCompleteExchanges(details.retainedToolCallIds, toolCalls, toolResults) ||
-			!allAutoreads(details.newlyPrunedAutoreadRowIds, autoreads) ||
-			!allAutoreads(details.retainedAutoreadRowIds, autoreads)
-		)
-			continue;
-		if (
-			details.newlyPrunedToolCallIds.some((id) => !exchangePrecedes(id, anchorCallIndex, toolCalls, toolResults)) ||
-			details.retainedToolCallIds.some((id) => !exchangePrecedes(id, anchorCallIndex, toolCalls, toolResults)) ||
-			details.newlyPrunedAutoreadRowIds.some((id) => {
-				const row = autoreads.get(id);
-				return row === undefined || row.index >= anchorCallIndex;
-			})
-		)
-			continue;
-		if (
-			details.newlyPrunedToolCallIds.some((id) => prunedToolCallIds.has(id)) ||
-			details.retainedToolCallIds.some((id) => prunedToolCallIds.has(id)) ||
-			details.newlyPrunedAutoreadRowIds.some((id) => prunedAutoreadRowIds.has(id)) ||
-			details.retainedAutoreadRowIds.some((id) => prunedAutoreadRowIds.has(id))
-		)
-			continue;
-		if (
-			details.refreshedFiles.some((file) => {
-				const row = autoreads.get(file.rowId);
-				return (
-					row?.count !== 1 ||
-					row.path !== file.path ||
-					row.servedHash !== file.servedHash ||
-					row.source !== "context-pruning" ||
-					row.batchId !== details.anchorToolCallId ||
-					!details.retainedAutoreadRowIds.includes(file.rowId)
-				);
-			})
-		)
-			continue;
-		const refreshedRowIds = new Set(details.refreshedFiles.map((file) => file.rowId));
-		if (
-			details.retainedAutoreadRowIds.some((id) => {
-				const row = autoreads.get(id);
-				return row === undefined || (row.index >= anchorCallIndex && !refreshedRowIds.has(id));
-			})
-		)
-			continue;
-
-		for (const id of details.newlyPrunedToolCallIds) prunedToolCallIds.add(id);
-		for (const id of details.newlyPrunedAutoreadRowIds) prunedAutoreadRowIds.add(id);
-		state.latestAnchorToolCallId = details.anchorToolCallId;
-		state.deferredFiles = details.deferredFiles;
-	}
-	return state;
 }
 
-function parseRefreshedFiles(value: unknown): ContextPruneRefreshedFileV1[] | undefined {
+function parseRefreshedFiles(value: unknown): ContextPruneRefreshedFileV2[] | undefined {
 	if (!Array.isArray(value)) return undefined;
-	const files: ContextPruneRefreshedFileV1[] = [];
-	const rowIds = new Set<string>();
+	const files: ContextPruneRefreshedFileV2[] = [];
 	for (const item of value) {
-		if (!hasExactKeys(item, ["path", "rowId", "servedHash"])) return undefined;
-		if (!isNonEmptyString(item.path) || !isNonEmptyString(item.rowId) || !isNonEmptyString(item.servedHash))
-			return undefined;
-		if (rowIds.has(item.rowId)) return undefined;
-		rowIds.add(item.rowId);
-		files.push({ path: item.path, rowId: item.rowId, servedHash: item.servedHash });
+		if (!isRecord(item) || !isNonEmptyString(item.path) || !isNonEmptyString(item.rowId)) return undefined;
+		if (!isNonEmptyString(item.servedHash) || !isRecord(item.autoreadDetails)) return undefined;
+		files.push({
+			path: item.path,
+			rowId: item.rowId,
+			servedHash: item.servedHash,
+			autoreadDetails: { ...item.autoreadDetails },
+		});
 	}
 	return files;
 }
 
-function parseDeferredFiles(value: unknown): ContextPruneDeferredFileV1[] | undefined {
+function parseDeferredFiles(value: unknown): ContextPruneDeferredFileV2[] | undefined {
 	if (!Array.isArray(value)) return undefined;
-	const files: ContextPruneDeferredFileV1[] = [];
+	const files: ContextPruneDeferredFileV2[] = [];
 	for (const item of value) {
-		if (!hasExactKeys(item, ["path", "reason", "relevantWhen"])) return undefined;
-		if (!isNonEmptyString(item.path) || !isNonEmptyString(item.reason) || !isNonEmptyString(item.relevantWhen))
-			return undefined;
+		if (!isRecord(item) || typeof item.path !== "string" || typeof item.reason !== "string") return undefined;
+		if (typeof item.relevantWhen !== "string") return undefined;
 		files.push({ path: item.path, reason: item.reason, relevantWhen: item.relevantWhen });
 	}
 	return files;
 }
 
-function parseUniqueStrings(value: unknown): string[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const strings: string[] = [];
-	const seen = new Set<string>();
-	for (const item of value) {
-		if (!isNonEmptyString(item) || seen.has(item)) return undefined;
-		seen.add(item);
-		strings.push(item);
-	}
+function parseUniqueStrings(value: unknown, allowEmpty = false): string[] | undefined {
+	const strings = parseStrings(value, allowEmpty);
+	if (!strings || new Set(strings).size !== strings.length) return undefined;
 	return strings;
 }
 
-function parseAutoreadReference(
-	value: unknown,
-): { rowId: string; path: string; servedHash: string; source: string; batchId: string } | undefined {
-	if (!isRecord(value) || value.status !== "read") return undefined;
-	if (
-		!isNonEmptyString(value.rowId) ||
-		!isNonEmptyString(value.path) ||
-		!isNonEmptyString(value.cwd) ||
-		!isNonEmptyString(value.source) ||
-		!isNonEmptyString(value.batchId)
-	)
+function parseStrings(value: unknown, allowEmpty = false): string[] | undefined {
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && (allowEmpty || item.length > 0))) {
 		return undefined;
-	if (!isRecord(value.readCache) || !isNonEmptyString(value.readCache.servedHash)) return undefined;
-	return {
-		rowId: value.rowId,
-		path: value.path,
-		servedHash: value.readCache.servedHash,
-		source: value.source,
-		batchId: value.batchId,
-	};
-}
-
-function allCompleteExchanges(
-	ids: readonly string[],
-	calls: ReadonlyMap<string, { count: number; name: string; index: number }>,
-	results: ReadonlyMap<string, { count: number; name: string; index: number }>,
-): boolean {
-	return ids.every((id) => {
-		const call = calls.get(id);
-		return call !== undefined && isCompleteExchange(id, call.name, calls, results);
-	});
-}
-
-function isCompleteExchange(
-	id: string,
-	name: string,
-	calls: ReadonlyMap<string, { count: number; name: string; index: number }>,
-	results: ReadonlyMap<string, { count: number; name: string; index: number }>,
-): boolean {
-	const call = calls.get(id);
-	const result = results.get(id);
-	return (
-		call?.count === 1 &&
-		result?.count === 1 &&
-		call.name === name &&
-		result.name === name &&
-		call.index < result.index
-	);
-}
-
-function exchangePrecedes(
-	id: string,
-	anchorCallIndex: number,
-	calls: ReadonlyMap<string, { index: number }>,
-	results: ReadonlyMap<string, { index: number }>,
-): boolean {
-	const call = calls.get(id);
-	const result = results.get(id);
-	return call !== undefined && result !== undefined && call.index < result.index && result.index < anchorCallIndex;
-}
-
-function allAutoreads(ids: readonly string[], autoreads: ReadonlyMap<string, { count: number }>): boolean {
-	return ids.every((id) => autoreads.get(id)?.count === 1);
-}
-
-function hasOverlap(left: readonly string[], right: readonly string[]): boolean {
-	const rightSet = new Set(right);
-	return left.some((item) => rightSet.has(item));
-}
-
-function hasExactKeys(value: unknown, keys: readonly string[]): value is Record<string, unknown> {
-	if (!isRecord(value)) return false;
-	const actual = Object.keys(value);
-	return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+	}
+	return [...value];
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -354,11 +158,3 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 function isNonEmptyString(value: unknown): value is string {
 	return typeof value === "string" && value.length > 0;
 }
-
-function isNonNegativeFinite(value: unknown): value is number {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-
-function isFiniteNumber(value: unknown): value is number {
-	return typeof value === "number" && Number.isFinite(value);
-}

package/extensions/context-pruning/file-evidence.ts

@@ -1,265 +0,0 @@
-import { realpath } from "node:fs/promises";
-import { basename, dirname, relative, resolve, sep } from "node:path";
-import { estimateTokens, type ContextEvent } from "@earendil-works/pi-coding-agent";
-import { prepareAutoreadMessage, type PreparedAutoreadMessage } from "../explore/autoread.ts";
-import { COMPLETE_FILE_SCOPE, MAX_COMPLETE_FILE_SNAPSHOT_BYTES } from "../explore/full-file-knowledge.ts";
-import { readMetaFromMessage, replayReadCache } from "../explore/read-cache.ts";
-
-type ContextMessage = ContextEvent["messages"][number];
-type ReadEvidenceMessage =
-	| Extract<ContextMessage, { role: "toolResult" }>
-	| Extract<ContextMessage, { role: "custom" }>;
-
-interface RequestedFile {
-	path: string;
-	relevance: string;
-}
-
-interface RequestedDeferredFile {
-	path: string;
-	reason: string;
-	relevantWhen: string;
-}
-
-interface CanonicalFile<T> {
-	canonicalPath: string;
-	displayPath: string;
-	request: T;
-}
-
-interface FileEvidenceSelection {
-	retainedToolCallIds: ReadonlySet<string>;
-	retainedAutoreadRowIds: ReadonlySet<string>;
-	preparedSnapshots: readonly PreparedAutoreadMessage[];
-	refreshedFiles: readonly { path: string; rowId: string; servedHash: string }[];
-}
-
-export async function canonicalizeFileSelections(options: {
-	cwd: string;
-	keepFiles: readonly RequestedFile[];
-	deferFiles: readonly RequestedDeferredFile[];
-}): Promise<{
-	keepFiles: CanonicalFile<RequestedFile>[];
-	deferFiles: CanonicalFile<RequestedDeferredFile>[];
-}> {
-	const seen = new Map<string, string>();
-	const canonicalCwd = await canonicalizePath(resolve(options.cwd));
-	const canonicalize = async <T extends { path: string }>(request: T): Promise<CanonicalFile<T>> => {
-		const requested = resolve(options.cwd, request.path.replace(/^@/, ""));
-		const canonicalPath = await canonicalizePath(requested);
-		const previous = seen.get(canonicalPath);
-		if (previous !== undefined) {
-			throw new Error(`Duplicate file selection: ${request.path} resolves to the same path as ${previous}`);
-		}
-		seen.set(canonicalPath, request.path);
-		const relativePath = relative(canonicalCwd, canonicalPath);
-		const displayPath =
-			relativePath !== "" && relativePath !== ".." && !relativePath.startsWith(`..${sep}`)
-				? relativePath
-				: canonicalPath;
-		return { canonicalPath, displayPath, request };
-	};
-
-	const keepFiles: CanonicalFile<RequestedFile>[] = [];
-	for (const request of options.keepFiles) keepFiles.push(await canonicalize(request));
-	const deferFiles: CanonicalFile<RequestedDeferredFile>[] = [];
-	for (const request of options.deferFiles) deferFiles.push(await canonicalize(request));
-	return { keepFiles, deferFiles };
-}
-
-export async function selectFileEvidence(options: {
-	cwd: string;
-	messages: readonly ContextMessage[];
-	files: readonly CanonicalFile<RequestedFile>[];
-	anchorToolCallId: string;
-	signal: AbortSignal | undefined;
-	isLifecycleCurrent: () => boolean;
-}): Promise<FileEvidenceSelection> {
-	const entries = options.messages.map((message) =>
-		message.role === "custom" ? { type: "custom_message", ...message } : { type: "message", message },
-	);
-	const replay = replayReadCache(entries, options.cwd);
-	const retainedToolCallIds = new Set<string>();
-	const retainedAutoreadRowIds = new Set<string>();
-	const preparedSnapshots: PreparedAutoreadMessage[] = [];
-	const refreshedFiles: Array<{ path: string; rowId: string; servedHash: string }> = [];
-	const rowMessages = indexEvidenceRows(options.messages);
-
-	for (let fileIndex = 0; fileIndex < options.files.length; fileIndex += 1) {
-		const file = options.files[fileIndex];
-		if (!file) continue;
-		options.signal?.throwIfAborted();
-		if (!options.isLifecycleCurrent()) throw new Error("Prune preparation crossed a session lifecycle boundary");
-
-		const rawRows: ContextMessage[] = [];
-		for (const message of options.messages) {
-			const pathKey = rawReadPath(message, options.cwd);
-			if (pathKey && (await canonicalizePath(pathKey)) === file.canonicalPath) rawRows.push(message);
-		}
-		if (rawRows.length === 0) throw new Error(`${file.displayPath} has no prior read evidence; read the file first`);
-		const rawCompleteRows = rawRows.filter((message) => rawScopeKey(message) === COMPLETE_FILE_SCOPE);
-		if (rawCompleteRows.length === 0) {
-			throw new Error(`${file.displayPath} has only partial read evidence; read the complete file first`);
-		}
-		const acceptedRows: Array<(typeof replay.acceptedRows)[number]> = [];
-		for (const row of replay.acceptedRows) {
-			if (row.scopeKey === COMPLETE_FILE_SCOPE && (await canonicalizePath(row.pathKey)) === file.canonicalPath)
-				acceptedRows.push(row);
-		}
-		if (acceptedRows.length === 0) {
-			throw new Error(`${file.displayPath} has malformed complete-file evidence; read the file again`);
-		}
-
-		const rowId = `${options.anchorToolCallId}:${fileIndex}`;
-		const prepared = await prepareAutoreadMessage({
-			rowId,
-			path: file.displayPath,
-			cwd: options.cwd,
-			source: "context-pruning",
-			batchId: options.anchorToolCallId,
-			signal: options.signal,
-			isLifecycleCurrent: options.isLifecycleCurrent,
-			maximumBytes: MAX_COMPLETE_FILE_SNAPSHOT_BYTES,
-		});
-		const currentHash = prepared.details.readCache.servedHash;
-		const unchangedBaseline = acceptedRows.find(
-			(row) => (row.meta.mode === "baseline" || row.meta.mode === "recovery") && row.meta.servedHash === currentHash,
-		);
-		if (unchangedBaseline) {
-			retainRows(unchangedBaseline.dependencyRowIds, rowMessages, retainedToolCallIds, retainedAutoreadRowIds);
-			continue;
-		}
-
-		let chain = replay.completeFileChains.get(file.canonicalPath);
-		if (!chain) {
-			for (const candidate of replay.completeFileChains.values()) {
-				if ((await canonicalizePath(candidate.pathKey)) === file.canonicalPath) {
-					chain = candidate;
-					break;
-				}
-			}
-		}
-		if (chain?.servedHash === currentHash) {
-			const chainCost = chain.rowIds.reduce((total, id) => total + (rowMessages.get(id)?.tokens ?? 0), 0);
-			const snapshotCost = estimatePreparedSnapshot(prepared);
-			if (chainCost <= snapshotCost) {
-				retainRows(chain.rowIds, rowMessages, retainedToolCallIds, retainedAutoreadRowIds);
-				continue;
-			}
-		}
-
-		preparedSnapshots.push(prepared);
-		retainedAutoreadRowIds.add(rowId);
-		refreshedFiles.push({ path: file.displayPath, rowId, servedHash: currentHash });
-	}
-
-	return { retainedToolCallIds, retainedAutoreadRowIds, preparedSnapshots, refreshedFiles };
-}
-
-function indexEvidenceRows(
-	messages: readonly ContextMessage[],
-): Map<string, { tokens: number; kind: "tool" | "autoread" }> {
-	const rows = new Map<string, { tokens: number; kind: "tool" | "autoread" }>();
-	const calls = new Map<string, { message: Extract<ContextMessage, { role: "assistant" }>; blockIndex: number }>();
-	for (const message of messages) {
-		if (message.role === "assistant") {
-			for (let blockIndex = 0; blockIndex < message.content.length; blockIndex += 1) {
-				const block = message.content[blockIndex];
-				if (block?.type === "toolCall") calls.set(block.id, { message, blockIndex });
-			}
-			continue;
-		}
-		if (message.role === "toolResult" && message.toolName === "read") {
-			const call = calls.get(message.toolCallId);
-			const block = call?.message.content[call.blockIndex];
-			if (call && block?.type === "toolCall") {
-				rows.set(message.toolCallId, {
-					tokens: estimateTokens({ ...call.message, content: [block] }) + estimateTokens(message),
-					kind: "tool",
-				});
-			}
-			continue;
-		}
-		if (message.role === "custom" && message.customType === "tau.autoread") {
-			const rowId = autoreadRowId(message);
-			if (rowId) rows.set(rowId, { tokens: estimateTokens(message), kind: "autoread" });
-		}
-	}
-	return rows;
-}
-
-function retainRows(
-	rowIds: readonly string[],
-	rows: ReadonlyMap<string, { kind: "tool" | "autoread" }>,
-	toolIds: Set<string>,
-	autoreadIds: Set<string>,
-): void {
-	for (const rowId of rowIds) {
-		const row = rows.get(rowId);
-		if (!row) throw new Error(`Complete-file dependency row is absent from projected context: ${rowId}`);
-		if (row.kind === "tool") toolIds.add(rowId);
-		else autoreadIds.add(rowId);
-	}
-}
-
-function estimatePreparedSnapshot(prepared: PreparedAutoreadMessage): number {
-	const message: ContextMessage = {
-		role: "custom",
-		customType: prepared.customType,
-		content: prepared.content,
-		display: prepared.display,
-		details: prepared.details,
-		timestamp: 0,
-	};
-	return estimateTokens(message);
-}
-
-function rawReadPath(message: ContextMessage, cwd: string): string | undefined {
-	const meta = readMetaFromMessage(message);
-	if (meta) return resolve(cwd, meta.pathKey);
-	if (!isReadEvidence(message) || !isRecord(message.details) || !isRecord(message.details.readCache)) return undefined;
-	const pathKey = message.details.readCache.pathKey;
-	return typeof pathKey === "string" ? resolve(cwd, pathKey) : undefined;
-}
-
-function rawScopeKey(message: ContextMessage): string | undefined {
-	if (!isReadEvidence(message) || !isRecord(message.details) || !isRecord(message.details.readCache)) return undefined;
-	return typeof message.details.readCache.scopeKey === "string" ? message.details.readCache.scopeKey : undefined;
-}
-
-function isReadEvidence(message: ContextMessage): message is ReadEvidenceMessage {
-	return (
-		(message.role === "toolResult" && message.toolName === "read") ||
-		(message.role === "custom" && message.customType === "tau.autoread")
-	);
-}
-
-function autoreadRowId(message: ContextMessage): string | undefined {
-	if (message.role !== "custom" || !isRecord(message.details)) return undefined;
-	return typeof message.details.rowId === "string" ? message.details.rowId : undefined;
-}
-
-function isMissingPathError(error: unknown): boolean {
-	return isRecord(error) && error.code === "ENOENT";
-}
-
-async function canonicalizePath(path: string): Promise<string> {
-	const missingSegments: string[] = [];
-	let cursor = path;
-	while (true) {
-		try {
-			const canonicalAncestor = await realpath(cursor);
-			return resolve(canonicalAncestor, ...missingSegments.reverse());
-		} catch (error) {
-			if (!isMissingPathError(error)) throw error;
-			const parent = dirname(cursor);
-			if (parent === cursor) return path;
-			missingSegments.push(basename(cursor));
-			cursor = parent;
-		}
-	}
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}