@oh-my-pi/pi-tui 18.7.0 → 18.8.0

package/src/overlays/plan-review-overlay.ts

@@ -21,6 +21,7 @@ import {
 	type Component,
 	Ellipsis,
 	Editor,
+	getWidthConfigEpoch,
 	Markdown,
 	type MarkdownTheme,
 	matchesKey,
@@ -32,7 +33,7 @@ import {
 } from "../index";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { sanitizeStatusText } from "../chrome/shared";
-import { getEditorTheme, getMarkdownTheme, theme } from "../theme/theme";
+import { getEditorTheme, getMarkdownTheme, getThemeEpoch, theme } from "../theme/theme";
 import {
 	matchesAppExternalEditor,
 	matchesSelectCancel,
@@ -76,6 +77,8 @@ const SIDEBAR_MIN_TOTAL_WIDTH = 64;
 const SIDEBAR_MIN_BODY_WIDTH = 40;
 /** Persisted line-context cap; render-time captions clamp again to the viewport. */
 const MAX_ANNOTATION_CONTEXT_WIDTH = 120;
+/** Oldest delete/annotate undo snapshots are dropped past this depth (each holds the full plan text). */
+const MAX_UNDO_ENTRIES = 100;
 
 type Focus = "toc" | "body" | "actions";
 
@@ -148,6 +151,78 @@ interface UndoEntry {
 	deleted: string[];
 }
 
+/** Concatenated plan body rows and their anchors, reused while every render input is unchanged. */
+interface BodyLayout {
+	width: number;
+	annotationRev: number;
+	themeEpoch: number;
+	widthEpoch: number;
+	/** Each section's `Markdown.render` result the layout was built from (compared by identity). */
+	rendered: readonly (readonly string[])[];
+	lines: readonly string[];
+	anchors: BodyRowAnchor[];
+	offsets: number[];
+}
+
+/** Line contexts per rendered-lines array; `Markdown.render` returns a stable array per (text, width). */
+const lineContextCache = new WeakMap<readonly string[], readonly LineAnchorContext[]>();
+/** Match keys per context list, so resolving several annotations normalizes each row once. */
+const normalizedContextCache = new WeakMap<readonly LineAnchorContext[], readonly string[]>();
+
+function lineContexts(rendered: readonly string[]): readonly LineAnchorContext[] {
+	let contexts = lineContextCache.get(rendered);
+	if (!contexts) {
+		contexts = rendered.map(line => {
+			const sanitized = sanitizeStatusText(line);
+			const truncated = visibleWidth(sanitized) > MAX_ANNOTATION_CONTEXT_WIDTH;
+			const text = truncateToWidth(sanitized, MAX_ANNOTATION_CONTEXT_WIDTH, Ellipsis.Unicode);
+			return { text: text || "(blank line)", truncated };
+		});
+		lineContextCache.set(rendered, contexts);
+	}
+	return contexts;
+}
+
+function normalizeLineContext(context: LineAnchorContext): string {
+	const normalized = sanitizeStatusText(context.text).replace(/\s+/g, " ").trim();
+	return context.truncated && normalized.endsWith("…") ? normalized.slice(0, -1) : normalized;
+}
+
+/** Row in `contexts` nearest `storedRow` whose text matches the stored context, or -1. */
+function resolveLineRow(
+	storedRow: number,
+	storedContext: LineAnchorContext,
+	contexts: readonly LineAnchorContext[],
+): number {
+	if (contexts.length === 0) return -1;
+	const targetRow = Math.max(0, Math.floor(storedRow));
+	const normalizedStoredContext = normalizeLineContext(storedContext);
+	if (!normalizedStoredContext) return -1;
+	let normalizedContexts = normalizedContextCache.get(contexts);
+	if (!normalizedContexts) {
+		normalizedContexts = contexts.map(normalizeLineContext);
+		normalizedContextCache.set(contexts, normalizedContexts);
+	}
+	let best = -1;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (let row = 0; row < normalizedContexts.length; row++) {
+		const normalizedContext = normalizedContexts[row]!;
+		if (
+			normalizedContext !== normalizedStoredContext &&
+			!normalizedContext.includes(normalizedStoredContext) &&
+			!normalizedStoredContext.includes(normalizedContext)
+		) {
+			continue;
+		}
+		const distance = Math.abs(row - targetRow);
+		if (distance < bestDistance) {
+			best = row;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+
 export interface PlanReviewOverlayCallbacks {
 	/** Invoked with the chosen option label (never a disabled one). */
 	onPick: (label: string) => void;
@@ -199,6 +274,10 @@ export class PlanReviewOverlay implements Component {
 	#sectionOffsets: number[] = [];
 	/** Rendered body row to underlying plan row; callouts retain their owner's anchor. */
 	#bodyRowAnchors: BodyRowAnchor[] = [];
+	/** Memoized {@link #buildBody} result. */
+	#bodyLayout: BodyLayout | undefined;
+	/** Lines last handed to the scroll view; unchanged layouts skip the copy and keep its render cache. */
+	#scrollLines: readonly string[] | undefined;
 	#undo: UndoEntry[] = [];
 	/** Titles of sections deleted in the overlay, surfaced as Refine feedback. */
 	#deleted: string[] = [];
@@ -444,8 +523,8 @@ export class PlanReviewOverlay implements Component {
 			) {
 				continue;
 			}
-			const contexts = section.md.render(MAX_ANNOTATION_CONTEXT_WIDTH).map(line => this.#lineContext(line));
-			const row = this.#resolveLineRow(
+			const contexts = lineContexts(section.md.render(MAX_ANNOTATION_CONTEXT_WIDTH));
+			const row = resolveLineRow(
 				entry.target.row,
 				{ text: entry.target.context, truncated: entry.target.contextTruncated === true },
 				contexts,
@@ -866,6 +945,7 @@ export class PlanReviewOverlay implements Component {
 	}
 
 	#pushUndo(): void {
+		if (this.#undo.length >= MAX_UNDO_ENTRIES) this.#undo.shift();
 		this.#undo.push({
 			text: joinPlanSections(this.#sections),
 			annotations: this.#sections.map(section =>
@@ -959,7 +1039,7 @@ export class PlanReviewOverlay implements Component {
 			seenRows.add(candidate.row);
 			sectionAnchors.push({ text: candidate.context, truncated: candidate.contextTruncated });
 		}
-		const resolvedRow = this.#resolveLineRow(
+		const resolvedRow = resolveLineRow(
 			annotation.target.row,
 			{ text: annotation.target.context, truncated: annotation.target.contextTruncated },
 			sectionAnchors,
@@ -1187,23 +1267,64 @@ export class PlanReviewOverlay implements Component {
 
 	#layoutBody(lines: readonly string[], height: number): void {
 		this.#captureScrollProgress();
-		this.#scrollView.setLines(lines);
+		if (lines !== this.#scrollLines) {
+			this.#scrollView.setLines(lines);
+			this.#scrollLines = lines;
+		}
 		this.#scrollView.setHeight(height);
 		const maxOffset = this.#scrollView.getMaxScrollOffset();
 		if (maxOffset > 0) this.#scrollView.setScrollOffset(Math.round(this.#scrollProgress * maxOffset));
 	}
 
-	/** Build the concatenated body lines and map each rendered row back to a plan anchor. */
-	#buildBody(bodyContentWidth: number): string[] {
+	/**
+	 * Build the concatenated body lines and map each rendered row back to a plan
+	 * anchor. Memoized on width, annotation revision, theme/width epochs and each
+	 * section's rendered-lines identity, so steady frames and scrolling reuse it.
+	 */
+	#buildBody(bodyContentWidth: number): readonly string[] {
+		const themeEpoch = getThemeEpoch();
+		const widthEpoch = getWidthConfigEpoch();
+		const cached = this.#bodyLayout;
+		if (
+			cached?.width === bodyContentWidth &&
+			cached.annotationRev === this.#annotationRev &&
+			cached.themeEpoch === themeEpoch &&
+			cached.widthEpoch === widthEpoch &&
+			cached.rendered.length === this.#sections.length &&
+			this.#sections.every((section, i) => section.md.render(bodyContentWidth) === cached.rendered[i])
+		) {
+			this.#sectionOffsets = cached.offsets;
+			this.#bodyRowAnchors = cached.anchors;
+			return cached.lines;
+		}
 		const lines: string[] = [];
 		const anchors: BodyRowAnchor[] = [];
+		const renderedSections: (readonly string[])[] = [];
 		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		const offsets: number[] = new Array(this.#sections.length);
 		for (let sectionIndex = 0; sectionIndex < this.#sections.length; sectionIndex++) {
 			const section = this.#sections[sectionIndex]!;
 			offsets[sectionIndex] = lines.length;
 			const rendered = section.md.render(bodyContentWidth);
-			const contexts = rendered.map(line => this.#lineContext(line));
+			renderedSections.push(rendered);
+			const contexts = lineContexts(rendered);
+			// Resolve each note's row once; notes on one row keep their array order.
+			let notesByRow: Map<number, string[]> | undefined;
+			for (const annotation of section.annotations) {
+				const annotationRow =
+					annotation.target.kind === "section"
+						? 0
+						: resolveLineRow(
+								annotation.target.row,
+								{ text: annotation.target.context, truncated: annotation.target.contextTruncated },
+								contexts,
+							);
+				if (annotationRow < 0) continue;
+				notesByRow ??= new Map();
+				const notes = notesByRow.get(annotationRow);
+				if (notes) notes.push(annotation.note);
+				else notesByRow.set(annotationRow, [annotation.note]);
+			}
 			for (let row = 0; row < rendered.length; row++) {
 				const context = contexts[row]!;
 				const anchor = {
@@ -1214,67 +1335,24 @@ export class PlanReviewOverlay implements Component {
 				};
 				lines.push(rendered[row]!);
 				anchors.push(anchor);
-				for (const annotation of section.annotations) {
-					const annotationRow =
-						annotation.target.kind === "section"
-							? 0
-							: this.#resolveLineRow(
-									annotation.target.row,
-									{
-										text: annotation.target.context,
-										truncated: annotation.target.contextTruncated,
-									},
-									contexts,
-								);
-					if (annotationRow === row) {
-						this.#appendAnnotationCallout(lines, anchors, annotation.note, anchor, bodyContentWidth);
-					}
-				}
+				const notes = notesByRow?.get(row);
+				if (!notes) continue;
+				for (const note of notes) this.#appendAnnotationCallout(lines, anchors, note, anchor, bodyContentWidth);
 			}
 		}
 		this.#sectionOffsets = offsets;
 		this.#bodyRowAnchors = anchors;
-		return lines;
-	}
-
-	#lineContext(line: string): LineAnchorContext {
-		const sanitized = sanitizeStatusText(line);
-		const truncated = visibleWidth(sanitized) > MAX_ANNOTATION_CONTEXT_WIDTH;
-		const text = truncateToWidth(sanitized, MAX_ANNOTATION_CONTEXT_WIDTH, Ellipsis.Unicode);
-		return { text: text || "(blank line)", truncated };
-	}
-
-	#resolveLineRow(
-		storedRow: number,
-		storedContext: LineAnchorContext,
-		contexts: readonly LineAnchorContext[],
-	): number {
-		if (contexts.length === 0) return -1;
-		const targetRow = Math.max(0, Math.floor(storedRow));
-		const normalize = (context: LineAnchorContext): string => {
-			const normalized = sanitizeStatusText(context.text).replace(/\s+/g, " ").trim();
-			return context.truncated && normalized.endsWith("…") ? normalized.slice(0, -1) : normalized;
+		this.#bodyLayout = {
+			width: bodyContentWidth,
+			annotationRev: this.#annotationRev,
+			themeEpoch,
+			widthEpoch,
+			rendered: renderedSections,
+			lines,
+			anchors,
+			offsets,
 		};
-		const normalizedStoredContext = normalize(storedContext);
-		if (!normalizedStoredContext) return -1;
-		let best = -1;
-		let bestDistance = Number.POSITIVE_INFINITY;
-		for (let row = 0; row < contexts.length; row++) {
-			const normalizedContext = normalize(contexts[row]!);
-			if (
-				normalizedContext !== normalizedStoredContext &&
-				!normalizedContext.includes(normalizedStoredContext) &&
-				!normalizedStoredContext.includes(normalizedContext)
-			) {
-				continue;
-			}
-			const distance = Math.abs(row - targetRow);
-			if (distance < bestDistance) {
-				best = row;
-				bestDistance = distance;
-			}
-		}
-		return best;
+		return lines;
 	}
 
 	#appendAnnotationCallout(

package/src/overlays/rewind-selector.ts

@@ -157,6 +157,14 @@ const STRIP_GAP = 2;
 /** Duration of the branch-swap camera slide. */
 const SLIDE_MS = 160;
 
+/** Same length and identical elements (or both undefined). */
+function sameElements<T>(a: readonly T[] | undefined, b: readonly T[] | undefined): boolean {
+	if (a === b) return true;
+	if (a === undefined || b === undefined || a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+
 export class RewindSelectorComponent implements Component {
 	#builder: ChatTranscriptBuilder;
 	#browser: TranscriptBrowser;
@@ -195,6 +203,24 @@ export class RewindSelectorComponent implements Component {
 	#rowText = new WeakMap<readonly string[], string>();
 	/** Native filter haystack: lowercased turn text per main target (no rendered rows under TSP). */
 	#nativeTexts: { targets: OutlineTarget[]; texts: string[] } | undefined;
+	/** Compiled word patterns of the last filter query. */
+	#filterPatterns: { query: string; patterns: RegExp[] } | undefined;
+	/**
+	 * Last {@link #filterMatches} result and its inputs. Frames hand back fresh
+	 * outer `mainRows`/`mainVisible` arrays over cached per-child rows, so those
+	 * compare element-wise.
+	 */
+	#filterMemo:
+		| {
+				query: string;
+				targets: OutlineTarget[];
+				expanded: boolean;
+				native: boolean;
+				mainRows: readonly (readonly string[])[];
+				mainVisible: readonly boolean[] | undefined;
+				matches: readonly number[];
+		  }
+		| undefined;
 	/** Last described bar and the state it was built from. */
 	#bar: { memo: string; targets: OutlineTarget[]; node: NativeNode } | undefined;
 
@@ -528,14 +554,25 @@ export class RewindSelectorComponent implements Component {
 	 * Matching the rendered rows keeps results honest: collapsed tool output
 	 * only matches once Ctrl+O expands it.
 	 */
-	#filterMatches(): number[] {
-		const words = (this.#filter ?? "").toLowerCase().split(/\s+/).filter(Boolean);
-		const patterns = words.map(word =>
-			/^[\p{Script=Latin}\p{N}_]+$/u.test(word)
-				? new RegExp(`(?<![\\p{L}\\p{N}_])${RegExp.escape(word)}(?![\\p{L}\\p{N}_])`, "u")
-				: new RegExp(RegExp.escape(word), "u"),
-		);
-		if (isNativeRendering() && this.#nativeTexts?.targets !== this.#targets) {
+	#filterMatches(): readonly number[] {
+		const query = this.#filter ?? "";
+		const native = isNativeRendering();
+		const memo = this.#filterMemo;
+		if (
+			memo &&
+			memo.query === query &&
+			memo.targets === this.#targets &&
+			memo.expanded === this.#expanded &&
+			memo.native === native &&
+			sameElements(memo.mainVisible, this.#mainVisible) &&
+			(native || sameElements(memo.mainRows, this.#mainRows))
+		) {
+			memo.mainRows = this.#mainRows;
+			memo.mainVisible = this.#mainVisible;
+			return memo.matches;
+		}
+		const patterns = this.#compileFilter(query);
+		if (native && this.#nativeTexts?.targets !== this.#targets) {
 			this.#nativeTexts = {
 				targets: this.#targets,
 				// Turn text plus its commands and tool output, like the expanded rendered rows.
@@ -550,21 +587,53 @@ export class RewindSelectorComponent implements Component {
 		for (let index = 0; index < this.#targets.length; index++) {
 			if (!this.#isMainSelectable(index)) continue;
 			const target = this.#targets[index]!;
-			const texts = isNativeRendering()
-				? [this.#nativeTexts?.texts[index] ?? ""]
-				: this.#mainRows.slice(target.start, target.end).map(rows => {
-						let text = this.#rowText.get(rows);
-						if (text === undefined) {
-							text = Bun.stripANSI(rows.join("\n")).toLowerCase();
-							this.#rowText.set(rows, text);
+			const matched = native
+				? patterns.every(pattern => pattern.test(this.#nativeTexts?.texts[index] ?? ""))
+				: patterns.every(pattern => {
+						for (let child = target.start; child < target.end; child++) {
+							const rows = this.#mainRows[child];
+							if (rows !== undefined && pattern.test(this.#plainRowText(rows))) return true;
 						}
-						return text;
+						return false;
 					});
-			if (patterns.every(pattern => texts.some(text => pattern.test(text)))) matches.push(index);
+			if (matched) matches.push(index);
 		}
+		this.#filterMemo = {
+			query,
+			targets: this.#targets,
+			expanded: this.#expanded,
+			native,
+			mainRows: this.#mainRows,
+			mainVisible: this.#mainVisible,
+			matches,
+		};
 		return matches;
 	}
 
+	/** Word patterns of `query`, compiled once per distinct query. */
+	#compileFilter(query: string): RegExp[] {
+		const cached = this.#filterPatterns;
+		if (cached?.query === query) return cached.patterns;
+		const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+		const patterns = words.map(word =>
+			/^[\p{Script=Latin}\p{N}_]+$/u.test(word)
+				? new RegExp(`(?<![\\p{L}\\p{N}_])${RegExp.escape(word)}(?![\\p{L}\\p{N}_])`, "u")
+				: new RegExp(RegExp.escape(word), "u"),
+		);
+		this.#filterPatterns = { query, patterns };
+		return patterns;
+	}
+
+	/** Lowercased plain text of one rendered child row array, cached by array identity. */
+	#plainRowText(rows: readonly string[]): string {
+		let text = this.#rowText.get(rows);
+		if (text === undefined) {
+			text = Bun.stripANSI(rows.join("\n")).toLowerCase();
+			this.#rowText.set(rows, text);
+		}
+		return text;
+	}
+
 	/** Up/Down: step within the active column; leaving a sibling column's top exits the strip. */
 	#moveVertical(delta: -1 | 1): void {
 		if (this.#activeVariant > 0) {

package/src/overlays/session-selector.ts

@@ -179,9 +179,13 @@ function sessionPreview(session: SessionSelectorEntry, forkedFrom: string | unde
 	]);
 }
 
+/** Absolute dates of week-old sessions; `toLocaleDateString` goes through Intl on every call. */
+const localeDateCache = new WeakMap<Date, { time: number; text: string }>();
+
 /** Relative age of a session's last modification (`"3 hours ago"`), falling back to the date after a week. */
 function formatSessionDate(date: Date): string {
-	const diffMs = Date.now() - date.getTime();
+	const time = date.getTime();
+	const diffMs = Date.now() - time;
 	const diffMins = Math.floor(diffMs / 60000);
 	const diffHours = Math.floor(diffMs / 3600000);
 	const diffDays = Math.floor(diffMs / 86400000);
@@ -192,7 +196,11 @@ function formatSessionDate(date: Date): string {
 	if (diffDays === 1) return "1 day ago";
 	if (diffDays < 7) return `${diffDays} days ago`;
 
-	return date.toLocaleDateString();
+	const cached = localeDateCache.get(date);
+	if (cached?.time === time) return cached.text;
+	const text = date.toLocaleDateString();
+	localeDateCache.set(date, { time, text });
+	return text;
 }
 
 /** A cached native session item and the inputs it was built from. */
@@ -545,6 +553,8 @@ class SessionList<T extends SessionSelectorEntry> implements Component {
 	#lastFilterQuery = "";
 	/** Bumped whenever the visible session set may have changed (native memo key). */
 	#itemsVersion = 0;
+	/** Per-row line heights of the visible list for the ANSI window, reused until the set changes. */
+	#rowHeights: { items: readonly T[]; length: number; version: number; heights: readonly number[] } | undefined;
 	#itemsNative:
 		| { version: number; showCwd: boolean; currentPath: string | undefined; items: NativeNode[] }
 		| undefined;
@@ -1130,14 +1140,13 @@ class SessionList<T extends SessionSelectorEntry> implements Component {
 		// worst-case count-based window would leave (then padded by
 		// fill-height).
 		const filtered = this.#menu.visibleItems;
-		const itemHeight = (session: T): number => (session.title ? 4 : 3);
 		const budget = this.#lineBudget();
 		const {
 			startIndex,
 			endIndex,
 			rowOffset: offsetRows,
 			totalRows: rawTotalRows,
-		} = getMenuWindow(filtered.map(itemHeight), this.#menu.selectedIndex, budget);
+		} = getMenuWindow(this.#visibleRowHeights(filtered), this.#menu.selectedIndex, budget);
 
 		// Each session block is built into sessionLines, then wrapped by ScrollView
 		// so the right-edge scrollbar is proportional at the physical-line level.
@@ -1232,6 +1241,17 @@ class SessionList<T extends SessionSelectorEntry> implements Component {
 		return lines;
 	}
 
+	/** Line height per visible session (3, or 4 when a title adds a preview line), memoized per visible set. */
+	#visibleRowHeights(items: readonly T[]): readonly number[] {
+		const cached = this.#rowHeights;
+		if (cached?.items === items && cached.length === items.length && cached.version === this.#itemsVersion) {
+			return cached.heights;
+		}
+		const heights = items.map(session => (session.title ? 4 : 3));
+		this.#rowHeights = { items, length: items.length, version: this.#itemsVersion, heights };
+		return heights;
+	}
+
 	handleInput(keyData: string): void {
 		// Delete key — or Backspace on an empty search query — request delete
 		// confirmation from the parent. macOS laptops have no dedicated Forward

package/src/overlays/settings-selector.ts

@@ -4,7 +4,7 @@ import {
 	type Component,
 	Container,
 	extractPrintableText,
-	fuzzyRank,
+	FuzzyCorpus,
 	getKeybindings,
 	getSettingItemFilterText,
 	type ImageBudget,
@@ -630,6 +630,12 @@ export class SettingsSelectorComponent implements Component {
 	#searchMatchCount = 0;
 	/** First matching item id per tab id, for Tab-key jumps while searching. */
 	#searchFirstMatch = new Map<string, string>();
+	/**
+	 * Per-tab search candidates prepared once per search session. Dropped on
+	 * search start/end and whenever a value or condition may have changed
+	 * (`#refreshItems`, `#onSearchSettingChange`); rebuilt lazily by `#setSearchQuery`.
+	 */
+	#searchCorpora: { tab: SettingTab; corpus: FuzzyCorpus<SettingItem> }[] | null = null;
 	#textInputActive = false;
 	#hasSectionJump = false;
 	// Frame geometry from the last render, for mouse hit-testing (the
@@ -1111,8 +1117,10 @@ export class SettingsSelectorComponent implements Component {
 
 	/** Rebuilds the visible items after a change made outside a list's own `onChange` (changed flags, conditions). */
 	#refreshItems(): void {
-		if (this.#searchList) this.#setSearchQuery(this.#searchQuery);
-		else if (this.#currentTabId !== "plugins")
+		if (this.#searchList) {
+			this.#searchCorpora = null;
+			this.#setSearchQuery(this.#searchQuery);
+		} else if (this.#currentTabId !== "plugins")
 			this.#refreshCurrentTabItems(getSettingsForTab(this.#context.settings.entries, this.#currentTabId));
 	}
 
@@ -1281,6 +1289,7 @@ export class SettingsSelectorComponent implements Component {
 	/** Swap the tab content for the global search result list. */
 	#startSearch(initialQuery: string): void {
 		this.#preSearchTabId = this.#currentTabId;
+		this.#searchCorpora = null;
 		this.#searchInput = new Input();
 		this.#searchInput.prompt = "";
 		this.#searchInput.setValue(initialQuery);
@@ -1324,13 +1333,17 @@ export class SettingsSelectorComponent implements Component {
 		const tabResults: { tab: SettingTab; matched: SettingItem[]; bestScore: number; order: number }[] = [];
 		this.#searchFirstMatch.clear();
 		let total = 0;
-		for (const tab of SETTING_TABS) {
+		this.#searchCorpora ??= SETTING_TABS.map(tab => {
 			const candidates: SettingItem[] = [];
 			for (const def of getSettingsForTab(this.#context.settings.entries, tab)) {
 				const item = this.#defToItem(def);
 				if (item) candidates.push(item);
 			}
-			const ranked = fuzzyRank(candidates, query, getSettingItemFilterText);
+			return { tab, corpus: new FuzzyCorpus(candidates, getSettingItemFilterText) };
+		});
+		for (let order = 0; order < this.#searchCorpora.length; order++) {
+			const { tab, corpus } = this.#searchCorpora[order]!;
+			const ranked = corpus.rank(query);
 			const matched = ranked.map(result => result.item);
 			counts.set(tab, matched.length);
 			if (matched.length === 0) continue;
@@ -1339,7 +1352,7 @@ export class SettingsSelectorComponent implements Component {
 				tab,
 				matched,
 				bestScore: ranked[0]?.score ?? 0,
-				order: SETTING_TABS.indexOf(tab),
+				order,
 			});
 		}
 
@@ -1378,6 +1391,7 @@ export class SettingsSelectorComponent implements Component {
 		const targetTab: SettingTab | "plugins" = selectedDef?.tab ?? this.#preSearchTabId;
 
 		this.#searchQuery = "";
+		this.#searchCorpora = null;
 		this.#searchFirstMatch.clear();
 		this.#searchMatchCount = 0;
 		this.#tabs = getSettingsTabs();
@@ -1441,6 +1455,7 @@ export class SettingsSelectorComponent implements Component {
 		}
 		// Values feed the searchable text and condition gates may have flipped:
 		// recompute results in place (selection is preserved by item id).
+		this.#searchCorpora = null;
 		this.#setSearchQuery(this.#searchQuery);
 	}
 

package/src/overlays/tree-selector.ts

@@ -2,7 +2,8 @@ import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import {
 	type Component,
 	Container,
-	fuzzyMatch,
+	FuzzyQuery,
+	FuzzyText,
 	Input,
 	matchesKey,
 	Spacer,
@@ -210,6 +211,8 @@ class TreeList implements Component {
 	#multipleRoots = false;
 	#activePathIds: Set<string> = new Set();
 	#containsActive: Map<TreeSelectorNode, boolean> = new Map();
+	/** Prepared search text per node; rebuilt when the node's label changes. */
+	#searchTextCache = new WeakMap<TreeSelectorNode, { label: string | undefined; text: FuzzyText }>();
 
 	onSelect?: (entryId: string, options: { summarize: boolean }) => void;
 	onCancel?: () => void;
@@ -373,7 +376,11 @@ class TreeList implements Component {
 	#buildFilter(): (node: TreeSelectorNode, row: TreeRow<TreeSelectorNode, string>) => boolean {
 		const filterMode = this.#filterMode;
 		const leafId = this.currentLeafId;
-		const searchTokens = this.getSearchQuery().toLowerCase().split(/\s+/).filter(Boolean);
+		const searchTokens = this.getSearchQuery()
+			.toLowerCase()
+			.split(/\s+/)
+			.filter(Boolean)
+			.map(token => new FuzzyQuery(token));
 		return node => {
 			const entry = node.entry;
 			const isCurrentLeaf = entry.id === leafId;
@@ -435,14 +442,23 @@ class TreeList implements Component {
 
 			// Apply fuzzy search filter
 			if (searchTokens.length > 0) {
-				const nodeText = this.#getSearchableText(node);
-				return searchTokens.every(token => fuzzyMatch(token, nodeText).matches);
+				const nodeText = this.#getFuzzyText(node);
+				return searchTokens.every(token => token.match(nodeText).matches);
 			}
 
 			return true;
 		};
 	}
 
+	/** Prepared fuzzy text for a node's searchable content, built once per label. */
+	#getFuzzyText(node: TreeSelectorNode): FuzzyText {
+		const cached = this.#searchTextCache.get(node);
+		if (cached !== undefined && cached.label === node.label) return cached.text;
+		const text = new FuzzyText(this.#getSearchableText(node));
+		this.#searchTextCache.set(node, { label: node.label, text });
+		return text;
+	}
+
 	/** Get searchable text content from a node */
 	#getSearchableText(node: TreeSelectorNode): string {
 		const entry = node.entry;