@selesai/code 0.13.40 → 0.14.3

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

@@ -9,9 +9,12 @@ 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 {
+	hasThinkingExperimentalMarkdownIdentity,
 	THINKING_EXPERIMENTAL_MAX_TRACKED_COMPONENTS,
 	ThinkingExperimentalController,
+	ThinkingStepsRows,
 } from "../extensions/zentui/thinking-experimental";
+import * as ThinkingStepsParser from "../extensions/zentui/thinking-steps";
 
 initTheme("dark", false);
 
@@ -123,6 +126,17 @@ function component(hideThinkingBlock = false): AssistantMessageComponent {
 	);
 }
 
+function visibleNativeChild(child: object): object {
+	// Pi 0.85+ keeps the native Markdown inside a MouseRegion.
+	return "onMouse" in child &&
+		typeof child.onMouse === "function" &&
+		"child" in child &&
+		child.child !== null &&
+		typeof child.child === "object"
+		? child.child
+		: child;
+}
+
 // 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 {
@@ -139,29 +153,39 @@ function bridgeSourceLoadedMarkdownIdentity(): void {
 			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);
+				const visible = visibleNativeChild(child);
+				const expected = constructors.get(visible.constructor.name);
+				if (expected && Object.getPrototypeOf(visible) !== expected)
+					Object.setPrototypeOf(visible, expected);
 			}
 			return result;
 		},
 	});
 }
 
