@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-zentui/docs/configuration.md

@@ -6,18 +6,19 @@ Zentui reads optional user configuration from `~/.pi/agent/zentui.json`. Missing
 
 ## `/zentui` settings
 
-The interactive `/zentui` menu is split into eight component-oriented sections. Use `Tab` and `Shift+Tab` to switch sections:
+The interactive `/zentui` menu is split into nine component-oriented sections. Use `Tab` and `Shift+Tab` to switch sections:
 
 1. **Appearance** — selector-border enablement, style, and colors; icon mode.
 2. **Editor** — enablement, style, colors, model label, border behavior, viewport indicators, settings for the selected editor style, and a static synthetic preview.
 3. **User messages** — enablement, style, colors, and a static synthetic Markdown preview.
-4. **Working line** — ownership, settled Turn summary, spinner and text speeds, optional spinner-color motion, text animation, color source, custom messages, Tool/Elapsed/Thinking/Tokens segments, and animated preview.
-5. **Footer** — Native, Starship, or Hidden. Starship additionally exposes colors, model label, responsive layout, separator, context style, and path display.
-6. **Segments** — visibility toggles for non-Git Starship segments.
-7. **Git** — Starship Git segment and probe controls.
-8. **Extensions** — Starship extension-status placement and color controls for active keys.
+4. **Thinking (Experimental)** — private Rail, Tree, or Streaming rendering; active Streaming can switch live to Rail or Tree, Rail and Tree can switch live between each other, and the private renderer may break after Pi updates.
+5. **Working line** — ownership, settled Turn summary, spinner and text speeds, optional spinner-color motion, text animation, color source, custom messages, Tool/Elapsed/Thinking time/Tokens segments, and animated preview.
+6. **Footer** — Native, Starship, or Hidden. Starship additionally exposes colors, model label, responsive layout, separator, context style, and path display.
+7. **Segments** — visibility toggles for non-Git Starship segments.
+8. **Git** — Starship Git segment and probe controls.
+9. **Extensions** — Starship extension-status placement and color controls for active keys.
 
-Editor, User messages, and Working line retain independent configuration. Editor and User-message previews remain visible while their component is disabled. Only the Working-line preview owns an animation timer. Footer-specific rows are shown only while Starship is selected, while Segments, Git, and Extensions remain available for preconfiguration under every Footer style.
+Editor, User messages, Thinking (Experimental), and Working line retain independent configuration. Editor, User-message, and Thinking previews remain visible while their component is disabled. Only the Working-line preview owns an animation timer. Footer-specific rows are shown only while Starship is selected, while Segments, Git, and Extensions remain available for preconfiguration under every Footer style.
 
 Free-form values such as custom formats, Opencode metadata formats, raw colors/styles, and inactive extension keys remain JSON-only. Working-line speed accepts validated custom milliseconds in `/zentui`.
 
@@ -99,6 +100,10 @@ Copy this example and change only the values you need. Optional editor source-aw
         "labeled": {}
       }
     },
