pi-posthorse 0.9.1 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.9.1",
+	"version": "0.9.2",
 	"type": "module",
 	"description": "Posthorse: fresh context, same journey. No-summary context rollover for Pi, with sparse budget reminders, handoffs, notes, and history.",
 	"keywords": [
@@ -32,7 +32,7 @@
 	},
 	"scripts": {
 		"check": "tsc",
-		"quality:prepare": "node scripts/setup-oxlint-engine.ts && node scripts/setup-quality-engine.ts",
+		"quality:prepare": "node scripts/quality-prepare.ts",
 		"quality:policy": "node scripts/quality-policy.ts",
 		"quality:probes": "npm run quality:prepare && node --test test/quality*.test.ts",
 		"lint": "npm run quality:prepare && npm run quality:policy && oxlint --deny-warnings .",
@@ -42,9 +42,9 @@
 		"format:check": "oxfmt --check .",
 		"build": "npm pack --dry-run",
 		"verify": "npm run lint && npm run format:check && npm run check:compat && npm run build",
-		"check:compat": "npm run check && npm test && npm run test:native",
+		"check:compat": "npm run check && npm test",
 		"test:native": "node --import ./test/pi-loader.ts --test test/host.test.mjs",
-		"test": "npm run quality:prepare && node --import ./test/pi-loader.ts --test test/*.test.ts",
+		"test": "npm run quality:prepare && node --import ./test/pi-loader.ts --test test/*.test.ts test/host.test.mjs",
 		"prepublishOnly": "npm run verify"
 	},
 	"peerDependencies": {

package/src/files.ts

@@ -112,25 +112,31 @@ export async function publishFile(
 		throw error;
 	}
 }
