@oh-my-pi/pi-coding-agent 15.5.12 → 15.5.15

package/src/session/session-manager.ts

@@ -702,6 +702,53 @@ export function buildSessionContext(
 		}
 	}
 
+	// Strip dangling tool_use blocks — a tool_use with no matching tool_result on the
+	// resolved leaf→root path — from ANY assistant turn, not just the trailing one.
+	// This happens whenever the leaf (or a branch point) lands such that an assistant
+	// turn's tool results are off the selected path: its result children live on a
+	// sibling branch, or it is the leaf itself (results are children below it). Left
+	// in place, `transformMessages` fabricates one synthetic "aborted"/"No result
+	// provided" result per dangling call plus a `<turn-aborted>` developer note, which
+	// render as phantom failed calls and re-inject the failed batch into the model's
+	// context — the rewind/restore loop.
+	//
+	// Stripping is necessary but not sufficient: a *modified* assistant turn that still
+	// carries signed `thinking`/`redacted_thinking` is rejected by Anthropic — "thinking
+	// blocks in the latest assistant message cannot be modified", and signed thinking
+	// replayed out of its original turn shape can also fail signature validation (this
+	// bites the handoff/branch-summary request). So when we rewrite a turn we also
+	// neutralize its protected reasoning: drop `redactedThinking` (encrypted, no
+	// plaintext to keep) and clear `thinking` signatures so the provider encoder
+	// downgrades them to plain text (verified accepted by the live API), preserving the
+	// visible reasoning while removing the immutability/invalid-signature hazard. Drop a
+	// turn left with no content. (Live turns never qualify: their results are persisted
+	// on the same path before any context rebuild.)
+	const pairedToolResultIds = new Set<string>();
+	for (const message of messages) {
+		if (message.role === "toolResult") pairedToolResultIds.add(message.toolCallId);
+	}
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		const hasDangling = message.content.some(
+			block => block.type === "toolCall" && !pairedToolResultIds.has(block.id),
+		);
+		if (!hasDangling) continue;
+		const normalized = message.content
+			.filter(
+				block =>
+					!(block.type === "toolCall" && !pairedToolResultIds.has(block.id)) && block.type !== "redactedThinking",
+			)
+			.map(block =>
+				block.type === "thinking" && block.thinkingSignature ? { ...block, thinkingSignature: undefined } : block,
+			);
+		if (normalized.length === 0) {
+			messages.splice(i, 1);
+		} else {
+			messages[i] = { ...message, content: normalized };
+		}
+	}
+
 	return {
 		messages,
 		thinkingLevel,

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/eval.ts

@@ -13,10 +13,19 @@ import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
-import { getTreeBranch, getTreeContinuePrefix, renderCodeCell } from "../tui";
+import { renderCodeCell } from "../tui";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { resolveEvalBackends, type ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
+import {
+	JSON_TREE_MAX_DEPTH_COLLAPSED,
+	JSON_TREE_MAX_DEPTH_EXPANDED,
+	JSON_TREE_MAX_LINES_COLLAPSED,
+	JSON_TREE_MAX_LINES_EXPANDED,
+	JSON_TREE_SCALAR_LEN_COLLAPSED,
+	JSON_TREE_SCALAR_LEN_EXPANDED,
+	renderJsonTreeLines,
+} from "./json-tree";
 import {
 	formatStyledTruncationWarning,
 	resolveOutputMaxColumns,
@@ -61,15 +70,6 @@ export type EvalToolResult = {
 
 export type EvalProxyExecutor = (params: EvalToolParams, signal?: AbortSignal) => Promise<EvalToolResult>;
 
-function formatJsonScalar(value: unknown): string {
-	if (value === null) return "null";
-	if (value === undefined) return "undefined";
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
-	if (typeof value === "function") return "[function]";
-	return "[object]";
-}
-
 /** Cap per `display()` value sent back to the model. */
 const MAX_DISPLAY_TEXT_BYTES = 8000;
 
@@ -102,41 +102,6 @@ function formatDisplayOutputsForText(outputs: EvalDisplayOutput[]): string {
 	return chunks.join("\n\n");
 }
 
-function renderJsonTree(value: unknown, theme: Theme, expanded: boolean, maxDepth = expanded ? 6 : 2): string[] {
-	const maxItems = expanded ? 20 : 5;
-
-	const renderNode = (node: unknown, prefix: string, depth: number, isLast: boolean, label?: string): string[] => {
-		const branch = getTreeBranch(isLast, theme);
-		const displayLabel = label ? `${label}: ` : "";
-
-		if (depth >= maxDepth || node === null || typeof node !== "object") {
-			return [`${prefix}${branch} ${displayLabel}${formatJsonScalar(node)}`];
-		}
-
-		const isArray = Array.isArray(node);
-		const entries = isArray
-			? node.map((val, index) => [String(index), val] as const)
-			: Object.entries(node as object);
-		const header = `${prefix}${branch} ${displayLabel}${isArray ? `Array(${entries.length})` : `Object(${entries.length})`}`;
-		const lines = [header];
-
-		const childPrefix = prefix + getTreeContinuePrefix(isLast, theme);
-		const visible = entries.slice(0, maxItems);
-		for (let i = 0; i < visible.length; i++) {
-			const [key, val] = visible[i];
-			const childLast = i === visible.length - 1 && (expanded || entries.length <= maxItems);
-			lines.push(...renderNode(val, childPrefix, depth + 1, childLast, isArray ? `[${key}]` : key));
-		}
-		if (!expanded && entries.length > maxItems) {
-			const moreBranch = theme.tree.last;
-			lines.push(`${childPrefix}${moreBranch} ${entries.length - maxItems} more item(s)`);
-		}
-		return lines;
-	};
-
-	return renderNode(value, "", 0, true);
-}
-
 export interface EvalToolDescriptionOptions {
 	py?: boolean;
 	js?: boolean;
@@ -669,6 +634,7 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		sh: "icon.package",
 		env: "icon.package",
 		batch: "icon.package",
+		llm: "icon.package",
 	};
 
 	const iconKey = opIcons[op] ?? "icon.file";
@@ -735,6 +701,11 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		case "batch":
 			parts.push(`${data.files} file${(data.files as number) !== 1 ? "s" : ""} processed`);
 			break;
+		case "llm":
+			if (data.model) parts.push(String(data.model));
+			if (data.tier && data.tier !== data.model) parts.push(`(${data.tier})`);
+			parts.push(`${data.chars ?? 0} chars`);
+			break;
 		case "wc":
 			parts.push(`${data.lines}L ${data.words}W ${data.chars}C`);
 			break;
@@ -950,10 +921,15 @@ export const evalToolRenderer = {
 		const output = stripOutputNotice(rawOutput, details?.meta).trimEnd();
 
 		const jsonOutputs = details?.jsonOutputs ?? [];
+		const treeExpanded = options.renderContext?.expanded ?? options.expanded;
+		const treeDepth = treeExpanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+		const treeLineCap = treeExpanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+		const treeScalarLen = treeExpanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+		const labelOutputs = jsonOutputs.length > 1;
 		const jsonLines = jsonOutputs.flatMap((value, index) => {
-			const header = `JSON output ${index + 1}`;
-			const treeLines = renderJsonTree(value, uiTheme, options.renderContext?.expanded ?? options.expanded);
-			return [header, ...treeLines];
+			const tree = renderJsonTreeLines(value, uiTheme, treeDepth, treeLineCap, treeScalarLen);
+			const body = tree.truncated ? [...tree.lines, uiTheme.fg("dim", "…")] : tree.lines;
+			return labelOutputs ? [uiTheme.fg("dim", `display[${index + 1}]`), ...body] : body;
 		});
 
 		const timeoutSeconds = options.renderContext?.timeout;

package/src/tools/index.ts

@@ -28,7 +28,6 @@ import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
-import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
@@ -69,7 +68,6 @@ export * from "./ast-edit";
 export * from "./ast-grep";
 export * from "./bash";
 export * from "./browser";
-export * from "./calculator";
 export * from "./checkpoint";
 export * from "./debug";
 export * from "./eval";
@@ -286,7 +284,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: AskTool.createIf,
 	debug: DebugTool.createIf,
 	eval: s => new EvalTool(s),
-	calc: s => new CalculatorTool(s),
 	ssh: loadSshTool,
 	github: GithubTool.createIf,
 	find: s => new FindTool(s),
@@ -455,7 +452,6 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
 		if (name === "search_tool_bm25") return discoveryActive;
-		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") {

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/renderers.ts

@@ -16,7 +16,6 @@ import { astEditToolRenderer } from "./ast-edit";
 import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
 import { browserToolRenderer } from "./browser/render";
-import { calculatorToolRenderer } from "./calculator";
 import { debugToolRenderer } from "./debug";
 import { evalToolRenderer } from "./eval";
 import { findToolRenderer } from "./find";
@@ -54,7 +53,6 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	recipe: recipeToolRenderer as ToolRenderer,
 	debug: debugToolRenderer as ToolRenderer,
 	eval: evalToolRenderer as ToolRenderer,
-	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
 	apply_patch: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,

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) {

package/src/tools/write.ts

@@ -130,9 +130,7 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 function maybeWriteSnapshotHeader(session: ToolSession, absolutePath: string, content: string): string | undefined {
 	if (!resolveFileDisplayMode(session).hashLines) return undefined;
 	const normalized = normalizeToLF(content);
-	const tag = getFileSnapshotStore(session).recordContiguous(absolutePath, 1, normalized.split("\n"), {
-		fullText: normalized,
-	});
+	const tag = getFileSnapshotStore(session).record(absolutePath, normalized);
 	return formatHashlineHeader(formatPathRelativeToCwd(absolutePath, session.cwd), tag);
 }
 

package/src/utils/file-mentions.ts

@@ -359,9 +359,7 @@ export async function generateFileMentionMessages(
 			const normalized = snapshotStore ? normalizeToLF(content) : content;
 			let { output, lineCount } = buildTextOutput(normalized);
 			if (snapshotStore) {
-				const tag = snapshotStore.recordContiguous(absolutePath, 1, normalized.split("\n"), {
-					fullText: normalized,
-				});
+				const tag = snapshotStore.record(absolutePath, normalized);
 				output = `${formatHashlineHeader(resolvedPath, tag)}\n${formatNumberedLines(output)}`;
 			}
 			files.push({ path: resolvedPath, content: output, lineCount });

package/dist/types/tools/calculator.d.ts

@@ -1,77 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import type { ToolSession } from ".";
-declare const calculatorSchema: z.ZodObject<{
-    calculations: z.ZodArray<z.ZodObject<{
-        expression: z.ZodString;
-        prefix: z.ZodString;
-        suffix: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export interface CalculatorToolDetails {
-    results: Array<{
-        expression: string;
-        value: number;
-        output: string;
-    }>;
-}
-type CalculatorParams = z.infer<typeof calculatorSchema>;
-/**
- * Calculator tool for evaluating mathematical expressions.
- *
- * Supports decimal, hex (0x), binary (0b), octal (0o) literals,
- * standard arithmetic operators, and parentheses.
- */
-export declare class CalculatorTool implements AgentTool<typeof calculatorSchema, CalculatorToolDetails> {
-    readonly name = "calc";
-    readonly approval: "read";
-    readonly label = "Calc";
-    readonly summary = "Evaluate a mathematical expression";
-    readonly loadMode = "discoverable";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        calculations: z.ZodArray<z.ZodObject<{
-            expression: z.ZodString;
-            prefix: z.ZodString;
-            suffix: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    constructor(_session: ToolSession);
-    execute(_toolCallId: string, { calculations }: CalculatorParams, signal?: AbortSignal): Promise<AgentToolResult<CalculatorToolDetails>>;
-}
-interface CalculatorRenderArgs {
-    calculations?: Array<{
-        expression: string;
-        prefix?: string;
-        suffix?: string;
-    }>;
-}
-/**
- * TUI renderer for calculator tool calls and results.
- * Handles both collapsed (preview) and expanded (full) display modes.
- */
-export declare const calculatorToolRenderer: {
-    /**
-     * Render the tool call header showing the first expression and count.
-     * Format: "Calc <expression> (N calcs)"
-     */
-    renderCall(args: CalculatorRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
-    /**
-     * Render calculation results as a tree list.
-     * Collapsed mode shows first N items with expand hint; expanded shows all.
-     */
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: CalculatorToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme, args?: CalculatorRenderArgs): Component;
-    mergeCallAndResult: boolean;
-};
-export {};

package/src/prompts/tools/calculator.md

@@ -1,10 +0,0 @@
-Performs basic calculations.
-
-<instruction>
-- Supports +, -, *, /, %, ** and parentheses
-- Supports decimal, hex (0x), binary (0b), and octal (0o) literals
-</instruction>
-
-<output>
-Returns each calculation result with its prefix and suffix applied.
-</output>