@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-zentui/test/thinking-experimental.test.ts

@@ -0,0 +1,1668 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import {
+	AssistantMessageComponent,
+	type ExtensionContext,
+	initTheme,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, Markdown, type MarkdownTheme, Spacer, Text } from "@earendil-works/pi-tui";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ThinkingStepsComponentConfig } from "../extensions/zentui/config";
+import { ZENTUI_PROTOTYPE_PATCH_REGISTRY } from "../extensions/zentui/prototype-patch-registry";
+import {
+	THINKING_EXPERIMENTAL_MAX_TRACKED_COMPONENTS,
+	ThinkingExperimentalController,
+} from "../extensions/zentui/thinking-experimental";
+
+initTheme("dark", false);
+
+const prototype = AssistantMessageComponent.prototype;
+const originalDescriptor = Object.getOwnPropertyDescriptor(prototype, "updateContent");
+const identity = (text: string) => text;
+const markdownTheme = Object.fromEntries(
+	[
+		"heading",
+		"link",
+		"linkUrl",
+		"code",
+		"codeBlock",
+		"codeBlockBorder",
+		"quote",
+		"quoteBorder",
+		"hr",
+		"listBullet",
+		"bold",
+		"italic",
+		"strikethrough",
+		"underline",
+	].map((key) => [key, identity]),
+) as unknown as MarkdownTheme;
+
+function message(thinking: string, timestamp = 1_000, answer?: string): AssistantMessage {
+	return messageWithContent(
+		[{ type: "thinking", thinking }, ...(answer ? [{ type: "text" as const, text: answer }] : [])],
+		timestamp,
+	);
+}
+
+function messageWithContent(
+	content: AssistantMessage["content"],
+	timestamp = 1_000,
+): AssistantMessage {
+	return {
+		role: "assistant",
+		content,
+		api: "test",
+		provider: "test",
+		model: "test",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp,
+	};
+}
+
+function plain(lines: string[]): string[] {
+	return lines.map((line) =>
+		line
+			.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+			.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+			.trimEnd(),
+	);
+}
+
+function context() {
+	let inputHandler: ((data: string) => { consume?: boolean } | undefined) | undefined;
+	let inputRegistrations = 0;
+	const stopInput = vi.fn();
+	const forbidden = {
+		setWorkingMessage: vi.fn(),
+		setWorkingVisible: vi.fn(),
+		setWorkingIndicator: vi.fn(),
+		setFooter: vi.fn(),
+		setStatus: vi.fn(),
+		setEditorComponent: vi.fn(),
+		setHiddenThinkingLabel: vi.fn(),
+	};
+	const ctx = {
+		mode: "tui",
+		hasUI: true,
+		ui: {
+			...forbidden,
+			theme: { fg: (_color: string, text: string) => text },
+			onTerminalInput(handler: typeof inputHandler) {
+				inputRegistrations += 1;
+				inputHandler = handler;
+				return stopInput;
+			},
+		},
+		sessionManager: { getEntries: () => [] },
+	} as unknown as ExtensionContext;
+	return {
+		ctx,
+		forbidden,
+		input: (data: string) => inputHandler?.(data),
+		inputRegistrations: () => inputRegistrations,
+		stopInput,
+	};
+}
+
+function component(hideThinkingBlock = false): AssistantMessageComponent {
+	return new AssistantMessageComponent(
+		undefined,
+		hideThinkingBlock,
+		markdownTheme,
+		"Thinking...",
+		1,
+		[],
+	);
+}
+
+// npm keeps Pi's own Pi-TUI package nested, while Pi's source loader deliberately
+// supplies one virtual-module identity. Bridge only the unit host to model that loader.
+function bridgeSourceLoadedMarkdownIdentity(): void {
+	const native = originalDescriptor?.value as (this: unknown, ...args: unknown[]) => unknown;
+	const constructors = new Map<string, object>([
+		["Markdown", Markdown.prototype],
+		["Spacer", Spacer.prototype],
+		["Text", Text.prototype],
+	]);
+	Object.defineProperty(prototype, "updateContent", {
+		...originalDescriptor,
+		value: function sourceLoadedIdentityBridge(this: unknown, ...args: unknown[]) {
+			const result = Reflect.apply(native, this, args);
+			const children = (this as { contentContainer?: { children?: object[] } }).contentContainer
+				?.children;
+			for (const child of children ?? []) {
+				const expected = constructors.get(child.constructor.name);
+				if (expected && Object.getPrototypeOf(child) !== expected)
+					Object.setPrototypeOf(child, expected);
+			}
+			return result;
+		},
+	});
+}
+
+function installLegacyThinkingRenderer(
+	afterNative?: (container: { children: Component[] }, children: Component[]) => void,
+): void {
+	Object.defineProperty(prototype, "updateContent", {
+		...originalDescriptor,
+		value: function legacyThinkingChildren(
+			this: { contentContainer?: { children: Component[] } },
+			value: AssistantMessage,
+		) {
+			const children: Component[] = [new Spacer(1)];
+			for (const [index, part] of value.content.entries()) {
+				if (part.type === "thinking" && part.thinking.trim()) {
+					children.push(
+						new Markdown(part.thinking.trim(), 1, 0, markdownTheme, {
+							color: identity,
+							italic: true,
+						}),
+					);
+					if (value.content.slice(index + 1).some((next) => next.type !== "toolCall")) {
+						children.push(new Spacer(1));
+					}
+				} else if (part.type === "text" && part.text.trim()) {
+					children.push(new Markdown(part.text.trim(), 1, 0, markdownTheme));
+				}
+			}
+			const container = this.contentContainer ?? { children: [] };
+			container.children = children;
+			this.contentContainer = container;
+			afterNative?.(container, children);
+			return value;
+		},
+	});
+}
+
+const controllers = new Set<ThinkingExperimentalController>();
+
+afterEach(() => {
+	for (const controller of controllers) controller.shutdown();
+	controllers.clear();
+	if (originalDescriptor) Object.defineProperty(prototype, "updateContent", originalDescriptor);
+	delete (prototype as unknown as Record<PropertyKey, unknown>)[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+	vi.useRealTimers();
+});
+
+function controller(
+	config: ThinkingStepsComponentConfig,
+	now: () => number = Date.now,
+	requestRender = vi.fn(),
+	getHostKeybindings?: () => {
+		getDefinition(action: string): unknown;
+		getKeys?(action: string): string[];
+		matches(data: string, action: string): boolean;
+	},
+	getHostKeyText?: (action: string) => string,
+): ThinkingExperimentalController {
+	const value = new ThinkingExperimentalController(
+		() => config,
+		requestRender,
+		now,
+		getHostKeybindings,
+		getHostKeyText,
+	);
+	controllers.add(value);
+	return value;
+}
+
+describe("Thinking (Experimental) private assistant decorator", () => {
+	it.each(["rail", "tree"] as const)(
+		"installs %s only at enabled startup, preserves hidden native thinking, and owns no input",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const host = context();
+			const value = controller({ enabled: true, mode });
+			expect(value.startSession(host.ctx)).toEqual({ applied: true });
+			expect(value.state).toMatchObject({ active: true, activeMode: mode });
+			expect(host.inputRegistrations()).toBe(0);
+			const visible = component(false);
+			visible.updateContent(message("# One\n# Two", 1_000), true);
+			const output = plain(visible.render(80)).join("\n");
+			expect(output).toContain(mode === "rail" ? "│ • Two" : "└─ • Two");
+			const hidden = component(true);
+			hidden.updateContent(message("\x1b[31m# Hidden\x1b[0m", 2_000), true);
+			const hiddenOutput = plain(hidden.render(80)).join("\n");
+			expect(hiddenOutput).toContain("Thinking...");
+			expect(hiddenOutput).not.toContain("Hidden");
+		},
+	);
+
+	it.each(["rail", "tree"] as const)(
+		"renders SGR-decorated thinking in %s and preserves mixed unsafe source natively",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const unsafeSource = "\x1b[38;2;137;180;250m# Native fallback\x1b[39m\x1b[2J";
+			const expectedNative = component();
+			expectedNative.updateContent(message(unsafeSource, 3_000), true);
+
+			const value = controller({ enabled: true, mode });
+			expect(value.startSession(context().ctx)).toEqual({ applied: true });
+			const decorated = component();
+			decorated.updateContent(
+				message(
+					"\x1b[38;2;137;180;250m# First\x1b[39m\n\x1b[38;2;186;194;222m# Second\x1b[39m",
+					2_000,
+				),
+				true,
+			);
+			const decoratedRows = decorated.render(80);
+			const decoratedPlain = plain(decoratedRows).join("\n");
+			expect(decoratedPlain).toContain(mode === "rail" ? "│ • Second" : "└─ • Second");
+			expect(decoratedRows.join("\n")).not.toContain("\x1b[38;2;137;180;250m");
+			expect(decoratedRows.join("\n")).not.toContain("\x1b[38;2;186;194;222m");
+
+			const unsafe = component();
+			unsafe.updateContent(message(unsafeSource, 3_000), true);
+			expect(unsafe.render(80)).toEqual(expectedNative.render(80));
+		},
+	);
+
+	it("preconfigures while disabled and requires restart for first enable and post-disable re-enable", () => {
+		const config: ThinkingStepsComponentConfig = { enabled: false, mode: "tree" };
+		const host = context();
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		expect(Object.getOwnPropertyDescriptor(prototype, "updateContent")).toEqual(originalDescriptor);
+
+		config.mode = "streaming";
+		expect(value.reconcile()).toEqual({ applied: true });
+		config.enabled = true;
+		expect(value.reconcile()).toEqual({
+			applied: false,
+			reason: "Saved: Streaming · Active: Native · restart required",
+		});
+		expect(config).toEqual({ enabled: true, mode: "streaming" });
+		expect(Object.getOwnPropertyDescriptor(prototype, "updateContent")).toEqual(originalDescriptor);
+		expect(value.state).toMatchObject({
+			available: true,
+			active: false,
+			restartRequired: true,
+		});
+		expect(value.state.reason).toBeUndefined();
+		expect(host.input("\x14")).toBeUndefined();
+		expect(host.inputRegistrations()).toBe(0);
+		expect(host.stopInput).not.toHaveBeenCalled();
+
+		value.shutdown();
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		expect(prototype.updateContent).not.toBe(originalDescriptor?.value);
+		expect(value.state).toMatchObject({
+			available: true,
+			active: true,
+			restartRequired: false,
+		});
+		expect(host.inputRegistrations()).toBe(1);
+		config.enabled = false;
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(value.state).toMatchObject({ active: false, restartRequired: false });
+		config.enabled = true;
+		expect(value.reconcile()).toMatchObject({ applied: false });
+		expect(value.state).toMatchObject({ active: false, restartRequired: true });
+	});
+
+	it("switches startup Streaming to Tree to Rail live with one redraw and releases resources", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, () => 2_000, requestRender);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		const current = message("# One\n# Two\n# Three\n# Four\n# Five\n# Six", 1_000);
+		(current as { stopReason: string }).stopReason = "pending";
+		assistant.updateContent(current, true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking 0.0s");
+		expect(host.inputRegistrations()).toBe(1);
+		expect(vi.getTimerCount()).toBe(1);
+
+		config.mode = "tree";
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ • Six");
+		expect(requestRender).toHaveBeenCalledTimes(1);
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		expect(vi.getTimerCount()).toBe(0);
+
+		config.mode = "rail";
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(plain(assistant.render(80)).join("\n")).toContain("│ • Six");
+		expect(requestRender).toHaveBeenCalledTimes(2);
+		expect(host.inputRegistrations()).toBe(1);
+		expect(vi.getTimerCount()).toBe(0);
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(requestRender).toHaveBeenCalledTimes(2);
+		for (const method of Object.values(host.forbidden)) expect(method).not.toHaveBeenCalled();
+	});
+
+	it("keeps a structural mode active and acquires no resources when Streaming is selected", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "tree" };
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, () => 2_000, requestRender);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		assistant.updateContent(message("# One\n# Two", 1_000), true);
+
+		config.mode = "streaming";
+		expect(value.reconcile()).toEqual({
+			applied: false,
+			reason: "Saved: Streaming · Active: Tree · restart required",
+		});
+		expect(value.state).toMatchObject({
+			rendererAvailable: true,
+			streamingAvailable: true,
+			active: true,
+			activeMode: "tree",
+			restartRequired: true,
+		});
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ • Two");
+		expect(requestRender).not.toHaveBeenCalled();
+		expect(host.inputRegistrations()).toBe(0);
+		expect(host.stopInput).not.toHaveBeenCalled();
+		expect(vi.getTimerCount()).toBe(0);
+	});
+
+	it("fails open native when startup Streaming cannot own listener cleanup", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		let leakedHandler: ((data: string) => { consume?: boolean } | undefined) | undefined;
+		(
+			host.ctx.ui as unknown as { onTerminalInput: (handler: typeof leakedHandler) => unknown }
+		).onTerminalInput = (handler) => {
+			leakedHandler = handler;
+			return { notCleanup: true };
+		};
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toMatchObject({
+			applied: false,
+			reason: expect.stringContaining("cleanup is unavailable"),
+		});
+		expect(value.state).toMatchObject({
+			rendererAvailable: true,
+			streamingAvailable: false,
+			active: false,
+			restartRequired: true,
+		});
+		const assistant = component();
+		assistant.updateContent(message("startup native reasoning"), true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("startup native reasoning");
+		expect(leakedHandler?.("\x14")).toBeUndefined();
+		value.shutdown();
+		expect(leakedHandler?.("\x14")).toBeUndefined();
+	});
+
+	it("does not fold the first pending Streaming message when timer startup fails", () => {
+		let nativeChildren: Component[] | undefined;
+		installLegacyThinkingRenderer((_container, children) => {
+			nativeChildren = children;
+		});
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		const value = controller(config, () => 2_000);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const interval = vi.spyOn(globalThis, "setInterval").mockImplementationOnce(() => {
+			throw new Error("timer denied");
+		});
+		const assistant = component();
+		const pending = message("first pending native reasoning", 1_000);
+		(pending as { stopReason: string }).stopReason = "pending";
+		expect(() => assistant.updateContent(pending, true)).not.toThrow();
+		interval.mockRestore();
+
+		const children = (assistant as unknown as { contentContainer: { children: Component[] } })
+			.contentContainer.children;
+		expect(children).toBe(nativeChildren);
+		expect(children.every((child, index) => child === nativeChildren?.[index])).toBe(true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("first pending native reasoning");
+		expect(value.state).toMatchObject({
+			rendererAvailable: true,
+			streamingAvailable: false,
+			active: false,
+			restartRequired: true,
+			reason: "Pi's thinking timer is unavailable",
+		});
+		expect(value.diagnostics).toMatchObject({ trackedComponents: 0, activeComponents: 0 });
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+	});
+
+	it("fails a live transition transactionally when a tracked layout becomes incompatible", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "rail" };
+		const host = context();
+		const value = controller(config, () => 5_000);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		const original = message("# Original Rail", 1_000);
+		(original as { stopReason: string }).stopReason = "pending";
+		assistant.updateContent(original, true);
+		const tracked = (
+			value as unknown as { states: WeakMap<object, { args: unknown[] }> }
+		).states.get(assistant);
+		expect(tracked).toBeDefined();
+		if (tracked) tracked.args = [message("incompatible native replacement", 2_000), true];
+
+		config.mode = "tree";
+		const result = value.reconcile();
+		expect(result).toEqual({
+			applied: false,
+			reason:
+				"Saved: Tree · Active: Native · Renderer unavailable · restart required · Pi's private assistant renderer shape is incompatible",
+		});
+		expect(value.state).toMatchObject({
+			available: false,
+			active: false,
+			restartRequired: true,
+			reason: "Pi's private assistant renderer shape is incompatible",
+		});
+		expect(value.state.activeMode).toBeUndefined();
+		expect(value.diagnostics).toMatchObject({ trackedComponents: 0, activeComponents: 0 });
+		expect(plain(assistant.render(80)).join("\n")).toContain("incompatible native replacement");
+		expect(host.stopInput).not.toHaveBeenCalled();
+		expect(vi.getTimerCount()).toBe(0);
+	});
+
+	it("contains throwing listener cleanup while leaving the selected structural mode active", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		host.stopInput.mockImplementation(() => {
+			throw new Error("cleanup denied");
+		});
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		assistant.updateContent(message("# Transition cleanup"), false);
+		config.mode = "tree";
+		let result: ReturnType<ThinkingExperimentalController["reconcile"]> | undefined;
+		expect(() => {
+			result = value.reconcile();
+		}).not.toThrow();
+		expect(result).toEqual({
+			applied: true,
+			reason:
+				"Saved: Tree · Active: Tree · Streaming unavailable · Pi's terminal input listener cleanup is unavailable",
+		});
+		expect(value.state).toMatchObject({
+			active: true,
+			activeMode: "tree",
+			streamingAvailable: false,
+			restartRequired: false,
+		});
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ · Transition cleanup");
+		expect(() => value.shutdown()).not.toThrow();
+	});
+
+	it("disables Streaming to native with a canonical warning when cleanup throws", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		host.stopInput.mockImplementation(() => {
+			throw new Error("cleanup denied");
+		});
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		const pending = message("# Disable cleanup");
+		(pending as { stopReason: string }).stopReason = "pending";
+		assistant.updateContent(pending, true);
+		expect(vi.getTimerCount()).toBe(1);
+
+		config.enabled = false;
+		expect(value.reconcile()).toEqual({
+			applied: true,
+			reason:
+				"Saved: Disabled · Active: Native · Streaming unavailable · Pi's terminal input listener cleanup is unavailable",
+		});
+		expect(value.state).toMatchObject({
+			active: false,
+			streamingAvailable: false,
+			streamingPoisoned: true,
+			restartRequired: false,
+			reason: "Pi's terminal input listener cleanup is unavailable",
+		});
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		expect(vi.getTimerCount()).toBe(0);
+		expect(host.input("\x14")).toBeUndefined();
+		const nativeOutput = plain(assistant.render(80)).join("\n");
+		expect(nativeOutput).toContain("Disable cleanup");
+		expect(nativeOutput).not.toContain("Thinking 0.0s");
+
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		expect(value.state).toMatchObject({
+			streamingAvailable: false,
+			streamingPoisoned: true,
+		});
+	});
+
+	it("keeps a failed timer handle inert and retries its cleanup at shutdown", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		const pending = message("# Timer cleanup");
+		(pending as { stopReason: string }).stopReason = "pending";
+		assistant.updateContent(pending, true);
+		expect(vi.getTimerCount()).toBe(1);
+		const clear = vi.spyOn(globalThis, "clearInterval").mockImplementationOnce(() => {
+			throw new Error("timer cleanup denied");
+		});
+
+		config.mode = "tree";
+		expect(value.reconcile()).toEqual({
+			applied: true,
+			reason:
+				"Saved: Tree · Active: Tree · Streaming unavailable · Pi's thinking timer cleanup is unavailable",
+		});
+		expect(value.state).toMatchObject({
+			active: true,
+			activeMode: "tree",
+			streamingAvailable: false,
+			streamingPoisoned: true,
+			restartRequired: false,
+			reason: "Pi's thinking timer cleanup is unavailable",
+		});
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		expect(host.input("\x14")).toBeUndefined();
+		expect(host.inputRegistrations()).toBe(1);
+		expect(vi.getTimerCount()).toBe(1);
+		expect(
+			(value as unknown as { interval?: ReturnType<typeof setInterval> }).interval,
+		).toBeDefined();
+		const rendersAfterTransition = requestRender.mock.calls.length;
+		vi.advanceTimersByTime(2_000);
+		expect(clear).toHaveBeenCalledTimes(1);
+		expect(requestRender).toHaveBeenCalledTimes(rendersAfterTransition);
+		expect(value.diagnostics.lastTimerWork).toBe(0);
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ • Timer cleanup");
+
+		expect(() => value.shutdown()).not.toThrow();
+		expect(clear).toHaveBeenCalledTimes(2);
+		expect(vi.getTimerCount()).toBe(0);
+		expect(
+			(value as unknown as { interval?: ReturnType<typeof setInterval> }).interval,
+		).toBeUndefined();
+	});
+
+	it("keeps an always-throwing cleared timer callback inert with an honest reason", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		const pending = message("# Permanent timer cleanup");
+		(pending as { stopReason: string }).stopReason = "pending";
+		assistant.updateContent(pending, true);
+		const clear = vi.spyOn(globalThis, "clearInterval").mockImplementation(() => {
+			throw new Error("timer cleanup denied");
+		});
+
+		config.mode = "rail";
+		expect(value.reconcile()).toEqual({
+			applied: true,
+			reason:
+				"Saved: Rail · Active: Rail · Streaming unavailable · Pi's thinking timer cleanup is unavailable",
+		});
+		const rendersAfterTransition = requestRender.mock.calls.length;
+		vi.advanceTimersByTime(2_000);
+		expect(clear).toHaveBeenCalledTimes(1);
+		expect(requestRender).toHaveBeenCalledTimes(rendersAfterTransition);
+		expect(host.inputRegistrations()).toBe(1);
+		expect(value.state).toMatchObject({
+			active: true,
+			activeMode: "rail",
+			streamingAvailable: false,
+			streamingPoisoned: true,
+			reason: "Pi's thinking timer cleanup is unavailable",
+		});
+
+		expect(() => value.shutdown()).not.toThrow();
+		expect(clear).toHaveBeenCalledTimes(2);
+		expect(vi.getTimerCount()).toBe(1);
+		expect(
+			(value as unknown as { interval?: ReturnType<typeof setInterval> }).interval,
+		).toBeDefined();
+		expect(value.state.reason).toBe("Pi's thinking timer cleanup is unavailable");
+	});
+
+	it("renders the final five native terminal rows, toggles full native reasoning, and refolds", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		let now = 8_100;
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config, () => now);
+		value.startSession(host.ctx);
+		const assistant = component();
+		const reasoning = Array.from({ length: 8 }, (_, index) => `rendered row ${index + 1}  `).join(
+			"\n",
+		);
+		const current = message(reasoning, 7_000, "Final **answer**");
+		assistant.updateContent(current, true);
+		const collapsed = plain(assistant.render(40));
+		expect(collapsed).toContain(" Thinking 0.0s  (ctrl+t to expand)");
+		expect(collapsed.some((line) => line.includes("rendered row 1"))).toBe(false);
+		for (const row of [4, 5, 6, 7, 8])
+			expect(collapsed.some((line) => line.includes(`rendered row ${row}`))).toBe(true);
+		expect(collapsed.some((line) => line.includes("Final answer"))).toBe(true);
+
+		expect(host.input("\x14")).toEqual({ consume: true });
+		const expanded = plain(assistant.render(40));
+		expect(expanded.some((line) => line.includes("Thinking "))).toBe(false);
+		expect(expanded.some((line) => line.includes("rendered row 1"))).toBe(true);
+		expect(host.input("\x14")).toEqual({ consume: true });
+		expect(plain(assistant.render(40))).toContain(" Thinking 0.0s  (ctrl+t to expand)");
+
+		now = 12_300;
+		assistant.updateContent(current, false);
+		const completed = plain(assistant.render(40));
+		expect(completed).toContain(" Thought for 4.2s  (ctrl+t to expand)");
+		expect(completed.filter((line) => line.includes("rendered row"))).toEqual([]);
+	});
+
+	it("maps equal and colliding text/thinking sources by exact ordered child identity", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config, () => 2_000);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+
+		const collision = component();
+		collision.updateContent(
+			messageWithContent([
+				{ type: "thinking", thinking: "A" },
+				{ type: "text", text: "B" },
+				{ type: "thinking", thinking: "B" },
+			]),
+			false,
+		);
+		const collisionFolded = plain(collision.render(80)).join("\n");
+		expect(collisionFolded).toContain("Thought");
+		expect(collisionFolded).not.toMatch(/^ A$/m);
+		expect(collisionFolded.match(/^ B$/gm)).toHaveLength(1);
+		expect(host.input("\x14")).toEqual({ consume: true });
+		const collisionExpanded = plain(collision.render(80)).join("\n");
+		expect(collisionExpanded.match(/^ A$/gm)).toHaveLength(1);
+		expect(collisionExpanded.match(/^ B$/gm)).toHaveLength(2);
+		expect(host.input("\x14")).toEqual({ consume: true });
+
+		const equal = component();
+		equal.updateContent(
+			messageWithContent([
+				{ type: "text", text: "SAME" },
+				{ type: "thinking", thinking: "SAME" },
+			]),
+			false,
+		);
+		const equalFolded = plain(equal.render(80)).join("\n");
+		expect(equalFolded.match(/^ SAME$/gm)).toHaveLength(1);
+		expect(equalFolded).toContain("Thought");
+		expect(host.input("\x14")).toEqual({ consume: true });
+		expect(
+			plain(equal.render(80))
+				.join("\n")
+				.match(/^ SAME$/gm),
+		).toHaveLength(2);
+	});
+
+	it("coalesces contiguous thinking and preserves separated runs across tool-only boundaries", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const contiguous = component();
+		contiguous.updateContent(
+			messageWithContent([
+				{ type: "thinking", thinking: "contiguous A" },
+				{ type: "thinking", thinking: "contiguous B" },
+			]),
+			false,
+		);
+		const contiguousFolded = plain(contiguous.render(80)).join("\n");
+		expect(contiguousFolded).toContain("Thought");
+		expect(contiguousFolded).not.toContain("contiguous A");
+		expect(contiguousFolded).not.toContain("contiguous B");
+
+		const separated = component();
+		separated.updateContent(
+			messageWithContent([
+				{ type: "thinking", thinking: "separated A" },
+				{ type: "toolCall", id: "tool-1", name: "read", arguments: {} },
+				{ type: "thinking", thinking: "separated B" },
+			]),
+			false,
+		);
+		const separatedFolded = plain(separated.render(80)).join("\n");
+		expect(separatedFolded.match(/Thought/g)).toHaveLength(1);
+		expect(separatedFolded).not.toContain("separated A");
+		expect(separatedFolded).not.toContain("separated B");
+		expect(host.input("\x14")).toEqual({ consume: true });
+		const separatedExpanded = plain(separated.render(80)).join("\n");
+		expect(separatedExpanded).toContain("separated A");
+		expect(separatedExpanded).toContain("separated B");
+	});
+
+	it.each(["rail", "tree"] as const)(
+		"groups a legacy adjacent thinking run into one %s title and run-level selection",
+		(mode) => {
+			installLegacyThinkingRenderer();
+			const value = controller({ enabled: true, mode });
+			expect(value.startSession(context().ctx)).toEqual({ applied: true });
+			const assistant = component();
+			assistant.updateContent(
+				messageWithContent([
+					{
+						type: "thinking",
+						thinking: ["# Legacy 1", "# Legacy 2", "# Legacy 3", "# Legacy 4"].join("\n"),
+					},
+					{
+						type: "thinking",
+						thinking: ["# Legacy 5", "# Legacy 6", "# Legacy 7", "# Legacy 8"].join("\n"),
+					},
+				]),
+				true,
+			);
+			const output = plain(assistant.render(80));
+			const titleRows = output.filter((row) => row.includes("Thinking"));
+			const labelRows = output.filter((row) => row.includes("Legacy"));
+			expect(titleRows).toHaveLength(1);
+			expect(labelRows).toHaveLength(mode === "rail" ? 8 : 5);
+			expect(labelRows.at(0)).toContain(mode === "rail" ? "Legacy 1" : "Legacy 4");
+			expect(labelRows.at(-1)).toContain("Legacy 8");
+			const titleIndex = output.findIndex((row) => row.includes("Thinking"));
+			expect(output.slice(titleIndex, titleIndex + labelRows.length + 1)).not.toContain("");
+		},
+	);
+
+	it.each(["modern", "legacy"] as const)(
+		"marks only an actually open final thinking run in exact %s streaming layouts",
+		(layout) => {
+			if (layout === "modern") bridgeSourceLoadedMarkdownIdentity();
+			else installLegacyThinkingRenderer();
+			for (const mode of ["rail", "tree"] as const) {
+				const value = controller({ enabled: true, mode });
+				expect(value.startSession(context().ctx)).toEqual({ applied: true });
+				const fixtures = [
+					{
+						name: "thinking→text→thinking",
+						content: [
+							{ type: "thinking" as const, thinking: "# Before" },
+							{ type: "text" as const, text: "boundary" },
+							{ type: "thinking" as const, thinking: "# After" },
+						],
+						rail: [" │ Thinking", " │ Before", " boundary", " │ Thinking", " │ • After"],
+						tree: [" ┆ Thinking", " └─ · Before", " boundary", " ┆ Thinking", " └─ • After"],
+					},
+					{
+						name: "thinking→tool→thinking",
+						content: [
+							{ type: "thinking" as const, thinking: "# Before" },
+							{ type: "toolCall" as const, id: "tool", name: "read", arguments: {} },
+							{ type: "thinking" as const, thinking: "# After" },
+						],
+						rail: [" │ Thinking", " │ Before", " │ Thinking", " │ • After"],
+						tree: [" ┆ Thinking", " └─ · Before", " ┆ Thinking", " └─ • After"],
+					},
+					{
+						name: "thinking→text",
+						content: [
+							{ type: "thinking" as const, thinking: "# Before" },
+							{ type: "text" as const, text: "boundary" },
+						],
+						rail: [" │ Thinking", " │ Before", " boundary"],
+						tree: [" ┆ Thinking", " └─ · Before", " boundary"],
+					},
+				] as const;
+				for (const fixture of fixtures) {
+					const assistant = component();
+					assistant.updateContent(messageWithContent([...fixture.content]), true);
+					const exactRows = plain(assistant.render(80)).filter(Boolean);
+					expect(exactRows, `${layout} ${mode} ${fixture.name}`).toEqual(fixture[mode]);
+				}
+				value.shutdown();
+				controllers.delete(value);
+			}
+		},
+	);
+
+	it("does not invoke an accessor setter that mutates native children before throwing", () => {
+		let originalChildren: Component[] = [];
+		const setter = vi.fn((replacement: Component[]) => {
+			originalChildren.splice(0, originalChildren.length, ...replacement);
+			throw new Error("atomic replacement rejected");
+		});
+		installLegacyThinkingRenderer((container, children) => {
+			originalChildren = children;
+			Object.defineProperty(container, "children", {
+				configurable: true,
+				get: () => children,
+				set: setter,
+			});
+		});
+		const value = controller({ enabled: true, mode: "rail" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		expect(() =>
+			assistant.updateContent(
+				messageWithContent([
+					{ type: "thinking", thinking: "# Atomic 1" },
+					{ type: "thinking", thinking: "# Atomic 2" },
+				]),
+				true,
+			),
+		).not.toThrow();
+		const children = (assistant as unknown as { contentContainer: { children: Component[] } })
+			.contentContainer.children;
+		expect(setter).not.toHaveBeenCalled();
+		expect(children).toBe(originalChildren);
+		expect(children.map((child) => child.constructor.name)).toEqual([
+			"Spacer",
+			"Markdown",
+			"Spacer",
+			"Markdown",
+		]);
+		expect(children.some((child) => child.constructor.name === "ThinkingStepsRows")).toBe(false);
+		expect(value.diagnostics.trackedComponents).toBe(0);
+	});
+
+	it.each(["nonwritable", "inherited"] as const)(
+		"retains native identity and output for a %s children property",
+		(shape) => {
+			let originalChildren: Component[] = [];
+			installLegacyThinkingRenderer((container, children) => {
+				originalChildren = children;
+				if (shape === "nonwritable") {
+					Object.defineProperty(container, "children", {
+						configurable: true,
+						writable: false,
+						value: children,
+					});
+				} else {
+					delete (container as { children?: Component[] }).children;
+					const inherited = Object.create(Object.getPrototypeOf(container)) as {
+						children: Component[];
+					};
+					inherited.children = children;
+					Object.setPrototypeOf(container, inherited);
+				}
+			});
+			const value = controller({ enabled: true, mode: "tree" });
+			value.startSession(context().ctx);
+			const assistant = component();
+			assistant.updateContent(message("# Native identity"), true);
+			const container = (assistant as unknown as { contentContainer: { children: Component[] } })
+				.contentContainer;
+			expect(container.children).toBe(originalChildren);
+			const output = plain(assistant.render(80)).join("\n");
+			expect(output).toContain("Native identity");
+			expect(output).not.toMatch(/[│┆][ •]? Thinking|[└├]─/);
+			expect(value.diagnostics.trackedComponents).toBe(0);
+		},
+	);
+
+	it("propagates the predecessor's exact thrown object without decoration containment", () => {
+		const marker = { source: "predecessor" };
+		Object.defineProperty(prototype, "updateContent", {
+			...originalDescriptor,
+			value() {
+				throw marker;
+			},
+		});
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		let caught: unknown;
+		try {
+			component().updateContent(message("# Never decorated"), true);
+		} catch (error) {
+			caught = error;
+		}
+		expect(caught).toBe(marker);
+		expect(value.diagnostics.trackedComponents).toBe(0);
+	});
+
+	it.each([
+		["rail", "hidden"],
+		["rail", "no-thinking"],
+		["tree", "hidden"],
+		["tree", "no-thinking"],
+	] as const)(
+		"drops stale %s state when an authoritative %s predecessor mutates then throws",
+		(mode, transition) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const native = prototype.updateContent;
+			const marker = { source: `${mode}-${transition}` };
+			let throwAfterMutation = false;
+			Object.defineProperty(prototype, "updateContent", {
+				...Object.getOwnPropertyDescriptor(prototype, "updateContent"),
+				value: function mutateThenThrow(this: unknown, ...args: unknown[]) {
+					const result = Reflect.apply(native, this, args);
+					if (throwAfterMutation) throw marker;
+					return result;
+				},
+			});
+			const requestRender = vi.fn();
+			const value = controller({ enabled: true, mode }, Date.now, requestRender);
+			value.startSession(context().ctx);
+			const assistant = component(false);
+			const stale = message("# Stale custom thinking", 84_000);
+			value.beginMessage({ message: stale });
+			assistant.updateContent(stale, true);
+			expect(value.diagnostics).toMatchObject({ trackedComponents: 1, activeComponents: 1 });
+
+			const authoritative =
+				transition === "hidden" ? stale : message("", 84_001, "Authoritative text after failure");
+			if (transition === "hidden")
+				(assistant as unknown as { hideThinkingBlock: boolean }).hideThinkingBlock = true;
+			throwAfterMutation = true;
+			let caught: unknown;
+			try {
+				assistant.updateContent(authoritative, false);
+			} catch (error) {
+				caught = error;
+			}
+			expect(caught).toBe(marker);
+			expect(value.diagnostics).toMatchObject({ trackedComponents: 0, activeComponents: 0 });
+			expect((value as unknown as { timings: Map<number, unknown> }).timings.has(84_000)).toBe(
+				false,
+			);
+			expect(
+				(value as unknown as { currentMessage?: AssistantMessage }).currentMessage,
+			).toBeUndefined();
+			expect(requestRender).not.toHaveBeenCalled();
+
+			value.shutdown();
+			expect(requestRender).not.toHaveBeenCalled();
+			const output = plain(assistant.render(80)).join("\n");
+			if (transition === "hidden") {
+				expect(output).toContain("Thinking...");
+				expect(output).not.toContain("Stale custom thinking");
+			} else {
+				expect(output).toContain("Authoritative text after failure");
+				expect(output).not.toContain("Stale custom thinking");
+			}
+		},
+	);
+
+	it.each(["rail", "tree"] as const)(
+		"drops %s ownership after a visible-to-native-hidden authoritative host update",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			const assistant = component(false);
+			const current = message("# Visible\n# Latest", 81_000);
+			assistant.updateContent(current, true);
+			expect(value.diagnostics.trackedComponents).toBe(1);
+			assistant.setHideThinkingBlock(true);
+			assistant.updateContent(current, true);
+			expect(value.diagnostics).toMatchObject({ trackedComponents: 0, activeComponents: 0 });
+			expect((value as unknown as { timings: Map<number, unknown> }).timings.has(81_000)).toBe(
+				false,
+			);
+			value.shutdown();
+			const rendered = plain(assistant.render(80)).join("\n");
+			expect(rendered).toContain("Thinking...");
+			expect(rendered).not.toContain("Visible");
+		},
+	);
+
+	it.each(["rail", "tree"] as const)(
+		"does not replay stale visible %s args when native-hidden ownership is displaced",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			const assistant = component(false);
+			const current = message("# Stale visible", 82_000);
+			assistant.updateContent(current, true);
+			assistant.setHideThinkingBlock(true);
+			assistant.updateContent(current, true);
+			const zentuiWrapper = prototype.updateContent;
+			Object.defineProperty(prototype, "updateContent", {
+				...Object.getOwnPropertyDescriptor(prototype, "updateContent"),
+				value: function successor(this: unknown, ...args: unknown[]) {
+					return Reflect.apply(zentuiWrapper, this, args);
+				},
+			});
+			expect(value.state.displaced).toBe(true);
+			const rendered = plain(assistant.render(80)).join("\n");
+			expect(rendered).toContain("Thinking...");
+			expect(rendered).not.toContain("Stale visible");
+		},
+	);
+
+	it.each(["streaming", "rail", "tree"] as const)(
+		"drops %s ownership on an authoritative thinking-to-no-thinking update",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			const assistant = component();
+			assistant.updateContent(message("# Old thinking", 83_000), true);
+			expect(value.diagnostics.trackedComponents).toBe(1);
+			assistant.updateContent(message("", 83_001, "Authoritative text only"), false);
+			expect(value.diagnostics).toMatchObject({ trackedComponents: 0, activeComponents: 0 });
+			expect((value as unknown as { timings: Map<number, unknown> }).timings.has(83_000)).toBe(
+				false,
+			);
+			value.shutdown();
+			const rendered = plain(assistant.render(80)).join("\n");
+			expect(rendered).toContain("Authoritative text only");
+			expect(rendered).not.toContain("Old thinking");
+		},
+	);
+
+	it("keeps Streaming temporarily visible while active, then restores the latest native-hidden state", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode: "streaming" }, () => 90_000);
+		value.startSession(context().ctx);
+		const assistant = component(false);
+		const current = message("# Temporarily shown", 89_000);
+		assistant.updateContent(current, true);
+		assistant.setHideThinkingBlock(true);
+		assistant.updateContent(current, true);
+		expect(value.diagnostics.trackedComponents).toBe(1);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking 0.0s");
+		value.shutdown();
+		const rendered = plain(assistant.render(80)).join("\n");
+		expect(rendered).toContain("Thinking...");
+		expect(rendered).not.toContain("Temporarily shown");
+	});
+
+	it.each(["count", "order", "text", "constructor"] as const)(
+		"fails open through one marker-free native rerender on a %s mismatch",
+		(mismatch) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const bridged = prototype.updateContent as (this: unknown, ...args: unknown[]) => unknown;
+			let calls = 0;
+			Object.defineProperty(prototype, "updateContent", {
+				...Object.getOwnPropertyDescriptor(prototype, "updateContent"),
+				value: function mismatchedNative(this: unknown, ...args: unknown[]) {
+					calls += 1;
+					const result = Reflect.apply(bridged, this, args);
+					if (calls !== 1) return result;
+					const children = (
+						this as { contentContainer?: { children?: Array<Record<string, unknown>> } }
+					).contentContainer?.children;
+					if (!children) return result;
+					const markdownIndexes = children.flatMap((child, index) =>
+						child.constructor === Markdown ? [index] : [],
+					);
+					if (mismatch === "count") children.pop();
+					else if (mismatch === "order") {
+						const first = markdownIndexes[0];
+						const second = markdownIndexes[1];
+						if (first !== undefined && second !== undefined)
+							[children[first], children[second]] = [children[second], children[first]];
+					} else {
+						const first = markdownIndexes[0];
+						const child = first === undefined ? undefined : children[first];
+						if (child && mismatch === "text") child.text = "__ZENTUI_MISMATCH_MARKER__";
+						if (child && mismatch === "constructor") Object.setPrototypeOf(child, {});
+					}
+					return result;
+				},
+			});
+			const config: ThinkingStepsComponentConfig = {
+				enabled: true,
+				mode: "streaming",
+			};
+			const value = controller(config);
+			expect(value.startSession(context().ctx)).toEqual({ applied: true });
+			const assistant = component();
+			assistant.updateContent(
+				messageWithContent([
+					{ type: "thinking", thinking: "native A" },
+					{ type: "text", text: "native B" },
+					{ type: "thinking", thinking: "native C" },
+				]),
+				false,
+			);
+			expect(calls).toBe(2);
+			expect(value.state).toMatchObject({ available: false, active: false });
+			const rendered = plain(assistant.render(80)).join("\n");
+			expect(rendered).toContain("native A");
+			expect(rendered).toContain("native B");
+			expect(rendered).toContain("native C");
+			expect(rendered).not.toMatch(/Thinking \d|Thought(?: for)?|ZENTUI_MISMATCH_MARKER/);
+		},
+	);
+
+	it("omits the expansion hint when a live render does not overflow", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config, () => 2_000);
+		value.startSession(host.ctx);
+		const assistant = component();
+		assistant.updateContent(message("one  \ntwo", 1_000), true);
+		const rendered = plain(assistant.render(80)).join("\n");
+		expect(rendered).toContain("Thinking 0.0s");
+		expect(rendered).not.toContain("to expand");
+	});
+
+	it("coalesces activation, timer, completion, and deactivation redraws", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		vi.setSystemTime(10_000);
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		expect(requestRender).toHaveBeenCalledTimes(0);
+
+		const current = message("live redraw reasoning", 5_000);
+		(current as { stopReason: string }).stopReason = "pending";
+		value.beginMessage({ message: current });
+		const assistant = component();
+		assistant.updateContent(current, true);
+		expect(requestRender).toHaveBeenCalledTimes(0);
+		vi.advanceTimersByTime(1_000);
+		expect(requestRender).toHaveBeenCalledTimes(1);
+		value.updateMessage({ message: current, assistantMessageEvent: { type: "text_delta" } });
+		expect(requestRender).toHaveBeenCalledTimes(2);
+		expect(plain(assistant.render(40)).join("\n")).toContain("Thought for 1.0s");
+
+		config.enabled = false;
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(value.state).toMatchObject({ active: false, restartRequired: false });
+		value.shutdown();
+		expect(requestRender).toHaveBeenCalledTimes(3);
+		expect(plain(assistant.render(40)).join("\n")).not.toMatch(/Thinking \d|Thought for/);
+		expect(plain(assistant.render(40)).join("\n")).toContain("live redraw reasoning");
+	});
+
+	it("freezes on stream boundaries, uses Thought without invented restored duration, and cleans resources", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		vi.setSystemTime(10_000);
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		value.startSession(host.ctx);
+		const current = message("private reasoning", 5_000);
+		value.beginMessage({ message: current });
+		const assistant = component();
+		assistant.updateContent(current, true);
+		const beforeTimer = requestRender.mock.calls.length;
+		vi.advanceTimersByTime(1_000);
+		expect(requestRender.mock.calls.length - beforeTimer).toBe(1);
+		value.updateMessage({ message: current, assistantMessageEvent: { type: "text_delta" } });
+		vi.setSystemTime(20_000);
+		assistant.updateContent(current, true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thought for 1.0s");
+
+		const restored = component();
+		restored.updateContent(message("old reasoning", 99), false);
+		expect(plain(restored.render(80)).join("\n")).toContain("Thought  (ctrl+t to expand)");
+		expect(plain(restored.render(80)).join("\n")).not.toContain("Thought for");
+
+		config.enabled = false;
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(value.state).toMatchObject({ active: false, restartRequired: false });
+		value.shutdown();
+		expect(plain(assistant.render(80)).join("\n")).toContain("private reasoning");
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		for (const method of Object.values(host.forbidden)) expect(method).not.toHaveBeenCalled();
+	});
+
+	it("refreshes Pi's latest visible↔hidden preference on every host update and restores ownership", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config, () => 2_000);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		const reasoning = message(
+			Array.from({ length: 8 }, (_, index) => `preference row ${index + 1}  `).join("\n"),
+			1_000,
+		);
+		const visibleToHidden = component(false);
+		const visibleToHiddenState = visibleToHidden as unknown as { hideThinkingBlock: boolean };
+		visibleToHidden.updateContent(reasoning, true);
+		visibleToHidden.setHideThinkingBlock(true);
+		visibleToHidden.updateContent(reasoning, true);
+		expect(Object.hasOwn(visibleToHidden, "hideThinkingBlock")).toBe(true);
+		expect(visibleToHiddenState.hideThinkingBlock).toBe(true);
+		expect(plain(visibleToHidden.render(80)).join("\n")).toContain("Thinking 0.0s");
+
+		const hiddenToVisible = component(true);
+		const hiddenToVisibleState = hiddenToVisible as unknown as { hideThinkingBlock: boolean };
+		hiddenToVisible.updateContent(reasoning, true);
+		hiddenToVisible.setHideThinkingBlock(false);
+		hiddenToVisible.updateContent(reasoning, true);
+		expect(Object.hasOwn(hiddenToVisible, "hideThinkingBlock")).toBe(true);
+		expect(hiddenToVisibleState.hideThinkingBlock).toBe(false);
+		expect(plain(hiddenToVisible.render(80)).join("\n")).toContain("Thinking 0.0s");
+
+		config.enabled = false;
+		expect(value.reconcile()).toEqual({ applied: true });
+		expect(value.state).toMatchObject({ active: false, restartRequired: false });
+		value.shutdown();
+		const hiddenNative = plain(visibleToHidden.render(80)).join("\n");
+		expect(hiddenNative).toContain("Thinking...");
+		expect(hiddenNative).not.toContain("preference row");
+		expect(Object.hasOwn(visibleToHidden, "hideThinkingBlock")).toBe(true);
+		expect(visibleToHiddenState.hideThinkingBlock).toBe(true);
+		const visibleNative = plain(hiddenToVisible.render(80)).join("\n");
+		expect(visibleNative).toContain("preference row 1");
+		expect(visibleNative).not.toMatch(/Thinking \d|Thought(?: for)?/);
+		expect(Object.hasOwn(hiddenToVisible, "hideThinkingBlock")).toBe(true);
+		expect(hiddenToVisibleState.hideThinkingBlock).toBe(false);
+
+		value.shutdown();
+		expect(visibleToHiddenState.hideThinkingBlock).toBe(true);
+		expect(hiddenToVisibleState.hideThinkingBlock).toBe(false);
+		for (const method of Object.values(host.forbidden)) expect(method).not.toHaveBeenCalled();
+	});
+
+	it("honors discovered remaps, falls back only without a definition, and ignores key releases", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const remapped = {
+			getDefinition: vi.fn(() => ({ defaultKeys: "ctrl+y" })),
+			getKeys: vi.fn(() => ["ctrl+y"]),
+			matches: vi.fn((data: string) => data === "\x19" || data.includes("121;5")),
+		};
+		const host = context();
+		const value = controller(
+			config,
+			Date.now,
+			vi.fn(),
+			() => remapped,
+			() => "ctrl+y",
+		);
+		value.startSession(host.ctx);
+		const assistant = component();
+		assistant.updateContent(message("remapped reasoning", 1_000), true);
+		expect(host.input("\x14")).toBeUndefined();
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking");
+		expect(host.input("\x19")).toEqual({ consume: true });
+		expect(plain(assistant.render(80)).join("\n")).toContain("remapped reasoning");
+		expect(host.input("\x1b[121;5:3u")).toEqual({ consume: true });
+		expect(plain(assistant.render(80)).join("\n")).toContain("remapped reasoning");
+		expect(host.input("\x19")).toEqual({ consume: true });
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking");
+
+		value.shutdown();
+		controllers.delete(value);
+		const fallbackHost = context();
+		const fallback = controller(config, Date.now, vi.fn(), () => ({
+			getDefinition: () => undefined,
+			matches: () => false,
+		}));
+		fallback.startSession(fallbackHost.ctx);
+		const fallbackAssistant = component();
+		fallbackAssistant.updateContent(message("fallback reasoning", 2_000), true);
+		expect(fallbackHost.input("\x14")).toEqual({ consume: true });
+		expect(plain(fallbackAssistant.render(80)).join("\n")).toContain("fallback reasoning");
+	});
+
+	it("accepts symbol and modified-symbol bindings and uses labels only when provided", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const cases = [
+			{ key: "?", data: "question", keyText: "Question mark", label: "Question mark" },
+			{ key: "/", data: "slash", keyText: "", label: "/" },
+			{ key: "-", data: "minus", keyText: "   ", label: "-" },
+			{ key: "ctrl+]", data: "modified-bracket", keyText: "Ctrl+]", label: "Ctrl+]" },
+		] as const;
+		for (const testCase of cases) {
+			const host = context();
+			const bindings = {
+				getDefinition: vi.fn(() => ({})),
+				getKeys: vi.fn(() => [testCase.key]),
+				matches: vi.fn((data: string) => data === testCase.data),
+			};
+			const value = controller(
+				config,
+				Date.now,
+				vi.fn(),
+				() => bindings,
+				() => testCase.keyText,
+			);
+			expect(value.startSession(host.ctx)).toEqual({ applied: true });
+			const assistant = component();
+			assistant.updateContent(
+				message(Array.from({ length: 8 }, (_, index) => `symbol row ${index + 1}`).join("\n")),
+				true,
+			);
+			expect(plain(assistant.render(80)).join("\n")).toContain(`(${testCase.label} to expand)`);
+			expect(host.input(testCase.data)).toEqual({ consume: true });
+			expect(bindings.matches).toHaveBeenCalledWith(testCase.data, "app.thinking.toggle");
+			expect(plain(assistant.render(80)).join("\n")).toContain("symbol row 1");
+			value.shutdown();
+			controllers.delete(value);
+		}
+	});
+
+	it("rejects empty and nonstring bindings and deactivates on a throwing matcher", () => {
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		for (const keys of [[], [""], [null], [42]]) {
+			const value = controller(config, Date.now, vi.fn(), () => ({
+				getDefinition: () => ({}),
+				getKeys: () => keys as unknown as string[],
+				matches: () => false,
+			}));
+			expect(value.startSession(context().ctx)).toMatchObject({
+				applied: false,
+				reason: expect.stringContaining("no usable configured binding"),
+			});
+			expect(value.state).toMatchObject({
+				rendererAvailable: true,
+				streamingAvailable: false,
+				active: false,
+			});
+			value.shutdown();
+			controllers.delete(value);
+		}
+
+		bridgeSourceLoadedMarkdownIdentity();
+		const host = context();
+		const throwing = controller(
+			config,
+			Date.now,
+			vi.fn(),
+			() => ({
+				getDefinition: () => ({}),
+				getKeys: () => ["ctrl+y"],
+				matches: () => {
+					throw new Error("matcher failure");
+				},
+			}),
+			() => "ctrl+y",
+		);
+		expect(throwing.startSession(host.ctx)).toEqual({ applied: true });
+		const assistant = component();
+		assistant.updateContent(message("must restore native", 3_000), true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking");
+		expect(host.input("\x19")).toBeUndefined();
+		expect(throwing.state).toMatchObject({
+			rendererAvailable: true,
+			streamingAvailable: false,
+			active: false,
+			reason: "Pi's thinking-toggle matcher failed at runtime",
+		});
+		const restored = plain(assistant.render(80)).join("\n");
+		expect(restored).toContain("must restore native");
+		expect(restored).not.toMatch(/Thinking \d|Thought(?: for)?/);
+	});
+
+	it("bounds settled history, restores an evicted native-hidden fold, and times only active refs", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		vi.useFakeTimers();
+		vi.setSystemTime(10_000);
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		expect(value.startSession(context().ctx)).toEqual({ applied: true });
+		const first = component(true);
+		first.updateContent(message("evicted native-hidden reasoning", 1), false);
+		for (let index = 1; index <= THINKING_EXPERIMENTAL_MAX_TRACKED_COMPONENTS; index += 1) {
+			component().updateContent(message(`settled reasoning ${index}`, index + 1), false);
+		}
+		expect(value.diagnostics).toMatchObject({
+			trackedComponents: THINKING_EXPERIMENTAL_MAX_TRACKED_COMPONENTS,
+			activeComponents: 0,
+		});
+		const restored = plain(first.render(80)).join("\n");
+		expect(restored).toContain("Thinking...");
+		expect(restored).not.toContain("evicted native-hidden reasoning");
+		expect((first as unknown as { hideThinkingBlock: boolean }).hideThinkingBlock).toBe(true);
+
+		const live = component();
+		const pending = message("only active timer work", 50_000);
+		(pending as { stopReason: string }).stopReason = "pending";
+		live.updateContent(pending, true);
+		expect(value.diagnostics).toMatchObject({
+			trackedComponents: THINKING_EXPERIMENTAL_MAX_TRACKED_COMPONENTS,
+			activeComponents: 1,
+		});
+		vi.advanceTimersByTime(1_000);
+		expect(value.diagnostics.lastTimerWork).toBe(1);
+		value.updateMessage({ message: pending, assistantMessageEvent: { type: "text_delta" } });
+		expect(value.diagnostics.activeComponents).toBe(0);
+	});
+
+	it("bounds current-session timings even for text-only assistant events", () => {
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const value = controller(config, () => 50_000);
+		value.startSession(context().ctx);
+		for (let index = 0; index < 300; index += 1) {
+			const textOnly = message("", index + 1, `answer ${index}`);
+			textOnly.content = [{ type: "text", text: `answer ${index}` }];
+			value.beginMessage({ message: textOnly });
+			value.endMessage({ message: textOnly });
+		}
+		const timings = (value as unknown as { timings: Map<number, unknown> }).timings;
+		expect(timings.size).toBe(256);
+		expect(timings.has(1)).toBe(false);
+		expect(timings.has(300)).toBe(true);
+	});
+
+	it("derives a pending live render without a boolean argument and keeps completed messages settled", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const value = controller(config, () => 5_000);
+		value.startSession(context().ctx);
+		const live = message("live no-argument reasoning", 4_000);
+		(live as { stopReason: string }).stopReason = "pending";
+		const liveAssistant = component();
+		liveAssistant.updateContent(live);
+		expect(plain(liveAssistant.render(80)).join("\n")).toContain("Thinking 0.0s");
+
+		const completed = component();
+		completed.updateContent(message("completed no-argument reasoning", 3_000));
+		expect(plain(completed.render(80)).join("\n")).toContain("Thought");
+		expect(plain(completed.render(80)).join("\n")).not.toContain("Thinking 0.0s");
+	});
+
+	it("logically displaces an older same-adapter controller while preserving the shared wrapper", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const firstHost = context();
+		const firstRender = vi.fn();
+		const first = controller(config, Date.now, firstRender);
+		first.startSession(firstHost.ctx);
+		const wrapper = prototype.updateContent;
+		const assistant = component();
+		assistant.updateContent(
+			message(
+				Array.from({ length: 8 }, (_, index) => `first owner row ${index + 1}  `).join("\n"),
+				1_000,
+			),
+			false,
+		);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thought");
+
+		const secondHost = context();
+		const secondRender = vi.fn();
+		const second = controller(config, Date.now, secondRender);
+		expect(second.startSession(secondHost.ctx)).toEqual({ applied: true });
+		expect(prototype.updateContent).toBe(wrapper);
+		expect(firstHost.input("\x14")).toBeUndefined();
+		expect(first.state).toMatchObject({ active: false, displaced: true });
+		const restored = plain(assistant.render(80)).join("\n");
+		expect(restored).not.toMatch(/Thinking \d|Thought(?: for)?/);
+		expect(restored).toContain("first owner row 1");
+		expect(restored).toContain("first owner row 8");
+		expect(firstRender).toHaveBeenCalledTimes(1);
+		expect(secondRender).toHaveBeenCalledTimes(0);
+		expect(second.state).toMatchObject({ active: true, displaced: false });
+		first.shutdown();
+		controllers.delete(first);
+		expect(prototype.updateContent).toBe(wrapper);
+		second.shutdown();
+		controllers.delete(second);
+		expect(prototype.updateContent).not.toBe(wrapper);
+	});
+
+	it("aborts a failed multi-component fold and restores every original hidden state once", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, () => 5_000, requestRender);
+		value.startSession(host.ctx);
+		const early = component();
+		const laterHidden = component(true);
+		const earlyMessage = message("early original reasoning", 1_000);
+		const hiddenMessage = message("later native hidden reasoning", 2_000);
+		early.updateContent(earlyMessage, true);
+		laterHidden.updateContent(hiddenMessage, true);
+
+		const states = (
+			value as unknown as {
+				states: WeakMap<object, { args: unknown[] }>;
+			}
+		).states;
+		const earlyState = states.get(early);
+		expect(earlyState).toBeDefined();
+		if (earlyState) earlyState.args = [message("incompatible replacement", 1_000), true];
+		value.updateMessage({
+			message: earlyMessage,
+			assistantMessageEvent: { type: "text_delta" },
+		});
+
+		expect(value.state).toMatchObject({ available: false, active: false });
+		expect(requestRender).toHaveBeenCalledTimes(1);
+		const earlyNative = plain(early.render(80)).join("\n");
+		expect(earlyNative).toContain("incompatible replacement");
+		expect(earlyNative).not.toMatch(/Thinking \d|Thought(?: for)?/);
+		const laterNative = plain(laterHidden.render(80)).join("\n");
+		expect(laterNative).toContain("Thinking...");
+		expect(laterNative).not.toContain("later native hidden reasoning");
+		expect((laterHidden as unknown as { hideThinkingBlock: boolean }).hideThinkingBlock).toBe(true);
+	});
+
+	it("makes a permanent renderer-shape failure reject retries", () => {
+		const native = originalDescriptor?.value as (this: unknown, ...args: unknown[]) => unknown;
+		Object.defineProperty(prototype, "updateContent", {
+			...originalDescriptor,
+			value: function incompatible(this: { contentContainer?: { children?: object[] } }) {
+				this.contentContainer = { children: [] };
+			},
+		});
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const value = controller(config);
+		expect(value.startSession(host.ctx)).toEqual({ applied: true });
+		Reflect.apply(prototype.updateContent, {}, [message("incompatible")]);
+		expect(value.state).toMatchObject({ available: false, active: false });
+		expect(value.startSession(host.ctx)).toMatchObject({ applied: false });
+		expect(prototype.updateContent).not.toBe(native);
+	});
+
+	it("fails open on foreign displacement and compare-and-swap cleanup preserves the successor", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const config: ThinkingStepsComponentConfig = {
+			enabled: true,
+			mode: "streaming",
+		};
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller(config, Date.now, requestRender);
+		value.startSession(host.ctx);
+		const assistant = component();
+		assistant.updateContent(
+			message(
+				Array.from({ length: 8 }, (_, index) => `displaced native row ${index + 1}  `).join("\n"),
+				1_000,
+			),
+			false,
+		);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thought");
+		const zentuiWrapper = prototype.updateContent;
+		const foreign = function foreignUpdate(this: unknown, ...args: unknown[]) {
+			return Reflect.apply(zentuiWrapper, this, args);
+		};
+		Object.defineProperty(prototype, "updateContent", {
+			...Object.getOwnPropertyDescriptor(prototype, "updateContent"),
+			value: foreign,
+		});
+		expect(value.state).toMatchObject({
+			available: false,
+			active: false,
+			displaced: true,
+			restartRequired: true,
+		});
+		const restored = plain(assistant.render(80)).join("\n");
+		expect(restored).not.toMatch(/Thinking \d|Thought(?: for)?/);
+		expect(restored).toContain("displaced native row 1");
+		expect(restored).toContain("displaced native row 8");
+		expect(requestRender).toHaveBeenCalledTimes(1);
+		expect(host.stopInput).toHaveBeenCalledTimes(1);
+		value.shutdown();
+		expect(prototype.updateContent).toBe(foreign);
+	});
+});