@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-zentui/test/settings-command.test.ts

@@ -8,6 +8,8 @@ import {
 	type FooterComponentConfig,
 	type PolishedTuiConfig,
 	type SelectorBordersComponentConfig,
+	type ThinkingStepsComponentConfig,
+	type ThinkingStepsMode,
 	type UserMessagesComponentConfig,
 	type WorkingLineComponentPatch,
 } from "../extensions/zentui/config";
@@ -23,6 +25,7 @@ const sectionNames = [
 	"Appearance",
 	"Editor",
 	"User messages",
+	"Thinking",
 	"Working line",
 	"Footer",
 	"Segments",
@@ -121,6 +124,7 @@ function createHarness(
 	let command: Command | undefined;
 	let component: Component | undefined;
 	const notifications: string[] = [];
+	const notificationEvents: Array<{ message: string; severity: string }> = [];
 	let doneCalls = 0;
 	const sessionLifecycle = new SessionLifecycle();
 	const calls = {
@@ -129,6 +133,7 @@ function createHarness(
 		polishedCopyFriendly: [] as Array<Record<string, unknown>>,
 		accentRail: [] as Array<Record<string, unknown>>,
 		messages: [] as Partial<UserMessagesComponentConfig>[],
+		thinkingSteps: [] as Partial<ThinkingStepsComponentConfig>[],
 		workingLine: [] as WorkingLineComponentPatch[],
 		renders: { shared: 0, local: 0 },
 		selectors: [] as Partial<SelectorBordersComponentConfig>[],
@@ -169,6 +174,12 @@ function createHarness(
 			calls.messages.push(patch);
 			Object.assign(config.components.userMessages, patch);
 		},
+		thinkingStepsCapability: { available: true },
+		setThinkingStepsComponent(patch: Partial<ThinkingStepsComponentConfig>) {
+			calls.thinkingSteps.push(patch);
+			Object.assign(config.components.thinkingSteps, patch);
+			return { applied: true };
+		},
 		setWorkingLineComponent(patch: WorkingLineComponentPatch) {
 			calls.workingLine.push(patch);
 			const { messages, segments, ...componentPatch } = patch;
@@ -240,8 +251,9 @@ function createHarness(
 		cwd: process.cwd(),
 		ui: {
 			theme: theme(),
-			notify(message: string) {
+			notify(message: string, severity = "info") {
 				notifications.push(message);
+				notificationEvents.push({ message, severity });
 			},
 			async custom(factory: (...args: unknown[]) => unknown) {
 				component = factory(
@@ -276,6 +288,7 @@ function createHarness(
 		ctx,
 		calls,
 		notifications,
+		notificationEvents,
 		sessionLifecycle,
 		doneCalls: () => doneCalls,
 	};
@@ -286,7 +299,7 @@ afterEach(() => {
 });
 
 describe("component-oriented /zentui settings", () => {
-	it("uses the exact eight-section order in wide and narrow navigation", async () => {
+	it("uses the exact nine-section order in wide and narrow navigation", async () => {
 		const harness = createHarness();
 		await harness.command().handler("", harness.ctx);
 		const component = harness.component();
@@ -300,7 +313,7 @@ describe("component-oriented /zentui settings", () => {
 		for (const [index, name] of sectionNames.entries()) {
 			const lines = component.render(40);
 			expect(lines[1]).toContain(name);
-			expect(lines[1]).toContain(`(${index + 1}/8)`);
+			expect(lines[1]).toContain(`(${index + 1}/9)`);
 			expect(lines.every((line) => visibleWidth(line) <= 40)).toBe(true);
 			component.handleInput("\t");
 		}
@@ -344,6 +357,8 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		expectFocusOrder(component, ["User messages", "Message style", "Message colors"]);
 		component.handleInput("\t");
+		expectFocusOrder(component, ["Enabled", "Mode"]);
+		component.handleInput("\t");
 		expectFocusOrder(component, [
 			"Enabled",
 			"Turn summary",
@@ -356,7 +371,7 @@ describe("component-oriented /zentui settings", () => {
 			"Custom messages",
 			"Tool",
 			"Elapsed",
-			"Thinking",
+			"Thinking time",
 			"Tokens",
 			"Message list",
 		]);
@@ -533,7 +548,7 @@ describe("component-oriented /zentui settings", () => {
 			{ showGit: false },
 		]);
 
-		for (let index = 0; index < 5; index += 1) component.handleInput("\t");
+		for (let index = 0; index < 6; index += 1) component.handleInput("\t");
 		for (const [label, value] of [
 			["Commit only on detached HEAD", "disabled"],
 			["Show exact-match tag", "disabled"],
@@ -691,6 +706,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput(" ");
 		component.handleInput("\t");
 		component.handleInput("\t");
+		component.handleInput("\t");
 		selectLabel(component, "Footer colors");
 		component.handleInput(" ");
 		selectLabel(component, "Footer model label");
@@ -774,6 +790,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
+		component.handleInput("\t");
 		selectLabel(component, "Ignore submodules");
 		component.handleInput(" ");
 		component.handleInput("\x1b[Z");
@@ -792,6 +809,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
+		component.handleInput("\t");
 		expect(row(component, "Ignore submodules")).toContain("enabled");
 		component.handleInput("\x1b[Z");
 		expect(row(component, "Model info")).toContain("enabled");
@@ -823,6 +841,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
+		component.handleInput("\t");
 		selectLabel(component, "Model info");
 		component.handleInput(" ");
 		expect(focusedRow(component)).toContain("> Model info");
@@ -835,6 +854,267 @@ describe("component-oriented /zentui settings", () => {
 		]);
 	});
 
+	it("shows Thinking (Experimental) with only Enabled and Mode focus rows", async () => {
+		const harness = createHarness();
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		expect(component.render(120).join("\n")).toContain("Thinking (Experimental)");
+		expectFocusOrder(component, ["Enabled", "Mode"]);
+		expect(component.render(120).join("\n")).toContain(
+			"Live switching supports Streaming → Rail/Tree and Rail ↔ Tree. Entering Streaming,",
+		);
+	});
+
+	it("shows saved and active mode mismatch honestly", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps.enabled = true;
+		config.components.thinkingSteps.mode = "streaming";
+		const harness = createHarness(config, {
+			thinkingStepsCapability: {
+				state: {
+					available: true,
+					rendererAvailable: true,
+					streamingAvailable: false,
+					active: true,
+					activeMode: "tree",
+					startup: { enabled: true, mode: "tree" },
+					displaced: false,
+					restartRequired: true,
+					reason: "Streaming listener unavailable; restart required",
+				},
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		const output = component.render(160).join("\n");
+		expect(output).toContain(
+			"Saved: Streaming · Active: Tree · Streaming unavailable · restart required · Streaming listener unavailable",
+		);
+		expect(output.match(/restart required/gi)).toHaveLength(2);
+		// One status appears in the preview and one in the focused setting description;
+		// neither duplicates reason text that already contained the phrase.
+	});
+
+	it("keeps private-renderer unavailability non-focusable and fails open to native", async () => {
+		const harness = createHarness(cloneConfig(), {
+			thinkingStepsCapability: { available: false },
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		const output = component.render(120).join("\n");
+		expect(output).toContain("Saved: Disabled · Active: Native · Renderer unavailable");
+		expectFocusOrder(component, ["Enabled", "Mode"]);
+	});
+
+	it("routes Thinking-step enablement and mode independently", async () => {
+		const harness = createHarness();
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		expectFocusOrder(component, ["Enabled", "Mode"]);
+		selectLabel(component, "Enabled");
+		component.handleInput(" ");
+		selectLabel(component, "Mode");
+		component.handleInput(" ");
+		expect(harness.calls.thinkingSteps).toEqual([{ enabled: true }, { mode: "rail" }]);
+		expect(harness.config.components.thinkingSteps).toEqual({
+			enabled: true,
+			mode: "rail",
+		});
+		expect(harness.notifications).toContain("Thinking (Experimental): Rail");
+	});
+
+	it("cycles the real mode setting through Streaming to Tree", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps = { enabled: true, mode: "streaming" };
+		const harness = createHarness(config);
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Mode");
+		component.handleInput(" ");
+		expect(harness.calls.thinkingSteps).toEqual([{ mode: "tree" }]);
+		expect(harness.config.components.thinkingSteps.mode).toBe("tree");
+	});
+
+	it("rebuilds Thinking settings in focus with honest live-success status and preview", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps = { enabled: true, mode: "streaming" };
+		const state = {
+			available: true,
+			active: true,
+			activeMode: "streaming" as ThinkingStepsMode,
+			startup: { enabled: true, mode: "streaming" as ThinkingStepsMode },
+			displaced: false,
+			restartRequired: false,
+		};
+		const harness = createHarness(config, {
+			thinkingStepsCapability: { state },
+			setThinkingStepsComponent(patch: Partial<ThinkingStepsComponentConfig>) {
+				Object.assign(config.components.thinkingSteps, patch);
+				if (patch.mode) state.activeMode = patch.mode;
+				return { applied: true };
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Mode");
+		component.handleInput(" ");
+		const output = component.render(160).join("\n");
+		expect(focusedRow(component)).toContain("> Mode");
+		expect(output).toContain("Saved: Tree · Active: Tree");
+		expect(harness.notificationEvents.at(-1)).toEqual({
+			message: "Thinking (Experimental): Tree",
+			severity: "info",
+		});
+	});
+
+	it("rebuilds Thinking settings in focus with saved/active failure status and preview", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps = { enabled: true, mode: "rail" };
+		const state = {
+			available: true,
+			rendererAvailable: true,
+			streamingAvailable: true,
+			active: true,
+			activeMode: "rail" as ThinkingStepsMode,
+			startup: { enabled: true, mode: "tree" as ThinkingStepsMode },
+			displaced: false,
+			restartRequired: false,
+			reason: undefined as string | undefined,
+		};
+		const harness = createHarness(config, {
+			thinkingStepsCapability: { state },
+			setThinkingStepsComponent(patch: Partial<ThinkingStepsComponentConfig>) {
+				Object.assign(config.components.thinkingSteps, patch);
+				state.restartRequired = true;
+				return {
+					applied: false,
+					reason: "Saved: Streaming · Active: Rail · restart required",
+				};
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Mode");
+		component.handleInput(" ");
+		const output = component.render(180).join("\n");
+		expect(focusedRow(component)).toContain("> Mode");
+		const expectedStatus = "Saved: Streaming · Active: Rail · restart required";
+		expect(output).toContain(expectedStatus);
+		expect(output).toContain("Thinking 7.1s");
+		expect(harness.notificationEvents.at(-1)).toEqual({
+			message: `Thinking (Experimental): Streaming (${expectedStatus})`,
+			severity: "warning",
+		});
+	});
+
+	it("includes a cleanup warning in a successful Thinking notification", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps = { enabled: true, mode: "streaming" };
+		const state = {
+			available: true,
+			rendererAvailable: true,
+			streamingAvailable: true,
+			active: true,
+			activeMode: "streaming" as ThinkingStepsMode,
+			startup: { enabled: true, mode: "streaming" as ThinkingStepsMode },
+			displaced: false,
+			restartRequired: false,
+			reason: undefined as string | undefined,
+		};
+		const warning =
+			"Saved: Tree · Active: Tree · Streaming unavailable · Pi's terminal input listener cleanup is unavailable";
+		const harness = createHarness(config, {
+			thinkingStepsCapability: { state },
+			setThinkingStepsComponent(patch: Partial<ThinkingStepsComponentConfig>) {
+				Object.assign(config.components.thinkingSteps, patch);
+				state.activeMode = "tree";
+				state.streamingAvailable = false;
+				state.reason = "Pi's terminal input listener cleanup is unavailable";
+				return { applied: true, reason: warning };
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Mode");
+		component.handleInput(" ");
+		expect(component.render(180).join("\n")).toContain(warning);
+		expect(harness.notificationEvents.at(-1)).toEqual({
+			message: `Thinking (Experimental): Tree (${warning})`,
+			severity: "warning",
+		});
+	});
+
+	it("shows a warning when disabling Streaming restores native output with degraded cleanup", async () => {
+		const config = cloneConfig();
+		config.components.thinkingSteps = { enabled: true, mode: "streaming" };
+		const state = {
+			available: true,
+			rendererAvailable: true,
+			streamingAvailable: true,
+			active: true,
+			activeMode: "streaming" as ThinkingStepsMode | undefined,
+			startup: { enabled: true, mode: "streaming" as ThinkingStepsMode },
+			displaced: false,
+			restartRequired: false,
+			reason: undefined as string | undefined,
+		};
+		const warning =
+			"Saved: Disabled · Active: Native · Streaming unavailable · Pi's terminal input listener cleanup is unavailable";
+		const harness = createHarness(config, {
+			thinkingStepsCapability: { state },
+			setThinkingStepsComponent(patch: Partial<ThinkingStepsComponentConfig>) {
+				Object.assign(config.components.thinkingSteps, patch);
+				state.active = false;
+				state.activeMode = undefined;
+				state.streamingAvailable = false;
+				state.reason = "Pi's terminal input listener cleanup is unavailable";
+				return { applied: true, reason: warning };
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Enabled");
+		component.handleInput(" ");
+		expect(component.render(180).join("\n")).toContain(warning);
+		expect(harness.notificationEvents.at(-1)).toEqual({
+			message: `Thinking (Experimental): disabled (${warning})`,
+			severity: "warning",
+		});
+	});
+
+	it("restores Thinking-step rows after persistence failure and exposes no direct route", async () => {
+		const harness = createHarness(cloneConfig(), {
+			setThinkingStepsComponent() {
+				throw new Error("read-only thinking");
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Thinking");
+		selectLabel(component, "Enabled");
+		component.handleInput(" ");
+		expect(focusedRow(component)).toContain("disabled");
+		expect(harness.notifications).toContain("Could not update Zentui settings: read-only thinking");
+		await harness.command().handler("thinking-steps", harness.ctx);
+		expect(harness.notifications.at(-1)).toMatch(/^Usage:/);
+		expect(
+			harness
+				.command()
+				.getArgumentCompletions("")
+				?.map((item) => item.value)
+				.join("\n"),
+		).not.toMatch(/thinking.steps/i);
+	});
+
 	it("routes all Working-line rows independently", async () => {
 		const harness = createHarness();
 		await harness.command().handler("working-line", harness.ctx);
@@ -851,7 +1131,7 @@ describe("component-oriented /zentui settings", () => {
 			"Custom messages",
 			"Tool",
 			"Elapsed",
-			"Thinking",
+			"Thinking time",
 			"Tokens",
 			"Message list",
 		]);
@@ -867,7 +1147,7 @@ describe("component-oriented /zentui settings", () => {
 			["Custom messages", "disabled"],
 			["Tool", "disabled"],
 			["Elapsed", "disabled"],
-			["Thinking", "disabled"],
+			["Thinking time", "disabled"],
 			["Tokens", "disabled"],
 		] as const) {
 			selectLabel(component, label);
@@ -1154,6 +1434,8 @@ describe("component-oriented /zentui settings", () => {
 		]);
 		expect(vi.getTimerCount()).toBe(0);
 		component.handleInput("\t");
+		expect(component.render(100).join("\n")).toContain("Thinking");
+		component.handleInput("\t");
 		const workingRows = component.render(100);
 		expectStackedPreview(workingRows, "Sautéing…");
 		component.handleInput("\t");

package/dist/extensions/pi-zentui/test/settings-previews.test.ts

@@ -10,6 +10,7 @@ import {
 } from "../extensions/zentui/config";
 import {
 	renderEditorSettingsPreview,
+	renderThinkingStepsSettingsPreview,
 	renderUserMessageSettingsPreview,
 	SETTINGS_PREVIEW_MAX_ROWS,
 	SETTINGS_PREVIEW_MAX_WIDTH,
@@ -275,6 +276,111 @@ describe("settings previews", () => {
 		expect(disabledOutput).not.toContain("preview");
 	});
 
+	it("renders all Rail labels and the latest five Tree labels through native Markdown rows", () => {
+		const source = config();
+		for (const mode of ["rail", "tree"] as const) {
+			source.components.thinkingSteps.mode = mode;
+			const output = plain(renderThinkingStepsSettingsPreview(source, theme(), 72));
+			expect(output).toContain(mode === "rail" ? "│ Thinking" : "┆ Thinking");
+			expect(output).toContain(
+				mode === "rail" ? "│ • Verify compatibility" : "└─ • Verify compatibility",
+			);
+			if (mode === "tree") expect(output).not.toContain("Inspect the change");
+			else expect(output).toContain("Inspect the change");
+		}
+	});
+
+	it("renders a pure static Streaming preview with saved/restart/active status", () => {
+		const current = config();
+		current.components.thinkingSteps.enabled = true;
+		current.components.thinkingSteps.mode = "streaming";
+		const output = plain(
+			renderThinkingStepsSettingsPreview(current, theme(), 72, {
+				state: {
+					available: true,
+					active: true,
+					activeMode: "tree",
+					startup: { enabled: true, mode: "tree" },
+					restartRequired: true,
+				},
+			}),
+		);
+		expect(output).toContain("Thinking 7.1s  (configured thinking toggle to expand)");
+		expect(output).toContain("Saved: Streaming · Active: Tree · restart required");
+	});
+
+	it.each([
+		{ active: true, activeMode: "rail" as const, expected: "active rail" },
+		{ active: false, activeMode: undefined, expected: "active native" },
+	])("keeps saved, active, restart, and unavailable reason in status ($expected)", (fixture) => {
+		const current = config();
+		current.components.thinkingSteps.enabled = true;
+		current.components.thinkingSteps.mode = "streaming";
+		const output = plain(
+			renderThinkingStepsSettingsPreview(current, theme(), 72, {
+				state: {
+					available: true,
+					rendererAvailable: true,
+					streamingAvailable: false,
+					active: fixture.active,
+					...(fixture.activeMode ? { activeMode: fixture.activeMode } : {}),
+					startup: { enabled: true, mode: "rail" },
+					restartRequired: true,
+					reason: "Pi's terminal input listener is unavailable; restart required",
+				},
+			}),
+		);
+		expect(output).toContain(
+			`Saved: Streaming · ${fixture.expected.replace("active", "Active:").replace("rail", "Rail").replace("native", "Native")} · Streaming unavailable`,
+		);
+		expect(output).toContain("Pi's terminal input listener is unavailable");
+		expect(output.match(/restart required/gi)).toHaveLength(1);
+	});
+
+	it("uses direct accent connectors and native thinking/bold Markdown callbacks", () => {
+		const calls: Array<[string, string]> = [];
+		const currentTheme = {
+			...theme(),
+			fg: (color: string, text: string) => {
+				calls.push([color, text]);
+				return text;
+			},
+		} as unknown as Theme;
+		const output = plain(renderThinkingStepsSettingsPreview(config(), currentTheme, 72));
+		expect(output).toContain("┆ Thinking");
+		expect(calls).toEqual(
+			expect.arrayContaining([
+				["accent", "┆ "],
+				["accent", "└─ • "],
+			]),
+		);
+		expect(calls.some(([color]) => color === "thinkingText")).toBe(true);
+	});
+
+	it("keeps unavailable/native status visible while disabled and width-bounded", () => {
+		const current = config();
+		current.components.thinkingSteps.enabled = false;
+		for (const mode of ["rail", "tree", "streaming"] as const) {
+			current.components.thinkingSteps.mode = mode;
+			const rendered = renderThinkingStepsSettingsPreview(current, theme(), 20, false);
+			expect(rendered.every((row) => visibleWidth(row) <= 20)).toBe(true);
+			expect(plain(rendered)).toContain("Renderer unavailable");
+		}
+	});
+
+	it("re-renders Thinking-step preview with current mode and theme immediately", () => {
+		const current = config();
+		current.components.thinkingSteps.mode = "rail";
+		const rail = renderThinkingStepsSettingsPreview(current, theme(0), 72);
+		current.components.thinkingSteps.mode = "tree";
+		const tree = renderThinkingStepsSettingsPreview(current, theme(37), 72);
+		expect(tree).not.toEqual(rail);
+		expect(plain(rail)).toContain("│ Thinking");
+		expect(plain(tree)).toContain("┆ Thinking");
+		expect(plain(rail)).not.toMatch(/Thinking ·|Thinking.*Rail|Thinking.*Tree/);
+		expect(plain(tree)).not.toMatch(/Thinking ·|Thinking.*Rail|Thinking.*Tree/);
+	});
+
 	it("sanitizes hostile source and configured icons before trusted preview styling", () => {
 		const current = config();
 		current.icons.rail = "\x1b]2;RAIL-OSC\x07│\u009b31m\u009dRAIL-C1\u009c\u009b0m";

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

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+const root = join(import.meta.dirname, "..");
+
+describe("Thinking (Experimental) documentation", () => {
+	it("documents live transitions, restart gating, native Markdown rows, all modes, and bounded ownership", () => {
+		for (const path of ["README.md", "docs/configuration.md"]) {
+			const documentation = readFileSync(join(root, path), "utf8");
+			expect(documentation).toContain("Thinking (Experimental)");
+			expect(documentation).toMatch(/0\.80\.5.*0\.82\.1.*0\.83\.0.*0\.84\.0.*0\.84\.4/s);
+			expect(documentation).toMatch(/switch.*live|live switching/i);
+			expect(documentation).toMatch(/restart/i);
+			expect(documentation).toMatch(/native.*Markdown|Pi `Markdown`/i);
+			expect(documentation).toMatch(/strict(?: 7-bit CSI)? SGR styling is stripped/i);
+			expect(documentation).toMatch(/every other terminal control/i);
+			expect(documentation).toMatch(/256/);
+			expect(documentation).toMatch(/Working line/);
+		}
+	});
+
+	it("uses the public Thinking copy and states the live boundary exactly", () => {
+		const readme = readFileSync(join(root, "README.md"), "utf8");
+		expect(readme).toContain(
+			"Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restarting Pi.",
+		);
+		expect(readme).not.toMatch(
+			/switches Rail, Tree, and Streaming live|Entering Streaming transactionally|Streaming → Tree → Rail → Streaming/,
+		);
+		const configuration = readFileSync(join(root, "docs/configuration.md"), "utf8");
+		expect(configuration).toContain("Rail parses each native contiguous thinking run");
+		expect(configuration).not.toMatch(/Streaming → Tree → Rail → Streaming/);
+		for (const path of [
+			"README.md",
+			"docs/configuration.md",
+			"extensions/zentui/settings-command.ts",
+		]) {
+			const source = readFileSync(join(root, path), "utf8");
+			expect(source, path).not.toMatch(/Thinking steps(?: mode)?/);
+		}
+	});
+
+	it("keeps both adapted MIT notices adjacent in packaged renderer source", () => {
+		const source = readFileSync(join(root, "extensions/zentui/thinking-experimental.ts"), "utf8");
+		expect(source).toContain("Copyright (c) 2026 Zach Yuen");
+		expect(source).toContain("Copyright (c) 2026 Marc Mironescu / FluxGear");
+		expect(source.match(/Permission is hereby granted, free of charge/g)).toHaveLength(2);
+		expect(source).not.toMatch(/setWorkingMessage|setWorkingVisible/);
+	});
+});

package/dist/extensions/pi-zentui/test/thinking-experimental-loader-diagnostics.mjs

@@ -0,0 +1,54 @@
+import { pathToFileURL } from "node:url";
+
+const diagnosticPatterns = [
+	/Failed to load extension(?:\s|:|")/i,
+	/Extension\s+(?:"[^"\r\n]*"|'[^'\r\n]*')\s+error\s*:/i,
+	/Extension error\s*\(/i,
+	/loader diagnostic\s*:/i,
+	/\b(?:ERR_MODULE_NOT_FOUND|ERR_PACKAGE_PATH_NOT_EXPORTED|ERR_UNKNOWN_FILE_EXTENSION|MODULE_NOT_FOUND)\b/i,
+];
+
+export function hasExtensionLoaderDiagnostic(output) {
+	return diagnosticPatterns.some((pattern) => pattern.test(output));
+}
+
+export const rejectedDiagnosticFixtures = Object.freeze([
+	'Extension "/tmp/any path/zentui.ts" error: SyntaxError: unexpected token',
+	"Extension '/private/quoted/path with spaces/index.ts' error: missing export",
+	'Failed to load extension "/tmp/zentui.ts": import failed',
+	"Failed to load extension: transform failed",
+	"Extension error (/tmp/zentui.ts): runtime failure",
+	"loader diagnostic: source module rejected",
+	"ERR_MODULE_NOT_FOUND: Cannot find package pi-tui",
+	"ERR_PACKAGE_PATH_NOT_EXPORTED: Package subpath './package.json' is not defined",
+	"ERR_UNKNOWN_FILE_EXTENSION: Unknown file extension .ts",
+	"MODULE_NOT_FOUND: Cannot find module 'pi-ai'",
+]);
+
+export const acceptedOutputFixtures = Object.freeze([
+	"Thinking 0.1s  (ctrl+t to expand)",
+	"Extension loaded: /tmp/zentui.ts",
+	"The user asked whether a loader diagnostic would help explain an extension error.",
+	"The assistant described the phrase extension error while discussing a loader diagnostic.",
+	"The assistant discussed extension recovery strategy.",
+]);
+
+export function assertExtensionLoaderDiagnosticFixtures() {
+	for (const fixture of rejectedDiagnosticFixtures) {
+		if (!hasExtensionLoaderDiagnostic(fixture)) {
+			throw new Error(`loader diagnostic fixture was not rejected: ${JSON.stringify(fixture)}`);
+		}
+	}
+	for (const fixture of acceptedOutputFixtures) {
+		if (hasExtensionLoaderDiagnostic(fixture)) {
+			throw new Error(`ordinary output fixture was rejected: ${JSON.stringify(fixture)}`);
+		}
+	}
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	assertExtensionLoaderDiagnosticFixtures();
+	console.log(
+		`loader-diagnostics: rejected=${rejectedDiagnosticFixtures.length} accepted=${acceptedOutputFixtures.length}`,
+	);
+}