pi-zentui 0.22.0 → 0.22.2

package/README.md

@@ -89,7 +89,7 @@ pi install git:github.com/lmilojevicc/pi-zentui
 
 ## Configure
 
-Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Thinking (Experimental), Working line, Footer, Segments, Git, and Extensions. Use `Tab` and `Shift+Tab` to switch sections. Most changes apply live; Thinking (Experimental) changes are saved and require restarting Pi. Configuration is saved to:
+Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Thinking (Experimental), Working line, Footer, Segments, Git, and Extensions. Use `Tab` and `Shift+Tab` to switch sections. Most changes apply live. Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restarting Pi. Configuration is saved to:
 
 ```text
 ~/.pi/agent/zentui.json
@@ -144,13 +144,13 @@ Useful shortcuts:
 /zentui format clear
 ```
 
-**Thinking (Experimental)** uses one restart-gated private `AssistantMessageComponent` renderer for Rail, Tree, and Streaming, tested against exact Pi versions 0.80.5, 0.83.0, 0.84.0, and 0.84.4. It is disabled by default and may break after Pi updates. Every enable, disable, or mode change is saved but does not alter the active startup snapshot; restart Pi to apply it. Zentui installs an enabled startup snapshot before transcript restoration. Missing constructors, incompatible child layouts, parser limits, theme/render/width errors, or displaced patch ownership fail open to complete native thinking rather than switching modes.
+**Thinking (Experimental)** uses one private `AssistantMessageComponent` renderer for Rail, Tree, and Streaming, tested against exact Pi versions 0.80.5, 0.82.1, 0.83.0, 0.84.0, and 0.84.4. It is disabled by default and may break after Pi updates. Zentui installs an enabled startup mode before transcript restoration. A healthy installed controller lets active Streaming switch live to Rail or Tree, and lets Rail and Tree switch live between each other, without reinstalling its patch. Entering Streaming from Rail or Tree saves the choice but keeps the active structural mode until restart. Disabling live restores native thinking and releases Streaming resources. First enable and re-enable after a live disable are also restart-gated. Mode changes while disabled only preconfigure the next enable. Startup failures, missing constructors, incompatible private child layouts, parser limits, theme/render/width errors, and displaced patch ownership fail open to complete native thinking. If cleanup throws while leaving Streaming, disabling still restores native thinking and a structural selection still becomes active; the successful change warns that Streaming is unavailable for the rest of the session.
 
-Rail shows every parsed label in each native contiguous thinking run (`│ Label`, with only the open final phase shown as `│ • Label`). Tree independently shows the latest five labels in each run (`├─ · Label`, settled `└─ · Label`, open `└─ • Label`); it never aggregates across intervening text or tool blocks. Labels are rendered by fresh host-shaped Pi Markdown instances before cropping, so emphasis, code, links, HTML, LaTeX, custom transforms, and native `thinkingText` styling remain host-controlled. Every label occupies one terminal row: ANSI/OSC/grapheme-aware cropping adds `…` only when needed. Native horizontal padding stays external. Connectors are styled directly with the current theme's `accent` callback on every render, so custom themes control them independently. Hidden native thinking remains hidden and keeps Pi's native hidden label.
+Rail shows every parsed label in each native contiguous thinking run (`│ Label`, with only the open final phase shown as `│ • Label`). Tree independently shows the latest five labels in each run (`├─ · Label`, settled `└─ · Label`, open `└─ • Label`); it never aggregates across intervening text or tool blocks. Rail and Tree follow Pi's thinking visibility, and unsafe or unstructured content remains native. Labels are rendered by fresh host-shaped Pi Markdown instances before cropping, so emphasis, code, links, HTML, LaTeX, custom transforms, and native `thinkingText` styling remain host-controlled. Every label occupies one terminal row: ANSI/OSC/grapheme-aware cropping adds `…` only when needed. Native horizontal padding stays external. Connectors are styled directly with the current theme's `accent` callback on every render, so custom themes control them independently. Hidden native thinking remains hidden and keeps Pi's native hidden label.
 
-Streaming retains Pi's host-rendered final five rows under `Thinking 7.1s`, folds completed reasoning under `Thought` or current-session `Thought for 12.3s`, and owns the configured thinking-toggle binding (Ctrl+T by default) only for an active Streaming startup. Restored completions cannot recover a duration because Pi does not persist the thinking-end timestamp. Expand/refold and lifecycle tracking are bounded to 256 retained assistant components; evicted entries are first restored natively. All modes restore/dispose on shutdown. Thinking (Experimental) never writes the Working line and does not change its existing **Thinking time** option, working text, Footer, Editor, statuses, or model behavior.
+Streaming retains Pi's host-rendered final five rows under `Thinking 7.1s`, folds completed reasoning under `Thought` or current-session `Thought for 12.3s`, and owns the configured thinking-toggle binding (Ctrl+T by default) only when started in Streaming. Its input listener and timer are acquired only for an enabled Streaming session start; startup acquisition failure uses native thinking and marks Streaming unavailable. Restored completions cannot recover a duration because Pi does not persist the thinking-end timestamp. Expand/refold and lifecycle tracking are bounded to 256 retained assistant components; evicted entries are first restored natively. All modes restore/dispose on shutdown. Thinking (Experimental) never writes the Working line and does not change its existing **Thinking time** option, working text, Footer, Editor, statuses, or model behavior.
 