-function installLegacyThinkingRenderer(
+function installCoalescedThinkingRenderer(
 	afterNative?: (container: { children: Component[] }, children: Component[]) => void,
 ): void {
 	Object.defineProperty(prototype, "updateContent", {
 		...originalDescriptor,
-		value: function legacyThinkingChildren(
+		value: function coalescedThinkingChildren(
 			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()) {
+			for (let index = 0; index < value.content.length; index++) {
+				const part = value.content[index];
+				if (part.type === "thinking") {
+					const blocks: string[] = [];
+					for (; index < value.content.length; index++) {
+						const next = value.content[index];
+						if (next.type !== "thinking") break;
+						if (next.thinking.trim()) blocks.push(next.thinking.trim());
+					}
+					index--;
+					if (!blocks.length) continue;
 					children.push(
-						new Markdown(part.thinking.trim(), 1, 0, markdownTheme, {
+						new Markdown(blocks.join("\n\n"), 1, 0, markdownTheme, {
 							color: identity,
 							italic: true,
 						}),
@@ -215,6 +239,490 @@ function controller(
 }
 
 describe("Thinking (Experimental) private assistant decorator", () => {
+	it("replaces cached rows on streamed source changes and completion, even for in-place message updates", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		const fixture = message("# First\nbody");
+		const decorated = () =>
+			visibleNativeChild(
+				(assistant as unknown as { contentContainer: { children: object[] } }).contentContainer
+					.children[1],
+			);
+		assistant.updateContent(fixture, true);
+		const initial = decorated();
+		expect(initial).toBeInstanceOf(ThinkingStepsRows);
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ • First");
+		fixture.content = [{ type: "thinking", thinking: "# Replacement\nbody" }];
+		assistant.updateContent(fixture, true);
+		expect(decorated()).not.toBe(initial);
+		const updated = plain(assistant.render(80)).join("\n");
+		expect(updated).toContain("└─ • Replacement");
+		expect(updated).not.toContain("First");
+		const streaming = decorated();
+		assistant.updateContent(fixture, false);
+		expect(decorated()).not.toBe(streaming);
+		expect(plain(assistant.render(80)).join("\n")).toContain("└─ · Replacement");
+	});
+
+	it("drops cached row trees from live children and controller snapshots on shutdown", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		assistant.updateContent(message("# Historical label\nbody"), false);
+		assistant.render(80);
+		const children = () =>
+			(
+				assistant as unknown as { contentContainer: { children: object[] } }
+			).contentContainer.children.map(visibleNativeChild);
+		expect(children().some((child) => child instanceof ThinkingStepsRows)).toBe(true);
+		value.shutdown();
+		expect(children().some((child) => child instanceof ThinkingStepsRows)).toBe(false);
+		expect(value.diagnostics.trackedComponents).toBe(0);
+		expect(value.diagnostics.activeComponents).toBe(0);
+		expect(plain(assistant.render(80)).join("\n")).not.toContain("┆ Thinking");
+	});
+
+	it.each(
+		(["tree", "rail"] as const).flatMap((mode) =>
+			["```ts", "~~~", "$$", "\\["].map((opening) => ({ mode, opening })),
+		),
+	)("retains $mode during an append-only unfinished $opening body", ({ mode, opening }) => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode });
+		value.startSession(context().ctx);
+		const assistant = component();
+		const source = "# Plan\nbody";
+		assistant.updateContent(message(source), true);
+		const initial = plain(assistant.render(80));
+		const partial = `${source}\n\n${opening}\nconst x = 1;`;
+		assistant.updateContent(message(partial), true);
+		expect(plain(assistant.render(80))).toEqual(initial);
+		assistant.updateContent(message(`${partial}\nmore body`), true);
+		expect(plain(assistant.render(80))).toEqual(initial);
+		const closing = opening === "```ts" ? "```" : opening === "\\[" ? "\\]" : opening;
+		assistant.updateContent(message(`${partial}\n${closing}`), true);
+		expect(plain(assistant.render(80))).toEqual(initial);
+	});
+
+	it.each(["tree", "rail"] as const)(
+		"fails open for nonrecoverable %s streaming updates",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			const source = "# Plan\nbody";
+			for (const next of [
+				"# Replacement\nbody\n```\nunfinished",
+				`${source}\n\n# ![image](asset.png)\n\n\`\`\`\nunfinished`,
+				`${source}\n\n# ${"x".repeat(513)}\n\n$$\nunfinished`,
+				`${source}\n\n\`\`\`bad\`info\nunfinished`,
+				`${source}\n\n\`\`\`\nunsafe\x1b[2J`,
+				`${source}\n\n$$\n${"x".repeat(65_536)}`,
+				`${source}\n${Array.from({ length: 128 }, (_, index) => `# Step ${index}`).join("\n")}\n$$`,
+			]) {
+				const assistant = component();
+				assistant.updateContent(message(source), true);
+				assistant.render(80);
+				assistant.updateContent(message(next), true);
+				const native = visibleNativeChild(
+					(assistant as unknown as { contentContainer: { children: object[] } }).contentContainer
+						.children[1],
+				);
+				expect(native).toBeInstanceOf(Markdown);
+			}
+		},
+	);
+
+	it.each(["tree", "rail"] as const)(
+		"does not retain %s without a prior successful presentation or active run",
+		(mode) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			const source = "# Plan\nbody";
+			const partial = `${source}\n\n\`\`\`\nunfinished`;
+			for (const condition of [
+				"first",
+				"unrendered",
+				"narrow",
+				"new-message",
+				"not-active",
+			] as const) {
+				const assistant = component();
+				if (condition !== "first") assistant.updateContent(message(source), true);
+				if (condition === "narrow") assistant.render(1);
+				if (condition === "new-message" || condition === "not-active") assistant.render(80);
+				assistant.updateContent(
+					message(
+						partial,
+						condition === "new-message" ? 2_000 : 1_000,
+						condition === "not-active" ? "answer" : undefined,
+					),
+					true,
+				);
+				expect(plain(assistant.render(80)).join("\n")).not.toContain(
+					mode === "tree" ? "┆ Thinking" : "│ Thinking",
+				);
+			}
+		},
+	);
+
+	it("drops retained presentation on a same-label body revision and on a native per-run hide", () => {
+		const overrides = new Map<number, boolean>();
+		installCoalescedThinkingRenderer((_container, children) => {
+			const child = overrides.get(0) ? new Text("Thinking...", 1, 0) : children[1];
+			const region = {
+				child,
+				onMouse: () => undefined,
+				render(width: number) {
+					return this.child.render(width);
+				},
+				invalidate() {
+					this.child.invalidate();
+				},
+			};
+			children[1] = region;
+		});
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		const source = "# Plan\nbody";
+		const partial = `${source}\n\n\`\`\`\nunfinished`;
+		const prime = () => {
+			assistant.updateContent(message(source), true);
+			assistant.render(80);
+			assistant.updateContent(message(partial), true);
+			expect(plain(assistant.render(80)).join("\n")).toContain("┆ Thinking");
+		};
+		prime();
+		assistant.updateContent(message(partial.replace("unfinished", "replacement")), true);
+		expect(plain(assistant.render(80)).join("\n")).not.toContain("┆ Thinking");
+		prime();
+		Object.assign(assistant, { thinkingVisibilityOverrides: overrides });
+		overrides.set(0, true);
+		assistant.updateContent(message(partial), true);
+		expect(plain(assistant.render(80)).join("\n")).toContain("Thinking...");
+		overrides.set(0, false);
+		assistant.updateContent(message(partial), true);
+		expect(plain(assistant.render(80)).join("\n")).not.toContain("┆ Thinking");
+	});
+
+	it.each(["host", "event"] as const)(
+		"restores final malformed content on %s completion",
+		(completion) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const value = controller({ enabled: true, mode: "tree" });
+			value.startSession(context().ctx);
+			const assistant = component();
+			const source = "# Plan\nbody";
+			assistant.updateContent(message(source), true);
+			assistant.render(80);
+			const final = message(`${source}\n\n$$\nunfinished`);
+			assistant.updateContent(final, true);
+			expect(plain(assistant.render(80)).join("\n")).toContain("┆ Thinking");
+			if (completion === "host") assistant.updateContent(final, false);
+			else value.endMessage({ message: final });
+			const output = plain(assistant.render(80)).join("\n");
+			expect(output).not.toContain("┆ Thinking");
+			expect(output).toContain("unfinished");
+		},
+	);
+
+	it.each(["theme", "hide", "disable", "mode"] as const)(
+		"clears retained steps at the %s boundary",
+		(boundary) => {
+			bridgeSourceLoadedMarkdownIdentity();
+			const config: ThinkingStepsComponentConfig = { enabled: true, mode: "tree" };
+			const value = controller(config);
+			value.startSession(context().ctx);
+			const assistant = component();
+			const source = "# Plan\nbody";
+			assistant.updateContent(message(source), true);
+			assistant.render(80);
+			const partial = message(`${source}\n\n$$\nunfinished`);
+			assistant.updateContent(partial, true);
+			expect(plain(assistant.render(80)).join("\n")).toContain("┆ Thinking");
+			if (boundary === "theme") assistant.invalidate();
+			else if (boundary === "hide") {
+				assistant.setHideThinkingBlock(true);
+				expect(plain(assistant.render(80)).join("\n")).toContain("Thinking...");
+				assistant.setHideThinkingBlock(false);
+			} else {
+				if (boundary === "mode") config.mode = "rail";
+				else config.enabled = false;
+				value.reconcile();
+			}
+			expect(plain(assistant.render(80)).join("\n")).not.toMatch(/[┆│] Thinking/);
+			expect(plain(assistant.render(80)).join("\n")).toContain("unfinished");
+		},
+	);
+
+	it("parses unchanged runs once across 100 native answer updates, then invalidates on source/theme/hidden changes", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const parse = vi.spyOn(ThinkingStepsParser, "parseThinkingStepsResult");
+		try {
+			const value = controller({ enabled: true, mode: "tree" });
+			value.startSession(context().ctx);
+			const assistant = component();
+			const source = `# Plan\n${"x".repeat(60_000)}`;
+			for (let index = 0; index < 100; index += 1) {
+				assistant.updateContent(message(source, 1_000, `answer ${index}`), true);
+				expect(plain(assistant.render(80)).join("\n")).toContain(`answer ${index}`);
+			}
+			expect(parse).toHaveBeenCalledTimes(1);
+			assistant.invalidate();
+			expect(parse).toHaveBeenCalledTimes(2);
+			assistant.updateContent(message(`${source}y`, 1_000, "answer"), true);
+			expect(parse).toHaveBeenCalledTimes(3);
+			assistant.setHideThinkingBlock(true);
+			assistant.setHideThinkingBlock(false);
+			expect(parse).toHaveBeenCalledTimes(4);
+		} finally {
+			parse.mockRestore();
+		}
+	});
+
+	it("does not reuse retained presentation when a host mutates the message identity in place", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		const fixture = message("# Plan\nbody");
+		assistant.updateContent(fixture, true);
+		assistant.render(80);
+		fixture.timestamp += 1_000;
+		fixture.content = [{ type: "thinking", thinking: "# Plan\nbody\n\n$$\nunfinished" }];
+		assistant.updateContent(fixture, true);
+		expect(plain(assistant.render(80)).join("\n")).not.toContain("┆ Thinking");
+	});
+
+	it("bounds the combined retained parse source across runs and discards snapshots on shutdown", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		assistant.updateContent(
+			messageWithContent([
+				{ type: "thinking", thinking: `# First\n${"x".repeat(40_000)}` },
+				{ type: "text", text: "between" },
+				{ type: "thinking", thinking: `# Second\n${"y".repeat(40_000)}` },
+			]),
+			true,
+		);
+		assistant.render(80);
+		const states = (
+			value as unknown as {
+				states: WeakMap<object, { structuralCache: { entries: Map<number, { source: string }> } }>;
+			}
+		).states;
+		const entries = states.get(assistant)?.structuralCache.entries;
+		if (!entries) throw new Error("expected retained parse entries");
+		expect(entries.size).toBe(1);
+		expect(entries.has(1)).toBe(true);
+		expect(
+			[...entries.values()].reduce((total, entry) => total + entry.source.length, 0),
+		).toBeLessThanOrEqual(65_536);
+		value.shutdown();
+		expect(value.diagnostics.trackedComponents).toBe(0);
+	});
+
+	it("keeps cached structural parsing behind exact native child validation", () => {
+		let incompatible = false;
+		installCoalescedThinkingRenderer((_container, children) => {
+			if (incompatible) children.push(new Text("foreign child"));
+		});
+		const value = controller({ enabled: true, mode: "tree" });
+		value.startSession(context().ctx);
+		const assistant = component();
+		const fixture = message("# Plan\nbody");
+		assistant.updateContent(fixture, true);
+		assistant.render(80);
+		incompatible = true;
+		assistant.updateContent(fixture, true);
+		expect(value.state.active).toBe(false);
+		expect(plain(assistant.render(80)).join("\n")).toContain("foreign child");
+		expect(plain(assistant.render(80)).join("\n")).not.toContain("┆ Thinking");
+	});
+
+	it("does not reattach or redraw elapsed headers after foreign child displacement", () => {
+		vi.useFakeTimers();
+		installCoalescedThinkingRenderer();
+		const requestRender = vi.fn();
+		const value = controller({ enabled: true, mode: "streaming" }, Date.now, requestRender);
+		value.startSession(context().ctx);
+		const assistant = component();
+		assistant.updateContent(message("# Plan\nbody"), true);
+		const container = (assistant as unknown as { contentContainer: { children: Component[] } })
+			.contentContainer;
+		const foreign = new Text("foreign child");
+		container.children = [foreign];
+		vi.advanceTimersByTime(1_000);
+		expect(container.children).toEqual([foreign]);
+		expect(value.diagnostics.lastTimerWork).toBe(0);
+		expect(requestRender).not.toHaveBeenCalled();
+	});
+
+	it("advances Streaming headers without rebuilding native content or unchanged header Markdown", () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(10_000);
+		const nativeUpdates = vi.fn();
+		installCoalescedThinkingRenderer(nativeUpdates);
+		const host = context();
+		const requestRender = vi.fn();
+		const value = controller({ enabled: true, mode: "streaming" }, Date.now, requestRender);
+		value.startSession(host.ctx);
+		const assistant = component();
+		const source = `# Plan\n${"long body ".repeat(6_000)}`;
+		assistant.updateContent(message(source), true);
+		const render = vi.spyOn(Markdown.prototype, "render");
+		const setText = vi.spyOn(Markdown.prototype, "setText");
+		try {
+			assistant.render(80);
+			const header = render.mock.instances.find((instance) =>
+				(instance as unknown as { text: string }).text.startsWith("Thinking 0.0s"),
+			);
+			expect(header).toBeDefined();
+			nativeUpdates.mockClear();
+			render.mockClear();
+			requestRender.mockClear();
+			for (let second = 1; second <= 10; second += 1) {
+				vi.advanceTimersByTime(1_000);
+				expect(plain(assistant.render(80)).join("\n")).toContain(`Thinking ${second}.0s`);
+				assistant.render(80);
+			}
+			expect(nativeUpdates).not.toHaveBeenCalled();
+			expect(render.mock.instances.every((instance) => instance === header)).toBe(true);
+			expect(render).toHaveBeenCalledTimes(20);
+			expect(setText).toHaveBeenCalledTimes(10);
+			expect(requestRender).toHaveBeenCalledTimes(10);
+			render.mockClear();
+			assistant.render(40);
+			expect(render).toHaveBeenCalledTimes(2); // body + header at the new width
+			assistant.render(40);
+			expect(render).toHaveBeenCalledTimes(3); // header only on the repeated paint
+			const section = (assistant as unknown as { contentContainer: { children: Component[] } })
+				.contentContainer.children[1];
+			section.invalidate();
+			render.mockClear();
+			assistant.render(40);
+			expect(render).toHaveBeenCalledTimes(2);
+			expect(render.mock.instances).not.toContain(header);
+			host.input("\x14");
+			nativeUpdates.mockClear();
+			requestRender.mockClear();
+			vi.advanceTimersByTime(10_000);
+			expect(nativeUpdates).not.toHaveBeenCalled();
+			expect(requestRender).not.toHaveBeenCalled();
+		} finally {
+			render.mockRestore();
+			setText.mockRestore();
+		}
+	});
+	it.each(
+		(["rail", "tree", "streaming"] as const).flatMap((mode) =>
+			[false, true].map((emptyRun) => ({ mode, emptyRun })),
+		),
+	)(
+		"preserves native clicks and restoration in $mode (empty run: $emptyRun)",
+		({ mode, emptyRun }) => {
+			const assistant = component();
+			const overrides = new Map<number, boolean>();
+			Object.assign(assistant, { thinkingVisibilityOverrides: overrides });
+			const fixture = emptyRun
+				? messageWithContent([
+						{ type: "thinking", thinking: " " },
+						{ type: "text", text: "separator" },
+						{ type: "thinking", thinking: "# Clickable step" },
+					])
+				: message("# Clickable step");
+			const childIndex = emptyRun ? 2 : 1;
+			let region: {
+				child: Component;
+				onMouse: () => { handled: boolean };
+				handleMouse: () => { handled: boolean };
+				render: (width: number) => string[];
+				invalidate: () => void;
+			};
+			installCoalescedThinkingRenderer((_container, children) => {
+				const child = overrides.get(0) ? new Text("Thinking...", 1, 0) : children[childIndex];
+				region = {
+					child,
+					onMouse() {
+						overrides.set(0, !overrides.get(0));
+						assistant.updateContent(fixture, false);
+						return { handled: true };
+					},
+					handleMouse() {
+						return this.onMouse();
+					},
+					render(width) {
+						return this.child.render(width);
+					},
+					invalidate() {
+						this.child.invalidate();
+					},
+				};
+				children[childIndex] = region;
+			});
+			const value = controller({ enabled: true, mode });
+			value.startSession(context().ctx);
+			assistant.updateContent(fixture, false);
+			for (const width of [1, 80]) {
+				const children = (assistant as unknown as { contentContainer: { children: Component[] } })
+					.contentContainer.children;
+				expect(children[childIndex]).toBe(region!);
+				assistant.render(width);
+				expect(region!.handleMouse()).toEqual({ handled: true });
+				expect(overrides.get(0)).toBe(true);
+				expect(value.state.rendererAvailable).toBe(true);
+				expect(plain(assistant.render(80)).join("\n")).toContain("Thinking...");
+				expect(region!.handleMouse()).toEqual({ handled: true });
+				expect(overrides.get(0)).toBe(false);
+				expect(value.state.active).toBe(true);
+			}
+			value.shutdown();
+			expect(region!.child).toBeInstanceOf(Markdown);
+			expect(region!.handleMouse()).toEqual({ handled: true });
+			expect(overrides.get(0)).toBe(true);
+		},
+	);
+
+	it("matches Pi 0.85 MouseRegion-wrapped thinking Markdown", () => {
+		const thinking = "# Wrapped step";
+		const markdown = new Markdown(thinking, 1, 0, markdownTheme, {
+			color: identity,
+			italic: true,
+		});
+		const region = {
+			child: markdown,
+			onMouse: () => undefined,
+			render: (width: number) => markdown.render(width),
+		};
+		const contentContainer = { children: [new Spacer(1), region] };
+		expect(hasThinkingExperimentalMarkdownIdentity({ contentContainer }, message(thinking))).toBe(
+			true,
+		);
+	});
+
+	it("does not unwrap a nested child without onMouse", () => {
+		const thinking = "# Nested step";
+		const markdown = new Markdown(thinking, 1, 0, markdownTheme, {
+			color: identity,
+			italic: true,
+		});
+		const nested = {
+			child: markdown,
+			render: (width: number) => markdown.render(width),
+		};
+		const contentContainer = { children: [new Spacer(1), nested] };
+		expect(hasThinkingExperimentalMarkdownIdentity({ contentContainer }, message(thinking))).toBe(
+			false,
+		);
+	});
+
 	it.each(["rail", "tree"] as const)(
 		"installs %s only at enabled startup, preserves hidden native thinking, and owns no input",
 		(mode) => {
@@ -405,7 +913,7 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 
 	it("does not fold the first pending Streaming message when timer startup fails", () => {
 		let nativeChildren: Component[] | undefined;
-		installLegacyThinkingRenderer((_container, children) => {
+		installCoalescedThinkingRenderer((_container, children) => {
 			nativeChildren = children;
 		});
 		const config: ThinkingStepsComponentConfig = { enabled: true, mode: "streaming" };
@@ -773,9 +1281,9 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 	});
 
 	it.each(["rail", "tree"] as const)(
-		"groups a legacy adjacent thinking run into one %s title and run-level selection",
+		"groups a coalesced adjacent thinking run into one %s title and run-level selection",
 		(mode) => {
-			installLegacyThinkingRenderer();
+			installCoalescedThinkingRenderer();
 			const value = controller({ enabled: true, mode });
 			expect(value.startSession(context().ctx)).toEqual({ applied: true });
 			const assistant = component();
@@ -783,77 +1291,73 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 				messageWithContent([
 					{
 						type: "thinking",
-						thinking: ["# Legacy 1", "# Legacy 2", "# Legacy 3", "# Legacy 4"].join("\n"),
+						thinking: ["# Adjacent 1", "# Adjacent 2", "# Adjacent 3", "# Adjacent 4"].join("\n"),
 					},
 					{
 						type: "thinking",
-						thinking: ["# Legacy 5", "# Legacy 6", "# Legacy 7", "# Legacy 8"].join("\n"),
+						thinking: ["# Adjacent 5", "# Adjacent 6", "# Adjacent 7", "# Adjacent 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"));
+			const labelRows = output.filter((row) => row.includes("Adjacent"));
 			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");
+			expect(labelRows.at(0)).toContain(mode === "rail" ? "Adjacent 1" : "Adjacent 4");
+			expect(labelRows.at(-1)).toContain("Adjacent 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("marks only an actually open final thinking run in exact supported streaming layouts", () => {
+		bridgeSourceLoadedMarkdownIdentity();
+		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, `${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[] = [];
@@ -861,7 +1365,7 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 			originalChildren.splice(0, originalChildren.length, ...replacement);
 			throw new Error("atomic replacement rejected");
 		});
-		installLegacyThinkingRenderer((container, children) => {
+		installCoalescedThinkingRenderer((container, children) => {
 			originalChildren = children;
 			Object.defineProperty(container, "children", {
 				configurable: true,
@@ -885,12 +1389,7 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 			.contentContainer.children;
 		expect(setter).not.toHaveBeenCalled();
 		expect(children).toBe(originalChildren);
-		expect(children.map((child) => child.constructor.name)).toEqual([
-			"Spacer",
-			"Markdown",
-			"Spacer",
-			"Markdown",
-		]);
+		expect(children.map((child) => child.constructor.name)).toEqual(["Spacer", "Markdown"]);
 		expect(children.some((child) => child.constructor.name === "ThinkingStepsRows")).toBe(false);
 		expect(value.diagnostics.trackedComponents).toBe(0);
 	});
@@ -899,7 +1398,7 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 		"retains native identity and output for a %s children property",
 		(shape) => {
 			let originalChildren: Component[] = [];
-			installLegacyThinkingRenderer((container, children) => {
+			installCoalescedThinkingRenderer((container, children) => {
 				originalChildren = children;
 				if (shape === "nonwritable") {
 					Object.defineProperty(container, "children", {
@@ -1116,7 +1615,7 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 					).contentContainer?.children;
 					if (!children) return result;
 					const markdownIndexes = children.flatMap((child, index) =>
-						child.constructor === Markdown ? [index] : [],
+						visibleNativeChild(child).constructor === Markdown ? [index] : [],
 					);
 					if (mismatch === "count") children.pop();
 					else if (mismatch === "order") {
@@ -1126,8 +1625,9 @@ describe("Thinking (Experimental) private assistant decorator", () => {
 							[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__";
+						const child = first === undefined ? undefined : visibleNativeChild(children[first]);
+						if (child && mismatch === "text")
+							Reflect.set(child, "text", "__ZENTUI_MISMATCH_MARKER__");
 						if (child && mismatch === "constructor") Object.setPrototypeOf(child, {});
 					}
 					return result;