-/** Split on LF only; Unicode line separators are valid inside JSONL strings and notes. */
-export async function* lfLines(file: string, signal?: AbortSignal): AsyncGenerator<string> {
-	const stream = createReadStream(file, { encoding: "utf8", signal });
-	let pending: string[] = [];
+/** Raw LF-delimited lines; UTF-8 never encodes LF inside another character. */
+export async function* lfLines(
+	file: string,
+	signal?: AbortSignal,
+	highWaterMark = 64 * 1024,
+): AsyncGenerator<Buffer> {
+	const stream = createReadStream(file, { signal, highWaterMark });
+	let pending: Buffer[] = [];
 	for await (const chunk of stream) {
-		if (typeof chunk !== "string") {
-			throw new Error("Expected a UTF-8 text stream.");
+		if (!Buffer.isBuffer(chunk)) {
+			throw new Error("Expected a byte stream.");
+		}
+		let start = 0;
+		for (let end = chunk.indexOf(10); end !== -1; end = chunk.indexOf(10, start)) {
+			const line = chunk.subarray(start, end);
+			yield pending.length === 0 ? line : Buffer.concat([...pending, line]);
+			pending = [];
+			start = end + 1;
 		}
-		const lines = chunk.split("\n");
-		pending.push(lines[0] ?? "");
-		if (lines.length > 1) {
-			yield pending.join("");
-			yield* lines.slice(1, -1);
-			pending = [lines.at(-1) ?? ""];
+		if (start < chunk.length) {
+			pending.push(chunk.subarray(start));
 		}
 	}
-	const last = pending.join("");
-	if (last !== "") {
-		yield last;
+	if (pending.length > 0) {
+		yield Buffer.concat(pending);
 	}
 }
 /** Git's heuristic: a NUL in the first 8,000 bytes marks binary content. */

package/src/history-search.ts

@@ -10,8 +10,9 @@ import {
 import { historyHit, seenText, reverseWindowEntries } from "./history-entries.ts";
 import { shortKey } from "./message-text.ts";
 import {
-	filesContaining,
+	needleLines,
 	prefilterNeedles,
+	type RawLine,
 	scopedSessionFiles,
 	sessionWindowEntries,
 } from "./session-files.ts";
@@ -192,13 +193,14 @@ async function scanArchive(
 		readonly source: string;
 		readonly query: string;
 		readonly signal?: AbortSignal;
+		readonly wanted?: (bytes: RawLine) => boolean;
 		readonly inContext: (entry: EntryLike) => boolean;
 	},
 	accumulator: SearchProgress,
 ): Promise<{ readonly groups: readonly (readonly HistoryHit[])[]; readonly skipped: number }> {
 	const collector = archiveCollector(accumulator);
 	let skipped = 0;
-	for await (const item of sessionWindowEntries(file, options.signal)) {
+	for await (const item of sessionWindowEntries(file, options.signal, options.wanted)) {
 		const hit = historyHit(item, options.query, options.source);
 		if (hit === undefined) {
 			continue;
@@ -221,10 +223,7 @@ async function archivedMatches(
 	accumulator: SearchProgress,
 ): Promise<number> {
 	const needles = prefilterNeedles(search.query);
-	const candidates =
-		needles === undefined
-			? undefined
-			: await filesContaining(source.dir, needles, search.signal);
+	const wanted = needles === undefined ? undefined : needleLines(needles);
 	const current =
 		source.currentFile === undefined || source.currentFile === ""
 			? undefined
@@ -235,7 +234,7 @@ async function archivedMatches(
 		cwd: source.cwd,
 		currentFile: source.currentFile,
 		signal: search.signal,
-		candidates: candidates === undefined ? undefined : (candidate) => candidates.has(candidate),
+		needles,
 	})) {
 		const inCurrent = resolve(file) === current;
 		const recent = await scanArchive(
@@ -244,6 +243,7 @@ async function archivedMatches(
 				source: relative(source.dir, file),
 				query: search.query,
 				signal: search.signal,
+				wanted,
 				inContext: (entry) => inCurrent && search.inContext(entry),
 			},
 			accumulator,

package/src/history.ts

@@ -7,7 +7,7 @@ import { toWindowedEntry, windowProjection } from "./history-entries.ts";
 import { historyReadPage, searchPage } from "./history-pages.ts";
 import { historyMatches, type HistorySource } from "./history-search.ts";
 import type { PageAccess } from "./paging.ts";
-import { filesContaining, scopedSessionFiles, sessionWindowEntries } from "./session-files.ts";
+import { scopedSessionFiles, sessionWindowEntries } from "./session-files.ts";
 
 type LocatedEntry = { readonly item: WindowedEntry; readonly source: string };
 function entryReference(id: string): { readonly entryId: string; readonly fileKey?: string } {
@@ -38,19 +38,20 @@ async function findEntry(
 	if (current !== undefined) {
 		return { item: current, source: "" };
 	}
-	const candidates =
-		fileKey === undefined && /^[\w-]+$/.test(entryId)
-			? await filesContaining(source.dir, [`"id":"${entryId}"`], signal)
-			: undefined;
 	for await (const file of scopedSessionFiles({
 		dir: source.dir,
 		cwd: source.cwd,
 		currentFile: source.currentFile,
 		signal,
 		fileKey,
-		candidates: candidates === undefined ? undefined : (candidate) => candidates.has(candidate),
+		needles:
+			fileKey === undefined && /^[\w-]+$/.test(entryId) ? [`"id":"${entryId}"`] : undefined,
 	})) {
-		for await (const item of sessionWindowEntries(file, signal, entryId)) {
+		for await (const item of sessionWindowEntries(
+			file,
+			signal,
+			(_bytes, entry) => entry.id === entryId,
+		)) {
 			return { item, source: relative(source.dir, file) };
 		}
 	}

package/src/session-files.ts

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
 
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
@@ -14,13 +15,21 @@ import { lfLines } from "./files.ts";
 import { toWindowedEntry, windowProjection } from "./history-entries.ts";
 import { shortKey } from "./message-text.ts";
 
+/** Newest archive bytes searched before the rest; common queries finish within them. */
+const FIRST_SEARCH_BYTES = 256 * 1024 * 1024;
+/** File-list characters per ripgrep run, within Windows' 32,767 and POSIX ARG_MAX limits. */
+const ARGUMENT_CHARS = process.platform === "win32" ? 30_000 : 256 * 1024;
+/** Pi writes these keys first, so most lines yield window metadata without JSON.parse. */
+const ENTRY_HEAD = /^\{"type":"([^"\\]*)","id":"([^"\\]*)","parentId":(null|"[^"\\]*")[,}]/u;
+
 function execFileText(
 	file: string,
 	args: readonly string[],
+	cwd: string,
 	signal?: AbortSignal,
 ): Promise<string> {
 	return new Promise((resolveOutput, reject) => {
-		execFile(file, args, { signal, maxBuffer: 64 * 1024 * 1024 }, (error, stdout) => {
+		execFile(file, args, { cwd, signal, maxBuffer: 64 * 1024 * 1024 }, (error, stdout) => {
 			if (error !== null) {
 				const failure: Error = error;
 				reject(failure);
@@ -30,65 +39,127 @@ function execFileText(
 		});
 	});
 }
-/** Raw JSONL needles must cover every match in normalized text; otherwise scan all files. */
+/** Label text normalization adds, and raw JSONL that every entry showing it contains. */
+const LABEL_SOURCES: readonly (readonly [label: string, needles: readonly string[]])[] = [
+	["call id", ['"type":"toolCall"', '"toolCallId"']],
+	["execution arguments", ['"executionArguments"']],
+	["no handoff", ['"type":"context_window"']],
+	["excluded from model context by pi", ['"excludeFromContext":true']],
+	["images", ['"type":"image"']],
+	["unknown type", ['"type":"image"']],
+	["unknown", ['"type":"custom_message"']],
+];
+/**
+ * Raw JSONL needles, one of which every line rendering the lowercase query contains; undefined
+ * means every line must be scanned.
+ */
 export function prefilterNeedles(query: string): string[] | undefined {
-	if (/["\\[\](){}:$\p{Cc}]/u.test(query) || query.trim() !== query) {
+	// A match contains every fragment between characters that JSON escapes or labels may add.
+	const [fragment] = query
+		.split(/["\\[\](){}:$\p{Cc}\p{Cs}]/u)
+		.map((part) => part.trim())
+		.sort((a, b) => b.length - a.length);
+	if (fragment === "") {
 		return undefined;
 	}
-	if (
-		["call id", "execution arguments", "no handoff", "excluded from model context by pi"].some(
-			(phrase) => phrase.includes(query),
-		)
-	) {
-		return undefined;
+	const image = fragment.includes(",") || /^\d+ ?i?m?a?g?e?s?$/.test(fragment);
+	return [
+		fragment,
+		...LABEL_SOURCES.filter(([label]) => label.includes(fragment)).flatMap(
+			([, needles]) => needles,
+		),
+		...(image ? ['"type":"image"'] : []),
+		// İ lowercases to i + U+0307, which case-insensitive raw matching cannot see.
+		...(/i|\u0307/u.test(fragment) ? ["\u0130"] : []),
+	];
+}
+/** UTF-8 of the only non-ASCII characters that case-fold to ASCII letters, read as Latin-1. */
+const ASCII_FOLDS: Readonly<Partial<Record<string, string>>> = {
+	k: "\u00e2\u0084\u00aa",
+	s: "\u00c5\u00bf",
+};
+const DOTTED_I = Buffer.from("\u0130");
+/** The read capabilities line filters need from a raw journal line. */
+export type RawLine = Readonly<Pick<Buffer, "includes" | "toString">>;
+/** Whether a raw line contains one of prefilterNeedles' needles, ignoring case like its text would. */
+export function needleLines(needles: readonly string[]): (bytes: RawLine) => boolean {
+	const others = needles.filter((needle) => needle !== "\u0130");
+	const dotted = others.length < needles.length;
+	if (others.every((needle) => /^[\0-\x7f]*$/u.test(needle))) {
+		// ASCII text matches its Latin-1 byte view, so most lines are never decoded as UTF-8.
+		const latin1 = others.map((needle) =>
+			needle
+				.split("")
+				.map((char) => {
+					const fold = ASCII_FOLDS[char.toLowerCase()];
+					return fold === undefined ? RegExp.escape(char) : `(?:${char}|${fold})`;
+				})
+				.join(""),
+		);
+		const pattern = new RegExp(latin1.join("|"), "i");
+		return (bytes) =>
+			(dotted && bytes.includes(DOTTED_I)) || pattern.test(bytes.toString("latin1"));
 	}
-	const image =
-		query.includes(",") ||
-		/^\d+ ?i?m?a?g?e?s?$/.test(query) ||
-		["images", "unknown type"].some((phrase) => phrase.includes(query));
-	return image ? [query, '"type":"image"'] : [query];
+	const pattern = new RegExp(needles.map((needle) => RegExp.escape(needle)).join("|"), "iu");
+	return (bytes) => pattern.test(bytes.toString("utf8"));
 }
-export async function filesContaining(
+/** File lists that each fit one ripgrep command line. */
+function commandGroups(paths: readonly string[]): string[][] {
+	const groups: string[][] = [];
+	let group: string[] = [];
+	let chars = 0;
+	for (const path of paths) {
+		if (group.length > 0 && chars + path.length > ARGUMENT_CHARS) {
+			groups.push(group);
+			group = [];
+			chars = 0;
+		}
+		group.push(path);
+		chars += path.length + 1;
+	}
+	return group.length > 0 ? [...groups, group] : groups;
+}
+/** Files containing a needle, per ripgrep; files of a failed run stay candidates. */
+function ripgrepFilter(
 	dir: string,
 	needles: readonly string[],
 	signal?: AbortSignal,
-): Promise<Set<string> | undefined> {
-	const args = [
+): (files: readonly string[]) => Promise<string[]> {
+	let binaries = [join(getAgentDir(), "bin", "rg"), "rg"];
+	const flags = [
 		"--files-with-matches",
+		"--null",
 		"--fixed-strings",
 		"--ignore-case",
-		"--no-ignore",
-		"--hidden",
 		"--no-messages",
-		"--glob",
-		"*.jsonl",
 		...needles.flatMap((needle) => ["--regexp", needle]),
-		dir,
+		"--",
 	];
-	for (const rg of [join(getAgentDir(), "bin", "rg"), "rg"]) {
-		try {
-			// Try the host-managed binary first; PATH is a fallback only when it is unavailable.
-			// oxlint-disable-next-line no-await-in-loop
-			const stdout = await execFileText(rg, args, signal);
-			return new Set(
-				stdout
-					.split("\n")
-					.filter((file) => file !== "")
-					.map((file) => resolve(file)),
-			);
-		} catch (error) {
-			const code = isRecord(error) ? error.code : undefined;
-			if (code === 1) {
-				return new Set();
+	const matching = async (paths: readonly string[]): Promise<readonly string[]> => {
+		for (const binary of binaries) {
+			try {
+				// Try the host-managed binary first; PATH is a fallback only when it is unavailable.
+				// oxlint-disable-next-line no-await-in-loop
+				return (await execFileText(binary, [...flags, ...paths], dir, signal)).split("\0");
+			} catch (error) {
+				const code = isRecord(error) ? error.code : undefined;
+				if (code === 1) {
+					return [];
+				}
+				if (code !== "ENOENT") {
+					signal?.throwIfAborted();
+					return paths;
+				}
+				binaries = binaries.filter((candidate) => candidate !== binary);
 			}
-			if (code === "ENOENT") {
-				continue;
-			}
-			signal?.throwIfAborted();
-			return undefined;
 		}
-	}
-	return;
+		return paths;
+	};
+	return async (files) => {
+		const paths = files.map((file) => relative(dir, file));
+		const found = new Set((await Promise.all(commandGroups(paths).map(matching))).flat());
+		return files.filter((_file, index) => found.has(paths[index]));
+	};
 }
 function messageFrom(value: unknown): MessageLike | undefined {
 	if (!isRecord(value)) {
@@ -138,40 +209,90 @@ function parsedEntry(line: string): EntryLike | undefined {
 		return undefined;
 	} // Pi skips malformed journal lines too.
 }
+/** Window metadata of a Pi-ordered line that cannot open a window, without parsing it. */
+function entryHead(bytes: RawLine): EntryLike | undefined {
+	const head = ENTRY_HEAD.exec(bytes.toString("utf8", 0, 512));
+	if (head === null || head[1] === "compaction" || head[1] === "context_window") {
+		return undefined;
+	}
+	return {
+		type: head[1],
+		id: head[2],
+		parentId: head[3] === "null" ? null : head[3].slice(1, -1),
+	};
+}
+/** Whether a caller may need a line; other lines only advance window ancestry. */
+type LineFilter = (bytes: RawLine, entry: EntryLike) => boolean;
 export async function* sessionWindowEntries(
 	file: string,
 	signal?: AbortSignal,
-	entryId?: string,
+	wanted: LineFilter = () => true,
 ): AsyncGenerator<WindowedEntry> {
 	if (!existsSync(file)) {
 		return;
 	}
 	const project = windowProjection();
-	for await (const line of lfLines(file, signal)) {
-		const entry = parsedEntry(line);
-		if (entry === undefined) {
+	for await (const bytes of lfLines(file, signal, 1024 * 1024)) {
+		const head = entryHead(bytes);
+		if (head !== undefined && !wanted(bytes, head)) {
+			project(head);
 			continue;
 		}
-		const windowId = project(entry);
-		if (entryId !== undefined && entry.id !== entryId) {
+		const entry = parsedEntry(bytes.toString("utf8"));
+		if (entry === undefined) {
 			continue;
 		}
-		const item = toWindowedEntry(entry, windowId);
+		const windowId = project(entry);
+		const item =
+			head !== undefined || wanted(bytes, entry)
+				? toWindowedEntry(entry, windowId)
+				: undefined;
 		if (item !== undefined) {
 			yield item;
 		}
 	}
 }
-function sessionFiles(dir: string): string[] {
-	if (!existsSync(dir)) {
-		return [];
+/** Breadth-first, like readdirSync's recursive order, reading each level concurrently. */
+async function sessionFiles(dir: string): Promise<string[]> {
+	const files: string[] = [];
+	let level = existsSync(dir) ? [dir] : [];
+	while (level.length > 0) {
+		// Each level lists the directories the previous level found.
+		// oxlint-disable-next-line no-await-in-loop
+		const listings = await Promise.all(
+			level.map((path) => readdir(path, { withFileTypes: true })),
+		);
+		level = [];
+		for (const entry of listings.flat()) {
+			const path = join(entry.parentPath, entry.name);
+			if (entry.isDirectory()) {
+				level.push(path);
+			} else if (
+				entry.isFile() &&
+				entry.name.endsWith(".jsonl") &&
+				!entry.name.includes(".intent.")
+			) {
+				files.push(path);
+			}
+		}
 	}
-	return readdirSync(dir, { recursive: true, withFileTypes: true })
-		.filter(
-			(entry) =>
-				entry.isFile() && entry.name.endsWith(".jsonl") && !entry.name.includes(".intent."),
-		)
-		.map((entry) => join(entry.parentPath, entry.name));
+	return files;
+}
+type SessionFile = { readonly file: string; readonly size: number; readonly mtime: number };
+async function newestFirst(files: readonly string[]): Promise<SessionFile[]> {
+	const stats = await Promise.all(files.map((file) => stat(file)));
+	return files
+		.map((file, index) => ({ file, size: stats[index].size, mtime: stats[index].mtimeMs }))
+		.sort((a, b) => b.mtime - a.mtime);
+}
+/** The newest files up to FIRST_SEARCH_BYTES, then the rest. */
+function searchPhases(files: readonly SessionFile[]): readonly (readonly string[])[] {
+	let count = 0;
+	for (let bytes = 0; count < files.length && bytes < FIRST_SEARCH_BYTES; count++) {
+		bytes += files[count].size;
+	}
+	const paths = files.map(({ file }) => file);
+	return [paths.slice(0, count), paths.slice(count)];
 }
 async function sessionHeader(
 	file: string,
@@ -179,7 +300,7 @@ async function sessionHeader(
 ): Promise<{ readonly cwd?: string } | undefined> {
 	for await (const line of lfLines(file, signal)) {
 		try {
-			const value: unknown = JSON.parse(line);
+			const value: unknown = JSON.parse(line.toString("utf8"));
 			if (value === null) {
 				continue;
 			}
@@ -212,7 +333,8 @@ export type SessionScope = {
 	readonly currentFile?: string;
 	readonly signal?: AbortSignal;
 	readonly fileKey?: string;
-	readonly candidates?: (file: string) => boolean;
+	/** Raw-text needles; files without any of them are skipped. */
+	readonly needles?: readonly string[];
 };
 /** Scope memoization is owned by one enumeration; nested runs inherit their parent's project. */
 function membership(
@@ -240,25 +362,31 @@ function membership(
 	};
 	return belongs;
 }
-/** Newest modified project session files, optionally limited by file key or prefilter. */
+/** Newest modified project session files, optionally limited by file key or needles. */
 export async function* scopedSessionFiles(scope: SessionScope): AsyncGenerator<string> {
-	const files = sessionFiles(scope.dir);
+	const files = await sessionFiles(scope.dir);
 	const fileSet = new Set(files);
 	const belongs = membership(scope, (file) => fileSet.has(file));
-	const selected = files
-		.filter(
+	const selected = await newestFirst(
+		files.filter(
 			(file) =>
-				(scope.candidates === undefined || scope.candidates(resolve(file))) &&
-				(scope.fileKey === undefined ||
-					scope.fileKey.startsWith(shortKey(relative(scope.dir, file)))),
-		)
-		.map((file) => ({ file, mtime: statSync(file).mtimeMs }))
-		.sort((a, b) => b.mtime - a.mtime);
-	for (const { file } of selected) {
-		// Preserve newest-first traversal while closing each header stream before opening another.
+				scope.fileKey === undefined ||
+				scope.fileKey.startsWith(shortKey(relative(scope.dir, file))),
+		),
+	);
+	const prefilter =
+		scope.needles === undefined
+			? undefined
+			: ripgrepFilter(scope.dir, scope.needles, scope.signal);
+	for (const phase of searchPhases(selected)) {
+		// Older files are searched only when the newest ones did not satisfy the caller.
 		// oxlint-disable-next-line no-await-in-loop
-		if (await belongs(file)) {
-			yield file;
+		for (const file of prefilter === undefined ? phase : await prefilter(phase)) {
+			// Preserve newest-first traversal while closing each header stream before opening another.
+			// oxlint-disable-next-line no-await-in-loop
+			if (await belongs(file)) {
+				yield file;
+			}
 		}
 	}
 }

package/src/ui/cards.ts

@@ -9,7 +9,16 @@ import {
 	type HistorySection,
 	type PosthorseDisplay,
 } from "./display.ts";
-import { argsOf, argument, clean, hint, textBlock, textOf, type OutputColor } from "./text.ts";
+import {
+	argsOf,
+	argument,
+	clean,
+	hint,
+	leadingRows,
+	textBlock,
+	textOf,
+	type OutputColor,
+} from "./text.ts";
 
 export type ToolName = "notes" | "history" | "get_context_remaining" | "new_context";
 const titles: Readonly<Record<ToolName, string>> = {
@@ -197,45 +206,6 @@ function previewBody(facts: ResultFacts, sections: readonly HistorySection[] | u
 		: body;
 }
 
-interface ResultLayout {
-	readonly full: Component;
-	readonly summary: Component;
-	readonly preview: Component;
-	readonly submitted: Component;
-	readonly attachment: string;
-	readonly attachmentBlock: Component;
-	readonly footer: Component;
-	readonly searchPreviews: readonly string[] | undefined;
-	readonly hasDetails: boolean;
-}
-
-function resultLayout(
-	facts: ResultFacts,
-	sections: readonly HistorySection[] | undefined,
-	theme: Theme,
-): ResultLayout {
-	const color = resultColor(facts);
-	const submission = submittedText(facts);
-	const attachment = attachmentSummary(facts);
-	const { display } = facts;
-	const footerLength = display?.kind === "history-search" ? (display.footerLength ?? 0) : 0;
-	return {
-		full: fullBody(facts, sections, theme),
-		summary: textBlock(resultSummary(facts, sections), theme, color),
-		preview: textBlock(previewBody(facts, sections), theme, color),
-		submitted: textBlock(submission, theme),
-		attachment,
-		attachmentBlock: textBlock(attachment, theme, "muted"),
-		footer: textBlock(
-			sections !== undefined && footerLength > 0 ? facts.raw.slice(-footerLength) : "",
-			theme,
-			"muted",
-		),
-		searchPreviews: searchPreviews(facts, sections, theme),
-		hasDetails: sections !== undefined || submission.length > 0 || noteHeaderLength(facts) > 0,
-	};
-}
-
 function attachmentSummary(facts: ResultFacts): string {
 	if (facts.imageCount === 0) {
 		return "";
@@ -275,58 +245,83 @@ function searchPreviews(
 		: undefined;
 }
 
-function previewRows(facts: ResultFacts, layout: ResultLayout, width: number): string[] {
+type RowView = (width: number) => string[];
+
+function expandedView(
+	facts: ResultFacts,
+	sections: readonly HistorySection[] | undefined,
+	theme: Theme,
+): RowView {
+	const full = fullBody(facts, sections, theme);
+	const attachment = textBlock(attachmentSummary(facts), theme, "muted");
+	const { display } = facts;
+	const footerLength = display?.kind === "history-search" ? (display.footerLength ?? 0) : 0;
+	const footer = textBlock(
+		sections !== undefined && footerLength > 0 ? facts.raw.slice(-footerLength) : "",
+		theme,
+		"muted",
+	);
+	const submission = submittedText(facts);
+	const submitted = textBlock(submission, theme);
+	return (width) => [
+		...full.render(width),
+		...attachment.render(width),
+		...footer.render(width),
+		...(submission.length > 0 ? ["", ...submitted.render(width)] : []),
+	];
+}
+
+function previewSource(
+	facts: ResultFacts,
+	sections: readonly HistorySection[] | undefined,
+	theme: Theme,
+): (width: number) => readonly string[] {
 	if (summaryOnly(facts.display) && !facts.isError && !facts.isPartial) {
-		return [];
+		return () => [];
 	}
-	return (
-		layout.searchPreviews?.map((line) => truncateToWidth(line, width)) ??
-		layout.preview.render(width)
-	);
+	const searches = searchPreviews(facts, sections, theme);
+	if (searches !== undefined) {
+		return (width) => searches.map((line) => truncateToWidth(line, width));
+	}
+	return leadingRows(previewBody(facts, sections), theme, resultColor(facts), 3);
 }
 
-function collapsedRows(
+function collapsedView(
 	facts: ResultFacts,
-	layout: ResultLayout,
+	sections: readonly HistorySection[] | undefined,
 	theme: Theme,
-	width: number,
-): string[] {
-	const summaryRows = layout.summary.render(width).slice(0, 5);
-	const previews = previewRows(facts, layout, width);
-	const shown = previews.slice(
-		0,
-		Math.max(0, Math.min(3, 5 - summaryRows.length - (layout.attachment.length > 0 ? 1 : 0))),
-	);
-	const hidden =
-		summaryOnly(facts.display) || previews.length > shown.length || layout.hasDetails;
-	const attachments =
-		layout.attachment.length > 0
-			? [truncateToWidth(theme.fg("muted", layout.attachment), width)]
-			: [];
-	return [...summaryRows, ...shown, ...attachments, ...(hidden ? [hint(theme, width)] : [])];
+): RowView {
+	const summary = textBlock(resultSummary(facts, sections), theme, resultColor(facts));
+	const previews = previewSource(facts, sections, theme);
+	const attachment = attachmentSummary(facts);
+	const details =
+		summaryOnly(facts.display) ||
+		sections !== undefined ||
+		submittedText(facts).length > 0 ||
+		noteHeaderLength(facts) > 0;
+	return (width) => {
+		const summaryRows = summary.render(width).slice(0, 5);
+		const rows = previews(width);
+		const shown = rows.slice(
+			0,
+			Math.max(0, Math.min(3, 5 - summaryRows.length - (attachment.length > 0 ? 1 : 0))),
+		);
+		const attachments =
+			attachment.length > 0 ? [truncateToWidth(theme.fg("muted", attachment), width)] : [];
+		const hidden = details || rows.length > shown.length;
+		return [...summaryRows, ...shown, ...attachments, ...(hidden ? [hint(theme, width)] : [])];
+	};
 }
 
 function resultComponent(facts: ResultFacts, theme: Theme): Component {
 	const sections =
 		!facts.isError && !facts.isPartial ? historySections(facts.raw, facts.display) : undefined;
-	const layout = resultLayout(facts, sections, theme);
+	const render = (facts.expanded ? expandedView : collapsedView)(facts, sections, theme);
 	return {
 		invalidate() {
-			// Pi creates this presentation for each result/theme update; it keeps no width cache.
-		},
-		render(width) {
-			if (facts.expanded) {
-				const submitted =
-					submittedText(facts).length > 0 ? ["", ...layout.submitted.render(width)] : [];
-				return [
-					...layout.full.render(width),
-					...layout.attachmentBlock.render(width),
-					...layout.footer.render(width),
-					...submitted,
-				];
-			}
-			return collapsedRows(facts, layout, theme, width);
+			// Pi creates this presentation for each result, theme, and expansion update.
 		},
+		render,
 	};
 }
 

package/src/ui/text.ts

@@ -44,6 +44,44 @@ export function textBlock(text: string, theme: Theme, color: OutputColor = "tool
 	return new Text(text.length > 0 ? theme.fg(color, clean(text)) : "", 0, 0);
 }
 
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/**
+ * Rows of `textBlock(text)` wrapped only as far as a preview needs, so resizing long text stays
+ * cheap: the first `count` rows are exact, and any further row means the full text has more.
+ */
+export function leadingRows(
+	text: string,
+	theme: Theme,
+	color: OutputColor,
+	count: number,
+): (width: number) => readonly string[] {
+	// One line past `count` already wraps to more rows when the text continues.
+	const head = clean(text)
+		.split("\n", count + 1)
+		.join("\n");
+	const segments = graphemes.segment(head);
+	const wrap = (width: number): readonly string[] => {
+		for (let limit = (count + 1) * width + 1024; ; limit *= 2) {
+			// pi-tui wraps greedily by grapheme, so text cut between graphemes wraps like the
+			// whole text in every row but its last.
+			const end = segments.containing(limit)?.index ?? head.length;
+			const prefix = theme.fg(color, head.slice(0, end));
+			const rows = new Text(text.length > 0 ? prefix : "", 0, 0).render(width);
+			if (end === head.length || rows.length > count) {
+				return rows;
+			}
+		}
+	};
+	let cached: { readonly width: number; readonly rows: readonly string[] } | undefined;
+	return (width) => {
+		if (cached?.width !== width) {
+			cached = { width, rows: wrap(width) };
+		}
+		return cached.rows;
+	};
+}
+
 export function hint(theme: Theme, width: number): string {
 	const key = keyText("app.tools.expand");
 	return truncateToWidth(

package/ui.ts

@@ -1,6 +1,12 @@
 import type { ExtensionAPI, MessageRenderer } from "@earendil-works/pi-coding-agent";
-import { Box, MouseRegion, truncateToWidth, type Component } from "@earendil-works/pi-tui";
-import { clean, hint, textBlock, textOf } from "./src/ui/text.ts";
+import {
+	Box,
+	MouseRegion,
+	truncateToWidth,
+	type Component,
+	type Text,
+} from "@earendil-works/pi-tui";
+import { clean, hint, leadingRows, textBlock, textOf } from "./src/ui/text.ts";
 
 export type { PosthorseDisplay } from "./src/ui/display.ts";
 export { toolCards } from "./src/ui/cards.ts";
@@ -27,12 +33,13 @@ export function registerPosthorseMessages(pi: ExtensionAPI): void {
 		const preview = window
 			? raw.slice(handoffAt < 0 ? raw.length : handoffAt + handoffLabel.length)
 			: raw;
-		const fullText = textBlock(raw, theme);
-		const previewText = textBlock(preview, theme);
+		const previewRows = window ? 2 : 3;
+		const previewText = leadingRows(preview, theme, "toolOutput", previewRows);
+		let fullText: Text | undefined;
 		const historyText = textBlock("Earlier conversation remains in history.", theme, "muted");
 		const content: Component = {
 			invalidate() {
-				// Message layout is recomputed for the supplied width without cached rows.
+				// Pi calls the renderer again on invalidation, so cached rows never outlive a theme.
 			},
 			render(width) {
 				const padding = Math.min(
@@ -46,10 +53,10 @@ export function registerPosthorseMessages(pi: ExtensionAPI): void {
 					inner,
 				);
 				const body = view.expanded
-					? fullText.render(inner)
+					? (fullText ??= textBlock(raw, theme)).render(inner)
 					: [
 							...(window ? historyText.render(inner).slice(0, 2) : []),
-							...previewText.render(inner).slice(0, window ? 2 : 3),
+							...previewText(inner).slice(0, previewRows),
 							hint(theme, inner),
 						];
 				const box = new Box(padding, 1, (line) => theme.bg("customMessageBg", line));