+    "thinkingSteps": {
+      "enabled": false,
+      "mode": "tree"
+    },
     "workingLine": {
       "enabled": false,
       "turnSummary": true,
@@ -267,7 +272,9 @@ Copy this example and change only the values you need. Optional editor source-aw
 - `components.editor` owns Editor enablement, `opencode | opencode-copy-friendly | accent-rail | minimalist` style selection, color source, border mode, model label, viewport indicators, and all four style configurations.
 - Editor `modelLabel` uses `id` by default; `name` uses the display name with ID fallback. Footer has an independent `modelLabel` control.
 - `components.userMessages` owns User-message enablement, `framed | framed-copy-friendly | compact | labeled` style selection, and color source. Disabling it delegates byte-for-byte to Pi's native renderer.
-- `components.workingLine.enabled` is the sole Working-line ownership switch.
+- `components.thinkingSteps` independently owns opt-in **Thinking (Experimental)** display. It defaults to `{ "enabled": false, "mode": "tree" }`; canonical modes are `rail | tree | streaming`. The former persisted `streaming-experimental` value is accepted only as a migration alias and is normalized to `streaming` on save.
+- All three modes decorate Pi's private host renderer and are tested on exact Pi versions 0.80.5, 0.82.1, 0.83.0, 0.84.0, and 0.84.4. 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 live disable require restart; live disable restores native thinking. Disabled mode changes only preconfigure.
+- `components.workingLine.enabled` is the sole Working-line ownership switch. Thinking (Experimental) never enables, configures, or owns the Working line and leaves the existing **Thinking time** option unchanged.
 - `components.selectorBorders` owns selector-border enablement, fixed `zentui` style, and color source. Disable it for native Pi behavior.
 - `components.footer` owns `native | starship | hidden` style selection, color source, model label, and Starship options. Hidden installs an empty component with zero rows.
 - Starship's package-version segment reads the project manifest and is distinct from the runtime segment, which reports the installed toolchain.
@@ -381,6 +388,27 @@ Missing, non-string, or empty values use `$model  $provider(  $thinking)`. A non
 - Disabling styling delegates to Pi's native renderer; native is not a style ID.
 - Zentui intentionally provides no custom `plain` style.
 
+## Thinking (Experimental)
+
+Rail, Tree, and Streaming share one private `AssistantMessageComponent` wrapper. The saved `{ enabled, mode }` value is read at session start before transcript restoration; disabled startup installs nothing. Once installed and healthy, active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other, without reinstalling the patch. Each supported transition rerenders tracked components once. Selecting Streaming from Rail or Tree saves Streaming but keeps the active structural mode unchanged and reports restart required; it never acquires input or timer resources live. Leaving Streaming releases those resources. If cleanup throws, a requested Rail or Tree mode still becomes active, while disable still restores native children; either successful change warns that Streaming is unavailable for the rest of the session. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restart, while mode changes when disabled only preconfigure. Shutdown restores native children, exact hidden-state ownership, and the predecessor descriptor. Startup acquisition or private constructor, layout, Markdown identity, parser, theme, rendering, width, or displacement failure uses native thinking. Private APIs may break after any Pi update.
+
+Rail parses each native contiguous thinking run and shows every label in that run. Tree shows the latest five in each run; neither aggregates across intervening text or tool blocks. Both follow Pi's thinking visibility. Labels come from headings, top-level list items, and blank-line-separated prose. Complete strict 7-bit CSI SGR styling is stripped before parsing; every other terminal control, unsafe or unstructured content, malformed or over-limit input, unterminated fences/math, and unsupported structure leave that complete run native. Fenced code, Mermaid, display math, and indented nested content remain opaque bodies.
+
+Each selected SGR-free label is rendered as Markdown by a fresh Pi `Markdown` with the host child's exact theme, default `thinkingText`/italic style, and transform options. Native emphasis, code, links, HTML, LaTeX, and custom theme/transform callbacks therefore remain authoritative. Host horizontal padding is applied externally. Each label is exactly one terminal row; Pi TUI's ANSI/OSC/grapheme-aware width utilities crop the first rendered row and reserve one cell for `…` only when required. Empty, image, non-text, impossible-width, or throwing output restores the whole native run. Connectors are separate from Markdown and call the current `theme.fg("accent", connector)` every render, so custom themes directly control their appearance. Visible forms are:
+
+```text
+│ Thinking       ┆ Thinking
+│ First          ├─ · Earlier
+│ Latest         └─ · Latest
+│ • Open         └─ • Open
+```
+
+Only an actually open thinking phase uses `•`; a text/tool transition or restored completion is settled. Rail and Tree preserve Pi's hidden state and native hidden label. The `/zentui` Mode action offers all three modes, but entering Streaming from Rail or Tree is saved for restart rather than applied live.
+
+Streaming keeps the reviewed host-rendered behavior: while open it shows the latest five rendered terminal rows beneath `Thinking 7.1s`; completion folds under `Thought` or current-session `Thought for Ns`. Restored entries have no duration because Pi does not persist a reliable thinking-end timestamp. Only a session started in active Streaming owns its validated configured `app.thinking.toggle` binding and one-second timer. Ctrl+T expands/refolds native reasoning. Startup resource failures and private-shape/render failures use complete native thinking. A cleanup callback that throws while leaving Streaming is contained: Rail or Tree remains active, while Streaming becomes unavailable for that session. Component and timing tracking are bounded to 256; evicted entries are restored natively first.
+
+The exact all-mode private matrix covers Pi 0.80.5, 0.82.1, 0.83.0, 0.84.0, and 0.84.4 under dark, light, and current themes, narrow/wide widths and resize; Pi 0.84.4 also has a fullscreen live-transition PTY smoke. Thinking (Experimental) never owns or writes the Working line, including its unchanged **Thinking time** option, and does not own Footer, Editor, widgets, statuses, or model behavior.
+
 ## Working line
 
 When enabled, Zentui owns Pi's complete working-row message and indicator. Five fixed-width spinner presets are available: Braille Orbit, Star Bloom, ASCII Pinwheel, Claude-inspired, and three-cell Pulse.
@@ -389,7 +417,7 @@ When enabled, Zentui owns Pi's complete working-row message and indicator. Five
 
 Committed totals stay provider-reported across tool loops, retries, compaction retries, and queued continuations. During a response, live output follows Pi's `↓N` convention whether usage is provider-reported or temporarily estimated. Final usage reconciles atomically; input is never estimated. Labels are sanitized and width-bounded.
 
-When Pi settles, the default-on **Turn summary** appends a persistent context-free row such as `Turn took 56s · thought for 10s · ↑7.1k ↓779`. Thought is cumulative wall-clock time from Pi's public thinking stream; overlaps count once and zero is omitted. Output already includes reasoning tokens, so reasoning is not added separately. Summaries always include both token totals, even when live Tokens or Thinking is hidden or zero, and can be disabled without changing historical rows. They use the fixed high style and are inactive while Working line is disabled.
+When Pi settles, the default-on **Turn summary** appends a persistent context-free row such as `Turn took 56s · thought for 10s · ↑7.1k ↓779`. Thought is cumulative wall-clock time from Pi's public thinking stream; overlaps count once and zero is omitted. Output already includes reasoning tokens, so reasoning is not added separately. Summaries always include both token totals, even when live Tokens or **Thinking time** is hidden or zero, and can be disabled without changing historical rows. They use the fixed high style and are inactive while Working line is disabled.
 
 Classic and KITT move color across message and segments. **Animate spinner color** optionally includes spinner cells and separator. Static colors the full row uniformly and ignores text speed/spinner-color participation without changing saved values. Spinner glyph motion always remains active.
 

package/dist/extensions/pi-zentui/extensions/zentui/config.ts

@@ -46,6 +46,7 @@ export type WorkingLineSpinner =
 	| "claude-inspired"
 	| "pulse";
 export type WorkingLineTextAnimation = "classic" | "kitt" | "disabled";
+export type ThinkingStepsMode = "rail" | "tree" | "streaming";
 export type ComponentStyleOwner = "editor" | "userMessages" | "selectorBorders" | "footer";
 export type MinimalistPathDisplayMode = "compact" | "project" | "full";
 export type MinimalistContextFormat = "percent" | "percent-total";
@@ -250,9 +251,15 @@ export type WorkingLineComponentPatch = Partial<
 	segments?: Partial<WorkingLineSegmentsConfig>;
 };
 
