@linxiraos/pi-tui 1.2.0 → 1.3.0

package/src/render/code-cell.ts

@@ -8,6 +8,7 @@ import { code, md, span } from "../native/describe";
 import type { NativeNode } from "../native/node";
 import { getMarkdownTheme, highlightCode, type Theme } from "../theme/theme";
 import { formatDuration, formatExpandHint, formatMoreItems, formatStatusIcon, replaceTabs } from "./render-utils";
+import { wrapPrefixedLine } from "./hanging-wrap";
 import {
 	describeOutputBlock,
 	type NativeOutputBlockSection,
@@ -167,6 +168,7 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 		}
 	}
 
+	const numberedCodeLines: string[] = [];
 	if (lineNumberWidth > 0 && visibleLineNumbers) {
 		for (let i = 0; i < codeLines.length; i++) {
 			const lineNum = visibleLineNumbers[i];
@@ -174,10 +176,14 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 				lineNum !== null && lineNum !== undefined
 					? String(lineNum).padStart(lineNumberWidth, " ")
 					: " ".repeat(lineNumberWidth);
-			codeLines[i] = theme.fg("dim", `${gutter} `) + codeLines[i];
+			const prefix = theme.fg("dim", `${gutter} `);
+			numberedCodeLines.push(
+				...wrapPrefixedLine(prefix, " ".repeat(lineNumberWidth + 1), codeLines[i]!, outputBlockContentWidth(width)),
+			);
 		}
 	}
 
+	const displayCodeLines = lineNumberWidth > 0 ? numberedCodeLines : codeLines;
 	if (hiddenCodeLines > 0) {
 		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
 		const gutterPad = lineNumberWidth > 0 ? " ".repeat(lineNumberWidth + 1) : "";
@@ -185,16 +191,16 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 			// Earlier rows scrolled above the live tail window — mark them on top so
 			// the newest streamed line stays pinned to the bottom of the box.
 			const earlier = `… ${hiddenCodeLines} earlier line${hiddenCodeLines === 1 ? "" : "s"}${hint ? ` ${hint}` : ""}`;
-			codeLines.unshift(theme.fg("dim", gutterPad + earlier));
+			displayCodeLines.unshift(theme.fg("dim", gutterPad + earlier));
 		} else {
 			const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
-			codeLines.push(theme.fg("dim", gutterPad + moreLine));
+			displayCodeLines.push(theme.fg("dim", gutterPad + moreLine));
 		}
 	}
 
 	const outputLines = renderCellOutput(output, expanded, outputMaxLines, theme);
 
-	const sections: Array<{ label?: string; lines: readonly string[] }> = [{ lines: codeLines }];
+	const sections: Array<{ label?: string; lines: readonly string[] }> = [{ lines: displayCodeLines }];
 	if (outputLines.length > 0) {
 		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
 	}
