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

package/src/overlays/agent-transcript-viewer.ts

@@ -49,7 +49,14 @@ export type AgentTranscriptEntry = SessionMessageEntryLike | { type: "model_chan
 
 /** Local filesystem and session parsing capabilities supplied by the host. */
 export interface AgentTranscriptSource {
-	fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync">;
+	/**
+	 * Sync primitives drive the first paint and the incremental tail. When the
+	 * host also supplies `promises.readFile` (e.g. passes `node:fs` itself), full
+	 * reloads after rotation/rewrite read the file off the UI thread.
+	 */
+	fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync"> & {
+		promises?: Pick<typeof fs.promises, "readFile">;
+	};
 	parseEntries(text: string): AgentTranscriptEntry[];
 }
 
@@ -86,6 +93,8 @@ export interface AgentTranscriptViewerDeps {
 
 /** How often to re-stat a file-backed transcript for growth (advisor/live tail). */
 const POLL_MS = 250;
+/** Every Nth idle poll re-verifies sentinels, catching same-size/mtime rewrites. */
+const IDLE_SENTINEL_CHECK_EVERY = 5;
 
 const SENTINEL_BYTES = 4096;
 
@@ -183,6 +192,10 @@ export class AgentTranscriptViewer implements Component {
 	#model: string | undefined;
 	#pollTimer: NodeJS.Timeout | undefined;
 	#disposed = false;
+	/** Async full reload in flight; polls are skipped until it lands. */
+	#localLoadInFlight = false;
+	/** Idle polls since the sentinels were last verified. */
+	#idlePolls = 0;
 	#initialEntryId: string | undefined;
 	/** Last described node and the visible inputs it was built from. */
 	#nativeCache: { signature: string; node: NativeNode } | undefined;
@@ -215,8 +228,10 @@ export class AgentTranscriptViewer implements Component {
 			this.#editor.setMaxHeight(4);
 			this.#editor.onSubmit = text => this.#submit(text);
 		}
-		this.#refresh();
-		this.#pollTimer = setInterval(() => this.#refresh(), POLL_MS);
+		// First paint loads synchronously so the initial entry can be revealed
+		// immediately; later full reloads from the poll may go async.
+		this.#refresh(false);
+		this.#pollTimer = setInterval(() => this.#refresh(true), POLL_MS);
 		this.#pollTimer.unref?.();
 	}
 
@@ -245,12 +260,13 @@ export class AgentTranscriptViewer implements Component {
 	// ========================================================================
 
 	/** Refresh the transcript from a local file or remote host. */
-	#refresh(): void {
+	#refresh(allowAsync: boolean): void {
 		if (this.#disposed) return;
 		if (this.#deps.remote) {
 			this.#fetchRemote();
 			return;
 		}
+		if (this.#localLoadInFlight) return;
 		const sessionFile = this.#deps.registry.get(this.#deps.agentId)?.sessionFile;
 		if (!sessionFile) {
 			this.#clearLocal("none");
@@ -264,14 +280,29 @@ export class AgentTranscriptViewer implements Component {
 			return;
 		}
 		const state = this.#localState;
-		if (state && this.#canAppendLocal(sessionFile, stat, state)) {
-			if (stat.size === state.size && stat.mtimeMs === state.mtimeMs) return;
-			if (stat.size > state.size) {
-				this.#appendLocal(sessionFile, stat, state);
+		if (state) {
+			// Idle fast path: an unchanged identity/size/mtime costs one stat;
+			// sentinels are re-read only every Nth idle poll so a rewrite that
+			// keeps size and mtime is still noticed.
+			if (
+				state.path === sessionFile &&
+				state.dev === stat.dev &&
+				state.ino === stat.ino &&
+				stat.size === state.size &&
+				stat.mtimeMs === state.mtimeMs
+			) {
+				if (++this.#idlePolls < IDLE_SENTINEL_CHECK_EVERY) return;
+				this.#idlePolls = 0;
+				if (this.#canAppendLocal(sessionFile, stat, state)) return;
+				this.#loadLocalFull(sessionFile, stat, allowAsync);
+				return;
+			}
+			if (stat.size > state.size && this.#canAppendLocal(sessionFile, stat, state)) {
+				this.#appendLocal(sessionFile, stat, state, allowAsync);
 				return;
 			}
 		}
-		this.#loadLocalFull(sessionFile, stat);
+		this.#loadLocalFull(sessionFile, stat, allowAsync);
 	}
 
 	#clearLocal(reason: string): void {
@@ -305,7 +336,23 @@ export class AgentTranscriptViewer implements Component {
 		return true;
 	}
 
-	#loadLocalFull(sessionFile: string, stat: fs.Stats): void {
+	#loadLocalFull(sessionFile: string, stat: fs.Stats, allowAsync: boolean): void {
+		const promises = allowAsync ? this.#deps.transcript.fs.promises : undefined;
+		if (promises) {
+			this.#localLoadInFlight = true;
+			void promises
+				.readFile(sessionFile)
+				.then(data => {
+					this.#localLoadInFlight = false;
+					if (!this.#disposed) this.#applyLocalFull(sessionFile, stat, data);
+				})
+				.catch((err: unknown) => {
+					// Leave #localState unchanged so a transient read error retries next poll.
+					this.#localLoadInFlight = false;
+					logger.debug("transcript viewer: read failed", { err: String(err) });
+				});
+			return;
+		}
 		let data: Buffer;
 		try {
 			data = this.#deps.transcript.fs.readFileSync(sessionFile);
@@ -314,6 +361,10 @@ export class AgentTranscriptViewer implements Component {
 			logger.debug("transcript viewer: read failed", { err: String(err) });
 			return;
 		}
+		this.#applyLocalFull(sessionFile, stat, data);
+	}
+
+	#applyLocalFull(sessionFile: string, stat: fs.Stats, data: Buffer): void {
 		// The file may have grown between the earlier `statSync` and this read.
 		// Anchor the tail cursor to what we actually consumed so the next poll's
 		// `#appendLocal` never re-renders bytes already in the rebuilt transcript;
@@ -347,7 +398,7 @@ export class AgentTranscriptViewer implements Component {
 		this.#rebuild(this.#extractMessages(this.#deps.transcript.parseEntries(complete)));
 	}
 
-	#appendLocal(sessionFile: string, stat: fs.Stats, state: LocalTranscriptState): void {
+	#appendLocal(sessionFile: string, stat: fs.Stats, state: LocalTranscriptState, allowAsync: boolean): void {
 		let chunk: string;
 		try {
 			chunk = readFileRangeSync(
@@ -358,7 +409,7 @@ export class AgentTranscriptViewer implements Component {
 			).toString("utf-8");
 		} catch (err) {
 			logger.debug("transcript viewer: tail read failed", { err: String(err) });
-			this.#loadLocalFull(sessionFile, stat);
+			this.#loadLocalFull(sessionFile, stat, allowAsync);
 			return;
 		}
 		const combined = state.pending + chunk;
@@ -373,7 +424,7 @@ export class AgentTranscriptViewer implements Component {
 			// File unlinked/rotated mid-poll: fall back to a guarded full reload
 			// instead of letting the open escape the poll timer.
 			logger.debug("transcript viewer: sentinel recompute failed", { err: String(err) });
-			this.#loadLocalFull(sessionFile, stat);
+			this.#loadLocalFull(sessionFile, stat, allowAsync);
 			return;
 		}
 		this.#localState = {

package/src/overlays/agents-hub.ts

@@ -15,7 +15,7 @@ import type { TspPickerAction, TspPickerColumn, TspPickerItem, TspPickerScope, T
 import {
 	type Component,
 	Editor,
-	fuzzyMatch,
+	FuzzyQuery,
 	Input,
 	matchesKey,
 	replaceTabs,
@@ -194,12 +194,12 @@ function listRowId(rowDef: ListRow): string {
 	return rowDef.kind === "new" ? "new" : `agent:${rowDef.agent.source}:${rowDef.agent.name}`;
 }
 
-function matchAgent(agent: HubAgent, query: string): boolean {
+/** All `tokens` (prepared once per query) fuzzy-match the agent's searchable text. */
+function matchAgent(agent: HubAgent, tokens: readonly FuzzyQuery[]): boolean {
+	// Not memoized: `overrideModel` is edited in place, and the module index
+	// cache already reuses the per-text index for unchanged agents.
 	const text = `${agent.name} ${agent.description} ${SOURCE_LABEL[agent.source]} ${agent.overrideModel ?? ""}`;
-	return query
-		.trim()
-		.split(/\s+/)
-		.every(token => fuzzyMatch(token, text).matches);
+	return tokens.every(token => token.match(text).matches);
 }
 
 /**
@@ -373,7 +373,14 @@ export class AgentsHubComponent implements Component {
 		const scoped =
 			entry.kind === "source" ? this.#allAgents.filter(agent => agent.source === entry.source) : this.#allAgents;
 		const query = this.#search.getValue();
-		const filtered = query ? scoped.filter(agent => matchAgent(agent, query)) : scoped;
+		let filtered = scoped;
+		if (query) {
+			const tokens = query
+				.trim()
+				.split(/\s+/)
+				.map(token => new FuzzyQuery(token));
+			filtered = scoped.filter(agent => matchAgent(agent, tokens));
+		}
 		this.#rows = [...filtered.map(agent => ({ kind: "agent", agent }) as ListRow), { kind: "new" }];
 	}
 

package/src/overlays/copy-selector.ts

@@ -327,6 +327,12 @@ interface ControlRegion {
 	end: number;
 }
 
+/** A block's preview rows (highlighted, width-cut, plus the "more lines" row) and its full line count. */
+interface BlockPreview {
+	rows: string[];
+	lineCount: number;
+}
+
 export class CopySelectorComponent implements Component {
 	#builder: ChatTranscriptBuilder;
 	#browser: TranscriptBrowser;
@@ -348,6 +354,8 @@ export class CopySelectorComponent implements Component {
 
 	/** Last described root and the state it was built from. */
 	#native: { memo: string; targets: OutlineTarget[]; blocks: CopyBlock[] | undefined; node: NativeNode } | undefined;
+	/** ANSI block previews (syntax highlight + width cut) of the exploded turn. */
+	#blockPreviews: { blocks: CopyBlock[]; inner: number; previews: readonly BlockPreview[] } | undefined;
 	/** Transcript list items, rebuilt only when the replayed targets change. */
 	#nativeItems: { targets: OutlineTarget[]; truncated: boolean; items: NativeNode[] } | undefined;
 	/** Timeline picker items of the replayed targets. */
@@ -414,6 +422,7 @@ export class CopySelectorComponent implements Component {
 	}
 
 	invalidate(): void {
+		this.#blockPreviews = undefined;
 		this.#builder.container.invalidate();
 		this.#browser.invalidate();
 	}
@@ -945,18 +954,13 @@ export class CopySelectorComponent implements Component {
 	 */
 	#composeBlocks(blocks: CopyBlock[], columnWidth: number, lineOffset: number): ComposedColumn {
 		const inner = Math.max(10, columnWidth - 4);
+		const previews = this.#previewBlocks(blocks, inner);
 		const lines: string[] = [];
 		let selStart = -1;
 		let selEnd = -1;
 		for (let index = 0; index < blocks.length; index++) {
 			const block = blocks[index]!;
-			const raw = block.content.split("\n");
-			const shown = raw.slice(0, BLOCK_PREVIEW_LINES);
-			const styled = block.language ? highlightCode(shown.join("\n"), block.language) : shown;
-			const rows = styled.map(row => truncateToWidth(replaceTabs(row), inner));
-			if (raw.length > shown.length) {
-				rows.push(theme.fg("dim", `… +${raw.length - shown.length} more lines`));
-			}
+			const { rows, lineCount } = previews[index]!;
 			const selected = index === this.#blockSelected;
 			const captionColor: ThemeColor = selected ? OUTLINE_COLOR : "dim";
 			const controls: Array<{ action: ControlRegion["action"]; text: string }> = [
@@ -965,7 +969,7 @@ export class CopySelectorComponent implements Component {
 			if (block.href && this.deps.onOpen) controls.push({ action: "open", text: `${theme.cmd.share} open` });
 			const controlsWidth = controls.reduce((sum, control) => sum + visibleWidth(control.text) + 2, 0);
 			const summary = truncateToWidth(
-				`${index + 1}/${blocks.length}${theme.sep.dot}${block.label}${theme.sep.dot}${raw.length} line${raw.length === 1 ? "" : "s"}`,
+				`${index + 1}/${blocks.length}${theme.sep.dot}${block.label}${theme.sep.dot}${lineCount} line${lineCount === 1 ? "" : "s"}`,
 				Math.max(4, inner - controlsWidth),
 			);
 			// Caption: two-space gutter, summary, then the controls, each preceded by two spaces.
@@ -998,6 +1002,24 @@ export class CopySelectorComponent implements Component {
 		lines.push("");
 		return { lines, selStart, selEnd };
 	}
+
+	/** Highlighted, width-cut previews of each block; rebuilt when the block set or width changes. */
+	#previewBlocks(blocks: CopyBlock[], inner: number): readonly BlockPreview[] {
+		const cached = this.#blockPreviews;
+		if (cached?.blocks === blocks && cached.inner === inner) return cached.previews;
+		const previews = blocks.map(block => {
+			const raw = block.content.split("\n");
+			const shown = raw.slice(0, BLOCK_PREVIEW_LINES);
+			const styled = block.language ? highlightCode(shown.join("\n"), block.language) : shown;
+			const rows = styled.map(row => truncateToWidth(replaceTabs(row), inner));
+			if (raw.length > shown.length) {
+				rows.push(theme.fg("dim", `… +${raw.length - shown.length} more lines`));
+			}
+			return { rows, lineCount: raw.length };
+		});
+		this.#blockPreviews = { blocks, inner, previews };
+		return previews;
+	}
 }
 
 /** Raw multi-line text of a user message (string or text blocks). */

package/src/overlays/extensions/state-manager.ts

@@ -1,5 +1,5 @@
 /** Pure dashboard tree, filtering, and selection state. */
-import { fuzzyMatch } from "../../fuzzy";
+import { FuzzyQuery, FuzzyText } from "../../fuzzy";
 import {
 	type DashboardState,
 	type DisabledReason,
@@ -118,6 +118,50 @@ export function flattenTree(tree: TreeNode[]): FlatTreeItem[] {
 	return flat;
 }
 
+/** Searchable fields an extension's cached {@link FuzzyText} was built from. */
+interface ExtensionSearchMemo {
+	name: string;
+	displayName: string;
+	description: string | undefined;
+	trigger: string | undefined;
+	providerName: string;
+	kind: string;
+	text: FuzzyText;
+}
+
+/** Prepared search text per extension; rebuilt if any searchable field changes. */
+const extensionSearchCache = new WeakMap<Extension, ExtensionSearchMemo>();
+
+function extensionSearchText(ext: Extension): FuzzyText {
+	const memo = extensionSearchCache.get(ext);
+	if (
+		memo !== undefined &&
+		memo.name === ext.name &&
+		memo.displayName === ext.displayName &&
+		memo.description === ext.description &&
+		memo.trigger === ext.trigger &&
+		memo.providerName === ext.source.providerName &&
+		memo.kind === ext.kind
+	) {
+		return memo.text;
+	}
+	const text = new FuzzyText(
+		[ext.name, ext.displayName, ext.description || "", ext.trigger || "", ext.source.providerName, ext.kind].join(
+			" ",
+		),
+	);
+	extensionSearchCache.set(ext, {
+		name: ext.name,
+		displayName: ext.displayName,
+		description: ext.description,
+		trigger: ext.trigger,
+		providerName: ext.source.providerName,
+		kind: ext.kind,
+		text,
+	});
+	return text;
+}
+
 /**
  * Apply fuzzy filter to extensions.
  */
@@ -126,22 +170,18 @@ export function applyFilter(extensions: Extension[], query: string): Extension[]
 		return extensions;
 	}
 
-	const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+	const tokens = query
+		.toLowerCase()
+		.split(/\s+/)
+		.filter(Boolean)
+		.map(token => new FuzzyQuery(token));
 	if (tokens.length === 0) {
 		return extensions;
 	}
 
 	return extensions.filter(ext => {
-		const searchable = [
-			ext.name,
-			ext.displayName,
-			ext.description || "",
-			ext.trigger || "",
-			ext.source.providerName,
-			ext.kind,
-		].join(" ");
-
-		return tokens.every(token => fuzzyMatch(token, searchable).matches);
+		const searchable = extensionSearchText(ext);
+		return tokens.every(token => token.match(searchable).matches);
 	});
 }
 

package/src/overlays/history-search.ts

@@ -65,6 +65,13 @@ const PICKER_KEY = "picker";
 /** Visible result rows; also the jump distance for PageUp/PageDown. */
 const MAX_VISIBLE = 10;
 
+/**
+ * Quiet period after the last query edit before the synchronous storage
+ * search runs. Only applied when the host wires {@link HistorySearchComponent.setOnRequestRender},
+ * since the deferred results need a repaint to show up.
+ */
+const SEARCH_DEBOUNCE_MS = 100;
+
 /** Split a query the same way `HistorySource` tokenizes it, so highlights align with matches. */
 function queryTokens(query: string): string[] {
 	return query
@@ -106,6 +113,8 @@ class HistoryResultsList implements Component {
 	#menu: MenuSelection<HistorySearchEntry>;
 	#tokens: string[] = [];
 	#maxVisible = MAX_VISIBLE;
+	/** Highlighted prompt text per entry, valid for one `(tokens, budget)` pair; reset on invalidate (theme). */
+	#highlightCache = new WeakMap<HistorySearchEntry, { tokens: string[]; budget: number; text: string }>();
 
 	constructor(menu: MenuSelection<HistorySearchEntry>) {
 		this.#menu = menu;
@@ -116,7 +125,17 @@ class HistoryResultsList implements Component {
 	}
 
 	invalidate(): void {
-		// No cached state to invalidate currently
+		this.#highlightCache = new WeakMap();
+	}
+
+	/** Truncated, token-highlighted prompt of `entry` for `budget` cells. */
+	#highlightedPrompt(entry: HistorySearchEntry, budget: number): string {
+		const cached = this.#highlightCache.get(entry);
+		if (cached !== undefined && cached.tokens === this.#tokens && cached.budget === budget) return cached.text;
+		const normalized = entry.prompt.replace(/\s+/g, " ").trim();
+		const text = highlightTokens(truncateToWidth(normalized, budget), this.#tokens);
+		this.#highlightCache.set(entry, { tokens: this.#tokens, budget, text });
+		return text;
 	}
 
 	render(width: number): readonly string[] {
@@ -151,9 +170,7 @@ class HistoryResultsList implements Component {
 			const showTime = rowWidth >= gutterWidth + 12 + timeWidth;
 
 			const promptBudget = Math.max(4, rowWidth - gutterWidth - (showTime ? timeWidth + 1 : 0));
-			const normalized = entry.prompt.replace(/\s+/g, " ").trim();
-			const plain = truncateToWidth(normalized, promptBudget);
-			const highlighted = highlightTokens(plain, this.#tokens);
+			const highlighted = this.#highlightedPrompt(entry, promptBudget);
 
 			const cursor = isSelected ? theme.fg("accent", cursorSymbol) : padding(gutterWidth);
 			let line = cursor + (isSelected ? theme.bold(highlighted) : highlighted);
@@ -186,12 +203,22 @@ export class HistorySearchComponent extends OverlayPanel {
 	#nativeHints: NativeNode | undefined;
 	#nativeMemo: HistoryNativeMemo | undefined;
 	#pickerItems: { items: readonly HistorySearchEntry[]; rows: readonly TspPickerItem[] } | undefined;
+	/** Trimmed query the current results were fetched for; `undefined` before the first fetch. */
+	#resultsQuery: string | undefined;
+	#searchTimer: NodeJS.Timeout | undefined;
+	#onRequestRender?: () => void;
 
 	constructor(historyStorage: HistorySource, onSelect: (prompt: string) => void, onCancel: () => void) {
 		super("History", "omp.overlay.history");
 		this.#historyStorage = historyStorage;
-		this.#onSelect = onSelect;
-		this.#onCancel = onCancel;
+		this.#onSelect = prompt => {
+			this.#cancelPendingSearch();
+			onSelect(prompt);
+		};
+		this.#onCancel = () => {
+			this.#cancelPendingSearch();
+			onCancel();
+		};
 
 		this.#menu = new MenuSelection<HistorySearchEntry>([], {
 			getKey: entry => `${entry.created_at}:${entry.prompt}`,
@@ -199,6 +226,7 @@ export class HistorySearchComponent extends OverlayPanel {
 		});
 		this.#searchInput = new Input();
 		this.#searchInput.onSubmit = () => {
+			this.#flushPendingSearch();
 			const selected = this.#menu.selectedItem;
 			if (selected) {
 				this.#onSelect(selected.prompt);
@@ -225,38 +253,59 @@ export class HistorySearchComponent extends OverlayPanel {
 		this.#updateResults();
 	}
 
+	/**
+	 * Repaint hook for debounced result updates. Once set, query edits search
+	 * storage after a {@link SEARCH_DEBOUNCE_MS} quiet period instead of on
+	 * every key; without it every edit searches synchronously.
+	 */
+	setOnRequestRender(callback: () => void): void {
+		this.#onRequestRender = callback;
+	}
+
+	override dispose(): void {
+		this.#cancelPendingSearch();
+		super.dispose();
+	}
+
 	handleInput(keyData: string): void {
 		if (matchesSelectUp(keyData)) {
+			this.#flushPendingSearch();
 			this.#menu.move(-1, false);
 			return;
 		}
 
 		if (matchesSelectDown(keyData)) {
+			this.#flushPendingSearch();
 			this.#menu.move(1, false);
 			return;
 		}
 
 		if (matchesSelectPageUp(keyData)) {
+			this.#flushPendingSearch();
 			this.#menu.move(-MAX_VISIBLE, false);
 			return;
 		}
 
 		if (matchesSelectPageDown(keyData)) {
+			this.#flushPendingSearch();
 			this.#menu.move(MAX_VISIBLE, false);
 			return;
 		}
 
 		if (matchesKey(keyData, "home")) {
+			this.#flushPendingSearch();
 			this.#menu.moveToBoundary("first");
 			return;
 		}
 
 		if (matchesKey(keyData, "end")) {
+			this.#flushPendingSearch();
 			this.#menu.moveToBoundary("last");
 			return;
 		}
 
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			this.#flushPendingSearch();
 			const selected = this.#menu.selectedItem;
 			if (selected) {
 				this.#onSelect(selected.prompt);
@@ -270,7 +319,7 @@ export class HistorySearchComponent extends OverlayPanel {
 		}
 
 		this.#searchInput.handleInput(keyData);
-		this.#updateResults();
+		this.#scheduleResults();
 	}
 
 	/**
@@ -372,6 +421,9 @@ export class HistorySearchComponent extends OverlayPanel {
 	 * Picker: a row click highlights, a second click or `Insert` inserts it
 	 * (Enter), `Close` cancels (Esc), `Clear search` empties the query.
 	 * List: picking a result does what highlighting it and pressing Enter does.
+	 * A row picked while a debounced search is pending belongs to the previous
+	 * query: results are refreshed first and the pick only lands if that entry
+	 * is still among them.
 	 */
 	handleNativeEvent(event: NativeUiEvent): void {
 		const ev = pickerEvent(event, PICKER_KEY);
@@ -385,6 +437,7 @@ export class HistorySearchComponent extends OverlayPanel {
 				}
 				return;
 			}
+			this.#flushPendingSearch();
 			const index = this.#menu.visibleItems.findIndex(entry => nativeEntryKey(entry) === ev.item);
 			if (index < 0) return;
 			this.#menu.setSelectedIndex(index);
@@ -392,6 +445,7 @@ export class HistorySearchComponent extends OverlayPanel {
 			return;
 		}
 		if ((event.type !== "select" && event.type !== "activate") || event.key !== "list") return;
+		this.#flushPendingSearch();
 		const index = this.#menu.visibleItems.findIndex(entry => nativeEntryKey(entry) === event.item);
 		const target = this.#menu.visibleItems[index];
 		if (!target) return;
@@ -399,8 +453,47 @@ export class HistorySearchComponent extends OverlayPanel {
 		this.#onSelect(target.prompt);
 	}
 
+	/**
+	 * Refresh results after a query edit: no-op when the trimmed query is
+	 * unchanged (cursor moves, trailing spaces), immediate for the empty query
+	 * or when no repaint hook is wired, debounced otherwise.
+	 */
+	#scheduleResults(): void {
+		const query = this.#searchInput.getValue().trim();
+		if (query === this.#resultsQuery) {
+			this.#cancelPendingSearch();
+			return;
+		}
+		const requestRender = this.#onRequestRender;
+		if (!query || !requestRender) {
+			this.#updateResults();
+			return;
+		}
+		this.#cancelPendingSearch();
+		this.#searchTimer = setTimeout(() => {
+			this.#searchTimer = undefined;
+			this.#updateResults();
+			requestRender();
+		}, SEARCH_DEBOUNCE_MS);
+	}
+
+	/** Run a pending debounced search now, so selection acts on the current query's results. */
+	#flushPendingSearch(): void {
+		if (this.#searchTimer === undefined) return;
+		this.#cancelPendingSearch();
+		this.#updateResults();
+	}
+
+	#cancelPendingSearch(): void {
+		if (this.#searchTimer === undefined) return;
+		clearTimeout(this.#searchTimer);
+		this.#searchTimer = undefined;
+	}
+
 	#updateResults(): void {
+		this.#cancelPendingSearch();
 		const query = this.#searchInput.getValue().trim();
+		this.#resultsQuery = query;
 		const results = query
 			? this.#historyStorage.search(query, this.#resultLimit)
 			: this.#historyStorage.getRecent(this.#resultLimit);

package/src/overlays/jobs-panel.ts

@@ -110,6 +110,8 @@ export class JobsSheet implements Component {
 	readonly #source: JobsSheetSource;
 	#selectedId: string | undefined;
 	#native: { key: string; output: string | undefined; node: NativeNode } | undefined;
+	/** Fallback output tail, reused while the selected job's output is unchanged. */
+	#tail: { id: string; output: string; lines: readonly string[] } | undefined;
 
 	constructor(source: JobsSheetSource) {
 		this.#source = source;
@@ -177,8 +179,9 @@ export class JobsSheet implements Component {
 				detail.artifactId && `artifact://${detail.artifactId}`,
 			]);
 			if (facts.length > 0) lines.push(truncateToWidth(`   ${facts.join(" · ")}`, width));
-			const tail = (detail.output ?? "").trimEnd().split("\n").slice(-FALLBACK_TAIL_LINES);
-			for (const line of tail) if (line) lines.push(truncateToWidth(`   ${line}`, width));
+			for (const line of this.#tailLines(selected.id, detail.output ?? "")) {
+				if (line) lines.push(truncateToWidth(`   ${line}`, width));
+			}
 		}
 		return lines;
 	}
@@ -210,6 +213,14 @@ export class JobsSheet implements Component {
 		return { jobs, selected };
 	}
 
+	#tailLines(id: string, output: string): readonly string[] {
+		const cached = this.#tail;
+		if (cached?.id === id && cached.output === output) return cached.lines;
+		const lines = tailLines(output, FALLBACK_TAIL_LINES);
+		this.#tail = { id, output, lines };
+		return lines;
+	}
+
 	#move(delta: number): void {
 		const { jobs, selected } = this.#current();
 		if (!selected) return;
@@ -228,6 +239,23 @@ function jobAge(job: JobsPanelJob, nowMs: number): number {
 	return Math.max(0, (job.endTime ?? nowMs) - job.startTime);
 }
 
+/**
+ * The last `count` pieces of `text.trimEnd().split("\n")`, found by scanning
+ * back from the end so a long running output is never split as a whole.
+ */
+function tailLines(text: string, count: number): string[] {
+	const trimmed = text.trimEnd();
+	const lines: string[] = [];
+	let end = trimmed.length;
+	while (lines.length < count) {
+		const newline = end > 0 ? trimmed.lastIndexOf("\n", end - 1) : -1;
+		lines.push(trimmed.slice(newline + 1, end));
+		if (newline < 0) break;
+		end = newline;
+	}
+	return lines.reverse();
+}
+
 /** A task job as an `agent` node when the terminal draws them, else a one-line dot row. */
 function describeJob(job: JobsPanelJob, nowMs: number, agent: boolean): NativeNode {
 	const settled = job.status !== "running";