+export type ThinkingStepsComponentConfig = {
+	enabled: boolean;
+	mode: ThinkingStepsMode;
+};
+
 export type ComponentsConfig = {
 	editor: EditorComponentConfig;
 	userMessages: UserMessagesComponentConfig;
+	thinkingSteps: ThinkingStepsComponentConfig;
 	workingLine: WorkingLineComponentConfig;
 	selectorBorders: SelectorBordersComponentConfig;
 	footer: FooterComponentConfig;
@@ -498,6 +505,7 @@ const defaultComponents: ComponentsConfig = {
 		colorSource: "theme",
 		styles: { framed: {}, "framed-copy-friendly": {}, compact: {}, labeled: {} },
 	},
+	thinkingSteps: { enabled: false, mode: "tree" },
 	workingLine: {
 		enabled: true,
 		turnSummary: true,
@@ -1194,6 +1202,7 @@ function resolveComponents(config: ConfigRecord): ComponentsConfig {
 	const userMessages = recordValue(components.userMessages);
 	const userMessageStyles = recordValue(userMessages.styles);
 	const framed = recordValue(userMessageStyles.framed);
+	const thinkingSteps = recordValue(components.thinkingSteps);
 	const workingLine = recordValue(components.workingLine);
 	const workingLineMessages = recordValue(workingLine.messages);
 	const workingLineSegments = recordValue(workingLine.segments);
@@ -1301,6 +1310,15 @@ function resolveComponents(config: ConfigRecord): ComponentsConfig {
 				labeled: {},
 			},
 		},
+		thinkingSteps: {
+			enabled: parseBoolean(thinkingSteps.enabled, defaultComponents.thinkingSteps.enabled),
+			mode:
+				thinkingSteps.mode === "rail" || thinkingSteps.mode === "tree"
+					? thinkingSteps.mode
+					: thinkingSteps.mode === "streaming" || thinkingSteps.mode === "streaming-experimental"
+						? "streaming"
+						: defaultComponents.thinkingSteps.mode,
+		},
 		workingLine: {
 			enabled: parseBoolean(workingLine.enabled, defaultComponents.workingLine.enabled),
 			turnSummary: parseBoolean(workingLine.turnSummary, defaultComponents.workingLine.turnSummary),
@@ -1746,6 +1764,17 @@ export function saveUserMessagesComponentPatch(
 	);
 }
 
+export function saveThinkingStepsComponentPatch(
+	patch: Partial<ThinkingStepsComponentConfig>,
+	path = configPath,
+): PolishedTuiConfig {
+	return saveComponentsMutation((components) => {
+		const component = components.thinkingSteps;
+		if (patch.enabled !== undefined) component.enabled = patch.enabled;
+		if (patch.mode !== undefined) component.mode = patch.mode;
+	}, path);
+}
+
 export function saveWorkingLineComponentPatch(
 	patch: WorkingLineComponentPatch,
 	path = configPath,

package/dist/extensions/pi-zentui/extensions/zentui/index.ts

@@ -14,6 +14,7 @@ import {
 import {
 	type AccentRailEditorStyleConfig,
 	type ContextStyle,
+	defaultConfig,
 	type EditorComponentConfig,
 	type ExtensionStatusColorMode,
 	type ExtensionStatusPlacement,
@@ -46,8 +47,10 @@ import {
 	savePolishedEditorStylePatch,
 	saveSelectorBordersComponentPatch,
 	saveStarshipFooterStylePatch,
+	saveThinkingStepsComponentPatch,
 	saveUserMessagesComponentPatch,
 	saveWorkingLineComponentPatch,
+	type ThinkingStepsComponentConfig,
 	type UserMessagesComponentConfig,
 	type WorkingLineComponentPatch,
 	type ZentuiConfig,
@@ -86,6 +89,7 @@ import { SessionLifecycle } from "./session-lifecycle";
 import { registerZentuiSettingsCommand } from "./settings-command";
 import { createInitialState, type FooterState, modelLabelFor, syncState } from "./state";
 import { resolveFooterTelemetry } from "./telemetry";
+import { ThinkingExperimentalController } from "./thinking-experimental";
 import { PolishedEditor, WrappedPolishedEditor } from "./ui";
 import { installUserMessageStyle, removeUserMessageStyle } from "./user-message";
 import {
@@ -180,7 +184,7 @@ export default function (pi: ExtensionAPI) {
 	const sessionLifecycle = new SessionLifecycle();
 	const editorOwnerToken = Symbol("zentui-editor-owner");
 
-	let currentConfig: PolishedTuiConfig = loadConfig();
+	let currentConfig: PolishedTuiConfig = structuredClone(defaultConfig);
 	// Keep the capability guard defensive for hosts with incomplete extension APIs.
 	if (typeof pi.registerEntryRenderer === "function") {
 		pi.registerEntryRenderer(TURN_SUMMARY_ENTRY_TYPE, (entry, options, theme) =>
@@ -278,6 +282,14 @@ export default function (pi: ExtensionAPI) {
 		requestFooterRender?.();
 		requestEditorRender?.();
 	};
+	const thinkingExperimental = new ThinkingExperimentalController(
+		() => currentConfig.components.thinkingSteps,
+	);
+	const thinkingStepsCapability = {
+		get state() {
+			return thinkingExperimental.state;
+		},
+	};
 	const liveContext = new LiveContextController(sessionLifecycle, refresh);
 	const getActiveTheme = () => activeTheme;
 	const getCurrentConfig = () => currentConfig;
@@ -1028,7 +1040,6 @@ export default function (pi: ExtensionAPI) {
 		const staleFooterOwner = ctxFooterOwner(ctx);
 		if (typeof staleFooterOwner === "symbol") installedFooterToken = staleFooterOwner;
 		ensureConfigExists();
-		currentConfig = loadConfig();
 		syncFooterState(ctx);
 		stopProjectRefresh();
 
@@ -1136,6 +1147,10 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		const lifecycleGeneration = sessionLifecycle.start();
+		// Reload synchronously so private ownership uses this session's disk snapshot before
+		// any await or transcript restoration.
+		currentConfig = loadConfig();
+		thinkingExperimental.startSession(ctx);
 		const layoutInstallSerial = ++accentRailLayoutPatchInstallSerial;
 		cleanupAccentRailLayoutPatch();
 		cleanupAccentRailLayoutPatch = () => {};
@@ -1216,6 +1231,14 @@ export default function (pi: ExtensionAPI) {
 			if (patch.enabled !== undefined || patch.style !== undefined) reconcileUserMessages();
 			refresh();
 		},
+		thinkingStepsCapability,
+		setThinkingStepsComponent(
+			patch: Partial<ThinkingStepsComponentConfig>,
+			_ctx: ExtensionContext,
+		) {
+			currentConfig = saveThinkingStepsComponentPatch(patch);
+			return thinkingExperimental.reconcile();
+		},
 		setWorkingLineComponent(patch: WorkingLineComponentPatch, ctx: ExtensionContext) {
 			currentConfig = saveWorkingLineComponentPatch(patch);
 			return workingLine.reconcile(ctx);
@@ -1303,6 +1326,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		thinkingExperimental.shutdown();
 		liveContext.clear();
 		interactionMetrics.shutdown();
 		workingLine.dispose(ctx);
@@ -1314,6 +1338,8 @@ export default function (pi: ExtensionAPI) {
 		refreshInteractiveState(ctx, true);
 	};
 
+	pi.on("message_start", (event) => thinkingExperimental.beginMessage(event));
+
 	pi.on("agent_start", (event, ctx) => {
 		liveContext.clear();
 		const { interactionStarted } = interactionMetrics.agentStart();
@@ -1326,6 +1352,7 @@ export default function (pi: ExtensionAPI) {
 		workingLine.startTurn(ctx);
 	});
 	pi.on("agent_end", (event, ctx) => {
+		thinkingExperimental.endAgent();
 		liveContext.clear();
 		const displayTokens = interactionMetrics.currentDisplayTokens();
 		interactionMetrics.agentEnd();
@@ -1342,6 +1369,7 @@ export default function (pi: ExtensionAPI) {
 	pi.on("thinking_level_select", syncInteractiveState);
 	pi.on("session_info_changed", syncInteractiveState);
 	pi.on("message_update", (event, ctx) => {
+		thinkingExperimental.updateMessage(event);
 		liveContext.update(event.message);
 		const metrics = interactionMetrics.messageUpdate(
 			event.message,
@@ -1352,6 +1380,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 	pi.on("message_end", (event, ctx) => {
+		thinkingExperimental.endMessage(event);
 		const result = interactionMetrics.messageEnd(event.message);
 		if (result.status === "accepted") {
 			workingLine.updateMetrics(result.displayTokens, interactionMetrics.currentThought(), ctx);

package/dist/extensions/pi-zentui/extensions/zentui/prototype-patch-registry.ts

@@ -3,7 +3,8 @@ export const ZENTUI_PROTOTYPE_PATCH_REGISTRY = Symbol.for("pi-zentui.prototype-p
 type PrototypePatchAdapter =
 	| "user-message-render"
 	| "user-message-invalidate"
-	| "selector-border-render";
+	| "selector-border-render"
+	| "thinking-experimental-update-content";
 
 type PrototypeMethod = (this: unknown, ...args: unknown[]) => unknown;
 
@@ -18,10 +19,13 @@ type PatchBehavior = (invocation: PatchInvocation) => unknown;
 type Registration = {
 	token: symbol;
 	behavior?: PatchBehavior;
+	onDisplaced?: () => void;
 };
 
+type PatchMethod = "render" | "invalidate" | "updateContent";
+
 type PatchRecord = {
-	method: "render" | "invalidate";
+	method: PatchMethod;
 	predecessor: PrototypeMethod;
 	predecessorDescriptor?: PropertyDescriptor;
 	wrapper: PrototypeMethod;
@@ -48,10 +52,20 @@ function registryFor(target: PatchTarget): PatchRegistry {
 	return registry;
 }
 
-function deactivateRecord(record: PatchRecord): void {
+function deactivateRecord(record: PatchRecord, displaced = false): void {
 	if (!record.registration) return;
-	record.registration.behavior = undefined;
+	const registration = record.registration;
+	const onDisplaced = registration.onDisplaced;
+	registration.behavior = undefined;
+	registration.onDisplaced = undefined;
 	record.registration = undefined;
+	if (displaced) {
+		try {
+			onDisplaced?.();
+		} catch {
+			// Registration handoff must not prevent the newer owner from installing.
+		}
+	}
 }
 
 function restorePredecessor(target: PatchTarget, record: PatchRecord): void {
@@ -77,15 +91,17 @@ function installWrapper(target: PatchTarget, record: PatchRecord): void {
 	});
 }
 
+export type PrototypePatchRegistration = (() => void) & Readonly<{ token: symbol }>;
+
 function createCleanup(
 	target: PatchTarget,
 	adapter: PrototypePatchAdapter,
 	registry: PatchRegistry,
 	record: PatchRecord,
 	token: symbol,
-): () => void {
+): PrototypePatchRegistration {
 	let cleaned = false;
-	return () => {
+	const cleanup = () => {
 		if (cleaned) return;
 		cleaned = true;
 		if (record.registration?.token !== token) return;
@@ -97,14 +113,16 @@ function createCleanup(
 		registry.delete(adapter);
 		if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
 	};
+	return Object.assign(cleanup, { token });
 }
 
 export function installPrototypePatch(
 	targetValue: object,
-	method: "render" | "invalidate",
+	method: PatchMethod,
 	adapter: PrototypePatchAdapter,
 	behavior: PatchBehavior,
-): () => void {
+	onDisplaced?: () => void,
+): PrototypePatchRegistration {
 	const target = targetValue as PatchTarget;
 	const registry = registryFor(target);
 	let record = registry.get(adapter);
@@ -141,17 +159,43 @@ export function installPrototypePatch(
 		}
 		record = nextRecord;
 		registry.set(adapter, record);
-		if (displacedRecord && displacedRecord !== record) deactivateRecord(displacedRecord);
+		if (displacedRecord && displacedRecord !== record) deactivateRecord(displacedRecord, true);
 	}
 
+	const previousRegistration = record.registration;
 	const token = Symbol(adapter);
-	record.registration = { token, behavior };
+	record.registration = { token, behavior, onDisplaced };
+	if (previousRegistration) {
+		previousRegistration.behavior = undefined;
+		try {
+			previousRegistration.onDisplaced?.();
+		} catch {
+			// Registration handoff must not prevent the newer owner from installing.
+		}
+		previousRegistration.onDisplaced = undefined;
+	}
 	return createCleanup(target, adapter, registry, record, token);
 }
 
+export function isPrototypePatchCurrent(
+	targetValue: object,
+	method: PatchMethod,
+	adapter: PrototypePatchAdapter,
+	token?: symbol,
+): boolean {
+	const target = targetValue as PatchTarget;
+	const record = existingRegistry(target)?.get(adapter);
+	return Boolean(
+		record &&
+			record.method === method &&
+			target[method] === record.wrapper &&
+			(token === undefined || record.registration?.token === token),
+	);
+}
+
 export function removePrototypePatch(
 	targetValue: object,
-	method: "render" | "invalidate",
+	method: PatchMethod,
 	adapter: PrototypePatchAdapter,
 ): void {
 	const target = targetValue as PatchTarget;

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

@@ -45,6 +45,8 @@ import {
 	type PolishedTuiConfig,
 	type SelectorBordersComponentConfig,
 	type SeparatorStyle,
+	type ThinkingStepsComponentConfig,
+	type ThinkingStepsMode,
 	type UserMessageStyle,
 	type UserMessagesComponentConfig,
 	type WorkingLineComponentPatch,
@@ -56,10 +58,12 @@ import { isIconMode } from "./icons";
 import type { SessionLifecycle } from "./session-lifecycle";
 import {
 	renderEditorSettingsPreview,
+	renderThinkingStepsSettingsPreview,
 	renderUserMessageSettingsPreview,
 	SETTINGS_PREVIEW_MAX_WIDTH,
 } from "./settings-previews";
 import { EDITOR_BORDER_STYLE, renderChromeBorder, safeThemeFg } from "./style";
+import { formatThinkingStatus, thinkingStatusLabels } from "./thinking-status";
 import {
 	buildWorkingLinePreviewFrames,
 	normalizeWorkingLineMessages,
@@ -132,11 +136,22 @@ const speedValues = (presets: readonly { label: string }[]) => [
 	"Custom…",
 ];
 const workingLineTextAnimationValues: WorkingLineTextAnimation[] = ["classic", "kitt", "disabled"];
+const thinkingStepsModeLabels: Record<ThinkingStepsMode, string> = {
+	rail: "Rail",
+	tree: "Tree",
+	streaming: "Streaming",
+};
+const thinkingStepsModeValues = (startupMode: ThinkingStepsMode): string[] => {
+	if (startupMode === "streaming") return ["Streaming", "Tree", "Rail"];
+	if (startupMode === "rail") return ["Rail", "Tree", "Streaming"];
+	return ["Tree", "Rail", "Streaming"];
+};
 
 const settingsSections = [
 	"appearance",
 	"editor",
 	"userMessages",
+	"thinkingSteps",
 	"workingLine",
 	"footer",
 	"segments",
@@ -164,6 +179,37 @@ type SettingsOutcome =
 	| "edit-working-line-spinner-speed"
 	| "edit-working-line-text-speed";
 
+type ThinkingControllerState = Readonly<{
+	available: boolean;
+	rendererAvailable?: boolean;
+	streamingAvailable?: boolean;
+	streamingPoisoned?: boolean;
+	active: boolean;
+	activeMode?: ThinkingStepsMode;
+	startup: Readonly<ThinkingStepsComponentConfig>;
+	displaced: boolean;
+	restartRequired: boolean;
+	reason?: string;
+}>;
+
+type ThinkingStepsSettingsCapability =
+	| Readonly<{ available: boolean }>
+	| Readonly<{ readonly state: ThinkingControllerState }>;
+
+function experimentalThinkingCapability(
+	capability: ThinkingStepsSettingsCapability,
+): ThinkingControllerState {
+	return "state" in capability
+		? capability.state
+		: {
+				available: capability.available,
+				active: false,
+				startup: { enabled: false, mode: "tree" },
+				displaced: false,
+				restartRequired: false,
+			};
+}
+
 type SettingsCommandDeps = {
 	sessionLifecycle: SessionLifecycle;
 	getConfig: () => PolishedTuiConfig;
@@ -176,6 +222,11 @@ type SettingsCommandDeps = {
 	setAccentRail: (patch: Partial<AccentRailEditorStyleConfig>, ctx: ExtensionContext) => void;
 	setMinimalist: (patch: Partial<MinimalistConfig>, ctx: ExtensionContext) => void;
 	setUserMessagesComponent: (patch: UserMessagesPatch, ctx: ExtensionContext) => void;
+	thinkingStepsCapability: ThinkingStepsSettingsCapability;
+	setThinkingStepsComponent: (
+		patch: Partial<ThinkingStepsComponentConfig>,
+		ctx: ExtensionContext,
+	) => ApplyResult;
 	setWorkingLineComponent: (patch: WorkingLineComponentPatch, ctx: ExtensionContext) => ApplyResult;
 	setSelectorBordersComponent: (
 		patch: Partial<SelectorBordersComponentConfig>,
@@ -210,6 +261,7 @@ const sectionLabels: Record<SettingsSection, string> = {
 	appearance: "Appearance",
 	editor: "Editor",
 	userMessages: "User messages",
+	thinkingSteps: "Thinking (Experimental)",
 	workingLine: "Working line",
 	footer: "Footer",
 	segments: "Segments",
@@ -308,6 +360,11 @@ function userMessageStyleId(label: string): UserMessageStyle | undefined {
 		([, value]) => value === label,
 	)?.[0];
 }
+function thinkingStepsModeId(label: string): ThinkingStepsMode | undefined {
+	return (Object.entries(thinkingStepsModeLabels) as Array<[ThinkingStepsMode, string]>).find(
+		([, value]) => value === label,
+	)?.[0];
+}
 function workingLineSpinnerId(label: string): WorkingLineSpinner | undefined {
 	return (Object.entries(workingLineSpinnerLabels) as Array<[WorkingLineSpinner, string]>).find(
 		([, value]) => value === label,
@@ -610,6 +667,32 @@ function buildUserMessagesItems(config: PolishedTuiConfig): SettingItem[] {
 		},
 	];
 }
+function buildThinkingStepsItems(
+	config: PolishedTuiConfig,
+	capability: ThinkingStepsSettingsCapability,
+): SettingItem[] {
+	const thinkingSteps = config.components.thinkingSteps;
+	const controller = experimentalThinkingCapability(capability);
+	const status = formatThinkingStatus(thinkingStatusLabels(thinkingSteps, controller));
+	const enabledDescription = `${status} Live switching supports Streaming → Rail/Tree and Rail ↔ Tree. Entering Streaming, first enable, and re-enable after live disable require restart. Private renderer may break after Pi updates.`;
+	return [
+		{
+			id: "thinkingStepsEnabled",
+			label: "Enabled",
+			description: enabledDescription,
+			currentValue: featureValue(thinkingSteps.enabled),
+			values: featureStateValues,
+		},
+		{
+			id: "thinkingStepsMode",
+			label: "Mode",
+			description: `${status} Rail shows every parsed label; Tree shows the latest five per contiguous run; both follow Pi thinking visibility, and unsafe or unstructured content remains native. Streaming folds to the latest five host-rendered rows and owns the configured thinking toggle only when active. Incompatibility uses native thinking.`,
+			currentValue: thinkingStepsModeLabels[thinkingSteps.mode],
+			values: thinkingStepsModeValues(controller.startup.mode),
+		},
+	];
+}
+
 function buildWorkingLineItems(config: PolishedTuiConfig): SettingItem[] {
 	const workingLine = config.components.workingLine;
 	const staticText = workingLine.textAnimation === "disabled";
@@ -700,7 +783,7 @@ function buildWorkingLineItems(config: PolishedTuiConfig): SettingItem[] {
 		},
 		{
 			id: "workingLineThought",
-			label: "Thinking",
+			label: "Thinking time",
 			description: "Show cumulative wall-clock thinking time and active updates.",
 			currentValue: featureValue(workingLine.segments.thought),
 			values: featureStateValues,
@@ -957,6 +1040,7 @@ function buildSectionItems(
 	section: SettingsSection,
 	config: PolishedTuiConfig,
 	active: ReadonlyMap<string, string>,
+	thinkingStepsCapability: ThinkingStepsSettingsCapability,
 ): SettingItem[] {
 	switch (section) {
 		case "appearance":
@@ -977,6 +1061,8 @@ function buildSectionItems(
 			];
 		case "userMessages":
 			return buildUserMessagesItems(config);
+		case "thinkingSteps":
+			return buildThinkingStepsItems(config, thinkingStepsCapability);
 		case "workingLine":
 			return buildWorkingLineItems(config);
 		case "footer":
@@ -1195,9 +1281,10 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 					};
 					const notifyChange = (label: string, value: string, result?: ApplyResult) => {
 						deps.requestRender();
+						const detail = result?.reason?.trim();
 						ctx.ui.notify(
-							`${label}: ${value}${result && !result.applied ? ` (${result.reason ?? "reload Pi to apply this change"})` : ""}`,
-							"info",
+							`${label}: ${value}${detail ? ` (${detail})` : result && !result.applied ? " (reload Pi to apply this change)" : ""}`,
+							result && (!result.applied || detail) ? "warning" : "info",
 						);
 						startPreview();
 						tui.requestRender();
@@ -1220,6 +1307,7 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 							activeSection,
 							deps.getConfig(),
 							deps.getActiveExtensionStatuses(),
+							deps.thinkingStepsCapability,
 						);
 						const list = new SettingsList(
 							items,
@@ -1362,6 +1450,23 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 										notifyChange("Message colors", newValue);
 										return;
 									}
+									if (id === "thinkingStepsEnabled" && enabled !== undefined) {
+										const result = deps.setThinkingStepsComponent({ enabled }, ctx);
+										settingsList = makeSettingsList("thinkingStepsEnabled");
+										notifyChange("Thinking (Experimental)", newValue, result);
+										return;
+									}
+									const selectedThinkingStepsMode =
+										id === "thinkingStepsMode" ? thinkingStepsModeId(newValue) : undefined;
+									if (selectedThinkingStepsMode) {
+										const result = deps.setThinkingStepsComponent(
+											{ mode: selectedThinkingStepsMode },
+											ctx,
+										);
+										settingsList = makeSettingsList("thinkingStepsMode");
+										notifyChange("Thinking (Experimental)", newValue, result);
+										return;
+									}
 									if (id === "workingLineEnabled" && enabled !== undefined) {
 										const result = deps.setWorkingLineComponent({ enabled }, ctx);
 										settingsList.updateValue(id, newValue);
@@ -1661,6 +1766,13 @@ export function registerZentuiSettingsCommand(pi: ExtensionAPI, deps: SettingsCo
 							return renderEditorSettingsPreview(deps.getConfig(), theme, previewWidth);
 						if (activeSection === "userMessages")
 							return renderUserMessageSettingsPreview(deps.getConfig(), theme, previewWidth);
+						if (activeSection === "thinkingSteps")
+							return renderThinkingStepsSettingsPreview(
+								deps.getConfig(),
+								theme,
+								previewWidth,
+								deps.thinkingStepsCapability,
+							);
 						if (activeSection === "workingLine" && preview && preview.frames.length > 0)
 							return [
 								truncateToWidth(