@@ -252,7 +258,14 @@ export function describeCodeCell(options: Omit<CodeCellOptions, "width">, theme:
 	const sections: NativeOutputBlockSection[] = [
 		{
 			key: "code",
-			body: [code(options.code ?? "", { lang: options.language, start, numbers: start !== undefined || undefined })],
+			body: [
+				code(options.code ?? "", {
+					lang: options.language,
+					start,
+					numbers: start !== undefined || undefined,
+					wrap: true,
+				}),
+			],
 		},
 	];
 	const output = describeCellOutput(options.output, expanded, outputMaxLines);

package/src/render/hanging-wrap.d.ts

@@ -0,0 +1,7 @@
+import type { Theme } from "../theme/theme";
+/** Wrap content under a distinct first-row prefix, preserving its column on continuation rows. */
+export declare function wrapPrefixedLine(prefix: string, continuationPrefix: string, content: string, width: number): string[];
+/** Preserve a tree connector's ancestor guides while hanging a long node beneath its label. */
+export declare function wrapTreeLine(line: string, width: number, theme: Theme): string[] | undefined;
+/** Hang a tree row beneath its connector, or a connector-less detail row beneath its guide rails. */
+export declare function wrapGuidedLine(line: string, width: number, theme: Theme): string[];

package/src/render/hanging-wrap.ts

@@ -0,0 +1,58 @@
+import { visibleWidth, wrapTextWithAnsi } from "../utils";
+import type { Theme } from "../theme/theme";
+
+/** Wrap content under a distinct first-row prefix, preserving its column on continuation rows. */
+export function wrapPrefixedLine(prefix: string, continuationPrefix: string, content: string, width: number): string[] {
+	const prefixWidth = visibleWidth(prefix);
+	const continuationWidth = visibleWidth(continuationPrefix);
+	if (width <= Math.max(prefixWidth, continuationWidth)) return wrapTextWithAnsi(prefix + content, width);
+	const rows = wrapTextWithAnsi(content, width - Math.max(prefixWidth, continuationWidth));
+	return rows.map((row, index) => `${index === 0 ? prefix : continuationPrefix}${row}`);
+}
+
+/** Preserve a tree connector's ancestor guides while hanging a long node beneath its label. */
+export function wrapTreeLine(line: string, width: number, theme: Theme): string[] | undefined {
+	for (const connector of [theme.tree.branch, theme.tree.last]) {
+		const marker = theme.fg("dim", connector);
+		const index = line.indexOf(marker);
+		if (index < 0) continue;
+		const before = line.slice(0, index);
+		if (!/^ *$/.test(Bun.stripANSI(before).replaceAll(theme.tree.vertical, ""))) continue;
+		const end = index + marker.length + 1;
+		if (line[end - 1] !== " ") continue;
+		const connectorWidth = visibleWidth(connector);
+		const guide =
+			connector === theme.tree.last
+				? " ".repeat(connectorWidth)
+				: `${theme.fg("dim", theme.tree.vertical)}${" ".repeat(Math.max(0, connectorWidth - visibleWidth(theme.tree.vertical)))}`;
+		return wrapPrefixedLine(line.slice(0, end), `${before}${guide} `, line.slice(end), width);
+	}
+	return undefined;
+}
+
+const SGR = /\x1b\[[0-9;]*m/y;
+
+/** End of the leading run of spaces, `vertical` guides and SGR escapes that a tree detail row hangs beneath. */
+function guideRunEnd(line: string, vertical: string): number {
+	let index = 0;
+	while (index < line.length) {
+		if (line[index] === " ") {
+			index++;
+		} else if (vertical && line.startsWith(vertical, index)) {
+			index += vertical.length;
+		} else {
+			SGR.lastIndex = index;
+			if (!SGR.test(line)) break;
+			index = SGR.lastIndex;
+		}
+	}
+	return index;
+}
+
+/** Hang a tree row beneath its connector, or a connector-less detail row beneath its guide rails. */
+export function wrapGuidedLine(line: string, width: number, theme: Theme): string[] {
+	const tree = wrapTreeLine(line, width, theme);
+	if (tree) return tree;
+	const prefix = line.slice(0, guideRunEnd(line, theme.tree.vertical));
+	return wrapPrefixedLine(prefix, prefix, line.slice(prefix.length), width);
+}

package/src/render/hyperlink.d.ts

@@ -70,6 +70,8 @@ export declare function urlHyperlinkAlways(url: string, displayText: string): st
  * Non-HTTP(S) or unparsable URLs yield a plain span.
  */
 export declare function urlLinkSpan(target: string, displayText: string, s?: string): TspSpan;
+/** Whether native link spans and nodes may carry an `href`: everything but an explicit `off` policy. */
+export declare function isNativeLinkEnabled(): boolean;
 /**
  * A native link span to a filesystem path as a plain `file://` URI (the
  * terminal opens it through the system; the location stays in the visible

package/src/render/hyperlink.ts

@@ -196,6 +196,11 @@ export function urlLinkSpan(target: string, displayText: string, s = "link"): Ts
 	}
 }
 
+/** Whether native link spans and nodes may carry an `href`: everything but an explicit `off` policy. */
+export function isNativeLinkEnabled(): boolean {
+	return hyperlinkMode !== "off";
+}
+
 /**
  * A native link span to a filesystem path as a plain `file://` URI (the
  * terminal opens it through the system; the location stays in the visible

package/src/render/render-utils.d.ts

@@ -105,14 +105,22 @@ export declare function cappedHeadLines(lines: readonly string[], max: number):
 };
 /** Get the first nonblank preview lines, trimmed and width-capped. */
 export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/** Collapse a possibly multi-line string into one line; whitespace runs (tabs included) become one space. */
+export declare function flattenLine(text: string): string;
 /**
  * Collapse a possibly multi-line string into a single line, then truncate it to
  * `maxWidth` display cells. {@link truncateToWidth} alone caps width but
  * newlines are zero-width, so multi-line content (markdown briefs, tool args,
  * provider errors) would otherwise spill a single status row across several
- * visual lines. Whitespace runs collapse to one space, so tabs are handled too.
+ * visual lines.
  */
 export declare function previewLine(text: string, maxWidth: number, ellipsis?: Ellipsis): string;
+/**
+ * Clip a result row to `maxWidth` only while collapsed. Expanded rows stay whole
+ * so the frame wraps them: the expand key ({@link formatExpandHint}) must reveal
+ * text, not re-clip it.
+ */
+export declare function clipCollapsed(text: string, maxWidth: number, expanded: boolean | undefined): string;
 /**
  * Extract domain from URL, stripping www. prefix.
  */

package/src/render/render-utils.ts

@@ -233,15 +233,29 @@ export function getPreviewLines(text: string, maxLines: number, maxLineLen: numb
 	return lines.slice(0, maxLines).map(l => truncateToWidth(l.trim(), maxLineLen, ellipsis));
 }
 
+/** Collapse a possibly multi-line string into one line; whitespace runs (tabs included) become one space. */
+export function flattenLine(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
 /**
  * Collapse a possibly multi-line string into a single line, then truncate it to
  * `maxWidth` display cells. {@link truncateToWidth} alone caps width but
  * newlines are zero-width, so multi-line content (markdown briefs, tool args,
  * provider errors) would otherwise spill a single status row across several
- * visual lines. Whitespace runs collapse to one space, so tabs are handled too.
+ * visual lines.
  */
 export function previewLine(text: string, maxWidth: number, ellipsis?: Ellipsis): string {
-	return truncateToWidth(text.replace(/\s+/g, " ").trim(), maxWidth, ellipsis);
+	return truncateToWidth(flattenLine(text), maxWidth, ellipsis);
+}
+
+/**
+ * Clip a result row to `maxWidth` only while collapsed. Expanded rows stay whole
+ * so the frame wraps them: the expand key ({@link formatExpandHint}) must reveal
+ * text, not re-clip it.
+ */
+export function clipCollapsed(text: string, maxWidth: number, expanded: boolean | undefined): string {
+	return expanded ? text : truncateToWidth(text, maxWidth);
 }
 
 // =============================================================================

package/src/render/utils.d.ts

@@ -32,7 +32,7 @@ export interface RenderCache {
     lines: string[];
 }
 /** Build indentation and continuing branches for ancestor levels. */
-export declare function buildTreePrefix(ancestors: boolean[], theme: Theme): string;
+export declare function buildTreePrefix(ancestors: readonly boolean[], theme: Theme): string;
 /** Return the branch glyph for a final or continuing tree item. */
 export declare function getTreeBranch(isLast: boolean, theme: Theme): string;
 /** Return the continuation prefix for subsequent lines of a tree item. */

package/src/render/utils.ts

@@ -76,7 +76,7 @@ export interface RenderCache {
 }
 
 /** Build indentation and continuing branches for ancestor levels. */
-export function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
+export function buildTreePrefix(ancestors: readonly boolean[], theme: Theme): string {
 	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
 }
 

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

@@ -25,7 +25,6 @@ export class WidthAwareText implements Component {
 	#cachedContentWidth = -1;
 	#cachedText: string | undefined;
 	#ignoreTight = false;
-	#nativeCols = -1;
 	#native: NativeNode | undefined;
 
 	constructor(format: (contentWidth: number) => string, paddingX = 1, paddingY = 1) {
@@ -71,10 +70,12 @@ export class WidthAwareText implements Component {
 	 * (the only width a describer knows) and again on `reformat()`.
 	 */
 	describe(cx: DescribeContext): NativeNode {
-		if (this.#cachedText === undefined || cx.cols !== this.#nativeCols) {
-			this.#nativeCols = cx.cols;
-			this.#cachedContentWidth = -1;
-			this.#cachedText = this.#format(Math.max(1, cx.cols));
+		// Native describe emits no padding, so the formatter gets the full
+		// column budget — the same width a native Text.describe() would use.
+		const contentWidth = Math.max(1, cx.cols);
+		if (this.#cachedText === undefined || contentWidth !== this.#cachedContentWidth) {
+			this.#cachedContentWidth = contentWidth;
+			this.#cachedText = this.#format(contentWidth);
 			this.#inner.setText(this.#cachedText);
 		}
 		this.#native ??= col([this.#inner]);

package/src/setup/scenes/splash.ts

@@ -6,7 +6,14 @@ import { formatKeyHint } from "../../app-keybindings";
 import { col, node, span, text } from "../../native/describe";
 import type { NativeNode } from "../../native/node";
 import { Memo } from "../../native/memo";
-import { gradientEscape, gradientLogo, ZETA_LOGO, type ShineConfig, logoNode } from "../../prompt/welcome";
+import {
+	gradientEscape,
+	gradientLogo,
+	ZETA_LOGO,
+	ZETA_SUBLINE,
+	type ShineConfig,
+	logoNode,
+} from "../../prompt/welcome";
 
 export const SETUP_SPLASH_MS = 2600;
 export const SETUP_TICK_MS = 33;
@@ -27,18 +34,11 @@ const RESET = "\x1b[0m";
 const MIN_SCENE_WIDTH = 56;
 const MIN_SCENE_HEIGHT = 22;
 
+/** Skip affordance; built at render time so it follows the live symbol preset. */
 function skipHint(): string {
-	return `press ${formatKeyHint("enter")} to skip`;
+	return tuiText("setupSkipHint", "press {key} to skip").replace("{key}", formatKeyHint("enter"));
 }
 
-/** Density ramp for the rippling water, lightest → heaviest. */
-const WATER_RAMP = [
-	{ min: 0.62, char: "█" },
-	{ min: 0.5, char: "▓" },
-	{ min: 0.36, char: "▒" },
-	{ min: 0.24, char: "░" },
-];
-
 function starAt(x: number, y: number, frame: number): string {
 	const hash = (x * 73856093) ^ (y * 19349663) ^ (frame * 83492791);
 	const bucket = Math.abs(hash) % 97;
@@ -85,39 +85,93 @@ function waterJitter(x: number, y: number): number {
 }
 
 /**
- * Rippling water amplitude in [0,1] at (x, y): three travelling sine waves
- * interfere, then a radial edge falloff and a downward fade concentrate the
- * ripples beneath the mark and dissolve them toward the edges/bottom. `t`
- * advances each tick, so the surface drifts.
+ * Time-invariant terms of the rippling water for one screen size: three
+ * travelling sine waves interfere, then a radial edge falloff and a downward
+ * fade concentrate the ripples beneath the mark and dissolve them toward the
+ * edges/bottom. Only the sine phases move per tick, so everything else is
+ * computed once per size.
  */
-function waterAmplitude(
-	x: number,
-	y: number,
-	cx: number,
-	waterTop: number,
-	waterHeight: number,
-	width: number,
-	t: number,
-): number {
-	const dx = (x - cx) / 2;
-	const dy = y - waterTop;
-	const dist = Math.sqrt(dx * dx + dy * dy);
-	const wave =
-		0.5 * Math.sin(dist * 0.55 - t) +
-		0.3 * Math.sin(x * 0.22 + y * 0.45 - t * 0.7) +
-		0.2 * Math.sin(Math.abs(dx) * 0.8 + dy * 0.5 - t * 1.4);
-	const level = 0.5 + 0.5 * wave;
-	const edge = Math.max(0, 1 - Math.abs(x - cx) / (width * 0.5));
-	const fade = Math.max(0, 1 - (dy / Math.max(1, waterHeight)) * 0.55);
-	return level * edge ** 0.7 * fade;
+interface WaterField {
+	readonly width: number;
+	readonly height: number;
+	readonly waterTop: number;
+	/** Per cell (row-major from `waterTop`): `dist * 0.55`. */
+	readonly radial: Float64Array;
+	/** Per cell: `x * 0.22 + y * 0.45`. */
+	readonly diagonal: Float64Array;
+	/** Per cell: `|dx| * 0.8 + dy * 0.5`. */
+	readonly cross: Float64Array;
+	/** Per cell: `(waterJitter(x, y) - 0.5) * 0.06`. */
+	readonly jitter: Float64Array;
+	/** Per column: `edge ** 0.7`. */
+	readonly edge: Float64Array;
+	/** Per water row: downward fade. */
+	readonly fade: Float64Array;
+}
+
+let waterField: WaterField | undefined;
+
+function getWaterField(width: number, height: number, cx: number, waterTop: number): WaterField {
+	const cached = waterField;
+	if (cached && cached.width === width && cached.height === height && cached.waterTop === waterTop) return cached;
+	const waterHeight = Math.max(1, height - waterTop);
+	const rows = Math.max(0, height - waterTop);
+	const radial = new Float64Array(rows * width);
+	const diagonal = new Float64Array(rows * width);
+	const cross = new Float64Array(rows * width);
+	const jitter = new Float64Array(rows * width);
+	const edge = new Float64Array(width);
+	const fade = new Float64Array(rows);
+	for (let x = 0; x < width; x++) edge[x] = Math.max(0, 1 - Math.abs(x - cx) / (width * 0.5)) ** 0.7;
+	for (let row = 0; row < rows; row++) {
+		const y = waterTop + row;
+		const dy = y - waterTop;
+		fade[row] = Math.max(0, 1 - (dy / waterHeight) * 0.55);
+		for (let x = 0; x < width; x++) {
+			const i = row * width + x;
+			const dx = (x - cx) / 2;
+			radial[i] = Math.sqrt(dx * dx + dy * dy) * 0.55;
+			diagonal[i] = x * 0.22 + y * 0.45;
+			cross[i] = Math.abs(dx) * 0.8 + dy * 0.5;
+			jitter[i] = (waterJitter(x, y) - 0.5) * 0.06;
+		}
+	}
+	waterField = { width, height, waterTop, radial, diagonal, cross, jitter, edge, fade };
+	return waterField;
+}
+
+/** Water glyph for an amplitude, lightest → heaviest density ramp; undefined below the floor. */
+function waterChar(amp: number): string | undefined {
+	if (amp > 0.62) return "█";
+	if (amp > 0.5) return "▓";
+	if (amp > 0.36) return "▒";
+	if (amp > 0.24) return "░";
+	return undefined;
 }
 
+/** Reused cell grid; resized when the screen changes. */
+let splashCells: string[][] = [];
+
+function resetCells(width: number, height: number): string[][] {
+	if (splashCells.length !== height || splashCells[0]?.length !== width) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
+		splashCells = Array.from({ length: height }, () => new Array<string>(width).fill(" "));
+	} else {
+		for (const row of splashCells) row.fill(" ");
+	}
+	return splashCells;
+}
+
+/** Per-frame gradient escapes, one per screen diagonal (the gradient only varies along it). */
+let diagonalEscapes: (string | undefined)[] = [];
+
 /**
- * Animated setup splash, in the spirit of the omp landing page: the brand ζ
- * mark rendered with the live diagonal gradient + shine sweep, rising out of a
- * rippling, gradient-lit water surface, under a faint twinkling starfield. The
- * mark and water share one continuous gradient so the sweep reads across the
- * whole scene; the water surface drifts each frame.
+ * Animated setup splash, in the spirit of the Zeta visual identity: the brand
+ * mark — the FIGlet-rendered Latin `Z`, the ASCII form of `Ζ` — with the live
+ * diagonal gradient + shine sweep, rising out of a rippling, gradient-lit water
+ * surface, under a faint twinkling starfield. The mark and water share one
+ * continuous gradient so the sweep reads across the whole scene; the water
+ * surface drifts each frame.
  */
 export function renderSetupSplash(width: number, height: number, elapsedMs: number): string[] {
 	const w = Math.max(1, width);
@@ -132,23 +186,46 @@ export function renderSetupSplash(width: number, height: number, elapsedMs: numb
 	const cx = Math.floor(w / 2);
 	const surfaceTime = frame * 0.13;
 
-	// [suppressed] length preallocation
-	const cells: string[][] = Array.from({ length: h }, () => new Array<string>(w).fill(" "));
+	const cells = resetCells(w, h);
 	const put = (x: number, y: number, glyph: string): void => {
 		if (y >= 0 && y < h && x >= 0 && x < w) cells[y][x] = glyph;
 	};
+	// Every cell on a diagonal shares one gradient position, so resolve each
+	// escape once per frame instead of once per cell.
+	const diagonals = w + h - 1;
+	if (diagonalEscapes.length !== diagonals) diagonalEscapes = Array.from({ length: diagonals });
+	else diagonalEscapes.fill(undefined);
+	const escapes = diagonalEscapes;
+	const gradient = (x: number, y: number): string => {
+		const d = x + (h - 1 - y);
+		let escape = escapes[d];
+		if (escape === undefined) {
+			escape = gradientEscape(screenGradientT(x, y, w, h, phase), shine);
+			escapes[d] = escape;
+		}
+		return escape;
+	};
 
 	const hx = Math.floor((w - LOGO_WIDTH) / 2);
 	const hy = Math.max(2, Math.floor(h * 0.16));
 	const waterTop = hy + LOGO_HEIGHT;
-	const waterHeight = Math.max(1, h - waterTop);
 
 	// 1. rippling water surface (shares the screen-wide gradient with the mark)
+	const field = getWaterField(w, h, cx, waterTop);
+	const tDiagonal = surfaceTime * 0.7;
+	const tCross = surfaceTime * 1.4;
 	for (let y = waterTop; y < h; y++) {
+		const row = y - waterTop;
+		const fade = field.fade[row];
 		for (let x = 0; x < w; x++) {
-			const amp = waterAmplitude(x, y, cx, waterTop, waterHeight, w, surfaceTime) + (waterJitter(x, y) - 0.5) * 0.06;
-			const cell = WATER_RAMP.find(step => amp > step.min);
-			if (cell) put(x, y, gradientEscape(screenGradientT(x, y, w, h, phase), shine) + cell.char + RESET);
+			const i = row * w + x;
+			const wave =
+				0.5 * Math.sin(field.radial[i] - surfaceTime) +
+				0.3 * Math.sin(field.diagonal[i] - tDiagonal) +
+				0.2 * Math.sin(field.cross[i] - tCross);
+			const level = 0.5 + 0.5 * wave;
+			const char = waterChar(level * field.edge[x] * fade + field.jitter[i]);
+			if (char) cells[y][x] = gradient(x, y) + char + RESET;
 		}
 	}
 	// 2. twinkling starfield in the sky above the water
@@ -162,18 +239,15 @@ export function renderSetupSplash(width: number, height: number, elapsedMs: numb
 	LARGE_LOGO.forEach((line, row) => {
 		let col = 0;
 		for (const ch of line) {
-			if (ch !== " ") {
-				put(
-					hx + col,
-					hy + row,
-					gradientEscape(screenGradientT(hx + col, hy + row, w, h, phase), shine) + ch + RESET,
-				);
-			}
+			const x = hx + col;
+			const y = hy + row;
+			if (ch !== " " && y >= 0 && y < h && x >= 0 && x < w) cells[y][x] = gradient(x, y) + ch + RESET;
 			col++;
 		}
 	});
-	// 4. skip hint on a cleared strip at the bottom so it stays legible over the water
-	const hint = tuiText("setupSkipHint", "press enter to skip");
+	// 4. skip hint on a cleared strip at the bottom so it stays legible over the water.
+	// `formatKeyHint` yields plain glyphs (no ANSI), so per-character dim styling is safe.
+	const hint = skipHint();
 	const hintWidth = visibleWidth(hint);
 	const hintStart = Math.floor((w - hintWidth) / 2);
 	const hintRow = h - 1;
@@ -199,7 +273,8 @@ export function describeSetupSplash(): NativeNode {
 			[
 				node("spacer", { grow: 1 }),
 				logoNode(LARGE_LOGO, true),
-				text([span("Z e t a", "strong")], { wrap: "none" }),
+				text([span("Zeta", "strong")], { wrap: "none" }),
+				text([span("Linxira-Zeta", "dim")], { wrap: "none" }),
 				node("spacer", { grow: 1 }),
 				text([span(hint, "dim")], { wrap: "none" }),
 			],
@@ -211,7 +286,12 @@ export function describeSetupSplash(): NativeNode {
 /** Centered fallback for windows too small to hold the full scene. */
 function renderCompactSplash(width: number, height: number, phase: number, shine: ShineConfig): string[] {
 	const art = height >= 14 ? LARGE_LOGO : ZETA_LOGO;
-	const content = [...gradientLogo(art, phase, shine), "", theme.bold("Z e t a")];
+	const content = [
+		...gradientLogo(art, phase, shine),
+		"",
+		theme.bold("Zeta"),
+		...ZETA_SUBLINE.map(row => theme.fg("dim", row)),
+	];
 	const start = Math.max(0, Math.floor((height - content.length) / 2));
 	const lines: string[] = [];
 	for (let y = 0; y < height; y++) {
@@ -219,9 +299,6 @@ function renderCompactSplash(width: number, height: number, phase: number, shine
 		lines.push(width > 0 ? padToWidth(item !== undefined ? centerLine(item, width) : "", width) : "");
 	}
 	if (height > 2)
-		lines[height - 2] =
-			width > 0
-				? padToWidth(centerLine(theme.fg("dim", tuiText("setupSkipHint", "press enter to skip")), width), width)
-				: "";
+		lines[height - 2] = width > 0 ? padToWidth(centerLine(theme.fg("dim", skipHint()), width), width) : "";
 	return lines;
 }

package/src/status-line/component.ts

@@ -380,6 +380,7 @@ interface ContextUsageMemo {
 	length: number;
 	lastFingerprint: string | undefined;
 	modelContextWindow: number;
+	toolSchemasInContext: boolean;
 	contextUsageRevision: number;
 	toolSchemaMetadataRevision: number;
 	settingsRevision: number;
@@ -774,9 +775,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	// than poison the fresh cache or advance its throttle.
 	#jjCacheGeneration = 0;
 
-	// PR lookup caching (invalidated on branch/repo context changes)
+	// PR lookup cache. `#cachedPrContext` is the branch/repo `#cachedPr` was
+	// resolved for; it is never shown for any other branch. Expiry forces a
+	// refetch while keeping that branch's PR visible until the lookup lands.
 	#cachedPr: { number: number; url: string } | null | undefined = undefined;
 	#cachedPrContext: PrCacheContext | undefined = undefined;
+	#cachedPrExpired = false;
 	#prLookupInFlight = false;
 	#defaultBranch?: string;
 	#defaultBranchCwd: string | undefined = undefined;
@@ -1457,8 +1461,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		// was designed to avoid. Explicit Git/repository invalidation (watcher
 		// HEAD-move, cwd/repo switch) goes through {@link invalidateGitCaches}.
 		// A tool may open, close, or merge a PR without moving HEAD. Expire the
-		// settled PR context on ordinary activity while leaving HEAD work intact.
-		this.#cachedPrContext = undefined;
+		// settled PR on ordinary activity while leaving HEAD work intact.
+		this.#cachedPrExpired = true;
 	}
 	#invalidateSessionCaches(): void {
 		this.#clearUsageStartTimer();
@@ -1489,7 +1493,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#branchResolveActive = undefined;
 		this.#branchLastFetch = undefined;
 		this.#branchCacheGeneration++;
-		this.#cachedPrContext = undefined;
+		this.#cachedPrExpired = true;
 		// A HEAD move (commit, checkout, reset) changes the dirty counts; keep the
 		// stale counts on screen but refetch on the next render. The generation
 		// bump stops an in-flight pre-move result from re-stamping freshness.
@@ -1810,11 +1814,16 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const branch = this.#getBranchLabel(activeRepoCache, this.#resolveRepository(activeRepoCache));
 		const currentContext = branch ? createPrCacheContext(branch, this.#cachedBranchRepoId ?? null) : null;
 
-		if (canReuseCachedPr(this.#cachedPr, this.#cachedPrContext, currentContext)) {
+		if (!this.#cachedPrExpired && canReuseCachedPr(this.#cachedPr, this.#cachedPrContext, currentContext)) {
 			return this.#cachedPr ?? null;
 		}
 
-		const stalePr = this.#cachedPr;
+		// Keep an expired PR visible during the refetch only on the branch it
+		// was resolved for; after a checkout the old PR must not linger.
+		const stalePr =
+			currentContext && isSamePrCacheContext(this.#cachedPrContext, currentContext)
+				? (this.#cachedPr ?? null)
+				: null;
 
 		if (!branch) {
 			this.#cachedPr = null;
@@ -1822,10 +1831,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			return null;
 		}
 
-		// Don't look up if detached, default branch, or already in flight.
-		if (branch === "detached" || this.#isDefaultBranch(branch, gitCwd) || this.#prLookupInFlight) {
-			return stalePr ?? null;
-		}
+		// Detached HEAD and the default branch never carry a PR; no lookup.
+		if (branch === "detached" || this.#isDefaultBranch(branch, gitCwd)) return null;
+		if (this.#prLookupInFlight) return stalePr;
 
 		this.#prLookupInFlight = true;
 		const lookupContext = currentContext;
@@ -1847,6 +1855,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 				if (lookupContext && isSamePrCacheContext(latestContext, lookupContext)) {
 					this.#cachedPr = value;
 					this.#cachedPrContext = lookupContext;
+					this.#cachedPrExpired = false;
 				}
 			};
 			try {
@@ -1980,6 +1989,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	 * cadence while a late successful fetch can still refresh the cached segment.
 	 */
 	refreshUsageInBackground(): void {
+		if (this.#disposed) return;
 		const now = Date.now();
 		const session = this.session;
 		const usageContextKey = this.#getUsageContextKey(session);
@@ -2407,6 +2417,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	getCachedContextBreakdown(): { usedTokens: number; contextWindow: number } {
 		const messages = this.session.messages ?? EMPTY_MESSAGES;
 		const modelContextWindow = this.session.model?.contextWindow ?? 0;
+		const toolSchemasInContext = this.session.model?.toolSchemasInContext !== false;
 		const length = messages.length;
 		const lastFingerprint = length > 0 ? messageFingerprint(messages[length - 1]!) : undefined;
 		// Bumps when the in-flight pending snapshot is set/cleared. Without it a
@@ -2428,6 +2439,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			cache.length === length &&
 			cache.lastFingerprint === lastFingerprint &&
 			cache.modelContextWindow === modelContextWindow &&
+			cache.toolSchemasInContext === toolSchemasInContext &&
 			cache.contextUsageRevision === contextUsageRevision &&
 			cache.systemPromptRef === systemPrompt &&
 			cache.toolsRef === tools &&
@@ -2448,6 +2460,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			length,
 			lastFingerprint,
 			modelContextWindow,
+			toolSchemasInContext,
 			contextUsageRevision,
 			toolSchemaMetadataRevision,
 			settingsRevision,