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

package/src/components/loader.ts

@@ -26,7 +26,14 @@ export class Loader extends Text {
 	#ui: TUI | null = null;
 	#lastSpinnerTick = 0;
 	#layoutSource?: readonly string[];
-	#layout?: readonly { leading: string; content: string; trailing: string }[];
+	#layout?: readonly {
+		leading: string;
+		message: string;
+		trailing: string;
+		spinner: boolean;
+		separator: string;
+		bodyWidth?: number;
+	}[];
 	#layoutFrames: readonly string[];
 	#layoutFrame: string;
 	#trailer?: () => string | undefined;
@@ -72,14 +79,28 @@ export class Loader extends Text {
 		if (source !== this.#layoutSource) {
 			const paddingX = getPaddingX(1);
 			this.#layoutSource = source;
-			this.#layout = source.map(line => {
+			this.#layout = source.map((line, i) => {
 				const clamped = visibleWidth(line) > width ? sliceByColumn(line, 0, width, true) : line;
 				const body = clamped.slice(paddingX);
 				const content = body.trimEnd();
+				const leading = clamped.slice(0, paddingX);
+				const spinner = i === 0 && content.startsWith(this.#layoutFrame);
+				const remainder = spinner ? content.slice(this.#layoutFrame.length) : content;
+				const separator = spinner && remainder.startsWith(" ") ? " " : "";
+				const message = remainder.slice(separator.length);
+				const plainMessage = i === 0 ? Bun.stripANSI(message) : "";
+				// A visible non-whitespace ending makes trimEnd independent of
+				// colorizer ANSI placement. The separator isolates spinner width
+				// from message graphemes; other cases retain whole-body measuring.
+				const stableBodyWidth =
+					plainMessage.length > 0 && plainMessage.trimEnd() === plainMessage && (!spinner || separator === " ");
 				return {
-					leading: clamped.slice(0, paddingX),
-					content,
+					leading,
+					message,
 					trailing: body.slice(content.length),
+					spinner,
+					separator,
+					bodyWidth: stableBodyWidth ? visibleWidth(leading + separator + message) : undefined,
 				};
 			});
 		}
@@ -88,28 +109,27 @@ export class Loader extends Text {
 		// The wrapped text carries one stable representative per frame width.
 		// Same-width frames swap only the visible glyph here; crossing widths
 		// rewraps against the representative selected by #syncText.
-		const sentinel = this.#layoutFrame;
 		const lines = [""];
 		const layout = this.#layout ?? [];
-		for (let i = 0; i < layout.length; i++) {
-			const { leading, content, trailing } = layout[i];
-			if (i === 0 && content.startsWith(sentinel)) {
-				const remainder = content.slice(sentinel.length);
-				const separator = remainder.startsWith(" ") ? " " : "";
-				const message = remainder.slice(separator.length);
-				lines.push(
-					`${leading}${this.spinnerColorFn(frame)}${separator}${message ? this.messageColorFn(message) : ""}${trailing}`,
-				);
-			} else {
-				lines.push(`${leading}${content ? this.messageColorFn(content) : ""}${trailing}`);
+		let coloredSpinner = "";
+		for (const { leading, message, trailing, spinner, separator } of layout) {
+			if (spinner) {
+				coloredSpinner = this.spinnerColorFn(frame);
 			}
+			lines.push(
+				`${leading}${spinner ? coloredSpinner : ""}${separator}${message ? this.messageColorFn(message) : ""}${trailing}`,
+			);
 		}
 		if (this.#trailer && lines.length > 1) {
 			const trailer = this.#trailer();
 			if (trailer) {
 				// Text pads rows to full width; drop that pad before docking right.
 				const body = lines[1].trimEnd();
-				const gap = width - visibleWidth(body) - visibleWidth(trailer);
+				const bodyWidth =
+					layout[0].bodyWidth === undefined
+						? visibleWidth(body)
+						: layout[0].bodyWidth + visibleWidth(coloredSpinner);
+				const gap = width - bodyWidth - visibleWidth(trailer);
 				if (gap >= 2) lines[1] = body + padding(gap) + trailer;
 			}
 		}

package/src/overlays/agent-hub.ts

@@ -102,13 +102,23 @@ function activityGlyph(row: AgentActivityRow): string {
 	}
 }
 
+const ACTIVITY_CLOCK_FORMAT = new Intl.DateTimeFormat(undefined, {
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false,
+});
+const ACTIVITY_CLOCK_CACHE_LIMIT = 512;
+const activityClockCache = new Map<number, string>();
+
 function activityClock(timestamp: number): string {
-	return new Date(timestamp).toLocaleTimeString(undefined, {
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		hour12: false,
-	});
+	let text = activityClockCache.get(timestamp);
+	if (text === undefined) {
+		text = ACTIVITY_CLOCK_FORMAT.format(timestamp);
+		if (activityClockCache.size >= ACTIVITY_CLOCK_CACHE_LIMIT) activityClockCache.clear();
+		activityClockCache.set(timestamp, text);
+	}
+	return text;
 }
 /** Result of one host-backed transcript read for the Agent Hub viewer. */
 export interface AgentHubRemoteTranscript {

package/src/overlays/copy-selector.ts

@@ -317,6 +317,11 @@ export class CopySelectorComponent implements Component {
 			}
 			index += delta;
 		}
+		// Stepping above the replayed tail continues into the earlier history.
+		if (delta < 0 && this.#truncated) {
+			this.#loadFullHistory();
+			this.#moveVertical(delta);
+		}
 	}
 
 	// ========================================================================

package/src/overlays/model-browser.ts

@@ -113,6 +113,11 @@ export interface ResolvedModelRoleValue {
 
 /** Host-provided preferences and model-role resolution for the browser. */
 export interface ModelBrowserSource extends ModelRoleLookup {
+	/**
+	 * Changes whenever any preference this source reads or resolves against changes,
+	 * except the storage-backed `mruOrder` and `modelPerf`. Keys derived-scope caches.
+	 */
+	readonly revision: number;
 	readonly defaultThinkingLevel: string;
 	readonly modelProviderOrder: readonly string[];
 	readonly knownRoleIds: readonly string[];
@@ -175,16 +180,32 @@ export function resolveRoleAssignments(
 		return ThinkingLevel.Inherit;
 	};
 
+	// Roles sharing an `accepts` predicate share one filtered array, so the
+	// resolver's array-keyed indexes are built once per pool, not once per role.
+	const eligible = (
+		pool: ReadonlyArray<Model>,
+		byAccepts: Map<ModelBrowserRoleInfo["accepts"], Model[]>,
+		role: string,
+	): Model[] => {
+		const accepts = settings.getRoleInfo(role).accepts;
+		let models = byAccepts.get(accepts);
+		if (!models) {
+			models = pool.filter(accepts);
+			byAccepts.set(accepts, models);
+		}
+		return models;
+	};
+
 	const roles: RoleAssignments = {};
 	const knownRoles = settings.knownRoleIds;
 	const configuredRoles = new Set<string>();
-	const catalog = [...allModels];
+	const catalogByAccepts = new Map<ModelBrowserRoleInfo["accepts"], Model[]>();
 
 	for (const role of knownRoles) {
 		const roleValue = settings.getModelRole(role);
 		if (!roleValue) continue;
 		configuredRoles.add(role);
-		const resolved = settings.resolveRoleValue(roleValue, catalog.filter(settings.getRoleInfo(role).accepts));
+		const resolved = settings.resolveRoleValue(roleValue, eligible(allModels, catalogByAccepts, role));
 		if (resolved.model) {
 			roles[role] = {
 				model: resolved.model,
@@ -195,13 +216,10 @@ export function resolveRoleAssignments(
 	}
 
 	if (autoCandidates.length > 0) {
-		const candidates = [...autoCandidates];
+		const candidatesByAccepts = new Map<ModelBrowserRoleInfo["accepts"], Model[]>();
 		for (const role of knownRoles) {
 			if (configuredRoles.has(role)) continue;
-			const resolved = settings.resolveRoleValue(
-				`pi/${role}`,
-				candidates.filter(settings.getRoleInfo(role).accepts),
-			);
+			const resolved = settings.resolveRoleValue(`pi/${role}`, eligible(autoCandidates, candidatesByAccepts, role));
 			if (!resolved.model) continue;
 			roles[role] = {
 				model: resolved.model,
@@ -332,32 +350,95 @@ export interface SessionModelScope {
 	error: string | undefined;
 }
 
+/** Catalog inputs a {@link SessionModelScope} is derived from. */
+interface SessionModelScopeInputs {
+	models: ReadonlyArray<Model>;
+	allModels: ReadonlyArray<Model>;
+	error: string | undefined;
+}
+
+function readSessionModelScopeInputs(
+	registry: ModelBrowserRegistry,
+	scopedModels: ReadonlyArray<Model>,
+): SessionModelScopeInputs {
+	if (scopedModels.length > 0) return { models: scopedModels, allModels: scopedModels, error: undefined };
+	const loadError = registry.getError();
+	let error = loadError ? String(loadError) : undefined;
+	let models: ReadonlyArray<Model>;
+	try {
+		models = registry.getAvailable();
+	} catch (cause) {
+		error = cause instanceof Error ? cause.message : String(cause);
+		models = [];
+	}
+	return { models, allModels: registry.getAll("all"), error };
+}
+
+function scopeFromInputs(settings: ModelBrowserSource, inputs: SessionModelScopeInputs): SessionModelScope {
+	const roles = resolveRoleAssignments(settings, inputs.allModels, inputs.models);
+	const mruOrder = settings.mruOrder;
+	const items = buildBrowserItems(inputs.models);
+	sortModelItems(items, { roles, mruOrder });
+	return { items, roles, mruOrder, error: inputs.error };
+}
+
 /** Build the session picker's current scope without creating an interactive browser. */
 export function buildSessionModelScope(
 	settings: ModelBrowserSource,
 	registry: ModelBrowserRegistry,
 	scopedModels: ReadonlyArray<Model>,
 ): SessionModelScope {
-	let models: ReadonlyArray<Model>;
-	let error: string | undefined;
-	if (scopedModels.length > 0) {
-		models = scopedModels;
-	} else {
-		const loadError = registry.getError();
-		error = loadError ? String(loadError) : undefined;
-		try {
-			models = registry.getAvailable();
-		} catch (cause) {
-			error = cause instanceof Error ? cause.message : String(cause);
-			models = [];
+	return scopeFromInputs(settings, readSessionModelScopeInputs(registry, scopedModels));
+}
+
+function sameEntries<T>(a: ReadonlyArray<T>, b: ReadonlyArray<T>): boolean {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+}
+
+/**
+ * {@link buildSessionModelScope} for per-keystroke callers: returns the same
+ * scope until the source revision, MRU order, scoped models, or the registry's
+ * available models, catalog, or load error change.
+ */
+export class SessionModelScopeCache {
+	#settings: ModelBrowserSource;
+	#registry: ModelBrowserRegistry;
+	#revision = 0;
+	#inputs: SessionModelScopeInputs | undefined;
+	#scope: SessionModelScope | undefined;
+
+	constructor(settings: ModelBrowserSource, registry: ModelBrowserRegistry) {
+		this.#settings = settings;
+		this.#registry = registry;
+	}
+
+	get(scopedModels: ReadonlyArray<Model>): SessionModelScope {
+		const revision = this.#settings.revision;
+		const inputs = readSessionModelScopeInputs(this.#registry, scopedModels);
+		const cachedInputs = this.#inputs;
+		const cached = this.#scope;
+		if (
+			cached &&
+			cachedInputs &&
+			revision === this.#revision &&
+			inputs.error === cachedInputs.error &&
+			sameEntries(inputs.models, cachedInputs.models) &&
+			sameEntries(inputs.allModels, cachedInputs.allModels) &&
+			sameEntries(this.#settings.mruOrder, cached.mruOrder)
+		) {
+			return cached;
 		}
+		const scope = scopeFromInputs(this.#settings, inputs);
+		this.#revision = revision;
+		this.#inputs = inputs;
+		this.#scope = scope;
+		return scope;
 	}
-	const allModels = scopedModels.length > 0 ? models : registry.getAll("all");
-	const roles = resolveRoleAssignments(settings, allModels, models);
-	const mruOrder = settings.mruOrder;
-	const items = buildBrowserItems(models);
-	sortModelItems(items, { roles, mruOrder });
-	return { items, roles, mruOrder, error };
 }
 
 interface RoleProviderStats {

package/src/overlays/rewind-selector.ts

@@ -22,7 +22,8 @@
  * variants at a fork and jump between user turns elsewhere, `f` opens a
  * filter (typing narrows the current path to matching items; Esc leaves the
  * filter with the selection kept), Enter rewinds to the outlined item, A loads
- * earlier turns without changing selection, Esc cancels.
+ * earlier turns without changing selection (stepping above the oldest replayed
+ * turn loads them too), Esc cancels.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import {
@@ -471,7 +472,10 @@ export class RewindSelectorComponent implements Component {
 		this.#move(delta, () => true);
 	}
 
-	/** Step the main selection by `delta` to the nearest visible target passing `accept`. */
+	/**
+	 * Step the main selection by `delta` to the nearest visible target passing
+	 * `accept`; stepping above the replayed tail loads the earlier history first.
+	 */
 	#move(delta: -1 | 1, accept: (target: OutlineTarget) => boolean): void {
 		let index = this.#selected + delta;
 		while (index >= 0 && index < this.#targets.length) {
@@ -485,6 +489,10 @@ export class RewindSelectorComponent implements Component {
 			}
 			index += delta;
 		}
+		if (delta < 0 && this.#truncated) {
+			this.#loadFullHistory();
+			this.#move(delta, accept);
+		}
 	}
 
 	#isMainSelectable(index: number): boolean {

package/src/prompt/composer-attachments.ts

@@ -50,9 +50,12 @@ const SKILL_ICONS = [...new Set(Object.values(SYMBOL_PRESETS).map(m => m["icon.e
 /** Skill names as they appear in chips: word characters and dashes, dots only between segments. */
 const SKILL_NAME_SOURCE = "[\\w-]+(?:\\.[\\w-]+)*";
 
-const SKILL_CHIP_SOURCE = `(?:${SKILL_ICONS.map(icon =>
-	/^[a-z]+$/i.test(icon) ? `(?<![A-Za-z])${RegExp.escape(icon)}` : RegExp.escape(icon),
-).join("|")}) (${SKILL_NAME_SOURCE})(?![\\w-])`;
+/** Regex source for a chip glyph; word glyphs (ASCII preset) must not continue a preceding word. */
+function glyphSource(icon: string): string {
+	return /^[a-z]+$/i.test(icon) ? `(?<![A-Za-z])${RegExp.escape(icon)}` : RegExp.escape(icon);
+}
+
+const SKILL_CHIP_SOURCE = `(?:${SKILL_ICONS.map(glyphSource).join("|")}) (${SKILL_NAME_SOURCE})(?![\\w-])`;
 
 /**
  * Replaces `/skill:<name>` tokens for known skills with compact chip labels and
@@ -96,11 +99,16 @@ export function collapseModelMentions(
 
 const CHIP_ICON_KEY = { image: "chip.image", video: "chip.video", paste: "chip.paste" } as const;
 
+/** Chip glyph the active theme renders for `kind`, including `symbols.overrides`. */
+function activeChipIcon(kind: ChipKind): string {
+	return typeof theme === "undefined"
+		? SYMBOL_PRESETS.unicode[CHIP_ICON_KEY[kind]]
+		: theme.symbol(CHIP_ICON_KEY[kind]);
+}
+
 /** Compact atomic composer token for attachment `n` in the active symbol preset. */
 export function chipLabel(kind: ChipKind, n: number): string {
-	const icon =
-		typeof theme === "undefined" ? SYMBOL_PRESETS.unicode[CHIP_ICON_KEY[kind]] : theme.symbol(CHIP_ICON_KEY[kind]);
-	return `${icon} #${n}`;
+	return `${activeChipIcon(kind)} #${n}`;
 }
 
 /** Every glyph a chip token may start with, across all symbol presets. */
@@ -111,7 +119,7 @@ const CHIP_ICONS: Record<ChipKind, readonly string[]> = {
 };
 
 const CHIP_TOKEN_SOURCE = `(?:${[...CHIP_ICONS.image, ...CHIP_ICONS.video, ...CHIP_ICONS.paste]
-	.map(icon => (/^[a-z]+$/i.test(icon) ? `(?<![A-Za-z])${RegExp.escape(icon)}` : RegExp.escape(icon)))
+	.map(glyphSource)
 	.join("|")}) #[1-9]\\d*`;
 
 /** Infers an attachment kind from a chip label emitted by any configured symbol preset. */
@@ -155,6 +163,45 @@ export const COMPOSER_TOKEN_REGEX = new RegExp(
 	"gu",
 );
 
+/**
+ * Attachment indices referenced by a composer buffer, per kind. Image/video count compact chips
+ * and expanded markers; paste counts compact chips only, since `[Paste #N]` markers number the
+ * base editor's separate paste buffer. Registered labels take precedence over theme glyphs so
+ * tokens created before a theme switch keep their kind; full numbers prevent `#1` matching `#10`.
+ */
+export function referencedAttachments(
+	text: string,
+	recorded: ReadonlyMap<string, ChipKind>,
+): Record<ChipKind, Set<number>> {
+	const kinds: readonly ChipKind[] = ["image", "video", "paste"];
+	const kindByIcon = new Map<string, ChipKind>();
+	for (const kind of kinds) for (const icon of CHIP_ICONS[kind]) kindByIcon.set(icon, kind);
+	for (const kind of kinds) kindByIcon.set(activeChipIcon(kind), kind);
+	const icons = [...kindByIcon.keys()].sort((a, b) => b.length - a.length).map(glyphSource);
+	const labels = [...recorded.keys()].sort((a, b) => b.length - a.length).map(label => RegExp.escape(label));
+	const recordedSource = labels.length > 0 ? labels.join("|") : "(?!)";
+	const scanner = new RegExp(
+		`${PLACEHOLDER_REGEX.source}|(${recordedSource})(?!\\d)|(${icons.join("|")}) #([1-9]\\d*)`,
+		"gu",
+	);
+
+	const refs: Record<ChipKind, Set<number>> = { image: new Set(), video: new Set(), paste: new Set() };
+	for (const match of text.matchAll(scanner)) {
+		if (match[1] === "Image") refs.image.add(Number(match[2]));
+		else if (match[1] === "Video") refs.video.add(Number(match[2]));
+		const label = match[3];
+		if (label !== undefined) {
+			const kind = recorded.get(label);
+			if (kind !== undefined) refs[kind].add(Number(label.slice(label.lastIndexOf("#") + 1)));
+		} else {
+			const icon = match[4];
+			const kind = icon === undefined ? undefined : kindByIcon.get(icon);
+			if (kind !== undefined) refs[kind].add(Number(match[5]));
+		}
+	}
+	return refs;
+}
+
 /** Add the registered model-chip labels to the composer placeholder matcher. */
 export function composerTokenRegex(mentionLabels: Iterable<string>): RegExp {
 	const labels = [...new Set(mentionLabels)].sort((a, b) => b.length - a.length);

package/src/prompt/composer.ts

@@ -369,12 +369,15 @@ export class Composer implements TerminalFrameProvider {
 		// editor drifts up above a band of blank rows (#11007).
 		this.#transientChromeFloor = Math.min(this.#transientChromeFloor ?? transientRows, transientRows);
 		const belowFloor = after.length - transientRows + this.#transientChromeFloor;
+		const now = performance.now();
+		const frame: AnimationFrame = { now, tick: Math.floor(now / 80) };
+		// Retirement measures the same live blocks the viewport lays out below;
+		// one open frame renders each of them once for both.
+		transcript.beginFrame(frame);
 		const history = this.#offerHistory(transcript, width, rows, preRoots.length + belowFloor);
 		const headerVisible = !this.#headerRetired && this.#offeredHistory?.source !== "header";
 		const headerRows = headerVisible ? this.#header.render(width) : [];
 		const before = [...headerRows, ...preRoots];
-		const now = performance.now();
-		const frame: AnimationFrame = { now, tick: Math.floor(now / 80) };
 		// The live tail is laid out against the same baseline retirement is
 		// billed against, so its compaction allocator (one row per block, no
 		// inter-block blanks) engages only when a block genuinely cannot retire.

package/src/prompt/custom-editor.ts

@@ -14,6 +14,7 @@ import { imageAttachmentSource } from "./image-source";
 import { isVideoPath } from "./video";
 import {
 	attachmentSgr,
+	type ChipKind,
 	COMPOSER_TOKEN_REGEX,
 	chipLabel,
 	collapseImageMarkers,
@@ -21,6 +22,8 @@ import {
 	collapseSkillTokens,
 	composerTokenRegex,
 	modelChipStyle,
+	PLACEHOLDER_REGEX,
+	referencedAttachments,
 	renderPlaceholders,
 	skillChipLabel,
 	skillChipStyle,
@@ -662,14 +665,29 @@ export class CustomEditor extends Editor {
 		) {
 			return cached.chips;
 		}
-		const text = this.getText();
+		const recorded = new Map<string, ChipKind>();
+		if (this.pendingImages.length > 0) {
+			for (const [label, expansion] of this.atoms) {
+				const kind = expansion.startsWith("[Image #")
+					? "image"
+					: expansion.startsWith("[Video #")
+						? "video"
+						: undefined;
+				if (kind !== undefined && expansion.match(PLACEHOLDER_REGEX)?.[0] === expansion) {
+					recorded.set(label, kind);
+				}
+			}
+		}
+		for (const entry of this.pendingTexts) {
+			// A reused label belongs to the atom currently expanding it, not a deleted paste.
+			if (!recorded.has(entry.label)) recorded.set(entry.label, "paste");
+		}
+		const refs = referencedAttachments(this.getText(), recorded);
 		const chips: ComposerChipDescriptor[] = [];
 		for (let i = 0; i < this.pendingImages.length; i++) {
 			const n = i + 1;
-			const video =
-				text.includes(chipLabel("video", n)) || text.includes(`[Video #${n}]`) || text.includes(`[Video #${n},`);
-			const image =
-				text.includes(chipLabel("image", n)) || text.includes(`[Image #${n}]`) || text.includes(`[Image #${n},`);
+			const video = refs.video.has(n);
+			const image = refs.image.has(n);
 			if (!video && !image) continue;
 			chips.push({
 				kind: video ? "video" : "image",
@@ -679,7 +697,7 @@ export class CustomEditor extends Editor {
 			});
 		}
 		for (const entry of this.pendingTexts) {
-			if (!text.includes(entry.label)) continue;
+			if (!refs.paste.has(entry.n)) continue;
 			chips.push({ kind: "paste", n: entry.n, text: entry });
 		}
 		this.#composerChipsCache = {

package/src/prompt/model-mention-autocomplete.ts

@@ -4,9 +4,11 @@ import type { ModelBrowserRegistry, ModelBrowserSource } from "../overlays/model
 import { modelMentionDisplayName } from "./model-mention-syntax";
 import type {
 	buildSearchAffinity as BuildSearchAffinity,
-	buildSessionModelScope as BuildSessionModelScope,
 	ModelBrowserItem,
 	rankModelItems as RankModelItems,
+	SearchAffinity,
+	SessionModelScope,
+	SessionModelScopeCache as SessionModelScopeCacheClass,
 } from "../overlays/model-browser";
 import { theme } from "../theme/theme";
 
@@ -17,7 +19,7 @@ const MAX_MODEL_MENTION_SUGGESTIONS = 20;
 export type ModelMentionCandidateSource = (query: string) => ReadonlyArray<ModelBrowserItem>;
 
 interface ModelBrowserModules {
-	buildSessionModelScope: typeof BuildSessionModelScope;
+	SessionModelScopeCache: typeof SessionModelScopeCacheClass;
 	buildSearchAffinity: typeof BuildSearchAffinity;
 	rankModelItems: typeof RankModelItems;
 }
@@ -75,20 +77,30 @@ export function applyModelMentionCompletion(
 	};
 }
 
-/** Create a fresh session-scoped model candidate lookup using picker ordering. */
+/**
+ * Create a session-scoped model candidate lookup using picker ordering. The
+ * scope and search affinity are reused across queries until their inputs change.
+ */
 export function createModelMentionSource(host: {
 	source: ModelBrowserSource;
 	registry: ModelBrowserRegistry;
 	scopedModels: () => ReadonlyArray<Model>;
 }): ModelMentionCandidateSource {
+	let scopeCache: SessionModelScopeCacheClass | undefined;
+	let affinityScope: SessionModelScope | undefined;
+	let affinityProviderOrder: readonly string[] | undefined;
+	let affinity: SearchAffinity | undefined;
 	return query => {
-		const { buildSearchAffinity, buildSessionModelScope, rankModelItems } = loadModelBrowser();
-		const scope = buildSessionModelScope(host.source, host.registry, host.scopedModels());
+		const { SessionModelScopeCache, buildSearchAffinity, rankModelItems } = loadModelBrowser();
+		scopeCache ??= new SessionModelScopeCache(host.source, host.registry);
+		const scope = scopeCache.get(host.scopedModels());
 		if (!query.trim()) return scope.items;
-		return rankModelItems(query, scope.items, {
-			roles: scope.roles,
-			mruOrder: scope.mruOrder,
-			affinity: buildSearchAffinity(host.source.modelProviderOrder, scope.roles, scope.mruOrder),
-		});
+		const providerOrder = host.source.modelProviderOrder;
+		if (!affinity || affinityScope !== scope || affinityProviderOrder !== providerOrder) {
+			affinity = buildSearchAffinity(providerOrder, scope.roles, scope.mruOrder);
+			affinityScope = scope;
+			affinityProviderOrder = providerOrder;
+		}
+		return rankModelItems(query, scope.items, { roles: scope.roles, mruOrder: scope.mruOrder, affinity });
 	};
 }

package/src/render/width-aware-text.ts

@@ -47,6 +47,15 @@ export class WidthAwareText implements Component {
 		this.#inner.invalidate();
 	}
 
+	/**
+	 * Re-run the formatter on the next render because its inputs changed.
+	 * Unlike {@link invalidate}, the inner `Text` keeps its wrap cache, so a
+	 * reformat that yields the same string skips re-wrapping and re-tinting.
+	 */
+	reformat(): void {
+		this.#cachedText = undefined;
+	}
+
 	render(width: number): readonly string[] {
 		const paddingX = this.#ignoreTight ? this.#paddingX : getPaddingX(this.#paddingX);
 		const contentWidth = Math.max(1, width - paddingX * 2);