@oh-my-pi/pi-coding-agent 15.5.11 → 15.5.13

package/src/modes/interactive-mode.ts

@@ -67,7 +67,7 @@ import type { LspStartupServerInfo } from "../tools";
 import { normalizeLocalScheme } from "../tools/path-utils";
 import { setAutoQaConsentHandler } from "../tools/report-tool-issue";
 import { type ResolveToolDetails, runResolveInvocation } from "../tools/resolve";
-import { formatPhaseDisplayName } from "../tools/todo-write";
+import { formatPhaseDisplayName, selectStickyTodoWindow, todoMatchesAnyDescription } from "../tools/todo-write";
 import { ToolError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
 import { getEditorCommand, openInEditor } from "../utils/external-editor";
@@ -324,6 +324,10 @@ export class InteractiveMode implements InteractiveModeContext {
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
+	#todoSpinnerInterval?: NodeJS.Timeout;
+	#todoSpinnerFrame = 0;
+	#todoClosingTimeout?: NodeJS.Timeout;
+	#todoClosingState: "idle" | "playing" | "done" = "idle";
 
 	constructor(
 		session: AgentSession,
@@ -529,6 +533,12 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#observerRegistry.setMainSession(this.sessionManager.getSessionFile() ?? undefined);
 		this.#observerRegistry.onChange(() => {
 			this.statusLine.setSubagentCount(this.#observerRegistry.getActiveSubagentCount());
+			// Auto-checkmark todos whose matching subagent just succeeded, then
+			// re-render so the running override (animated row when a subagent
+			// is doing the work for a still-pending todo) updates as subagents
+			// start, finish, or fail. Also handles spinner start/stop.
+			this.#reconcileTodosWithSubagents();
+			this.#renderTodoList();
 			this.ui.requestRender();
 		});
 
@@ -839,6 +849,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#pendingSubmissionDispose = undefined;
 		}
 		this.editor.setText("");
+		this.ui.refreshNativeScrollbackIfDirty();
 		this.ensureLoadingAnimation();
 		this.ui.requestRender();
 		return submission;
@@ -949,21 +960,101 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.renderSessionContext(context);
 	}
 
-	#formatTodoLine(todo: TodoItem, prefix: string): string {
+	#formatTodoLine(todo: TodoItem, prefix: string, matched: boolean, spinnerOn: boolean): string {
 		const checkbox = theme.checkbox;
 		const marker = formatHudNoteMarker(todo.notes?.length ?? 0);
+		const frames = theme.spinnerFrames;
+		// When the spinner is ticking, use the current animated frame; otherwise
+		// fall back to the static "running" glyph so in_progress rows still look
+		// distinct from pending rows.
+		const runningGlyph =
+			spinnerOn && frames.length > 0
+				? (frames[this.#todoSpinnerFrame % frames.length] ?? theme.status.running)
+				: theme.status.running;
 		switch (todo.status) {
 			case "completed":
-				return theme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(todo.content)}`) + marker;
+				return (
+					theme.fg("success", `${prefix}${theme.status.success} ${chalk.strikethrough(todo.content)}`) + marker
+				);
 			case "in_progress":
-				return theme.fg("accent", `${prefix}${checkbox.unchecked} ${todo.content}`) + marker;
+				return theme.fg("accent", `${prefix}${runningGlyph} ${todo.content}`) + marker;
 			case "abandoned":
 				return theme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(todo.content)}`) + marker;
 			default:
+				if (matched) {
+					return theme.fg("accent", `${prefix}${runningGlyph} ${todo.content}`) + marker;
+				}
 				return theme.fg("dim", `${prefix}${checkbox.unchecked} ${todo.content}`) + marker;
 		}
 	}
 
