@oh-my-pi/pi-coding-agent 11.2.3 → 11.4.0

package/src/tools/render-utils.ts

@@ -7,9 +7,8 @@
 import * as os from "node:os";
 import { type Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
-import { getTreeBranch } from "../tui/utils";
 
-export { Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
+export { Ellipsis, replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 
 // =============================================================================
 // Standardized Display Constants
@@ -27,6 +26,10 @@ export const PREVIEW_LIMITS = {
 	OUTPUT_COLLAPSED: 3,
 	/** Output preview lines in expanded view */
 	OUTPUT_EXPANDED: 10,
+	/** Max hunks shown when collapsed (edit tool) */
+	DIFF_COLLAPSED_HUNKS: 8,
+	/** Max diff lines shown when collapsed (edit tool) */
+	DIFF_COLLAPSED_LINES: 40,
 } as const;
 
 /** Truncation lengths for different content types */
@@ -669,52 +672,9 @@ export function wrapBrackets(text: string, theme: Theme): string {
 	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
 }
 
-export function replaceTabs(text: string): string {
-	return text.replace(/\t/g, "   ");
-}
-
 function pluralize(label: string, count: number): string {
 	if (count === 1) return label;
 	if (/(?:ch|sh|s|x|z)$/i.test(label)) return `${label}es`;
 	if (/[^aeiou]y$/i.test(label)) return `${label.slice(0, -1)}ies`;
 	return `${label}s`;
 }
-
-// =============================================================================
-// Tree Rendering Utilities
-// =============================================================================
-/**
- * Render a list of items with tree branches, handling truncation.
- *
- * @param items - Full list of items to render
- * @param expanded - Whether view is expanded
- * @param maxCollapsed - Max items to show when collapsed
- * @param renderItem - Function to render a single item
- * @param itemType - Type name for "more X" message (e.g., "file", "entry")
- * @param theme - Theme instance
- * @returns Array of formatted lines
- */
-export function renderTreeList<T>(
-	items: T[],
-	expanded: boolean,
-	maxCollapsed: number,
-	renderItem: (item: T, branch: string, isLast: boolean, theme: Theme) => string,
-	itemType: string,
-	theme: Theme,
-): string[] {
-	const lines: string[] = [];
-	const maxItems = expanded ? items.length : Math.min(items.length, maxCollapsed);
-
-	for (let i = 0; i < maxItems; i++) {
-		const isLast = i === maxItems - 1 && (expanded || items.length <= maxCollapsed);
-		const branch = getTreeBranch(isLast, theme);
-		lines.push(renderItem(items[i], branch, isLast, theme));
-	}
-
-	if (!expanded && items.length > maxCollapsed) {
-		const remaining = items.length - maxCollapsed;
-		lines.push(` ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(remaining, itemType))}`);
-	}
-
-	return lines;
-}

package/src/tools/ssh.ts

@@ -12,7 +12,8 @@ import sshDescriptionBase from "../prompts/tools/ssh.md" with { type: "text" };
 import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
-import { renderOutputBlock, renderStatusLine } from "../tui";
+import { renderStatusLine } from "../tui";
+import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
@@ -249,7 +250,6 @@ export const sshToolRenderer = {
 		uiTheme: Theme,
 		args?: SshRenderArgs,
 	): Component {
-		const { expanded, renderContext } = options;
 		const details = result.details;
 		const host = args?.host || "…";
 		const command = args?.command || "…";
@@ -257,59 +257,62 @@ export const sshToolRenderer = {
 			{ icon: "success", title: "SSH", description: `[${host}] $ ${command}` },
 			uiTheme,
 		);
-		const outputLines: string[] = [];
-
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-		const output = textContent.trimEnd();
-
-		if (output) {
-			if (expanded) {
-				outputLines.push(...output.split("\n").map(line => uiTheme.fg("toolOutput", line)));
-			} else if (renderContext?.visualLines) {
-				const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
-				if (skippedCount > 0) {
-					outputLines.push(
-						uiTheme.fg(
-							"dim",
-							`… (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
-						),
-					);
-				}
-				const styledVisual = visualLines.map(line =>
-					line.includes("\x1b[") ? line : uiTheme.fg("toolOutput", line),
-				);
-				outputLines.push(...styledVisual);
-			} else {
-				const outputLinesRaw = output.split("\n");
-				const maxLines = 5;
-				const displayLines = outputLinesRaw.slice(0, maxLines);
-				const remaining = outputLinesRaw.length - maxLines;
-				outputLines.push(...displayLines.map(line => uiTheme.fg("toolOutput", line)));
-				if (remaining > 0) {
-					outputLines.push(uiTheme.fg("dim", `… (${remaining} more lines) (ctrl+o to expand)`));
-				}
-			}
-		}
-
 		const truncation = details?.meta?.truncation;
-		if (truncation) {
-			const warnings: string[] = [];
-			if (truncation.artifactId) {
-				warnings.push(`Full output: artifact://${truncation.artifactId}`);
-			}
-			if (truncation.truncatedBy === "lines") {
-				warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-			} else {
-				warnings.push(
-					`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.outputBytes)} limit)`,
-				);
-			}
-			outputLines.push(uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme)));
-		}
+		const outputBlock = new CachedOutputBlock();
 
 		return {
-			render: (width: number) =>
-				renderOutputBlock(
+			render: (width: number): string[] => {
+				// REACTIVE: read mutable options at render time
+				const { expanded, renderContext } = options;
+				const output = textContent.trimEnd();
+				const outputLines: string[] = [];
+
+				if (output) {
+					if (expanded) {
+						outputLines.push(...output.split("\n").map(line => uiTheme.fg("toolOutput", line)));
+					} else if (renderContext?.visualLines) {
+						const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
+						if (skippedCount > 0) {
+							outputLines.push(
+								uiTheme.fg(
+									"dim",
+									`… (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
+								),
+							);
+						}
+						const styledVisual = visualLines.map(line =>
+							line.includes("\x1b[") ? line : uiTheme.fg("toolOutput", line),
+						);
+						outputLines.push(...styledVisual);
+					} else {
+						const outputLinesRaw = output.split("\n");
+						const maxLines = 5;
+						const displayLines = outputLinesRaw.slice(0, maxLines);
+						const remaining = outputLinesRaw.length - maxLines;
+						outputLines.push(...displayLines.map(line => uiTheme.fg("toolOutput", line)));
+						if (remaining > 0) {
+							outputLines.push(uiTheme.fg("dim", `… (${remaining} more lines) (ctrl+o to expand)`));
+						}
+					}
+				}
+
+				if (truncation) {
+					const warnings: string[] = [];
+					if (truncation.artifactId) {
+						warnings.push(`Full output: artifact://${truncation.artifactId}`);
+					}
+					if (truncation.truncatedBy === "lines") {
+						warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+					} else {
+						warnings.push(
+							`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.outputBytes)} limit)`,
+						);
+					}
+					outputLines.push(uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme)));
+				}
+
+				return outputBlock.render(
 					{
 						header,
 						state: "success",
@@ -317,8 +320,11 @@ export const sshToolRenderer = {
 						width,
 					},
 					uiTheme,
-				),
-			invalidate: () => {},
+				);
+			},
+			invalidate: () => {
+				outputBlock.invalidate();
+			},
 		};
 	},
 	mergeCallAndResult: true,

package/src/tools/submit-result.ts

@@ -113,8 +113,8 @@ export class SubmitResultTool implements AgentTool<TObject, SubmitResultDetails>
 
 		// Skip validation when aborting - data is optional for aborts
 		if (status === "success") {
-			if (params.data === undefined) {
-				throw new Error("data is required when status is 'success'");
+			if (params.data === undefined || params.data === null) {
+				throw new Error("data is required when status is 'success' (got null/undefined)");
 			}
 			if (this.schemaError) {
 				throw new Error(`Invalid output schema: ${this.schemaError}`);

package/src/tools/todo-write.ts

@@ -11,7 +11,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
-import { renderStatusLine, renderTreeList } from "../tui";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { PREVIEW_LIMITS } from "./render-utils";
 
 const todoWriteSchema = Type.Object({
@@ -227,7 +227,6 @@ export const todoWriteToolRenderer = {
 		uiTheme: Theme,
 		_args?: TodoWriteRenderArgs,
 	): Component {
-		const { expanded } = options;
 		const todos = result.details?.todos ?? [];
 		const header = renderStatusLine(
 			{ icon: "success", title: "Todo Write", meta: [`${todos.length} items`] },
@@ -235,20 +234,39 @@ export const todoWriteToolRenderer = {
 		);
 		if (todos.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text ?? "No todos";
-			return new Text([header, uiTheme.fg("dim", fallback)].join("\n"), 0, 0);
+			const renderedLines = [header, uiTheme.fg("dim", fallback)];
+			return {
+				render() {
+					return renderedLines;
+				},
+				invalidate() {},
+			};
 		}
-		const lines = renderTreeList(
-			{
-				items: todos,
-				expanded,
-				maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-				itemType: "todo",
-				renderItem: todo => formatTodoLine(todo, uiTheme, ""),
-			},
-			uiTheme,
-		);
+		let cached: RenderCache | undefined;
 
-		return new Text([header, ...lines].join("\n"), 0, 0);
+		return {
+			render(width) {
+				const { expanded } = options;
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
+				const treeLines = renderTreeList(
+					{
+						items: todos,
+						expanded,
+						maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+						itemType: "todo",
+						renderItem: todo => formatTodoLine(todo, uiTheme, ""),
+					},
+					uiTheme,
+				);
+				const lines = [header, ...treeLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
+				cached = { key, lines };
+				return lines;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/truncate.ts

@@ -287,7 +287,7 @@ export function truncateLine(
 	if (line.length <= maxChars) {
 		return { text: line, wasTruncated: false };
 	}
-	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+	return { text: `${line.slice(0, maxChars)}…`, wasTruncated: true };
 }
 
 // =============================================================================

package/src/tools/write.ts

@@ -8,14 +8,14 @@ import type {
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
-import { renderStatusLine } from "../tui";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import { type OutputMeta, outputMeta } from "./output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
@@ -23,6 +23,7 @@ import {
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
+	replaceTabs,
 	shortenPath,
 	ToolUIKit,
 } from "./render-utils";
@@ -33,6 +34,8 @@ const writeSchema = Type.Object({
 	content: Type.String({ description: "Content to write to the file" }),
 });
 
+export type WriteToolInput = Static<typeof writeSchema>;
+
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {
 	diagnostics?: FileDiagnosticsResult;
@@ -158,7 +161,7 @@ function formatStreamingContent(content: string, uiTheme: Theme, ui: ToolUIKit):
 		text += uiTheme.fg("dim", `… (${hidden} earlier lines)\n`);
 	}
 	for (const line of displayLines) {
-		text += `${uiTheme.fg("toolOutput", ui.truncate(line, 80))}\n`;
+		text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
 	}
 	text += uiTheme.fg("dim", `… (streaming)`);
 	return text;
@@ -173,7 +176,7 @@ function renderContentPreview(content: string, expanded: boolean, uiTheme: Theme
 
 	let text = "\n\n";
 	for (const line of displayLines) {
-		text += `${uiTheme.fg("toolOutput", ui.truncate(line, 80))}\n`;
+		text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
 	}
 	if (!expanded && hidden > 0) {
 		const hint = formatExpandHint(uiTheme, expanded, hidden > 0);
@@ -208,7 +211,7 @@ export const writeToolRenderer = {
 
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails },
-		{ expanded }: RenderResultOptions,
+		options: RenderResultOptions,
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
 	): Component {
@@ -230,29 +233,42 @@ export const writeToolRenderer = {
 			},
 			uiTheme,
 		);
-		let text = header;
-
-		// Add metadata line
-		text += `\n${formatMetadataLine(lineCount, lang ?? "text", uiTheme)}`;
-
-		// Show content preview (collapsed tail, expandable)
-		text += renderContentPreview(fileContent, expanded, uiTheme, ui);
-
-		// Show diagnostics if available
-		if (result.details?.diagnostics) {
-			const diagText = formatDiagnostics(result.details.diagnostics, expanded, uiTheme, fp =>
-				uiTheme.getLangIcon(getLanguageFromPath(fp)),
-			);
-			if (diagText.trim()) {
-				const diagLines = diagText.split("\n");
-				const firstNonEmpty = diagLines.findIndex(line => line.trim());
-				if (firstNonEmpty >= 0) {
-					text += `\n${diagLines.slice(firstNonEmpty).join("\n")}`;
+		const metadataLine = formatMetadataLine(lineCount, lang ?? "text", uiTheme);
+		const diagnostics = result.details?.diagnostics;
+
+		let cached: RenderCache | undefined;
+
+		return {
+			render(width: number) {
+				const { expanded } = options;
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
+
+				let text = header;
+				text += `\n${metadataLine}`;
+				text += renderContentPreview(fileContent, expanded, uiTheme, ui);
+
+				if (diagnostics) {
+					const diagText = formatDiagnostics(diagnostics, expanded, uiTheme, fp =>
+						uiTheme.getLangIcon(getLanguageFromPath(fp)),
+					);
+					if (diagText.trim()) {
+						const diagLines = diagText.split("\n");
+						const firstNonEmpty = diagLines.findIndex(line => line.trim());
+						if (firstNonEmpty >= 0) {
+							text += `\n${diagLines.slice(firstNonEmpty).join("\n")}`;
+						}
+					}
 				}
-			}
-		}
 
-		return new Text(text, 0, 0);
+				const lines = text.split("\n").map(l => truncateToWidth(l, width, Ellipsis.Omit));
+				cached = { key, lines };
+				return lines;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
 	},
 	mergeCallAndResult: true,
 };

package/src/tui/code-cell.ts

@@ -90,7 +90,7 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
 		const displayLines = rawLines
 			.slice(0, maxLines)
-			.map(line => (line.includes("\x1b[") ? line : theme.fg("toolOutput", line)));
+			.map(line => (line.includes("\x1b[") ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))));
 		outputLines.push(...displayLines);
 		const remaining = rawLines.length - maxLines;
 		if (remaining > 0) {

package/src/tui/output-block.ts

@@ -4,7 +4,8 @@
 import { padding, visibleWidth } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import type { State } from "./types";
-import { getStateBgColor, padToWidth, truncateToWidth } from "./utils";
+import type { RenderCache } from "./utils";
+import { getStateBgColor, Hasher, padToWidth, truncateToWidth } from "./utils";
 
 export interface OutputBlockOptions {
 	header?: string;
@@ -31,7 +32,18 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 					? "accent"
 					: "dim";
 	const border = (text: string) => theme.fg(borderColor, text);
-	const bgFn = state && applyBg ? (text: string) => theme.bg(getStateBgColor(state), text) : undefined;
+	const bgFn = (() => {
+		if (!state || !applyBg) return undefined;
+		const bgAnsi = theme.getBgAnsi(getStateBgColor(state));
+		// Keep block background stable even if inner content contains SGR resets (e.g. "\x1b[0m"),
+		// which would otherwise clear the outer background mid-line.
+		return (text: string) => {
+			const stabilized = text
+				.replace(/\x1b\[(?:0)?m/g, m => `${m}${bgAnsi}`)
+				.replace(/\x1b\[49m/g, m => `${m}${bgAnsi}`);
+			return `${bgAnsi}${stabilized}\x1b[49m`;
+		};
+	})();
 
 	const buildBarLine = (leftChar: string, rightChar: string, label?: string, meta?: string): string => {
 		const left = border(`${leftChar}${cap}`);
@@ -69,7 +81,10 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
 		for (const line of allLines) {
-			const text = truncateToWidth(line, contentWidth);
+			// Sections may receive content that was already padded to terminal width
+			// (e.g. from Text.render()). Trailing spaces would trigger truncateToWidth()
+			// to append an ellipsis even when the *semantic* content fits.
+			const text = truncateToWidth(line.trimEnd(), contentWidth);
 			const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(text)));
 			const fullLine = `${contentPrefix}${text}${innerPadding}${contentSuffix}`;
 			lines.push(padToWidth(fullLine, lineWidth, bgFn));
@@ -84,3 +99,46 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 
 	return lines;
 }
+
+/**
+ * Cached wrapper around `renderOutputBlock`.
+ *
+ * Since output blocks are re-rendered on every frame (via `render(width)` closures),
+ * but their content rarely changes, this cache avoids redundant `visibleWidth()` and
+ * `padding()` computations on ~99% of render calls.
+ */
+export class CachedOutputBlock {
+	private cache?: RenderCache;
+
+	/** Render with caching. Returns cached result if options haven't changed. */
+	render(options: OutputBlockOptions, theme: Theme): string[] {
+		const key = this.buildKey(options);
+		if (this.cache?.key === key) return this.cache.lines;
+		const lines = renderOutputBlock(options, theme);
+		this.cache = { key, lines };
+		return lines;
+	}
+
+	/** Invalidate the cache, forcing a rebuild on next render. */
+	invalidate(): void {
+		this.cache = undefined;
+	}
+
+	private buildKey(options: OutputBlockOptions): bigint {
+		const h = new Hasher();
+		h.u32(options.width);
+		h.optional(options.header);
+		h.optional(options.headerMeta);
+		h.optional(options.state);
+		h.bool(options.applyBg ?? true);
+		if (options.sections) {
+			for (const s of options.sections) {
+				h.optional(s.label);
+				for (const line of s.lines) {
+					h.str(line);
+				}
+			}
+		}
+		return h.digest();
+	}
+}

package/src/tui/tree-list.ts

@@ -2,7 +2,7 @@
  * Hierarchical tree list rendering helper.
  */
 import type { Theme } from "../modes/theme/theme";
-import { formatMoreItems } from "../tools/render-utils";
+import { formatMoreItems, replaceTabs } from "../tools/render-utils";
 import type { TreeContext } from "./types";
 import { getTreeBranch, getTreeContinuePrefix } from "./utils";
 
@@ -35,12 +35,12 @@ export function renderTreeList<T>(options: TreeListOptions<T>, theme: Theme): st
 		const rendered = renderItem(items[i], context);
 		if (Array.isArray(rendered)) {
 			if (rendered.length === 0) continue;
-			lines.push(`${prefix}${rendered[0]}`);
+			lines.push(`${prefix}${replaceTabs(rendered[0])}`);
 			for (let j = 1; j < rendered.length; j++) {
-				lines.push(`${continuePrefix}${rendered[j]}`);
+				lines.push(`${continuePrefix}${replaceTabs(rendered[j])}`);
 			}
 		} else {
-			lines.push(`${prefix}${rendered}`);
+			lines.push(`${prefix}${replaceTabs(rendered)}`);
 		}
 	}
 

package/src/tui/utils.ts

@@ -5,7 +5,77 @@ import { padding, visibleWidth } from "@oh-my-pi/pi-tui";
 import type { Theme, ThemeBg } from "../modes/theme/theme";
 import type { IconType, State } from "./types";
 
-export { truncateToWidth } from "@oh-my-pi/pi-tui";
+export { Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
+
+/** Cached typed-array scratch space for hashing non-string primitives. */
+const hashBuf = new ArrayBuffer(8);
+const hashView = new DataView(hashBuf);
+const hashBytes1 = new Uint8Array(hashBuf, 0, 1);
+const hashBytes4 = new Uint8Array(hashBuf, 0, 4);
+const hashBytes8 = new Uint8Array(hashBuf, 0, 8);
+
+/**
+ * Incremental xxHash64 key builder.
+ *
+ * Chains `Bun.hash.xxHash64` calls via seeding — each fed value
+ * mixes into the running hash without intermediate string allocations.
+ * Accepts strings, numbers (u32), booleans, bigints, and `undefined`/`null`
+ * (hashed as a sentinel byte) natively.
+ */
+export class Hasher {
+	private h = 0n;
+
+	/** Feed a string. */
+	str(s: string): this {
+		hashView.setUint32(0, s.length);
+		this.h = Bun.hash.xxHash64(hashBytes4, this.h);
+		this.h = Bun.hash.xxHash64(s, this.h);
+		return this;
+	}
+
+	/** Feed an unsigned 32-bit integer. */
+	u32(n: number): this {
+		hashView.setUint32(0, n);
+		this.h = Bun.hash.xxHash64(hashBytes4, this.h);
+		return this;
+	}
+
+	/** Feed a 64-bit bigint. */
+	u64(n: bigint): this {
+		hashView.setBigUint64(0, n);
+		this.h = Bun.hash.xxHash64(hashBytes8, this.h);
+		return this;
+	}
+
+	/** Feed a boolean (single byte: 1 = true, 0 = false). */
+	bool(b: boolean): this {
+		hashView.setUint8(0, b ? 1 : 0);
+		this.h = Bun.hash.xxHash64(hashBytes1, this.h);
+		return this;
+	}
+
+	/** Feed a value that may be `undefined` or `null` (hashed as a 0xFF sentinel byte). */
+	optional(v: string | undefined | null): this {
+		if (v == null) {
+			hashView.setUint8(0, 0xff);
+			this.h = Bun.hash.xxHash64(hashBytes1, this.h);
+		} else {
+			this.h = Bun.hash.xxHash64(v, this.h);
+		}
+		return this;
+	}
+
+	/** Return the final hash digest. */
+	digest(): bigint {
+		return this.h;
+	}
+}
+
+/** Render-cache entry used by tool renderers. */
+export interface RenderCache {
+	key: bigint;
+	lines: string[];
+}
 
 export function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
 	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");

package/src/utils/frontmatter.ts

@@ -10,7 +10,7 @@ function toError(value: unknown): Error {
 }
 
 function truncate(content: string, maxLength: number): string {
-	return content.length > maxLength ? `${content.slice(0, maxLength)}...` : content;
+	return content.length > maxLength ? `${content.slice(0, maxLength)}…` : content;
 }
 
 export class FrontmatterError extends Error {

package/src/utils/title-generator.ts

@@ -84,7 +84,7 @@ export async function generateSessionTitle(
 
 	// Truncate message if too long
 	const truncatedMessage =
-		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
+		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
 	const userMessage = `<user-message>\n${truncatedMessage}\n</user-message>`;
 
 	for (const model of candidates) {