@oh-my-pi/pi-tui 18.4.1 → 18.4.3

package/dist/types/tools/web-search.d.ts

@@ -6,6 +6,7 @@
 import type { Component } from "../index.js";
 import type { RenderResultOptions } from "./renderer.js";
 import { type Theme } from "../theme/theme.js";
+import { type SearchResponse } from "./web-search-types.js";
 /** Search response and optional failure shown in the transcript. */
 export interface SearchRenderDetails {
     response: SearchResponse;
@@ -33,171 +34,3 @@ export declare const webSearchToolRenderer: {
     renderResult: typeof renderSearchResult;
     mergeCallAndResult: true;
 };
-/**
- * Web Search Types
- *
- * Unified types for web search responses across supported providers.
- */
-export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
-    readonly value: "auto";
-    readonly label: "Auto";
-    readonly description: "Automatically uses the first configured web-search provider";
-}, {
-    readonly value: "parallel";
-    readonly label: "Parallel";
-    readonly description: "Uses API auth when configured; otherwise searches through the keyless public MCP";
-}, {
-    readonly value: "perplexity";
-    readonly label: "Perplexity";
-    readonly description: "Uses auth when configured; explicit selection falls back to anonymous search";
-}, {
-    readonly value: "gemini";
-    readonly label: "Gemini";
-    readonly description: "Google Search grounding via Gemini (uses google-gemini-cli or google-antigravity OAuth)";
-}, {
-    readonly value: "anthropic";
-    readonly label: "Anthropic";
-    readonly description: "Claude's native web_search tool (uses Anthropic OAuth or ANTHROPIC_API_KEY)";
-}, {
-    readonly value: "codex";
-    readonly label: "OpenAI Codex";
-    readonly description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)";
-}, {
-    readonly value: "openai";
-    readonly label: "OpenAI API";
-    readonly description: "OpenAI hosted web_search via OPENAI_API_KEY or OpenAI API-key registry credentials; billed by API usage";
-}, {
-    readonly value: "xai";
-    readonly label: "xAI";
-    readonly description: "Grok web search via xAI Responses API (uses SuperGrok/X Premium+ OAuth via /login xai-oauth, or XAI_API_KEY)";
-}, {
-    readonly value: "openrouter";
-    readonly label: "OpenRouter";
-    readonly description: "OpenRouter plugins-based web search with model-selected grounding";
-}, {
-    readonly value: "zai";
-    readonly label: "Z.AI";
-    readonly description: "Calls Z.AI webSearchPrime MCP";
-}, {
-    readonly value: "exa";
-    readonly label: "Exa";
-    readonly description: "API via /login exa or EXA_API_KEY; explicit keyless fallback via MCP";
-}, {
-    readonly value: "tinyfish";
-    readonly label: "TinyFish";
-    readonly description: "Requires TINYFISH_API_KEY";
-}, {
-    readonly value: "jina";
-    readonly label: "Jina";
-    readonly description: "Requires JINA_API_KEY";
-}, {
-    readonly value: "kagi";
-    readonly label: "Kagi";
-    readonly description: "Requires KAGI_API_KEY and Kagi Search API beta access";
-}, {
-    readonly value: "tavily";
-    readonly label: "Tavily";
-    readonly description: "Requires TAVILY_API_KEY";
-}, {
-    readonly value: "firecrawl";
-    readonly label: "Firecrawl";
-    readonly description: "Uses Firecrawl API when FIRECRAWL_API_KEY is set; falls back to keyless mode";
-}, {
-    readonly value: "brave";
-    readonly label: "Brave";
-    readonly description: "Requires BRAVE_API_KEY";
-}, {
-    readonly value: "kimi";
-    readonly label: "Kimi";
-    readonly description: "Kimi Code search (requires a Kimi Code Console key via KIMI_SEARCH_API_KEY/MOONSHOT_SEARCH_API_KEY or /login kimi-code; not MOONSHOT_API_KEY)";
-}, {
-    readonly value: "synthetic";
-    readonly label: "Synthetic";
-    readonly description: "Requires SYNTHETIC_API_KEY";
-}, {
-    readonly value: "ollama";
-    readonly label: "Ollama";
-    readonly description: "Requires OLLAMA_CLOUD_API_KEY";
-}, {
-    readonly value: "searxng";
-    readonly label: "SearXNG";
-    readonly description: "Requires SEARXNG_ENDPOINT or searxng.endpoint";
-}, {
-    readonly value: "startpage";
-    readonly label: "Startpage";
-    readonly description: "Credential-free scrape of Startpage (Google-backed) results; may be bot-challenged";
-}, {
-    readonly value: "duckduckgo";
-    readonly label: "DuckDuckGo";
-    readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
-}, {
-    readonly value: "ecosia";
-    readonly label: "Ecosia";
-    readonly description: "Credential-free browser-backed scrape of Ecosia (Google-backed) results";
-}, {
-    readonly value: "google";
-    readonly label: "Google";
-    readonly description: "Credential-free browser-backed fallback; slower and may be bot-challenged";
-}, {
-    readonly value: "mojeek";
-    readonly label: "Mojeek";
-    readonly description: "Credential-free browser-backed scrape of Mojeek's independent index";
-}, {
-    readonly value: "public";
-    readonly label: "Public Web";
-    readonly description: "Queries every credential-free engine in parallel and consolidates deduplicated results";
-}];
-/** Supported web search providers (every option except `auto`). */
-export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;
-/** Display labels, derived from {@link SEARCH_PROVIDER_OPTIONS}. */
-export declare const SEARCH_PROVIDER_LABELS: Record<SearchProviderId, string>;
-/** Source returned by search (all providers) */
-export interface SearchSource {
-    title: string;
-    url: string;
-    snippet?: string;
-    /** ISO date string or relative ("2d ago") */
-    publishedDate?: string;
-    /** Age in seconds for consistent formatting */
-    ageSeconds?: number;
-    author?: string;
-}
-/** Citation with text reference (LLM-mediated providers) */
-export interface SearchCitation {
-    url: string;
-    title: string;
-    citedText?: string;
-}
-/** Usage metrics */
-export interface SearchUsage {
-    inputTokens?: number;
-    outputTokens?: number;
-    /** Anthropic: number of web search requests made */
-    searchRequests?: number;
-    /** Perplexity: combined token count */
-    totalTokens?: number;
-}
-/** Unified response across providers */
-export interface SearchResponse {
-    provider: SearchProviderId | "none";
-    /** Synthesized answer text (LLM-mediated providers) */
-    answer?: string;
-    /** Search result sources */
-    sources: SearchSource[];
-    /** Text citations with context */
-    citations?: SearchCitation[];
-    /** Intermediate search queries (anthropic) */
-    searchQueries?: string[];
-    /** Follow-up question suggestions (provider-dependent) */
-    relatedQuestions?: string[];
-    /** Token usage metrics */
-    usage?: SearchUsage;
-    /** Model used */
-    model?: string;
-    /** Request ID for debugging */
-    requestId?: string;
-    /** Authentication mode used by the provider (e.g. oauth, api-key) */
-    authMode?: string;
-}
-/** Cheap, sync metadata accessor — never triggers a provider load. */
-export declare function getSearchProviderLabel(id: SearchProviderId): string;