+	#getActiveSubagentDescriptions(): string[] {
+		const out: string[] = [];
+		for (const session of this.#observerRegistry.getSessions()) {
+			if (session.kind !== "subagent") continue;
+			if (session.status !== "active") continue;
+			const candidate =
+				session.description?.trim() || session.progress?.description?.trim() || session.label?.trim();
+			if (candidate) out.push(candidate);
+		}
+		return out;
+	}
+
+	/**
+	 * Auto-complete any pending/in_progress todo whose content matches a
+	 * subagent that has finished successfully. Fires on every observer
+	 * `onChange` so the visual state stays in sync with subagent lifecycle
+	 * without requiring the agent to issue a follow-up `todo_write`. Failed
+	 * and aborted subagents are intentionally NOT auto-completed — those
+	 * stay open so the user (or the next agent turn) can decide what to do.
+	 *
+	 * Idempotent: only flips open tasks, never re-touches completed ones.
+	 */
+	#reconcileTodosWithSubagents(): void {
+		const completedDescs: string[] = [];
+		for (const session of this.#observerRegistry.getSessions()) {
+			if (session.kind !== "subagent") continue;
+			if (session.status !== "completed") continue;
+			const candidate =
+				session.description?.trim() || session.progress?.description?.trim() || session.label?.trim();
+			if (candidate) completedDescs.push(candidate);
+		}
+		if (completedDescs.length === 0) return;
+
+		let mutated = false;
+		const next: TodoPhase[] = this.todoPhases.map(phase => ({
+			name: phase.name,
+			tasks: phase.tasks.map(task => {
+				if (task.status !== "pending" && task.status !== "in_progress") return task;
+				if (!todoMatchesAnyDescription(task.content, completedDescs)) return task;
+				mutated = true;
+				return { ...task, status: "completed" as const };
+			}),
+		}));
+		if (!mutated) return;
+		this.todoPhases = next;
+		this.session.setTodoPhases(next);
+	}
+
+	#updateTodoSpinnerAnimation(needSpinner: boolean): void {
+		if (needSpinner) {
+			if (this.#todoSpinnerInterval) return;
+			this.#todoSpinnerInterval = setInterval(() => {
+				const frames = theme.spinnerFrames;
+				if (frames.length === 0) return;
+				this.#todoSpinnerFrame = (this.#todoSpinnerFrame + 1) % frames.length;
+				// Rebuild the todo container so the new frame appears, then schedule
+				// a paint. The renderer self-stops the interval once no row needs it.
+				this.#renderTodoList();
+				this.ui.requestRender();
+			}, 80);
+		} else if (this.#todoSpinnerInterval) {
+			clearInterval(this.#todoSpinnerInterval);
+			this.#todoSpinnerInterval = undefined;
+			this.#todoSpinnerFrame = 0;
+		}
+	}
+
 	#getActivePhase(phases: TodoPhase[]): TodoPhase | undefined {
 		const nonEmpty = phases.filter(phase => phase.tasks.length > 0);
 		const active = nonEmpty.find(phase =>
@@ -976,44 +1067,183 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.todoContainer.clear();
 		const phases = this.todoPhases.filter(phase => phase.tasks.length > 0);
 		if (phases.length === 0) {
+			this.#updateTodoSpinnerAnimation(false);
+			this.#stopTodoClosingAnimation();
+			this.#todoClosingState = "idle";
 			return;
 		}
 
+		// When every visible task is completed or abandoned, fold the panel
+		// away with a brief celebratory animation (see
+		// #startTodoClosingAnimation). State machine guards against replaying
+		// on every re-render once the animation has finished.
+		const allClosed = phases.every(phase =>
+			phase.tasks.every(t => t.status === "completed" || t.status === "abandoned"),
+		);
+		if (allClosed) {
+			this.#updateTodoSpinnerAnimation(false);
+			if (this.#todoClosingState === "done") return;
+			if (this.#todoClosingState === "idle") this.#startTodoClosingAnimation(phases);
+			return;
+		}
+		// Any open task here means the close animation is no longer applicable.
+		this.#stopTodoClosingAnimation();
+		this.#todoClosingState = "idle";
+
 		const indent = "  ";
 		const hook = theme.tree.hook;
 		const lines = ["", indent + theme.bold(theme.fg("accent", "Todos"))];
 
+		const activeDescs = this.#getActiveSubagentDescriptions();
+		// Cache matcher results so we don't re-scan the description list per row
+		// twice (once for the spinner decision, once for the render).
+		const matchedSet = new Set<TodoItem>();
+		const isMatched = (todo: TodoItem): boolean => {
+			if (activeDescs.length === 0) return false;
+			if (matchedSet.has(todo)) return true;
+			if (todoMatchesAnyDescription(todo.content, activeDescs)) {
+				matchedSet.add(todo);
+				return true;
+			}
+			return false;
+		};
+
+		// The cube animates whenever any visible open todo is "live":
+		// (a) status is in_progress (the agent itself is working it), or
+		// (b) a still-pending todo has a matching in-flight subagent doing
+		// the work for it. The renderer self-stops the interval once no row
+		// qualifies, so an orphan in_progress row at end-of-session keeps
+		// ticking — that's the intentional "this todo is still open" signal.
+		let needsSpinner = false;
+		const considerForSpinner = (todo: TodoItem): void => {
+			if (todo.status === "in_progress") {
+				needsSpinner = true;
+				return;
+			}
+			if (todo.status !== "pending") return;
+			if (isMatched(todo)) needsSpinner = true;
+		};
+
 		if (!this.todoExpanded) {
 			const activeIdx = phases.indexOf(this.#getActivePhase(phases) ?? phases[0]);
 			const activePhase = phases[activeIdx];
-			if (!activePhase) return;
+			if (!activePhase) {
+				this.#updateTodoSpinnerAnimation(false);
+				return;
+			}
+			const { visible, hiddenOpenCount } = selectStickyTodoWindow(activePhase.tasks, 5);
+			for (const todo of visible) considerForSpinner(todo);
+			this.#updateTodoSpinnerAnimation(needsSpinner);
+
 			lines.push(
 				`${indent}${theme.fg("accent", `${hook} ${formatPhaseDisplayName(activePhase.name, activeIdx + 1)}`)}`,
 			);
-			const visibleTasks = activePhase.tasks.slice(0, 5);
-			visibleTasks.forEach((todo, index) => {
+			visible.forEach((todo, index) => {
 				const prefix = `${indent}${index === 0 ? hook : " "} `;
-				lines.push(this.#formatTodoLine(todo, prefix));
+				lines.push(this.#formatTodoLine(todo, prefix, matchedSet.has(todo), needsSpinner));
 			});
-			if (visibleTasks.length < activePhase.tasks.length) {
-				const remaining = activePhase.tasks.length - visibleTasks.length;
-				lines.push(theme.fg("muted", `${indent}  ${hook} +${remaining} more`));
+			if (hiddenOpenCount > 0) {
+				lines.push(theme.fg("muted", `${indent}  ${hook} +${hiddenOpenCount} more`));
 			}
 			this.todoContainer.addChild(new Text(lines.join("\n"), 1, 0));
 			return;
 		}
 
+		for (const phase of phases) for (const todo of phase.tasks) considerForSpinner(todo);
+		this.#updateTodoSpinnerAnimation(needsSpinner);
+
 		phases.forEach((phase, phaseIndex) => {
 			lines.push(`${indent}${theme.fg("accent", `${hook} ${formatPhaseDisplayName(phase.name, phaseIndex + 1)}`)}`);
 			phase.tasks.forEach((todo, index) => {
 				const prefix = `${indent}${index === 0 ? hook : " "} `;
-				lines.push(this.#formatTodoLine(todo, prefix));
+				lines.push(this.#formatTodoLine(todo, prefix, matchedSet.has(todo), needsSpinner));
 			});
 		});
 
 		this.todoContainer.addChild(new Text(lines.join("\n"), 1, 0));
 	}
 
+	/**
+	 * Play a short "all done" close animation: a celebratory bright frame,
+	 * a brief dim transition, then a row-by-row vertical collapse until the
+	 * panel is empty. Triggered from #renderTodoList exactly once per
+	 * open-to-all-closed transition; #todoClosingState gates re-entry.
+	 *
+	 * While playing, the animator owns the panel container; #renderTodoList
+	 * returns early. Subsequent renders with state === "done" keep the
+	 * panel hidden until a fresh open task flips state back to "idle".
+	 */
+	#startTodoClosingAnimation(phases: TodoPhase[]): void {
+		this.#stopTodoClosingAnimation();
+		this.#todoClosingState = "playing";
+
+		const indent = "  ";
+		const hook = theme.tree.hook;
+		const snapshot: string[] = ["", `${indent}Todos ${theme.status.success}`];
+		for (let i = 0; i < phases.length; i++) {
+			const phase = phases[i];
+			snapshot.push(`${indent}${hook} ${formatPhaseDisplayName(phase.name, i + 1)}`);
+			for (let j = 0; j < phase.tasks.length; j++) {
+				const task = phase.tasks[j];
+				const mark = task.status === "abandoned" ? theme.status.aborted : theme.status.success;
+				const prefix = `${indent}${j === 0 ? hook : " "} `;
+				snapshot.push(`${prefix}${mark} ${task.content}`);
+			}
+		}
+
+		// Frame schedule (tint, drop-from-bottom, hold-ms). Frame 0 holds long
+		// enough for the user to actually read the final checkmarks before the
+		// fade starts; later frames fade and progressively drop rows from the
+		// bottom for the collapse effect. Total runtime ≈ 1.4s.
+		const frames = [
+			{ tint: "success" as const, drop: 0, holdMs: 900 },
+			{ tint: "success" as const, drop: 0, holdMs: 150 },
+			{ tint: "muted" as const, drop: 1, holdMs: 90 },
+			{ tint: "muted" as const, drop: 2, holdMs: 90 },
+			{ tint: "dim" as const, drop: 3, holdMs: 80 },
+			{ tint: "dim" as const, drop: 4, holdMs: 80 },
+		];
+
+		let frameIdx = 0;
+		const tick = (): void => {
+			if (this.#todoClosingState !== "playing") return;
+			if (frameIdx >= frames.length) {
+				this.todoContainer.clear();
+				this.#stopTodoClosingAnimation();
+				this.#todoClosingState = "done";
+				this.ui.requestRender();
+				return;
+			}
+			const { tint, drop, holdMs } = frames[frameIdx];
+			const visibleCount = Math.max(0, snapshot.length - drop);
+			this.todoContainer.clear();
+			if (visibleCount > 0) {
+				const visible = snapshot.slice(0, visibleCount);
+				const painted = visible.map((line, idx) => {
+					if (idx === 1) {
+						// Header row gets a bold flourish on the opening tick.
+						const colored = theme.fg(tint, line);
+						return frameIdx === 0 ? theme.bold(colored) : colored;
+					}
+					return theme.fg(tint, line);
+				});
+				this.todoContainer.addChild(new Text(painted.join("\n"), 1, 0));
+			}
+			this.ui.requestRender();
+			frameIdx++;
+			this.#todoClosingTimeout = setTimeout(tick, holdMs);
+		};
+
+		tick();
+	}
+
+	#stopTodoClosingAnimation(): void {
+		if (this.#todoClosingTimeout) {
+			clearTimeout(this.#todoClosingTimeout);
+			this.#todoClosingTimeout = undefined;
+		}
+	}
+
 	async #loadTodoList(): Promise<void> {
 		this.todoPhases = this.session.getTodoPhases();
 		this.#renderTodoList();
@@ -2035,6 +2265,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.loadingAnimation = undefined;
 		}
 		this.#cleanupMicAnimation();
+		this.#updateTodoSpinnerAnimation(false);
 		this.#cancelGoalContinuation();
 		if (this.#sttController) {
 			this.#sttController.dispose();

package/src/tools/ast-edit.ts

@@ -290,7 +290,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 					const absolutePath = path.resolve(this.session.cwd, relativePath);
 					try {
 						const fullText = normalizeToLF(await Bun.file(absolutePath).text());
-						const tag = snapshotStore.recordContiguous(absolutePath, 1, fullText.split("\n"), { fullText });
+						const tag = snapshotStore.record(absolutePath, fullText);
 						hashContexts.set(relativePath, { tag });
 					} catch {
 						// Best-effort: if a file disappears between ast-edit and rendering, emit plain line output.

package/src/tools/ast-grep.ts

@@ -1,5 +1,3 @@
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
 import * as path from "node:path";
 import { formatHashlineHeader } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
@@ -8,7 +6,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { getFileSnapshotStore } from "../edit/file-snapshot-store";
+import { recordFileSnapshot } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
@@ -221,17 +219,14 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			}
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
-			const hashContexts = new Map<string, { absolutePath: string; tag?: string }>();
-			const snapshotStore = useHashLines ? getFileSnapshotStore(this.session) : undefined;
+			const hashContexts = new Map<string, { tag: string }>();
 			if (useHashLines) {
 				for (const relativePath of fileList) {
 					const absolutePath = path.resolve(this.session.cwd, relativePath);
-					try {
-						await access(absolutePath, constants.R_OK);
-						hashContexts.set(relativePath, { absolutePath });
-					} catch {
-						// Best-effort: if a file disappears between ast-grep and rendering, emit plain line output.
-					}
+					// Whole-file content tag: any anchor validates while the file is
+					// unchanged; over-cap / unreadable files get no tag (plain output).
+					const tag = await recordFileSnapshot(this.session, absolutePath);
+					if (tag) hashContexts.set(relativePath, { tag });
 				}
 			}
 			const outputLines: string[] = [];
@@ -246,7 +241,6 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					const endLine = match.startLine + lineCount - 1;
 					return Math.max(width, String(match.startLine).length, String(endLine).length);
 				}, 0);
-				const cacheEntries: Array<readonly [number, string]> = [];
 				for (const match of fileMatches) {
 					const matchLines = match.text.split("\n");
 					for (let index = 0; index < matchLines.length; index++) {
@@ -257,7 +251,6 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 							formatMatchLine(lineNumber, line, isMatch, { useHashLines: hashContext !== undefined }),
 						);
 						displayOut.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
-						cacheEntries.push([lineNumber, line] as const);
 					}
 					if (match.metaVariables && Object.keys(match.metaVariables).length > 0) {
 						const serializedMeta = Object.entries(match.metaVariables)
@@ -269,10 +262,6 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					}
 					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 				}
-				if (hashContext && cacheEntries.length > 0) {
-					const tag = snapshotStore?.recordSparse(hashContext.absolutePath, cacheEntries);
-					if (tag) hashContext.tag = tag;
-				}
 				return { model: modelOut, display: displayOut };
 			};
 

package/src/tools/read.ts

@@ -9,7 +9,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, logger, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { getFileSnapshotStore } from "../edit/file-snapshot-store";
+import { getFileSnapshotStore, recordFileSnapshot } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -130,9 +130,7 @@ function recordFullHashlineContext(
 ): HashlineHeaderContext | undefined {
 	if (!absolutePath || !path.isAbsolute(absolutePath)) return undefined;
 	const normalized = normalizeToLF(fullText);
-	const tag = getFileSnapshotStore(session).recordContiguous(absolutePath, 1, normalized.split("\n"), {
-		fullText: normalized,
-	});
+	const tag = getFileSnapshotStore(session).record(absolutePath, normalized);
 	return {
 		header: formatHashlineHeader(displayPath, tag),
 		tag,
@@ -1033,7 +1031,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		const shouldAddHashLines = !rawSelector && displayMode.hashLines;
 		const shouldAddLineNumbers = rawSelector ? false : shouldAddHashLines ? false : displayMode.lineNumbers;
-		const sparseSnapshotEntries: Array<readonly [number, string]> = [];
 		const maxColumns = resolveOutputMaxColumns(this.session.settings);
 
 		const blocks: string[] = [];
@@ -1063,10 +1060,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			}
 
 			const collectedLines = streamResult.lines;
-			// Column truncation is display-only. The snapshot (sparseSnapshotEntries)
-			// MUST hold on-disk content so later edits can verify line content against
-			// the live file. Stamping ellipsis-truncated lines into the snapshot makes
-			// every long-line file uneditable on the next edit attempt.
+			// Column truncation is display-only; clone before stamping ellipsis so
+			// the original on-disk lines stay intact for display reconstruction.
 			let displayLines: string[] = collectedLines;
 			if (!rawSelector && maxColumns > 0) {
 				let cloned: string[] | undefined;
@@ -1080,19 +1075,16 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				}
 				if (cloned) displayLines = cloned;
 			}
-
-			for (let index = 0; index < collectedLines.length; index++) {
-				sparseSnapshotEntries.push([range.startLine + index, collectedLines[index]]);
-			}
-
 			const blockText = displayLines.join("\n");
 			blocks.push(formatTextWithMode(blockText, range.startLine, shouldAddHashLines, shouldAddLineNumbers));
 		}
 
 		let outputText = blocks.join("\n\n…\n\n");
-		if (shouldAddHashLines && sparseSnapshotEntries.length > 0 && outputText) {
-			const tag = getFileSnapshotStore(this.session).recordSparse(absolutePath, sparseSnapshotEntries);
-			outputText = `${formatHashlineHeader(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag)}\n${outputText}`;
+		if (shouldAddHashLines && outputText) {
+			const tag = await recordFileSnapshot(this.session, absolutePath);
+			if (tag) {
+				outputText = `${formatHashlineHeader(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag)}\n${outputText}`;
+			}
 		}
 		if (notices.length > 0) {
 			outputText = outputText ? `${outputText}\n${notices.join("\n")}` : notices.join("\n");
@@ -1905,17 +1897,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					const shouldAddLineNumbers = rawSelector ? false : shouldAddHashLines ? false : displayMode.lineNumbers;
 					let hashContext: HashlineHeaderContext | undefined;
 					if (shouldAddHashLines && collectedLines.length > 0 && !firstLineExceedsLimit) {
-						const store = getFileSnapshotStore(this.session);
-						const tag =
-							offset === undefined && limit === undefined && !wasTruncated
-								? (() => {
-										const normalized = normalizeToLF(collectedLines.join("\n"));
-										return store.recordContiguous(absolutePath, 1, normalized.split("\n"), {
-											fullText: normalized,
-										});
-									})()
-								: store.recordContiguous(absolutePath, startLineDisplay, collectedLines);
-						hashContext = hashlineHeaderContext(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag);
+						// The tag is a content hash of the WHOLE file. A whole-file read
+						// already holds every line in memory; a range read re-reads the
+						// file (bounded by SNAPSHOT_MAX_BYTES) so the tag fingerprints the
+						// full file and any anchor validates while the file is unchanged.
+						const isWholeFile = offset === undefined && limit === undefined && !wasTruncated;
+						const tag = isWholeFile
+							? getFileSnapshotStore(this.session).record(absolutePath, normalizeToLF(collectedLines.join("\n")))
+							: await recordFileSnapshot(this.session, absolutePath);
+						if (tag) {
+							hashContext = hashlineHeaderContext(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag);
+						}
 					}
 
 					let capturedDisplayContent: { text: string; startLine: number } | undefined;
@@ -2060,11 +2052,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const shouldAddLineNumbers = shouldAddHashLines ? false : displayMode.lineNumbers;
 
 		const rawText = region.lines.join("\n");
-		const hashContext = shouldAddHashLines
-			? hashlineHeaderContext(
-					formatPathRelativeToCwd(entry.absolutePath, this.session.cwd),
-					getFileSnapshotStore(this.session).recordContiguous(entry.absolutePath, region.startLine, region.lines),
-				)
+		const tag = shouldAddHashLines ? await recordFileSnapshot(this.session, entry.absolutePath) : undefined;
+		const hashContext = tag
+			? hashlineHeaderContext(formatPathRelativeToCwd(entry.absolutePath, this.session.cwd), tag)
 			: undefined;
 		const formattedBody = formatTextWithMode(rawText, region.startLine, shouldAddHashLines, shouldAddLineNumbers);
 		const formattedText = prependHashlineHeader(formattedBody, hashContext);

package/src/tools/search.ts

@@ -1,5 +1,4 @@
-import { constants } from "node:fs";
-import { access, mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { formatHashlineHeader } from "@oh-my-pi/hashline";
@@ -9,7 +8,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { getFileSnapshotStore } from "../edit/file-snapshot-store";
+import { recordFileSnapshot } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
@@ -610,19 +609,17 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					matchesByFile.get(relativePath)!.push(match);
 				}
 				const displayLines: string[] = [];
-				const hashContexts = new Map<string, { absolutePath: string; tag?: string }>();
-				const snapshotStore = baseDisplayMode.hashLines ? getFileSnapshotStore(this.session) : undefined;
+				const hashContexts = new Map<string, { tag: string }>();
 				if (baseDisplayMode.hashLines) {
 					for (const relativePath of fileList) {
 						if (archiveDisplaySet.has(relativePath)) continue;
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
 						if (immutableSourcePaths.has(absoluteFilePath)) continue;
-						try {
-							await access(absoluteFilePath, constants.R_OK);
-							hashContexts.set(relativePath, { absolutePath: absoluteFilePath });
-						} catch {
-							// Best-effort: if the file disappeared between grep and render, fall back to plain line output.
-						}
+						// Mint a whole-file content tag so any anchor validates while the
+						// file is unchanged; over-cap / unreadable files get no tag (and
+						// therefore plain, non-editable line output).
+						const tag = await recordFileSnapshot(this.session, absoluteFilePath);
+						if (tag) hashContexts.set(relativePath, { tag });
 					}
 				}
 				const renderMatchesForFile = (relativePath: string): { model: string[]; display: string[] } => {
@@ -641,40 +638,34 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						}
 						return nextWidth;
 					}, 0);
-					const cacheEntries: Array<readonly [number, string]> = [];
 					let lastEmittedLine: number | undefined;
 					const gutterPad = " ".repeat(lineNumberWidth + 1);
 					for (const match of fileMatches) {
-						const pushLine = (lineNumber: number, line: string, isMatch: boolean, recordable: boolean) => {
+						const pushLine = (lineNumber: number, line: string, isMatch: boolean) => {
 							if (lastEmittedLine !== undefined && lineNumber > lastEmittedLine + 1) {
 								modelOut.push("...");
 								displayOut.push(`${gutterPad}│...`);
 							}
 							modelOut.push(formatMatchLine(lineNumber, line, isMatch, { useHashLines }));
 							displayOut.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
-							if (recordable) cacheEntries.push([lineNumber, line] as const);
 							lastEmittedLine = lineNumber;
 						};
 						if (match.contextBefore) {
 							for (const ctx of match.contextBefore) {
-								pushLine(ctx.lineNumber, ctx.line, false, true);
+								pushLine(ctx.lineNumber, ctx.line, false);
 							}
 						}
-						pushLine(match.lineNumber, match.line, true, !match.truncated);
+						pushLine(match.lineNumber, match.line, true);
 						if (match.truncated) {
 							linesTruncated = true;
 						}
 						if (match.contextAfter) {
 							for (const ctx of match.contextAfter) {
-								pushLine(ctx.lineNumber, ctx.line, false, true);
+								pushLine(ctx.lineNumber, ctx.line, false);
 							}
 						}
 						fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 					}
-					if (cacheEntries.length > 0 && hashContext) {
-						const tag = snapshotStore?.recordSparse(hashContext.absolutePath, cacheEntries);
-						if (tag) hashContext.tag = tag;
-					}
 					return { model: modelOut, display: displayOut };
 				};
 				if (isDirectory) {