-Pi 0.84 also provides a native fullscreen TUI with a sticky editor and Footer. Zentui does not enable it automatically; select fullscreen from Pi's `/settings`, set `"tuiMode": "fullscreen"` in Pi settings, or launch Pi with `--tui-mode fullscreen`.
+Pi 0.84 also provides a native fullscreen TUI with a sticky editor and Footer. Pi 0.84.4 is covered by a fullscreen live-transition PTY smoke in addition to the standard matrix. Zentui does not enable fullscreen automatically; select it from Pi's `/settings`, set `"tuiMode": "fullscreen"` in Pi settings, or launch Pi with `--tui-mode fullscreen`.
 
 ## Requirements
 
@@ -192,8 +192,10 @@ See [CONTRIBUTING.md](https://github.com/lmilojevicc/pi-zentui/blob/main/CONTRIB
 - [Opencode](https://github.com/anomalyco/opencode) — inspiration for the Opencode editor treatment
 - [Oh My Pi (`omp`)](https://github.com/can1357/oh-my-pi) by [Can Bölük](https://github.com/can1357) — visual inspiration for the filled, single-left-rail Accent Rail editor
 - [Pi Custom Input](https://github.com/VinhLe1410/pi-custom-input) by [Vinh Le](https://github.com/VinhLe1410) — visual inspiration for Minimalist's framed, border-embedded session, model, context, Git, and path metadata
+- [Pi Thinking Steps](https://github.com/crustyhacker/pi-thinking-steps) by Marc Mironescu / FluxGear — structural-step parsing and the Rail/Tree visual language; adapted in Thinking (Experimental) under the MIT License
+- [Pi Thinking Fold](https://github.com/99percentpeople/pi-extensions/tree/master/extensions/thinking-fold) by [Zach Yuen](https://github.com/99percentpeople) — native rendered-row folding, timing, expand/refold behavior, and fail-open compatibility patterns; adapted in Thinking (Experimental) under the MIT License
 
-Zentui's implementations are independent; these credits acknowledge product and visual inspiration rather than source-code reuse.
+Most Zentui implementations are independent; these credits acknowledge product and visual inspiration. Thinking (Experimental) also adapts MIT-licensed implementation work from Pi Thinking Steps and Pi Thinking Fold. Their complete copyright and permission notices are retained in the packaged [`thinking-experimental.ts`](./extensions/zentui/thinking-experimental.ts) source.
 
 ## License
 

package/extensions/zentui/settings-command.ts

@@ -63,6 +63,7 @@ import {
 	SETTINGS_PREVIEW_MAX_WIDTH,
 } from "./settings-previews";
 import { EDITOR_BORDER_STYLE, renderChromeBorder, safeThemeFg } from "./style";
+import { formatThinkingStatus, thinkingStatusLabels } from "./thinking-status";
 import {
 	buildWorkingLinePreviewFrames,
 	normalizeWorkingLineMessages,
@@ -140,7 +141,11 @@ const thinkingStepsModeLabels: Record<ThinkingStepsMode, string> = {
 	tree: "Tree",
 	streaming: "Streaming",
 };
-const thinkingStepsModeValues = Object.values(thinkingStepsModeLabels);
+const thinkingStepsModeValues = (startupMode: ThinkingStepsMode): string[] => {
+	if (startupMode === "streaming") return ["Streaming", "Tree", "Rail"];
+	if (startupMode === "rail") return ["Rail", "Tree", "Streaming"];
+	return ["Tree", "Rail", "Streaming"];
+};
 
 const settingsSections = [
 	"appearance",
@@ -176,6 +181,9 @@ type SettingsOutcome =
 
 type ThinkingControllerState = Readonly<{
 	available: boolean;
+	rendererAvailable?: boolean;
+	streamingAvailable?: boolean;
+	streamingPoisoned?: boolean;
 	active: boolean;
 	activeMode?: ThinkingStepsMode;
 	startup: Readonly<ThinkingStepsComponentConfig>;
@@ -665,20 +673,8 @@ function buildThinkingStepsItems(
 ): SettingItem[] {
 	const thinkingSteps = config.components.thinkingSteps;
 	const controller = experimentalThinkingCapability(capability);
-	const startupLabel = controller.startup.enabled
-		? `Active startup: ${thinkingStepsModeLabels[controller.startup.mode]}`
-		: "Active startup: native thinking";
-	const savedLabel = thinkingSteps.enabled
-		? `Saved: ${thinkingStepsModeLabels[thinkingSteps.mode]}`
-		: "Saved: disabled";
-	const status = !controller.available
-		? `${controller.reason ?? "Private renderer unavailable"}; using native thinking.`
-		: controller.restartRequired
-			? `${savedLabel}; ${startupLabel}. Restart Pi to apply.`
-			: controller.active
-				? `${startupLabel}.`
-				: `${savedLabel}; using native thinking.`;
-	const enabledDescription = `${status} Private renderer; every enable, disable, or mode change requires restart and may break after Pi updates.`;
+	const status = formatThinkingStatus(thinkingStatusLabels(thinkingSteps, controller));
+	const enabledDescription = `${status} Live switching supports Streaming → Rail/Tree and Rail ↔ Tree. Entering Streaming, first enable, and re-enable after live disable require restart. Private renderer may break after Pi updates.`;
 	return [
 		{
 			id: "thinkingStepsEnabled",
@@ -690,9 +686,9 @@ function buildThinkingStepsItems(
 		{
 			id: "thinkingStepsMode",
 			label: "Mode",
-			description: `${status} Rail shows every parsed label; Tree shows the latest five per contiguous run; Streaming folds to the latest five host-rendered rows and owns the configured thinking toggle only when active. Incompatibility uses native thinking.`,
+			description: `${status} Rail shows every parsed label; Tree shows the latest five per contiguous run; both follow Pi thinking visibility, and unsafe or unstructured content remains native. Streaming folds to the latest five host-rendered rows and owns the configured thinking toggle only when active. Incompatibility uses native thinking.`,
 			currentValue: thinkingStepsModeLabels[thinkingSteps.mode],
-			values: thinkingStepsModeValues,
+			values: thinkingStepsModeValues(controller.startup.mode),
 		},
 	];
 }
@@ -1285,9 +1281,10 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 					};
 					const notifyChange = (label: string, value: string, result?: ApplyResult) => {
 						deps.requestRender();
+						const detail = result?.reason?.trim();
 						ctx.ui.notify(
-							`${label}: ${value}${result && !result.applied ? ` (${result.reason ?? "reload Pi to apply this change"})` : ""}`,
-							"info",
+							`${label}: ${value}${detail ? ` (${detail})` : result && !result.applied ? " (reload Pi to apply this change)" : ""}`,
+							result && (!result.applied || detail) ? "warning" : "info",
 						);
 						startPreview();
 						tui.requestRender();

package/extensions/zentui/settings-previews.ts

@@ -6,6 +6,7 @@ import { sanitizeEditorMetadataText } from "./editor-metadata-format";
 import { renderMinimalistFrame } from "./minimalist-editor";
 import { safeThemeFg } from "./style";
 import { createThinkingStepsRows } from "./thinking-experimental";
+import { formatThinkingStatus, thinkingStatusLabels } from "./thinking-status";
 import { parseThinkingSteps } from "./thinking-steps";
 import { renderPolishedEditorFrame } from "./ui";
 import { makeMarkdownTheme, renderUserMessageStyle } from "./user-message-styles";
@@ -25,6 +26,9 @@ export const THINKING_STEPS_PREVIEW_MARKDOWN = [
 ].join("\n");
 type ThinkingPreviewState = Readonly<{
 	available: boolean;
+	rendererAvailable?: boolean;
+	streamingAvailable?: boolean;
+	streamingPoisoned?: boolean;
 	active: boolean;
 	activeMode?: "rail" | "tree" | "streaming";
 	startup: Readonly<{ enabled: boolean; mode: "rail" | "tree" | "streaming" }>;
@@ -37,6 +41,23 @@ type ThinkingPreviewCapability =
 	| Readonly<{ available: boolean }>
 	| Readonly<{ readonly state: ThinkingPreviewState }>;
 
+function wrapPreviewText(text: string, width: number): string[] {
+	if (width <= 0) return [];
+	const rows: string[] = [];
+	for (const fact of text.split(" · ")) {
+		const candidate = rows.length > 0 ? `${rows.at(-1)} · ${fact}` : fact;
+		if (visibleWidth(candidate) <= width) {
+			if (rows.length > 0) rows[rows.length - 1] = candidate;
+			else rows.push(candidate);
+			continue;
+		}
+		if (rows.length === 0 || rows.at(-1) !== fact) rows.push(fact);
+	}
+	return rows.flatMap((row) =>
+		visibleWidth(row) <= width ? [row] : [truncateToWidth(row, width, "")],
+	);
+}
+
 function boundedRows(rows: string[], width: number): string[] {
 	const safeWidth = Math.max(0, Math.min(SETTINGS_PREVIEW_MAX_WIDTH, width));
 	if (safeWidth <= 0) return [];
@@ -176,20 +197,17 @@ export function renderThinkingStepsSettingsPreview(
 						startup: { enabled: false, mode: "tree" },
 						restartRequired: false,
 					};
-	const saved = thinkingSteps.enabled ? `saved ${thinkingSteps.mode}` : "saved disabled";
-	const active = state.active && state.activeMode ? `active ${state.activeMode}` : "native active";
-	const status = !state.available
-		? `${state.reason ?? "private renderer unavailable"} · native thinking`
-		: state.restartRequired
-			? `${saved} · ${active} · restart required`
-			: `${saved} · ${active}`;
+	const status = formatThinkingStatus(thinkingStatusLabels(thinkingSteps, state));
+	const statusRows = wrapPreviewText(status, previewWidth).map((row) =>
+		safeThemeFg(theme, "muted", row),
+	);
 	if (thinkingSteps.mode === "streaming") {
 		return boundedRows(
 			[
+				...statusRows,
 				safeThemeFg(theme, "thinkingText", "Thinking 7.1s  (configured thinking toggle to expand)"),
 				safeThemeFg(theme, "thinkingText", "Inspect the host-rendered reasoning tail."),
 				safeThemeFg(theme, "thinkingText", "Preserve native Markdown and wrapping."),
-				safeThemeFg(theme, "muted", status),
 			],
 			previewWidth,
 		);
@@ -223,6 +241,5 @@ export function renderThinkingStepsSettingsPreview(
 				() => theme,
 			).render(previewWidth)
 		: native.render(previewWidth);
-	rows.push(safeThemeFg(theme, "muted", status));
-	return boundedRows(rows, previewWidth);
+	return boundedRows([...statusRows, ...rows], previewWidth);
 }

package/extensions/zentui/thinking-experimental.ts

@@ -17,6 +17,7 @@ import {
 	isPrototypePatchCurrent,
 	type PrototypePatchRegistration,
 } from "./prototype-patch-registry";
+import { formatThinkingStatus, thinkingStatusLabels } from "./thinking-status";
 import { parseThinkingSteps, type ThinkingStep } from "./thinking-steps";
 
 /*
@@ -114,7 +115,11 @@ export type ThinkingExperimentalDiagnostics = Readonly<{
 }>;
 
 export type ThinkingExperimentalState = Readonly<{
+	/** Backward-compatible alias for whole renderer availability. */
 	available: boolean;
+	rendererAvailable: boolean;
+	streamingAvailable: boolean;
+	streamingPoisoned: boolean;
 	active: boolean;
 	activeMode?: ThinkingStepsMode;
 	startup: Readonly<ThinkingStepsComponentConfig>;
@@ -123,6 +128,11 @@ export type ThinkingExperimentalState = Readonly<{
 	reason?: string;
 }>;
 
+export type ThinkingExperimentalApplyResult = Readonly<{
+	applied: boolean;
+	reason?: string;
+}>;
+
 function messageTimestamp(message: AssistantMessage): number | undefined {
 	return Number.isFinite(message.timestamp) ? message.timestamp : undefined;
 }
@@ -747,6 +757,11 @@ export class ThinkingExperimentalController {
 	private displaced = false;
 	private restartRequired = false;
 	private unavailableReason: string | undefined;
+	private streamingUnavailableReason: string | undefined;
+	private streamingListenerPoisoned = false;
+	private disposed = false;
+	private resourceToken = 0;
+	private timerToken = 0;
 	private patchRegistration: PrototypePatchRegistration | undefined;
 	private context: ExtensionContext | undefined;
 	private stopInput: (() => void) | undefined;
@@ -789,12 +804,15 @@ export class ThinkingExperimentalController {
 
 	get state(): ThinkingExperimentalState {
 		this.checkDisplacement();
+		const rendererAvailable = !this.unavailableReason && !this.displaced;
 		const reason = this.displaced
-			? "Private renderer patch ownership was displaced; restart required"
-			: (this.unavailableReason ??
-				(this.restartRequired ? "Restart Pi to apply saved Thinking changes." : undefined));
+			? "Private renderer patch ownership was displaced"
+			: (this.unavailableReason ?? this.streamingUnavailableReason);
 		return Object.freeze({
-			available: !this.unavailableReason && !this.displaced,
+			available: rendererAvailable,
+			rendererAvailable,
+			streamingAvailable: !this.streamingUnavailableReason,
+			streamingPoisoned: this.streamingListenerPoisoned,
 			active: this.active && !this.displaced,
 			...(this.activeMode ? { activeMode: this.activeMode } : {}),
 			startup: Object.freeze({ ...this.startup }),
@@ -804,6 +822,13 @@ export class ThinkingExperimentalController {
 		});
 	}
 
+	private failureResult(): ThinkingExperimentalApplyResult {
+		return {
+			applied: false,
+			reason: formatThinkingStatus(thinkingStatusLabels(this.getConfig(), this.state)),
+		};
+	}
+
 	get diagnostics(): ThinkingExperimentalDiagnostics {
 		return Object.freeze({
 			trackedComponents: this.trackedEntries().length,
@@ -812,56 +837,106 @@ export class ThinkingExperimentalController {
 		});
 	}
 
-	/** Activates the private renderer only during session startup, before transcript restoration. */
-	startSession(ctx: ExtensionContext): { applied: boolean; reason?: string } {
+	/** Activates the private renderer during session startup, before transcript restoration. */
+	startSession(ctx: ExtensionContext): ThinkingExperimentalApplyResult {
+		this.disposed = false;
+		this.resourceToken += 1;
+		this.streamingUnavailableReason = undefined;
+		this.streamingListenerPoisoned = false;
 		if (ctx.mode === "tui" && ctx.hasUI) this.context = ctx;
 		this.startup = { ...this.getConfig() };
 		this.restartRequired = false;
 		this.activeMode = undefined;
 		if (!this.startup.enabled) return { applied: true };
 		if (!this.context) {
-			return { applied: false, reason: "Thinking (Experimental) requires a TUI session" };
+			this.unavailableReason = "Thinking (Experimental) requires a TUI session";
+			this.restartRequired = true;
+			return this.failureResult();
+		}
+		if (this.unavailableReason) {
+			this.restartRequired = true;
+			return this.failureResult();
 		}
-		if (this.unavailableReason) return { applied: false, reason: this.unavailableReason };
 		if (this.startup.mode === "streaming" && !this.resolveToggleInput()) {
-			return {
-				applied: false,
-				reason: this.unavailableReason ?? "Experimental thinking toggle is unavailable",
-			};
+			this.restartRequired = true;
+			return this.failureResult();
 		}
 		if (!this.install()) {
-			return {
-				applied: false,
-				reason:
-					this.unavailableReason ?? "Experimental renderer unavailable; using native thinking",
-			};
+			this.unavailableReason ??= "Experimental renderer unavailable; using native thinking";
+			this.restartRequired = true;
+			return this.failureResult();
 		}
 		if (this.checkDisplacement()) {
 			this.restartRequired = true;
-			return {
-				applied: false,
-				reason: "Experimental renderer was displaced; restart required, using native thinking",
-			};
+			return this.failureResult();
+		}
+		if (this.startup.mode === "streaming") {
+			const acquired = this.acquireStreamingResources();
+			if (!acquired.applied) {
+				this.restartRequired = true;
+				return this.failureResult();
+			}
 		}
 		this.active = true;
 		this.activeMode = this.startup.mode;
-		if (this.activeMode === "streaming") this.installInputListener();
-		if (!this.active) {
-			return {
-				applied: false,
-				reason: this.unavailableReason ?? "Experimental input handling is unavailable",
-			};
-		}
 		return { applied: true };
 	}
 
-	/** Persists live settings while retaining the immutable startup renderer snapshot. */
-	reconcile(): { applied: boolean; reason?: string } {
+	/** Applies healthy installed transitions while preserving persistence as the authority. */
+	reconcile(): ThinkingExperimentalApplyResult {
 		const desired = this.getConfig();
-		this.restartRequired =
-			desired.enabled !== this.startup.enabled || desired.mode !== this.startup.mode;
-		if (!this.restartRequired) return { applied: true };
-		return { applied: false, reason: "Restart Pi to apply saved Thinking changes." };
+		if (!desired.enabled) {
+			this.restartRequired = false;
+			return this.active ? this.deactivate() : { applied: true };
+		}
+		if (this.active && this.activeMode === desired.mode) {
+			this.restartRequired = false;
+			return { applied: true };
+		}
+		if (
+			!this.active ||
+			!this.installed ||
+			this.displaced ||
+			this.unavailableReason ||
+			this.checkDisplacement()
+		) {
+			this.restartRequired = true;
+			return this.failureResult();
+		}
+		const previousMode = this.activeMode;
+		if (!previousMode) {
+			this.restartRequired = true;
+			return this.failureResult();
+		}
+		if (desired.mode === "streaming") {
+			// Streaming owns terminal input and a timer. Never acquire either from a
+			// settings callback: entering Streaming is an explicit restart boundary.
+			this.restartRequired = true;
+			return this.failureResult();
+		}
+		const streamingCleanupSucceeded =
+			previousMode !== "streaming" || this.releaseStreamingResources();
+		this.expanded = false;
+		this.activeMode = desired.mode;
+		this.restartRequired = false;
+		this.rerenderTracked();
+		const result = this.liveTransitionResult(desired.mode);
+		if (!result.applied || streamingCleanupSucceeded) return result;
+		return {
+			applied: true,
+			reason: formatThinkingStatus(thinkingStatusLabels(this.getConfig(), this.state)),
+		};
+	}
+
+	private liveTransitionResult(mode: ThinkingStepsMode): ThinkingExperimentalApplyResult {
+		if (this.active && this.activeMode === mode && !this.displaced && !this.unavailableReason) {
+			return { applied: true };
+		}
+		this.restartRequired = true;
+		if (!this.unavailableReason && !this.streamingUnavailableReason) {
+			this.unavailableReason = "Experimental renderer failed during the live transition";
+		}
+		return this.failureResult();
 	}
 
 	private install(): boolean {
@@ -952,7 +1027,25 @@ export class ThinkingExperimentalController {
 							this.failShape("Pi's private assistant renderer shape is incompatible");
 							return nativeResult;
 						}
-						this.track(component, message, args, predecessor, incomplete, nativeHidden);
+						const trackedState = this.track(
+							component,
+							message,
+							args,
+							predecessor,
+							incomplete,
+							nativeHidden,
+						);
+						// Tracking can synchronously acquire the first Streaming timer. If that
+						// transaction fails, failActiveStreaming has already restored native UI.
+						if (
+							!this.active ||
+							this.activeMode !== mode ||
+							this.displaced ||
+							this.unavailableReason ||
+							this.states.get(component) !== trackedState ||
+							(mode === "streaming" && (this.streamingListenerPoisoned || !this.stopInput))
+						)
+							return nativeResult;
 						if (mode === "streaming" && this.expanded) return nativeResult;
 						if (
 							!replaceThinkingChildren(
@@ -1000,15 +1093,16 @@ export class ThinkingExperimentalController {
 		predecessor: (this: unknown, ...args: unknown[]) => unknown,
 		incomplete: boolean,
 		nativeHidden: HiddenState,
-	): void {
-		this.states.set(component, {
+	): TrackedState {
+		const trackedState: TrackedState = {
 			message,
 			args: [...args],
 			predecessor,
 			incomplete,
 			nativeHidden,
 			folded: false,
-		});
+		};
+		this.states.set(component, trackedState);
 		let reference = this.references.get(component);
 		if (!reference) {
 			reference = new WeakRef(component);
@@ -1034,6 +1128,7 @@ export class ThinkingExperimentalController {
 		}
 		this.pruneTimings();
 		this.reconcileTimer();
+		return trackedState;
 	}
 
 	private headerFor(message: AssistantMessage, incomplete: boolean, hidden: boolean): string {
@@ -1055,6 +1150,7 @@ export class ThinkingExperimentalController {
 	}
 
 	private resolveToggleInput(): boolean {
+		if (this.streamingListenerPoisoned) return false;
 		if (this.toggleInput) return true;
 		const action = "app.thinking.toggle";
 		if (!this.getHostKeybindings) {
@@ -1131,22 +1227,68 @@ export class ThinkingExperimentalController {
 	}
 
 	private failToggleCapability(reason: string): false {
-		this.unavailableReason = reason;
+		this.poisonStreamingListener(reason);
+		return false;
+	}
+
+	private poisonStreamingListener(
+		reason = "Pi's terminal input listener cleanup is unavailable",
+	): void {
+		this.streamingListenerPoisoned = true;
+		this.streamingUnavailableReason = reason;
+		this.toggleInput = undefined;
+	}
+
+	private cleanupInput(stopInput: (() => void) | undefined): boolean {
+		if (!stopInput) return true;
+		try {
+			stopInput();
+			return true;
+		} catch {
+			this.poisonStreamingListener();
+			return false;
+		}
+	}
+
+	private failActiveStreaming(reason: string): void {
+		// Invalidate first so a retained or currently executing callback can never act again.
+		this.resourceToken += 1;
+		this.releaseStreamingResources();
+		this.poisonStreamingListener(reason);
 		this.active = false;
-		this.stopTimer();
-		this.stopInput?.();
-		this.stopInput = undefined;
-		this.rerenderTracked(true);
+		this.activeMode = undefined;
+		this.restartRequired = true;
+		this.rerenderTracked(true, true);
 		this.clearTrackedSnapshots();
-		this.toggleInput = undefined;
-		return false;
+		this.clearLiveState();
 	}
 
-	private installInputListener(): void {
-		if (this.stopInput || !this.context || !this.toggleInput) return;
+	private acquireStreamingResources(): { applied: boolean; reason?: string } {
+		if (this.stopInput || this.interval) {
+			return { applied: false, reason: "Experimental input resources are already owned" };
+		}
+		if (this.streamingListenerPoisoned) {
+			return {
+				applied: false,
+				reason:
+					this.streamingUnavailableReason ?? "Pi's terminal input listener cleanup is unavailable",
+			};
+		}
+		if (!this.context || !this.toggleInput) {
+			return { applied: false, reason: "Experimental input handling is unavailable" };
+		}
+		const token = ++this.resourceToken;
+		let stopInput: unknown;
 		try {
-			const stopInput = this.context.ui.onTerminalInput((data) => {
-				if (!this.active || this.checkDisplacement()) return;
+			stopInput = this.context.ui.onTerminalInput((data) => {
+				if (
+					this.disposed ||
+					token !== this.resourceToken ||
+					!this.active ||
+					this.activeMode !== "streaming" ||
+					this.checkDisplacement()
+				)
+					return;
 				const input = this.toggleInput;
 				if (!input) return;
 				let matches = false;
@@ -1159,7 +1301,7 @@ export class ThinkingExperimentalController {
 						matches = parsed !== undefined && input.keys.includes(parsed);
 					}
 				} catch {
-					this.failToggleCapability("Pi's thinking-toggle matcher failed at runtime");
+					this.failActiveStreaming("Pi's thinking-toggle matcher failed at runtime");
 					return;
 				}
 				if (!matches) return;
@@ -1169,14 +1311,64 @@ export class ThinkingExperimentalController {
 				}
 				return { consume: true };
 			});
-			if (typeof stopInput !== "function") {
-				this.failToggleCapability("Pi's terminal input listener cleanup is unavailable");
-				return;
-			}
-			this.stopInput = stopInput;
 		} catch {
-			this.failToggleCapability("Pi's terminal input listener is unavailable");
+			// Registration may retain the callback before throwing. Invalidate it and never
+			// attempt another registration in this session because ownership is unknowable.
+			this.resourceToken += 1;
+			this.poisonStreamingListener("Pi's terminal input listener registration is unavailable");
+			return { applied: false, reason: this.streamingUnavailableReason };
+		}
+		if (typeof stopInput !== "function") {
+			// The host may have retained the callback without giving us a release mechanism.
+			// Poison Streaming for this session and leave that callback permanently inert.
+			this.resourceToken += 1;
+			this.poisonStreamingListener();
+			return { applied: false, reason: this.streamingUnavailableReason };
 		}
+		const releaseInput = stopInput as () => void;
+		let interval: ReturnType<typeof setInterval> | undefined;
+		try {
+			if (this.activeEntries().length > 0) interval = this.createStreamingTimer(token);
+		} catch {
+			// Registration succeeded but the acquisition transaction did not. Invalidate the
+			// candidate callback before cleanup and poison Streaming even when cleanup succeeds.
+			this.resourceToken += 1;
+			this.cleanupInput(releaseInput);
+			this.poisonStreamingListener("Pi's thinking timer is unavailable");
+			return { applied: false, reason: this.streamingUnavailableReason };
+		}
+		this.stopInput = releaseInput;
+		this.interval = interval;
+		return { applied: true };
+	}
+
+	private createStreamingTimer(resourceToken = this.resourceToken): ReturnType<typeof setInterval> {
+		const timerToken = ++this.timerToken;
+		return setInterval(() => {
+			// Timer/resource release invalidates callbacks before attempting host cleanup.
+			// A host that throws from clearInterval may retain this callback, so stale
+			// callbacks must be wholly inert while a later release retries the same handle.
+			if (
+				this.disposed ||
+				resourceToken !== this.resourceToken ||
+				timerToken !== this.timerToken ||
+				!this.active ||
+				this.activeMode !== "streaming"
+			)
+				return;
+			if (this.checkDisplacement()) return;
+			this.rerenderActive();
+			this.reconcileTimer();
+		}, 1000);
+	}
+
+	private releaseStreamingResources(): boolean {
+		this.resourceToken += 1;
+		const timerCleanupSucceeded = this.stopTimer();
+		const stopInput = this.stopInput;
+		this.stopInput = undefined;
+		const inputCleanupSucceeded = this.cleanupInput(stopInput);
+		return timerCleanupSucceeded && inputCleanupSucceeded;
 	}
 
 	private trackedEntries(): Array<[object, TrackedState]> {
@@ -1263,13 +1455,20 @@ export class ThinkingExperimentalController {
 		}
 	}
 
-	private restoreNative(entries: Array<[object, TrackedState]>): number {
+	private restoreNative(
+		entries: Array<[object, TrackedState]>,
+		preserveVisibleUnfolded = false,
+	): number {
 		let processed = 0;
 		for (const [component, state] of entries) {
 			processed += 1;
 			const instance = component as PatchableAssistant;
 			try {
-				renderWithHiddenState(instance, state.predecessor, state.args, state.nativeHidden);
+				// A visible native predecessor has already produced the authoritative children
+				// when first-message timer acquisition fails inside track(). Preserve their exact
+				// identity rather than invoking the predecessor a second time.
+				if (!preserveVisibleUnfolded || state.folded || state.nativeHidden.value === true)
+					renderWithHiddenState(instance, state.predecessor, state.args, state.nativeHidden);
 			} catch {
 				// A stale transcript component must never break restoration of later components.
 			} finally {
@@ -1328,7 +1527,7 @@ export class ThinkingExperimentalController {
 						state.folded = true;
 					}
 				} catch {
-					this.dropComponent(component);
+					this.failShape("Pi's private assistant renderer failed during a live rerender");
 				}
 				if (this.shapeFailureDuringRerender) break;
 			}
@@ -1345,9 +1544,11 @@ export class ThinkingExperimentalController {
 		return processed;
 	}
 
-	private rerenderTracked(nativeOnly = false): void {
+	private rerenderTracked(nativeOnly = false, preserveVisibleUnfolded = false): void {
 		const entries = this.trackedEntries();
-		const processed = this.rerenderEntries(entries, nativeOnly);
+		const processed = nativeOnly
+			? this.restoreNative(entries, preserveVisibleUnfolded)
+			: this.rerenderEntries(entries);
 		if (processed > 0) this.requestHostRender();
 	}
 
@@ -1362,7 +1563,7 @@ export class ThinkingExperimentalController {
 	}
 
 	private reconcileTimer(): void {
-		if (!this.active || this.activeMode !== "streaming") {
+		if (!this.active || this.activeMode !== "streaming" || !this.stopInput) {
 			this.stopTimer();
 			return;
 		}
@@ -1370,21 +1571,29 @@ export class ThinkingExperimentalController {
 			this.stopTimer();
 			return;
 		}
-		if (!this.interval) {
-			this.interval = setInterval(() => {
-				if (!this.active || this.checkDisplacement()) {
-					this.stopTimer();
-					return;
-				}
-				this.rerenderActive();
-				this.reconcileTimer();
-			}, 1000);
+		if (!this.interval && !this.streamingListenerPoisoned) {
+			try {
+				this.interval = this.createStreamingTimer();
+			} catch {
+				this.failActiveStreaming("Pi's thinking timer is unavailable");
+			}
 		}
 	}
 
-	private stopTimer(): void {
-		if (this.interval) clearInterval(this.interval);
-		this.interval = undefined;
+	private stopTimer(): boolean {
+		const interval = this.interval;
+		if (!interval) return true;
+		this.timerToken += 1;
+		try {
+			clearInterval(interval);
+			this.interval = undefined;
+			return true;
+		} catch {
+			// Keep the exact handle so shutdown or another release can retry it. Streaming
+			// remains poisoned, preventing any replacement timer/listener acquisition.
+			this.poisonStreamingListener("Pi's thinking timer cleanup is unavailable");
+			return false;
+		}
 	}
 
 	private checkDisplacement(): boolean {
@@ -1405,9 +1614,7 @@ export class ThinkingExperimentalController {
 				// Restore every component synchronously before relinquishing input/timer ownership.
 				this.rerenderTracked(true);
 				this.clearTrackedSnapshots();
-				this.stopTimer();
-				this.stopInput?.();
-				this.stopInput = undefined;
+				this.releaseStreamingResources();
 			}
 		}
 		return this.displaced;
@@ -1416,9 +1623,9 @@ export class ThinkingExperimentalController {
 	private failShape(reason: string): void {
 		this.unavailableReason = reason;
 		this.active = false;
-		this.stopTimer();
-		this.stopInput?.();
-		this.stopInput = undefined;
+		this.activeMode = undefined;
+		this.restartRequired = true;
+		this.releaseStreamingResources();
 		if (this.rerendering) {
 			this.shapeFailureDuringRerender = reason;
 			return;
@@ -1440,19 +1647,22 @@ export class ThinkingExperimentalController {
 		this.currentMessage = undefined;
 	}
 
-	private deactivate(): void {
+	private deactivate(): ThinkingExperimentalApplyResult {
 		this.active = false;
 		this.activeMode = undefined;
 		this.expanded = false;
-		this.stopTimer();
-		this.stopInput?.();
-		this.stopInput = undefined;
+		const streamingCleanupSucceeded = this.releaseStreamingResources();
 		this.rerenderTracked(true);
 		// Cached host components stay native until Pi next rebuilds/updates them. Dropping
 		// snapshots is intentional: reactivation must never replay pre-disable content.
 		this.clearTrackedSnapshots();
 		this.clearLiveState();
 		this.toggleInput = undefined;
+		if (streamingCleanupSucceeded) return { applied: true };
+		return {
+			applied: true,
+			reason: formatThinkingStatus(thinkingStatusLabels(this.getConfig(), this.state)),
+		};
 	}
 
 	beginMessage(event: unknown): void {
@@ -1544,6 +1754,7 @@ export class ThinkingExperimentalController {
 	}
 
 	shutdown(): void {
+		this.disposed = true;
 		this.deactivate();
 		this.startup = { enabled: false, mode: "tree" };
 		this.restartRequired = false;

package/extensions/zentui/thinking-status.ts

@@ -0,0 +1,69 @@
+import type { ThinkingStepsComponentConfig, ThinkingStepsMode } from "./config";
+
+export type ThinkingStatusState = Readonly<{
+	active: boolean;
+	activeMode?: ThinkingStepsMode;
+	restartRequired: boolean;
+	/** Whole private renderer capability, independent of mode-specific resources. */
+	rendererAvailable?: boolean;
+	/** Streaming input/timer capability for this session. */
+	streamingAvailable?: boolean;
+	/** Irreversible session-local acquisition/callback poison. */
+	streamingPoisoned?: boolean;
+	/** Legacy whole-renderer capability accepted by settings adapters. */
+	available?: boolean;
+	reason?: string;
+}>;
+
+export type ThinkingStatusLabels = Readonly<{
+	saved: ThinkingStepsMode | "disabled";
+	active: ThinkingStepsMode | "native";
+	rendererUnavailable: boolean;
+	streamingUnavailable: boolean;
+	streamingPoisoned: boolean;
+	restartRequired: boolean;
+	reason?: string;
+}>;
+
+function cleanReason(value: string | undefined): string | undefined {
+	const reason = value
+		?.replace(/(?:[;,·]\s*)?restart required\b[.!]?/gi, "")
+		.replace(/^restart pi to apply(?: saved thinking changes)?[.!]?$/i, "")
+		.replace(/^[\s;,.·]+|[\s;,.·]+$/g, "")
+		.trim();
+	if (!reason || /^(?:renderer|streaming) unavailable$/i.test(reason)) return undefined;
+	return reason;
+}
+
+/** Builds independent status facts once so every consumer reports the same state. */
+export function thinkingStatusLabels(
+	config: ThinkingStepsComponentConfig,
+	state: ThinkingStatusState,
+): ThinkingStatusLabels {
+	const rendererAvailable = state.rendererAvailable ?? state.available ?? true;
+	const reason = cleanReason(state.reason);
+	return {
+		saved: config.enabled ? config.mode : "disabled",
+		active: state.active && state.activeMode ? state.activeMode : "native",
+		rendererUnavailable: !rendererAvailable,
+		streamingUnavailable: state.streamingAvailable === false || state.streamingPoisoned === true,
+		streamingPoisoned: state.streamingPoisoned === true,
+		restartRequired: state.restartRequired,
+		...(reason ? { reason } : {}),
+	};
+}
+
+const modeLabel = (mode: ThinkingStepsMode | "disabled" | "native"): string =>
+	`${mode.charAt(0).toUpperCase()}${mode.slice(1)}`;
+
+/** Formats the canonical complete status line used by settings, previews, and apply failures. */
+export function formatThinkingStatus(facts: ThinkingStatusLabels): string {
+	return [
+		`Saved: ${modeLabel(facts.saved)}`,
+		`Active: ${modeLabel(facts.active)}`,
+		...(facts.rendererUnavailable ? ["Renderer unavailable"] : []),
+		...(facts.streamingUnavailable ? ["Streaming unavailable"] : []),
+		...(facts.restartRequired ? ["restart required"] : []),
+		...(facts.reason ? [facts.reason] : []),
+	].join(" · ");
+}

package/extensions/zentui/ui.ts

@@ -602,7 +602,7 @@ function renderAccentRailFrameFromBase({
 		above: parsedTop?.count,
 		below: parsedBottom?.count,
 	};
-	const lines = renderAccentRailEditorFrame({
+	const renderedLines = renderAccentRailEditorFrame({
 		width,
 		editorLines,
 		autocompleteLines,
@@ -610,6 +610,7 @@ function renderAccentRailFrameFromBase({
 		uiTheme,
 		config,
 	});
+	const lines = renderedLines.length === 1 ? ["", ...renderedLines, ""] : renderedLines;
 	POLISHED_FRAME_SPLITS.set(lines, {
 		rows: Object.freeze([...lines]),
 		split: { editorLines, trailingLines: autocompleteLines, viewport },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-zentui",
-	"version": "0.22.0",
+	"version": "0.22.2",
 	"description": "A Starship-inspired statusline and Opencode-style TUI for Pi.",
 	"type": "module",
 	"license": "MIT",