package/dist/types/tui.d.ts

@@ -273,8 +273,9 @@ export declare class Container implements Component {
 /**
  * Merge runs of byte-adjacent SGR sequences (`CSI [0-9;:]* m`) into one. Only
  * CSI-SGR sequences are touched; text, cursor moves, OSC, hyperlinks and image
- * payloads pass through verbatim. Returns the original reference when nothing
- * merges, so SGR-light lines incur only a single `indexOf` scan.
+ * payloads pass through verbatim. Isolated sequences require no parameter
+ * slices or arrays; output is built only at merged boundaries or empty resets
+ * that need normalization within an adjacent run.
  */
 export declare function coalesceAdjacentSgr(line: string): string;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.4.1",
+	"version": "18.4.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.4.1",
-		"@oh-my-pi/pi-agent-core": "18.4.1",
-		"@oh-my-pi/pi-ai": "18.4.1",
-		"@oh-my-pi/pi-catalog": "18.4.1",
-		"@oh-my-pi/pi-natives": "18.4.1",
-		"@oh-my-pi/pi-utils": "18.4.1",
-		"@oh-my-pi/pi-wire": "18.4.1",
-		"@oh-my-pi/snapcompact": "18.4.1"
+		"@oh-my-pi/omptype": "18.4.3",
+		"@oh-my-pi/pi-agent-core": "18.4.3",
+		"@oh-my-pi/pi-ai": "18.4.3",
+		"@oh-my-pi/pi-catalog": "18.4.3",
+		"@oh-my-pi/pi-natives": "18.4.3",
+		"@oh-my-pi/pi-utils": "18.4.3",
+		"@oh-my-pi/pi-wire": "18.4.3",
+		"@oh-my-pi/snapcompact": "18.4.3"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/chat/assistant-message.ts

@@ -33,7 +33,8 @@ const EMPTY_STABLE_RENDER: readonly string[] = [];
 
 type ThinkingContentBlock = Extract<AssistantMessage["content"][number], { type: "thinking" }>;
 type DisplayThinkingContentBlock = ThinkingContentBlock & { rawThinking?: string };
-type StablePart = { kind: "thinking" | "text"; text: string } | { kind: "spacer" };
+type StablePartKind = "thinking" | "text";
+type StablePart = { kind: StablePartKind; text: string } | { kind: "spacer" };
 
 /**
  * One published prefix of the block's finished content. Later snapshots extend
@@ -47,6 +48,37 @@ interface StableSnapshot {
 	readonly lastTextLength: number;
 }
 
+/**
+ * Stable-row renders at one width. `rows` renders snapshot `newest`; every
+ * count in `ends` renders byte-identically to `rows.slice(0, end)` — checked
+ * against `rows` when recorded — so an earlier prefix is a slice of the newest
+ * render instead of a re-render, and one row array stays resident per width.
+ */
+interface StableRowLedger {
+	newest: number;
+	rows: readonly string[];
+	readonly ends: Map<number, number>;
+	/** Rendered rows of parts a snapshot has closed (full text final), by part index. */
+	readonly parts: (
+		| { readonly kind: StablePartKind; readonly text: string; readonly rows: readonly string[] }
+		| undefined
+	)[];
+}
+
+/** One Markdown instance reused while a stable part's text grows between renders. */
+interface StablePartRenderer {
+	readonly index: number;
+	readonly kind: StablePartKind;
+	readonly md: Markdown;
+}
+
+/** Theme inputs cached stable renders were produced with; any change drops them. */
+interface StableRenderInputs {
+	readonly prose: MarkdownTheme;
+	readonly markdown: MarkdownTheme;
+	readonly color: ((text: string) => string) | undefined;
+}
+
 function isSnapshotExtension(previous: readonly StablePart[], current: readonly StablePart[]): boolean {
 	if (previous.length > current.length) return false;
 	for (let index = 0; index < previous.length; index++) {
@@ -260,13 +292,20 @@ export class AssistantMessageComponent extends Container {
 	#nextStableRowId = 0;
 	#transcriptStableRows: TranscriptStableRow[] = [];
 	/**
-	 * Rendered rows per published snapshot index and width. The container asks
-	 * for several different counts in one frame (emitted, offered end,
-	 * projected, pressure-loop +1s); a 2-entry LRU thrashes across those and
-	 * re-renders the whole prefix per miss. Sized generously so the live prefix
-	 * stays cached; cleared on reset/finalize like before.
+	 * Verified stable-row renders per width ({@link StableRowLedger}). The
+	 * container asks for several counts per frame (emitted, offered end,
+	 * projected) and each publication re-checks the previous prefix; the ledger
+	 * answers all of them from the newest render. A few widths cover resizes.
+	 * Cleared on reset, finalize, and theme change.
 	 */
-	#stableRenderCache = new LRUCache<string, readonly string[]>({ max: 64 });
+	#stableLedgers = new LRUCache<number, StableRowLedger>({ max: 4 });
+	/** Prefixes handed out as ledger slices or rendered off-ledger, by `${count}:${width}`. */
+	#stableRenderCache = new LRUCache<string, readonly string[]>({ max: 8 });
+	/** Reused for the growing final part of each publication candidate. */
+	#stableHeadRenderer: StablePartRenderer | undefined;
+	/** Reused for final parts of published snapshots rendered off-ledger (reflow, replay). */
+	#stableReplayRenderer: StablePartRenderer | undefined;
+	#stableRenderInputs: StableRenderInputs | undefined;
 	/** Provider-reported tokens in the live thinking block — reasoning tokens when
 	 *  the provider streams them, else total output — shown dimmed beside the
 	 *  speed badge. 0 when no thinking is streaming. */
@@ -626,22 +665,33 @@ export class AssistantMessageComponent extends Container {
 		this.#stableSnapshots = [];
 		this.#stableParts = [];
 		this.#transcriptStableRows = [];
-		this.#stableRenderCache.clear();
+		this.#dropStableRenders();
 	}
 
 	renderTranscriptStableRows(count: number, width: number): readonly string[] {
 		const index = Math.min(Math.trunc(count), this.#stableSnapshots.length);
 		if (index <= 0) return EMPTY_STABLE_RENDER;
+		this.#syncStableRenderInputs();
+		const ledger = this.#stableLedgers.get(width);
+		if (ledger?.newest === index) return ledger.rows;
 		const key = `${index}:${width}`;
 		const cached = this.#stableRenderCache.get(key);
 		if (cached) return cached;
-		const snapshot = this.#stableSnapshots[index - 1]!;
-		const parts = this.#stableParts.slice(0, snapshot.partCount);
-		const last = parts.at(-1);
-		if (last && last.kind !== "spacer") {
-			parts[parts.length - 1] = { kind: last.kind, text: last.text.slice(0, snapshot.lastTextLength) };
+		const end = ledger?.ends.get(index);
+		let rows: readonly string[];
+		if (ledger !== undefined && end !== undefined) {
+			rows = ledger.rows.slice(0, end);
+		} else {
+			const snapshot = this.#stableSnapshots[index - 1]!;
+			rows = this.#renderStableParts(
+				this.#stableParts,
+				snapshot.partCount,
+				snapshot.lastTextLength,
+				width,
+				"replay",
+			);
+			if (this.#recordStableRows(index, width, rows)) return rows;
 		}
-		const rows = this.#renderStableSnapshot(parts, width);
 		this.#stableRenderCache.set(key, rows);
 		return rows;
 	}
@@ -662,9 +712,12 @@ export class AssistantMessageComponent extends Container {
 		if (!last || last.kind === "spacer") return;
 		const snapshot = { partCount: parts.length, lastTextLength: last.text.length };
 		const previous = this.#stableSnapshots.at(-1);
-		if (previous && !isSnapshotExtension(this.#stableParts, parts)) return;
+		// An unmoved boundary publishes nothing whether or not it still extends
+		// the last snapshot, so most frames skip the whole-document comparison.
 		if (previous?.partCount === snapshot.partCount && previous.lastTextLength === snapshot.lastTextLength) return;
-		const currentRows = this.#renderStableSnapshot(parts, width);
+		if (previous && !isSnapshotExtension(this.#stableParts, parts)) return;
+		this.#syncStableRenderInputs();
+		const currentRows = this.#renderStableParts(parts, parts.length, last.text.length, width, "head");
 		// The container verifies stable rows against the blank-trimmed render.
 		if (!isRowPrefix(currentRows, trimBlankEdges(rendered))) return;
 		const previousRows = previous
@@ -676,7 +729,7 @@ export class AssistantMessageComponent extends Container {
 		this.#stableParts = parts;
 		this.#stableSnapshots.push(snapshot);
 		this.#transcriptStableRows.push({ key: `thinking:${this.#nextStableRowId++}` });
-		this.#stableRenderCache.set(`${this.#stableSnapshots.length}:${width}`, currentRows);
+		this.#recordStableRows(this.#stableSnapshots.length, width, currentRows);
 	}
 
 	/**
@@ -726,37 +779,136 @@ export class AssistantMessageComponent extends Container {
 		return parts;
 	}
 
-	#renderStableSnapshot(parts: readonly StablePart[], width: number): readonly string[] {
+	/**
+	 * Render the first `partCount` stable parts, the final one cut to
+	 * `lastLength`. Rows match fresh Markdown renders of each part byte for
+	 * byte — {@link #createStableMarkdown} mirrors the live children — but a
+	 * closed part renders once per width, and the growing final part reuses one
+	 * Markdown instance so its already-frozen blocks are not re-lexed.
+	 */
+	#renderStableParts(
+		parts: readonly StablePart[],
+		partCount: number,
+		lastLength: number,
+		width: number,
+		role: "head" | "replay",
+	): readonly string[] {
+		const ledger = this.#stableLedger(width);
 		const rows: string[] = [];
-		for (const part of parts) {
+		const lastIndex = partCount - 1;
+		for (let index = 0; index < partCount; index++) {
+			const part = parts[index]!;
 			if (part.kind === "spacer") {
 				rows.push("");
 				continue;
 			}
-			// Constructor args mirror the live child Markdown exactly so these
-			// rows are byte-identical to the block render's prefix — including the
-			// trim the live children apply, which drops the trailing blank line a
-			// frozen prefix still carries.
-			const text = part.text.trim();
-			const markdown =
-				part.kind === "text"
-					? new Markdown(
-							text,
-							1,
-							0,
-							this.#getProseTheme(),
-							this.#textColorTransform ? { color: this.#textColorTransform } : undefined,
-							0,
-						)
-					: new Markdown(text, 1, 0, getMarkdownTheme(), {
-							color: (value: string) => theme.fg("thinkingText", value),
-							italic: true,
-						});
-			rows.push(...markdown.render(width));
+			const closed = index < lastIndex;
+			const text = closed || lastLength === part.text.length ? part.text : part.text.slice(0, lastLength);
+			const cached = ledger.parts[index];
+			let partRows: readonly string[];
+			if (cached?.kind === part.kind && cached.text === text) {
+				partRows = cached.rows;
+			} else {
+				partRows = this.#renderStablePart(index, part.kind, text, width, closed ? undefined : role);
+				if (closed) ledger.parts[index] = { kind: part.kind, text, rows: partRows };
+			}
+			for (const row of partRows) rows.push(row);
 		}
 		return rows;
 	}
 
+	/**
+	 * Render one part's Markdown. `role` names the instance reused for a final
+	 * part as its text grows; a closed part continues whichever instance was
+	 * already growing it, else renders once. Finalized blocks keep no instance.
+	 */
+	#renderStablePart(
+		index: number,
+		kind: StablePartKind,
+		text: string,
+		width: number,
+		role: "head" | "replay" | undefined,
+	): readonly string[] {
+		// Trim like the live children, dropping the trailing blank line a frozen
+		// prefix still carries.
+		const trimmed = text.trim();
+		if (this.#transcriptBlockFinalized) return this.#createStableMarkdown(kind, trimmed).render(width);
+		const head = this.#stableHeadRenderer;
+		const replay = this.#stableReplayRenderer;
+		const renderer = role === "head" ? head : role === "replay" ? replay : head?.index === index ? head : replay;
+		if (renderer?.index === index && renderer.kind === kind) {
+			renderer.md.setText(trimmed);
+			return renderer.md.render(width);
+		}
+		const md = this.#createStableMarkdown(kind, trimmed);
+		if (role === "head") this.#stableHeadRenderer = { index, kind, md };
+		else if (role === "replay") this.#stableReplayRenderer = { index, kind, md };
+		return md.render(width);
+	}
+
+	/** Constructor args mirror the live child Markdown so stable rows prefix the block render. */
+	#createStableMarkdown(kind: StablePartKind, text: string): Markdown {
+		return kind === "text"
+			? new Markdown(
+					text,
+					1,
+					0,
+					this.#getProseTheme(),
+					this.#textColorTransform ? { color: this.#textColorTransform } : undefined,
+					0,
+				)
+			: new Markdown(text, 1, 0, getMarkdownTheme(), {
+					color: (value: string) => theme.fg("thinkingText", value),
+					italic: true,
+				});
+	}
+
+	#stableLedger(width: number): StableRowLedger {
+		let ledger = this.#stableLedgers.get(width);
+		if (ledger === undefined) {
+			ledger = { newest: 0, rows: EMPTY_STABLE_RENDER, ends: new Map(), parts: [] };
+			this.#stableLedgers.set(width, ledger);
+		}
+		return ledger;
+	}
+
+	/**
+	 * Remember `rows` as snapshot `index`'s render at `width`. A newer snapshot
+	 * becomes the ledger's newest render — keeping earlier counts only when it
+	 * extends their rows; an older one that prefixes the newest keeps just its
+	 * row count. Returns whether `rows` is now the newest render.
+	 */
+	#recordStableRows(index: number, width: number, rows: readonly string[]): boolean {
+		const ledger = this.#stableLedger(width);
+		if (index > ledger.newest) {
+			if (!isRowPrefix(ledger.rows, rows)) ledger.ends.clear();
+			ledger.newest = index;
+			ledger.rows = rows;
+			ledger.ends.set(index, rows.length);
+			return true;
+		}
+		if (index < ledger.newest && isRowPrefix(rows, ledger.rows)) ledger.ends.set(index, rows.length);
+		return false;
+	}
+
+	/** Drop cached stable renders once the themes they were rendered with change. */
+	#syncStableRenderInputs(): void {
+		const prose = this.#getProseTheme();
+		const markdown = getMarkdownTheme();
+		const color = this.#textColorTransform;
+		const inputs = this.#stableRenderInputs;
+		if (inputs?.prose === prose && inputs.markdown === markdown && inputs.color === color) return;
+		this.#dropStableRenders();
+		this.#stableRenderInputs = { prose, markdown, color };
+	}
+
+	#dropStableRenders(): void {
+		this.#stableLedgers.clear();
+		this.#stableRenderCache.clear();
+		this.#stableHeadRenderer = undefined;
+		this.#stableReplayRenderer = undefined;
+	}
+
 	/** Render completed prose rather than an earlier thinking row under emergency viewport pressure. */
 	renderTranscriptBlockEmergencyRow(width: number): string | undefined {
 		if (!this.#transcriptBlockFinalized) return undefined;
@@ -769,7 +921,7 @@ export class AssistantMessageComponent extends Container {
 
 	markTranscriptBlockFinalized(): void {
 		this.#transcriptBlockFinalized = true;
-		this.#stableRenderCache.clear();
+		this.#dropStableRenders();
 		this.#stopThinkingAnimation();
 		// If the live pulse was on screen when the block sealed, drop the fast path
 		// and rebuild so the placeholder is removed — finalized blocks never animate.

package/src/chat/thinking-display.ts

@@ -1,13 +1,16 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { FENCE_RE } from "../render/render-utils";
 
-// Single-slot-per-mode memo for formatThinkingForDisplay. During a streaming
+// Small per-mode MRU memo for formatThinkingForDisplay. During a streaming
 // tick the same growing thinking text is formatted up to three times (reveal
 // count, reveal slice, component render); this collapses them to one
 // computation. Prose and raw modes produce different output for the same text,
-// so each mode keeps its own slot. One entry per mode is enough for the common
-// case of one active thinking block and never regresses (a miss recomputes
-// exactly as before).
+// so each mode keeps its own slots. A message routinely holds several thinking
+// blocks (thinking → text → thinking), and every tick formats each of them, so
+// one slot per mode would thrash between blocks and turn every append into a
+// full refold; {@link DISPLAY_CACHE_SLOTS} slots keep one checkpoint per live
+// block. A miss recomputes exactly as before and evicts the least recently
+// used slot.
 //
 // Each slot also carries the fold state for incremental extension: when the
 // incoming text is an append of the previously formatted text (streaming only
@@ -85,8 +88,69 @@ function freshDisplayCache(): DisplayCache {
 	return { text: "", value: "", hadComment: false, startLineByte: 0, state: freshFoldState(), resumable: true };
 }
 
-const proseCache = freshDisplayCache();
-const rawCache = freshDisplayCache();
+/** Slots per mode: enough for the thinking blocks of one streaming message. */
+const DISPLAY_CACHE_SLOTS = 4;
+// Most recently used first.
+const proseSlots: DisplayCache[] = [];
+const rawSlots: DisplayCache[] = [];
+
+/** Drop every memo slot so the next call recomputes from scratch. Tests only. */
+export function resetThinkingDisplayCacheForTests(): void {
+	proseSlots.length = 0;
+	rawSlots.length = 0;
+}
+
+/**
+ * Pick the slot to format `text` into and move it to the front: an exact memo
+ * hit, else the resumable slot holding the longest verbatim prefix of `text`
+ * (an append). A miss overwrites a non-resumable slot holding a prefix of
+ * `text` — the same stream's retired checkpoint, e.g. the raw identity
+ * shortcut — so such a stream never evicts the other blocks' checkpoints;
+ * otherwise the least recently used slot (or a new one below the cap).
+ * Append detection runs here once so the caller never re-verifies.
+ */
+function acquireDisplayCache(
+	slots: DisplayCache[],
+	text: string,
+): { cache: DisplayCache; match: "hit" | "append" | "miss" } {
+	// Identity pass first: the repeated renders of one streaming tick must not
+	// pay any prefix verification against the other blocks' slots.
+	let index = slots.findIndex(slot => slot.text === text);
+	let match: "hit" | "append" | "miss" = index === -1 ? "miss" : "hit";
+	if (index === -1) {
+		let appendLength = 0;
+		let retired = -1;
+		let retiredLength = 0;
+		for (let i = 0; i < slots.length; i++) {
+			const slot = slots[i]!;
+			const length = slot.text.length;
+			if (length <= (slot.resumable ? appendLength : retiredLength) || !isAppend(slot, text)) continue;
+			if (slot.resumable) {
+				index = i;
+				match = "append";
+				appendLength = length;
+			} else {
+				retired = i;
+				retiredLength = length;
+			}
+		}
+		if (index === -1) index = retired;
+	}
+	if (index === -1) {
+		if (slots.length < DISPLAY_CACHE_SLOTS) {
+			const cache = freshDisplayCache();
+			slots.unshift(cache);
+			return { cache, match };
+		}
+		index = slots.length - 1;
+	}
+	const cache = slots[index]!;
+	if (index > 0) {
+		slots.splice(index, 1);
+		slots.unshift(cache);
+	}
+	return { cache, match };
+}
 
 export function canonicalizeMessage(text: string | null | undefined): string {
 	if (!text) return "";
@@ -190,14 +254,12 @@ function renderFold(state: FoldState): string {
  */
 export function formatThinkingForDisplay(text: string, proseOnly: boolean): string {
 	if (!text) return text;
-	const cache = proseOnly ? proseCache : rawCache;
-	// Identity memo first: the 2nd and 3rd renders of one streaming tick pass
-	// the same text and must not pay the prefix verification below.
-	if (text === cache.text) return cache.value;
+	const { cache, match } = acquireDisplayCache(proseOnly ? proseSlots : rawSlots, text);
+	if (match === "hit") return cache.value;
 	let hasComment: boolean;
 	let fromByte: number;
 	let state: FoldState;
-	if (cache.resumable && isAppend(cache, text)) {
+	if (match === "append") {
 		// Append: a `<!--` introduced by the suffix flips the noise gate, and a
 		// marker straddling the seam can start at most 3 bytes back — identical
 		// to rescanning the full text, at O(delta).