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

package/src/terminal-capabilities.ts

@@ -514,11 +514,15 @@ function parseTmuxVersionFromEnv(env: NodeJS.ProcessEnv): { major: number; minor
  * Policy (highest precedence first):
  *   1. Explicit user override (`PI_NO_HYPERLINKS=1` off, `PI_FORCE_HYPERLINKS=1`
  *      on). Opt-out wins ties.
- *   2. Static terminal capability — terminals whose {@link TerminalInfo} marks
+ *   2. Herdr pane with no nested screen/tmux: on. Herdr hides the outer
+ *      terminal (`TERM=xterm-256color`, no `TERM_PROGRAM`), but it renders
+ *      OSC 8 in its own grid and opens links itself on Ctrl+click, so the
+ *      outer terminal's support does not matter.
+ *   3. Static terminal capability — terminals whose {@link TerminalInfo} marks
  *      `hyperlinks: false` (e.g. `base`) stay off unless the user forced on.
- *   3. GNU screen's explicit session marker (`STY`) always off, even if tmux is
+ *   4. GNU screen's explicit session marker (`STY`) always off, even if tmux is
  *      also present: a screen layer anywhere in the path cannot forward OSC 8.
- *   4. tmux session (`TMUX` set): enabled when tmux self-reports >= 3.4 via
+ *   5. tmux session (`TMUX` set): enabled when tmux self-reports >= 3.4 via
  *      `TERM_PROGRAM_VERSION` (tmux 3.4 stores OSC 8 as a cell attribute and
  *      forwards it to outer terminals whose `terminal-features` include
  *      `hyperlinks`). Older or unknown versions stay off; on outer terminals
@@ -526,11 +530,11 @@ function parseTmuxVersionFromEnv(env: NodeJS.ProcessEnv): { major: number; minor
  *      identical to today. Checked before the screen-family TERM heuristic
  *      because tmux's historical `default-terminal` is `screen-256color`, so
  *      `TERM=screen*` inside a tmux session must NOT short-circuit to off.
- *   5. screen-family TERM without `TMUX` always off: screen never gained OSC 8
+ *   6. screen-family TERM without `TMUX` always off: screen never gained OSC 8
  *      support.
- *   6. tmux-family TERM without `TMUX` env — unusual (e.g. inspection scripts);
+ *   7. tmux-family TERM without `TMUX` env — unusual (e.g. inspection scripts);
  *      no version available, so off.
- *   7. Otherwise honor the static terminal capability.
+ *   8. Otherwise honor the static terminal capability.
  */
 export function shouldEnableHyperlinksByDefault(
 	env: NodeJS.ProcessEnv = Bun.env,
@@ -539,6 +543,8 @@ export function shouldEnableHyperlinksByDefault(
 	const override = hyperlinksUserOverride(env);
 	if (override !== null) return override;
 
+	if (isInsideHerdr(env) && !env.STY && !env.TMUX) return true;
+
 	if (!getTerminalInfo(terminalId).hyperlinks) return false;
 
 	// STY is GNU screen's explicit session marker. It vetoes tmux enabling when

package/src/terminal.ts

@@ -171,10 +171,14 @@ export const STDOUT_BACKLOG_CLEAR_BYTES = 256 * 1024;
 /**
  * How long an armed backlog may go without any drain progress before the
  * consumer is declared gone. A slow-but-alive terminal keeps reaching new
- * low-water marks (so it never trips); a wedged one that flushes nothing is
- * torn down within this window.
+ * low-water marks (so it never trips), but a live one can also stop reading
+ * for seconds at a time: a busy tmux server holding a slow client, or a
+ * container's attach stream. Waiting costs no memory, because frames are
+ * deferred while the backlog is up (`TUI.#deferRenderForOutputBacklog`), so the
+ * window is long enough to ride those out; a reader that never comes back is
+ * still torn down within it.
  */
-const STDOUT_STALL_TIMEOUT_MS = 2_000;
+const STDOUT_STALL_TIMEOUT_MS = 60_000;
 
 /** Cadence at which {@link ProcessTerminal} re-samples the backlog while an episode is armed. */
 const STDOUT_STALL_POLL_MS = 250;
@@ -768,6 +772,10 @@ export class ProcessTerminal implements Terminal {
 	// enqueues frames and performs the blocking write(2) on its own thread;
 	// `pendingOutputBytes` exposes the backlog for render-side frame skipping.
 	#outputPump?: TtyWriter;
+	// Upper bound on the pump's backlog: the count its last enqueue or read
+	// reported. Only #safeWrite enqueues and the pump thread only drains, so
+	// the live backlog cannot exceed this until the next enqueue refreshes it.
+	#pumpBacklogBound = 0;
 
 	#windowsVTInputRestore?: () => void;
 	#xtermScrollToBottomRestoreModes = new Set<number>();
@@ -808,6 +816,11 @@ export class ProcessTerminal implements Terminal {
 	#reportedRows?: number;
 	#mode2031DebounceTimer?: Timer;
 	#windowsTerminalAppearancePollTimer?: Timer;
+	#progressActive = false;
+	// Ghostty expires OSC 9;4 state without a heartbeat. Persistent hosts such
+	// as Windows Terminal restart their indeterminate animation on every write.
+	readonly #keepProgressAlive = TERMINAL.id === "ghostty";
+	#bracketedPasteRefreshTimer?: Timer;
 	#progressTimer?: Timer;
 
 	constructor(options?: ProcessTerminalOptions) {
@@ -931,14 +944,14 @@ export class ProcessTerminal implements Terminal {
 		if (process.platform !== "win32" && process.stdout.isTTY && !isBunTestRuntime() && !this.#outputPump) {
 			try {
 				this.#outputPump = new TtyWriter(1);
+				this.#pumpBacklogBound = 0;
 			} catch (err) {
 				logger.debug("tty output pump unavailable; using direct stdout writes", { err: String(err) });
 			}
 		}
 
-		// Keep unmanaged fd-2 writes (macOS libmalloc/framework diagnostics) off
-		// the viewport while we own the terminal; released in stop(). See
-		// stderr-guard in pi-utils (mirrors openai/codex#24459).
+		// Keep unmanaged native fd-2 writes off the viewport while we own the
+		// terminal; released in stop(). See stderr-guard in pi-utils.
 		suppressTerminalStderr();
 
 		// Set up resize handler immediately. The OS refreshes process.stdout
@@ -1765,7 +1778,15 @@ export class ProcessTerminal implements Terminal {
 		// heuristic pure downside — turn it off so stall-batched keystrokes are
 		// not misread as a paste (#12540). `supported` is only true here after an
 		// explicit DECRPM reply (the DA1-sentinel fallback resolves unsupported).
-		if (mode === 2004 && supported) this.#stdinBuffer?.setRawPasteClassification(false);
+		if (mode === 2004 && supported) {
+			this.#stdinBuffer?.setRawPasteClassification(false);
+			// A terminal can reset this mode after the initial probe (for example,
+			// iTerm2's Terminal State toggle). Keep the mode asserted while we own
+			// the TTY, since the raw fallback is disabled after confirmation.
+			this.#bracketedPasteRefreshTimer ??= setInterval(() => {
+				if (this.#active && !this.#dead) this.#safeWrite("\x1b[?2004h");
+			}, 1000);
+		}
 	}
 
 	#syncWindowsTerminalAppearancePolling(mode2031Supported: boolean): void {
@@ -1897,6 +1918,10 @@ export class ProcessTerminal implements Terminal {
 		// Suppress observer/timer callbacks before any teardown can yield or throw.
 		this.#active = false;
 		this.#inputDeferred = false;
+		if (this.#bracketedPasteRefreshTimer) {
+			clearInterval(this.#bracketedPasteRefreshTimer);
+			this.#bracketedPasteRefreshTimer = undefined;
+		}
 		if (this.#headless) return;
 		// Unregister from emergency cleanup
 		if (activeTerminal === this) {
@@ -1908,7 +1933,9 @@ export class ProcessTerminal implements Terminal {
 		// step throws.
 		restoreTerminalStderr();
 
-		if (this.#clearProgressTimer()) {
+		this.#clearProgressTimer();
+		if (this.#progressActive) {
+			this.#progressActive = false;
 			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
 		}
 
@@ -2061,6 +2088,10 @@ export class ProcessTerminal implements Terminal {
 	#markTerminalDisconnected(reason: string, err?: unknown): void {
 		if (this.#dead) return;
 		this.#dead = true;
+		if (this.#bracketedPasteRefreshTimer) {
+			clearInterval(this.#bracketedPasteRefreshTimer);
+			this.#bracketedPasteRefreshTimer = undefined;
+		}
 		this.#disarmStdoutStallWatchdog();
 		logger.warn("terminal disconnected; stopping interactive rendering", { reason, err });
 
@@ -2109,19 +2140,27 @@ export class ProcessTerminal implements Terminal {
 		this.#trackCursorVisibility(data);
 		const pump = this.#outputPump;
 		if (pump) {
-			if (pump.dead) {
-				this.#markTerminalDisconnected("stdout failed; output pump died");
-				return;
-			}
+			let pending: number;
 			try {
-				// Feed the live backlog to the stall watchdog rather than tripping on
-				// the instantaneous byte count: a single large-but-draining frame (a
-				// resume repaint of many inline images) must open normally, while a
-				// never-draining reader is still torn down (#6854, #10430).
-				this.#trackStdoutBacklog(pump.write(data));
+				pending = pump.write(data);
 			} catch (err) {
 				this.#markTerminalDisconnected("stdout failed", err);
+				return;
 			}
+			// A live enqueue reports at least this chunk's UTF-8 size, never below
+			// its UTF-16 length; a dead pump enqueues nothing and reports only the
+			// remainder it is dropping (soon zero). Only a report that small can
+			// come from a dead pump, so the native `dead` read is skipped otherwise.
+			if ((pending < data.length || data.length === 0) && pump.dead) {
+				this.#markTerminalDisconnected("stdout failed; output pump died");
+				return;
+			}
+			this.#pumpBacklogBound = pending;
+			// Feed the live backlog to the stall watchdog rather than tripping on
+			// the instantaneous byte count: a single large-but-draining frame (a
+			// resume repaint of many inline images) must open normally, while a
+			// never-draining reader is still torn down (#6854, #10430).
+			this.#trackStdoutBacklog(pending);
 			return;
 		}
 		// A console-sharing child process may have flipped the console codepage
@@ -2164,8 +2203,19 @@ export class ProcessTerminal implements Terminal {
 		if (this.#inBandResizeActive && this.#reportedColumns) return this.#reportedColumns;
 		return process.stdout.columns || Number(Bun.env.COLUMNS) || 80;
 	}
+	/**
+	 * With the output pump, a backlog bound at or below
+	 * {@link STDOUT_BACKLOG_CLEAR_BYTES} is reported as-is instead of re-read:
+	 * both consumers (the render gate and the stall watchdog) act only on a
+	 * backlog above that level, so the bound already decides them and spares a
+	 * native read on every frame.
+	 */
 	get pendingOutputBytes(): number {
-		if (this.#outputPump) return this.#outputPump.pending();
+		const pump = this.#outputPump;
+		if (pump) {
+			if (this.#pumpBacklogBound > STDOUT_BACKLOG_CLEAR_BYTES) this.#pumpBacklogBound = pump.pending();
+			return this.#pumpBacklogBound;
+		}
 		// Stream fallback: bytes queued past the high-water mark by refused writes.
 		return process.stdout.writableLength ?? 0;
 	}
@@ -2270,7 +2320,9 @@ export class ProcessTerminal implements Terminal {
 			if (final === 0x68 /* h */ || final === 0x6c /* l */) break;
 			idx = idx === 0 ? -1 : data.lastIndexOf("\x1b[?25", idx - 1);
 		}
-		if (data.lastIndexOf("\x1b[?1049") > idx) {
+		// Only a switch after the last cursor sequence matters: search that tail
+		// rather than the whole frame.
+		if (data.indexOf("\x1b[?1049", idx + 1) !== -1) {
 			this.#cursorVisible = undefined;
 			return;
 		}
@@ -2297,14 +2349,17 @@ export class ProcessTerminal implements Terminal {
 	setProgress(active: boolean): void {
 		if (this.#headless) return;
 		if (active) {
+			if (this.#progressActive) return;
+			this.#progressActive = true;
 			this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
-			if (!this.#progressTimer) {
+			if (this.#keepProgressAlive && !this.#progressTimer) {
 				this.#progressTimer = setInterval(() => {
 					this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
 				}, TERMINAL_PROGRESS_KEEPALIVE_MS);
 				this.#progressTimer.unref?.();
 			}
 		} else {
+			this.#progressActive = false;
 			this.#clearProgressTimer();
 			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
 		}

package/src/theme/color.ts

@@ -18,12 +18,27 @@ export function detectColorMode(env: NodeJS.ProcessEnv = Bun.env): ColorMode {
 	return terminal.trueColor ? "truecolor" : "256color";
 }
 
+const ANSI_COLOR_CACHE_LIMIT = 256;
+const ANSI_COLOR_CACHE_MAX_LENGTH = 128;
+const ansiColorCaches: Record<ColorMode, Map<string, string>> = {
+	truecolor: new Map(),
+	"256color": new Map(),
+};
+
+/** Convert a theme color to foreground SGR at the requested depth; throws for invalid colors. */
 export function colorToAnsi(color: string, mode: ColorMode): string {
+	const cache = color.length <= ANSI_COLOR_CACHE_MAX_LENGTH ? ansiColorCaches[mode] : undefined;
+	const cached = cache?.get(color);
+	if (cached !== undefined) return cached;
 	const format = mode === "truecolor" ? "ansi-16m" : "ansi-256";
 	const ansi = Bun.color(color, format);
 	if (ansi === null) {
 		throw new Error(`Invalid color value: ${color}`);
 	}
+	if (cache) {
+		if (cache.size >= ANSI_COLOR_CACHE_LIMIT) cache.clear();
+		cache.set(color, ansi);
+	}
 	return ansi;
 }
 

package/src/theme/session-color.ts

@@ -145,11 +145,11 @@ const LIGHT_HUE_INTERVALS: readonly HueInterval[] = [[195, 330]];
 /** Theme-derived inputs for {@link getSessionAccentHex}; see `Theme.sessionAccentInputs`. */
 export interface SessionAccentTheme {
 	/** Theme accent hex; the session accent adopts its OKLCH lightness and chroma. */
-	accentHex: string;
+	readonly accentHex: string;
 	/** Major theme color hexes checked for hue collision. */
-	colorHexes: string[];
+	readonly colorHexes: readonly string[];
 	/** WCAG luminance of the status-line surface on light themes; undefined on dark themes. */
-	surfaceLuminance?: number;
+	readonly surfaceLuminance?: number;
 }
 
 /**
@@ -180,6 +180,22 @@ export interface SessionAccentTheme {
  * @param theme — accent hex, collision colors, and surface luminance of the active theme.
  */
 export function getSessionAccentHex(name: string, theme: SessionAccentTheme): string {
+	// Pure function of its inputs; keyed by value so structurally equal inputs
+	// share an entry. Bounded: sessions × themes stays tiny in practice.
+	const key = `${name}\0${theme.accentHex}\0${theme.surfaceLuminance}\0${theme.colorHexes.join(",")}`;
+	const cached = accentHexCache.get(key);
+	if (cached !== undefined) return cached;
+	const hex = computeSessionAccentHex(name, theme);
+	if (accentHexCache.size >= ACCENT_CACHE_LIMIT) accentHexCache.clear();
+	accentHexCache.set(key, hex);
+	return hex;
+}
+
+const ACCENT_CACHE_LIMIT = 256;
+const accentHexCache = new Map<string, string>();
+const accentAnsiCache = new Map<string, string | undefined>();
+
+function computeSessionAccentHex(name: string, theme: SessionAccentTheme): string {
 	// 1. Pick hue range based on theme mode
 	const isDark = theme.surfaceLuminance === undefined;
 	const intervals = isDark ? DARK_HUE_INTERVALS : LIGHT_HUE_INTERVALS;
@@ -249,5 +265,11 @@ export function getSessionAccentHex(name: string, theme: SessionAccentTheme): st
  */
 export function getSessionAccentAnsi(hex: string | undefined): string | undefined {
 	if (!hex) return undefined;
-	return Bun.color(hex, TERMINAL.trueColor ? "ansi-16m" : "ansi-256") ?? undefined;
+	const trueColor = TERMINAL.trueColor;
+	const key = trueColor ? hex : `256:${hex}`;
+	if (accentAnsiCache.has(key)) return accentAnsiCache.get(key);
+	const ansi = Bun.color(hex, trueColor ? "ansi-16m" : "ansi-256") ?? undefined;
+	if (accentAnsiCache.size >= ACCENT_CACHE_LIMIT) accentAnsiCache.clear();
+	accentAnsiCache.set(key, ansi);
+	return ansi;
 }

package/src/theme/shimmer.ts

@@ -27,7 +27,7 @@ const BOLD_OPEN = "\x1b[1m";
 const BOLD_CLOSE = "\x1b[22m";
 
 type ShimmerTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
-/** Sweep style for animated shimmer text; `disabled` renders every tier as the low color. */
+/** Sweep style for animated shimmer text; `disabled` renders every tier as the mid color. */
 export type ShimmerMode = "classic" | "kitt" | "disabled";
 
 let activeMode: ShimmerMode = "classic";
@@ -114,13 +114,8 @@ function compile(theme: ShimmerTheme, palette: ShimmerPalette): CompiledPalette
 
 // ─── Intensity profiles ──────────────────────────────────────────────────────
 /** Smooth cosine bump sweeping left → right with edge padding. */
-function classicIntensity(time: number, index: number, length: number): number {
-	const period = length + CLASSIC_PADDING * 2;
-	// Fixed-velocity, un-floored band position: advancing at a constant
-	// cells/second (not period / fixed-sweep) keeps the per-frame step ≤1 cell at
-	// the default cadence for any length, so long messages are no steppier.
-	const pos = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % period;
-	const dist = Math.abs(index + CLASSIC_PADDING - pos);
+function classicIntensity(index: number, position: number): number {
+	const dist = Math.abs(index + CLASSIC_PADDING - position);
 	if (dist >= CLASSIC_BAND_HALF_WIDTH) return 0;
 	return 0.5 * (1 + Math.cos((Math.PI * dist) / CLASSIC_BAND_HALF_WIDTH));
 }
@@ -130,16 +125,7 @@ function classicIntensity(time: number, index: number, length: number): number {
  * bar with a quadratic-decay trail behind it. No leading glow — LEDs don't
  * predict the future.
  */
-function kittIntensity(time: number, index: number, length: number): number {
-	const range = length - 1;
-	if (range <= 0) return 1;
-	// Fixed head velocity: a triangle ping-pong over a 2*range round trip at a
-	// constant cells/second, so the bright head advances ≤1 cell per frame at the
-	// default cadence regardless of bar length. Round-trip duration scales with length.
-	const cycleCells = 2 * range;
-	const sweep = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % cycleCells;
-	const goingRight = sweep < range;
-	const head = goingRight ? sweep : cycleCells - sweep;
+function kittIntensity(index: number, head: number, goingRight: boolean): number {
 	const delta = index - head;
 	const abs = delta < 0 ? -delta : delta;
 	if (abs <= KITT_HEAD_HALF) return 1;
@@ -181,46 +167,66 @@ export function shimmerEnabled(): boolean {
 export function shimmerSegments(segments: readonly ShimmerSegment[], theme: ShimmerTheme): string {
 	const mode = activeMode;
 
-	// Pre-scan: total code-point count (positions the band) and resolved palette.
-	// The per-segment string is kept verbatim — iterating UTF-16 units with a
-	// surrogate-pair guard produces the same code points as `Array.from(text)`
-	// at zero per-frame allocation (previously the #1 hotspot at ~10% of profiled
-	// CPU during streaming — the working message is shimmered every animation
-	// frame at 30fps and `Array.from` reallocated the code-point array each tick).
-	let total = 0;
-	const perSeg: { text: string; palette: ShimmerPalette }[] = [];
-	for (const seg of segments) {
-		total += countCodePoints(seg.text);
-		perSeg.push({ text: seg.text, palette: seg.palette ?? DEFAULT_SHIMMER_PALETTE });
-	}
-	if (total === 0) return "";
-
-	// Disabled: no animation, no per-char work. Paint each segment in its mid
-	// tier so the working line stays legible without movement.
+	// Disabled: no animation or code-point scan. Preserve the all-empty result,
+	// but include empty segments' ANSI pairs when any segment has text.
 	if (mode === "disabled") {
+		let hasText = false;
+		for (const { text } of segments) {
+			if (text.length > 0) {
+				hasText = true;
+				break;
+			}
+		}
+		if (!hasText) return "";
 		let out = "";
-		for (const { text, palette } of perSeg) {
-			const seq = compile(theme, palette).mid;
+		for (const { text, palette } of segments) {
+			const seq = compile(theme, palette ?? DEFAULT_SHIMMER_PALETTE).mid;
 			out += `${seq.open}${text}${seq.close}`;
 		}
 		return out;
 	}
 
-	const time = Date.now();
-	const intensityFn = mode === "kitt" ? kittIntensity : classicIntensity;
+	// Position the band in code points without copying the segments or splitting
+	// their strings. Surrogate pairs are counted independently in each segment.
+	let total = 0;
+	for (const { text } of segments) total += countCodePoints(text);
+	if (total === 0) return "";
+
+	// Fixed velocity keeps the per-frame step independent of message length.
+	// Share the frame's phase/head between the window and every active character.
+	const travel = (Date.now() / 1000) * SHIMMER_SPEED_CELLS_PER_S;
+	const isKitt = mode === "kitt";
+	let position: number;
+	let goingRight = true;
+	let bandLo: number;
+	let bandHi: number;
+	if (isKitt) {
+		const range = total - 1;
+		if (range <= 0) {
+			position = 0;
+		} else {
+			const cycleCells = 2 * range;
+			const sweep = travel % cycleCells;
+			goingRight = sweep < range;
+			position = goingRight ? sweep : cycleCells - sweep;
+		}
+		// Only the head and its direction-dependent trailing cells can light up.
+		bandLo = goingRight ? position - KITT_HEAD_HALF - KITT_TRAIL_LEN : position - KITT_HEAD_HALF;
+		bandHi = goingRight ? position + KITT_HEAD_HALF : position + KITT_HEAD_HALF + KITT_TRAIL_LEN;
+	} else {
+		position = travel % (total + CLASSIC_PADDING * 2);
+		bandLo = position - CLASSIC_PADDING - CLASSIC_BAND_HALF_WIDTH;
+		bandHi = position - CLASSIC_PADDING + CLASSIC_BAND_HALF_WIDTH;
+	}
 
-	// Fast-path window: outside `[bandLo, bandHi]` the intensity is guaranteed
-	// zero (tier "low"), so we can skip `intensityFn` + `tierFor` entirely for
-	// the prefix/suffix of every segment. On the typical ~60-char working
-	// message the classic band spans ~12 cells, so ~80% of the per-char loop
-	// disappears — the intensity call and the tier compare were the residual
-	// per-frame cost after #4353 removed the allocation hotspot (issue #4377).
-	const { lo: bandLo, hi: bandHi } = activeBand(mode, time, total);
+	// Outside this window intensity is zero, so skip the intensity and tier
+	// calculations for the low-tier prefix/suffix of every segment.
+	const intensityFn = isKitt ? kittIntensity : classicIntensity;
 
 	let out = "";
 	let index = 0;
-	for (const { text, palette } of perSeg) {
-		const compiled = compile(theme, palette);
+	for (const { text, palette } of segments) {
+		const compiled = compile(theme, palette ?? DEFAULT_SHIMMER_PALETTE);
 		let runTier: Tier | null = null;
 		let runStart = 0;
 		let runEnd = 0;
@@ -234,7 +240,8 @@ export function shimmerSegments(segments: readonly ShimmerSegment[], theme: Shim
 				const c2 = text.charCodeAt(i + 1);
 				if (c2 >= 0xdc00 && c2 <= 0xdfff) step = 2;
 			}
-			const tier: Tier = index < bandLo || index > bandHi ? "low" : tierFor(intensityFn(time, index, total));
+			const tier: Tier =
+				index < bandLo || index > bandHi ? "low" : tierFor(intensityFn(index, position, goingRight));
 			if (tier !== runTier) {
 				if (runTier !== null && runEnd > runStart) {
 					const seq = compiled[runTier];
@@ -255,34 +262,6 @@ export function shimmerSegments(segments: readonly ShimmerSegment[], theme: Shim
 	return out;
 }
 
-/**
- * Sweep window (code-point indices) outside which the intensity is guaranteed
- * zero for `mode` at `time` over `total` cells. Widening the window is safe —
- * the per-char intensity call still runs inside the window and reports 0 for
- * off-band code points — but narrower windows skip more of the per-char loop.
- */
-function activeBand(mode: "classic" | "kitt", time: number, total: number): { lo: number; hi: number } {
-	if (mode === "classic") {
-		const period = total + CLASSIC_PADDING * 2;
-		const pos = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % period;
-		return {
-			lo: pos - CLASSIC_PADDING - CLASSIC_BAND_HALF_WIDTH,
-			hi: pos - CLASSIC_PADDING + CLASSIC_BAND_HALF_WIDTH,
-		};
-	}
-	const range = total - 1;
-	if (range <= 0) return { lo: 0, hi: total };
-	const cycleCells = 2 * range;
-	const sweep = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % cycleCells;
-	const goingRight = sweep < range;
-	const head = goingRight ? sweep : cycleCells - sweep;
-	// The trail always lies behind the head for the current direction — chars
-	// ahead of the head are dark. See {@link kittIntensity} for the exact rule.
-	return goingRight
-		? { lo: head - KITT_HEAD_HALF - KITT_TRAIL_LEN, hi: head + KITT_HEAD_HALF }
-		: { lo: head - KITT_HEAD_HALF, hi: head + KITT_HEAD_HALF + KITT_TRAIL_LEN };
-}
-
 function countCodePoints(text: string): number {
 	let n = 0;
 	let i = 0;

package/src/theme/theme-class.ts

@@ -132,6 +132,14 @@ const LANG_BRAND_COLORS: Partial<Record<SymbolKey, string>> = {
 const BACKGROUND_RESET_PATTERN = /\x1b\[(?:0|49)m/g;
 const FOREGROUND_RESET_PATTERN = /\x1b\[(?:0|39)m/g;
 
+// Prebuilt stylers: each `chalk.<style>` access builds a fresh builder. Builders share the
+// root chalk context, so later `chalk.level` changes still apply.
+const boldStyler = chalk.bold;
+const italicStyler = chalk.italic;
+const underlineStyler = chalk.underline;
+const strikethroughStyler = chalk.strikethrough;
+const inverseStyler = chalk.inverse;
+
 export class Theme {
 	#fgColors: Record<ThemeColor, string>;
 	#bgColors: Record<ThemeBg, string>;
@@ -139,6 +147,10 @@ export class Theme {
 	readonly #hexFgColors: Record<ThemeColor, string>;
 	/** Resolved hex strings for background colors — populated at construction. */
 	readonly #hexBgColors: Record<ThemeBg, string>;
+	/** Lazily resolved `fgResolved` ANSI per color; colors and mode are fixed per instance. */
+	readonly #resolvedFgColors = new Map<ThemeColor, string>();
+	/** Lazily built, frozen `sessionAccentInputs`; every input it reads is fixed per instance. */
+	#sessionAccentInputs: SessionAccentTheme | undefined;
 	#symbols: SymbolMap;
 	#spinnerFramesOverrides: Partial<Record<SpinnerType, string[]>>;
 	/**
@@ -279,14 +291,15 @@ export class Theme {
 	 * Theme-derived inputs for `getSessionAccentHex`: the accent hex whose
 	 * OKLCH weight session accents adopt, the major colors they must not
 	 * hue-collide with, and the light-theme surface luminance to contrast
-	 * against.
+	 * against. Built once per instance and frozen; callers share the object.
 	 */
 	get sessionAccentInputs(): SessionAccentTheme {
-		return {
+		this.#sessionAccentInputs ??= Object.freeze({
 			accentHex: this.getAccentColorHex(),
-			colorHexes: this.getMajorThemeColorHexes(),
+			colorHexes: Object.freeze(this.getMajorThemeColorHexes()),
 			surfaceLuminance: this.accentSurfaceLuminance,
-		};
+		});
+		return this.#sessionAccentInputs;
 	}
 
 	fg(color: ThemeColor, text: string): string {
@@ -297,9 +310,13 @@ export class Theme {
 
 	/** Apply a foreground, replacing terminal-default tokens with the theme's contrast-safe fallback. */
 	fgResolved(color: ThemeColor, text: string): string {
-		const ansi = this.#fgColors[color];
-		if (!ansi) throw new Error(`Unknown theme color: ${color}`);
-		const resolved = ansi === "\x1b[39m" ? colorToAnsi(this.getColorHex(color), this.mode) : ansi;
+		let resolved = this.#resolvedFgColors.get(color);
+		if (resolved === undefined) {
+			const ansi = this.#fgColors[color];
+			if (!ansi) throw new Error(`Unknown theme color: ${color}`);
+			resolved = ansi === "\x1b[39m" ? colorToAnsi(this.getColorHex(color), this.mode) : ansi;
+			this.#resolvedFgColors.set(color, resolved);
+		}
 		return `${resolved}${text.replace(FOREGROUND_RESET_PATTERN, `$&${resolved}`)}\x1b[39m`;
 	}
 
@@ -332,23 +349,23 @@ export class Theme {
 	}
 
 	bold(text: string): string {
-		return chalk.bold(text);
+		return boldStyler(text);
 	}
 
 	italic(text: string): string {
-		return chalk.italic(text);
+		return italicStyler(text);
 	}
 
 	underline(text: string): string {
-		return chalk.underline(text);
+		return underlineStyler(text);
 	}
 
 	strikethrough(text: string): string {
-		return chalk.strikethrough(text);
+		return strikethroughStyler(text);
 	}
 
 	inverse(text: string): string {
-		return chalk.inverse(text);
+		return inverseStyler(text);
 	}
 
 	getFgAnsi(color: ThemeColor): string {

package/src/tools/output-meta.ts

@@ -58,7 +58,8 @@ export interface DiagnosticMeta {
  */
 export interface LimitsMeta {
 	matchLimit?: { reached: number; suggestion: number };
-	resultLimit?: { reached: number; suggestion: number };
+	/** `suggestion` is omitted when the tool is already at its hard cap, so no larger usable limit exists to advise. */
+	resultLimit?: { reached: number; suggestion?: number };
 	headLimit?: { reached: number; suggestion: number };
 	/** `unit` may be absent in sessions persisted before it was recorded. */
 	columnTruncated?: { maxColumn: number; unit?: "bytes" | "chars"; artifactId?: string };
@@ -187,7 +188,7 @@ function isGeneratedOutputNoticeLine(line: string): boolean {
 	return (
 		body.startsWith("Showing ") ||
 		/^\d+ matches limit reached\. Use limit=\d+ for more/u.test(body) ||
-		/^\d+ results limit reached\. Use limit=\d+ for more/u.test(body) ||
+		/^\d+ results limit reached(?:\.|$)/u.test(body) ||
 		body.startsWith("Some lines truncated to ")
 	);
 }
@@ -300,7 +301,14 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 	}
 	if (meta.limits?.resultLimit) {
 		const l = meta.limits.resultLimit;
-		parts.push(`${l.reached} results limit reached. Use limit=${l.suggestion} for more`);
+		// At the tool's hard cap there is no larger usable limit, so the
+		// "Use limit=" advice would name a value that gets clamped right
+		// back — emit the bare reached notice instead (#13263).
+		parts.push(
+			l.suggestion === undefined
+				? `${l.reached} results limit reached`
+				: `${l.reached} results limit reached. Use limit=${l.suggestion} for more`,
+		);
 	}
 	if (meta.limits?.headLimit) {
 		const l = meta.limits.headLimit;