gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.e146beb20

package/packages/pi-coding-agent/src/modes/interactive/components/tool-execution.ts

@@ -1,3 +1,4 @@
+// GSD-2 Interactive Tool Execution Rendering
 import {
 	Box,
 	Container,
@@ -6,6 +7,7 @@ import {
 	type ImageDimensions,
 	imageFallback,
 	Spacer,
+	style,
 	Text,
 	type TUI,
 	truncateToWidth,
@@ -103,13 +105,11 @@ function renderToolFrame(
 	const outerWidth = Math.max(20, width);
 	const contentWidth = Math.max(1, outerWidth - 2); // "│ " + content
 
-	const borderColor = opts.tone === "error" ? "error" : "toolTitle";
-	const topColor = opts.tone === "error" ? "error" : "toolTitle";
-	const labelColor = opts.tone === "error" ? "error" : "toolTitle";
-	const statusColor = opts.tone === "error" ? "error" : opts.tone === "pending" ? "warning" : "success";
-	const border = (s: string) => theme.fg(borderColor, s);
-
-	const leftStyled = theme.fg(labelColor, theme.bold(`• ${opts.label}`));
+	const borderColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
+	const topColor = borderColor;
+	const labelColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
+	const statusColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
+	const leftStyled = theme.fg(labelColor, theme.bold(opts.label));
 	const rightStyled = theme.fg(statusColor, opts.status);
 	const gap = Math.max(1, outerWidth - visibleWidth(leftStyled) - visibleWidth(rightStyled));
 	const headerRow = `${leftStyled}${" ".repeat(gap)}${rightStyled}`;
@@ -118,20 +118,52 @@ function renderToolFrame(
 	const sourceLines = trimOuterBlankLines(contentLines);
 	const bodyLines = (sourceLines.length > 0 ? sourceLines : [""]).map((line) => {
 		const clipped = truncateToWidth(line, contentWidth, "");
-		return border("│ ") + clipped;
+		return clipped;
 	});
 
-	return [
-		theme.fg(topColor, "─".repeat(outerWidth)),
-		headerRow + " ".repeat(headerPad),
-		...bodyLines,
-	];
+	return style()
+		.border("rule")
+		.borderColor((line) => theme.fg(line.startsWith("─") ? topColor : borderColor, line))
+		.title(headerRow + " ".repeat(headerPad))
+		.render(bodyLines, outerWidth);
+}
+
+function renderCollapsedToolRow(
+	label: string,
+	status: string,
+	width: number,
+	tone: Extract<ToolFrameTone, "success">,
+): string[] {
+	const outerWidth = Math.max(20, width);
+	const contentWidth = Math.max(1, outerWidth - 2);
+	const statusColor = tone === "success" ? "toolSuccess" : "toolMuted";
+	const labelStyled = theme.fg(statusColor, label);
+	const statusStyled = theme.fg(statusColor, status);
+	const labelWidth = Math.max(1, contentWidth - visibleWidth(statusStyled) - 1);
+	const clippedLabel = truncateToWidth(labelStyled, labelWidth, "");
+	const gap = Math.max(1, contentWidth - visibleWidth(clippedLabel) - visibleWidth(statusStyled));
+	const line = `${clippedLabel}${" ".repeat(gap)}${statusStyled}`;
+	return style()
+		.border("minimal")
+		.borderColor((text) => theme.fg(statusColor, text))
+		.render([line], outerWidth);
 }
 
 const COMPACT_ARG_VALUE_LIMIT = 60;
 const GENERIC_OUTPUT_PREVIEW_LINES = 10;
 const GENERIC_ARGS_JSON_PREVIEW_LINES = 10;
 
+export type ToolExecutionPhase = {
+	label: string;
+	count: number;
+	durationMs: number;
+};
+
+function formatElapsed(ms: number): string {
+	if (ms < 1000) return `${ms}ms`;
+	return `${Math.max(1, Math.round(ms / 1000))}s`;
+}
+
 /**
  * Format tool args for the generic-renderer fallback. Produces a one-line
  * `k=v, k=v` summary when every value is a primitive that fits inline; falls
@@ -200,6 +232,8 @@ export class ToolExecutionComponent extends Container {
 	private toolDefinition?: ToolDefinition;
 	private ui: TUI;
 	private cwd: string;
+	private readonly startedAt = Date.now();
+	private endedAt: number | undefined;
 	private result?: {
 		content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
 		isError: boolean;
@@ -434,6 +468,9 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;
+		if (!isPartial) {
+			this.endedAt = this.endedAt ?? Date.now();
+		}
 		if (this.normalizedToolName === "write" && !isPartial) {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const fileContent = str(this.args?.content);
@@ -456,6 +493,7 @@ export class ToolExecutionComponent extends Container {
 	markHistoricalNoResult(): void {
 		if (this.result) return; // real result already set, nothing to do
 		this.isPartial = false;
+		this.endedAt = this.endedAt ?? Date.now();
 		this.result = {
 			content: [],
 			isError: false,
@@ -468,6 +506,7 @@ export class ToolExecutionComponent extends Container {
 	 */
 	completeWithError(message?: string): void {
 		this.isPartial = false;
+		this.endedAt = this.endedAt ?? Date.now();
 		if (this.result) {
 			let content = this.result.content;
 			if (message) {
@@ -538,14 +577,18 @@ export class ToolExecutionComponent extends Container {
 		}
 		const frameWidth = Math.max(20, width);
 		const contentWidth = Math.max(1, frameWidth - 4);
-		const lines = super.render(contentWidth);
 		const frameTone: ToolFrameTone =
 			this.result?.isError ? "error" : this.isPartial || !this.result ? "pending" : "success";
-		const frameStatus = this.isPartial || !this.result ? "Running" : this.result.isError ? "Error" : "Done";
+		const elapsed = formatElapsed((this.endedAt ?? Date.now()) - this.startedAt);
+		const frameStatus = `${this.isPartial || !this.result ? "running" : this.result.isError ? "failed" : "success"} · ${elapsed}`;
 		const parsed = parseMcpToolName(this.toolName);
 		const frameLabel = parsed
-			? `Tool ${parsed.server}·${parsed.tool}`
-			: `Tool ${prettifyToolName(this.toolName, this.toolDefinition?.label) || "unknown"}`;
+			? `${parsed.server}·${parsed.tool}`
+			: prettifyToolName(this.toolName, this.toolDefinition?.label) || "unknown";
+		if (this.shouldRenderCompactSuccess()) {
+			return ["", ...renderCollapsedToolRow(this.getCompactSummary(frameLabel), frameStatus, frameWidth, "success")];
+		}
+		const lines = super.render(contentWidth);
 		const framed = renderToolFrame(lines, frameWidth, {
 			label: frameLabel,
 			status: frameStatus,
@@ -554,6 +597,43 @@ export class ToolExecutionComponent extends Container {
 		return framed.length > 0 ? ["", ...framed] : framed;
 	}
 
+	private shouldRenderCompactSuccess(): boolean {
+		if (this.expanded || this.isPartial || !this.result || this.result.isError) return false;
+		const hasImages = this.result.content?.some((block) => block.type === "image") ?? false;
+		return !hasImages;
+	}
+
+	getRollupPhase(): ToolExecutionPhase | null {
+		if (!this.shouldRenderCompactSuccess()) return null;
+		const label = this.getPhaseLabel();
+		const endedAt = this.endedAt ?? Date.now();
+		return {
+			label,
+			count: 1,
+			durationMs: Math.max(0, endedAt - this.startedAt),
+		};
+	}
+
+	private getPhaseLabel(): string {
+		const name = this.normalizedToolName;
+		const displayName = prettifyToolName(this.toolName, this.toolDefinition?.label);
+
+		if (name === "bash") return "Setup / shell";
+		if (name === "read" || name === "ls" || name === "find" || name === "grep") return "Context reads";
+		if (name === "write" || name === "edit") return "File changes";
+		if (name === "web_search" || displayName === "ToolSearch") return "Discovery";
+		if (displayName === "Memory Query" || displayName === "Memory Capture" || displayName === "Gsd Graph") {
+			return "Memory lookups";
+		}
+		if (displayName === "Update Requirement" || displayName === "Save Requirement") return "Requirement writes";
+		if (displayName.startsWith("Complete ")) return "Finalization";
+		return "Other tool actions";
+	}
+
+	private getCompactSummary(frameLabel: string): string {
+		return frameLabel;
+	}
+
 	private updateDisplay(): void {
 		// Tool body now uses transparent background; status is conveyed in the frame header.
 		const bgFn = (text: string) => text;
@@ -1201,3 +1281,24 @@ export class ToolExecutionComponent extends Container {
 		return text;
 	}
 }
+
+export class ToolPhaseSummaryComponent extends Container {
+	constructor(private readonly phases: ToolExecutionPhase[]) {
+		super();
+	}
+
+	override render(width: number): string[] {
+		const frameWidth = Math.max(20, width);
+		const rows = this.phases.map((phase) => {
+			const left = `${phase.label} ${phase.count} ${phase.count === 1 ? "action" : "actions"}`;
+			const right = `success · ${formatElapsed(phase.durationMs)}`;
+			const contentWidth = Math.max(1, frameWidth - 2);
+			const leftWidth = Math.max(1, contentWidth - visibleWidth(right) - 1);
+			const leftText = truncateToWidth(left, leftWidth, "");
+			const gap = Math.max(1, contentWidth - visibleWidth(leftText) - visibleWidth(right));
+			return `${theme.fg("toolSuccess", leftText)}${" ".repeat(gap)}${theme.fg("toolSuccess", right)}`;
+		});
+
+		return ["", ...style().border("minimal").borderColor((text) => theme.fg("toolSuccess", text)).render(rows, frameWidth)];
+	}
+}

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.test.ts

@@ -1,7 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { findLatestPinnableText } from "./chat-controller.js";
+import { findLatestPinnableText, handleAgentEvent } from "./chat-controller.js";
+import { initTheme } from "../theme/theme.js";
 
 test("findLatestPinnableText: empty content returns empty string", () => {
 	assert.equal(findLatestPinnableText([]), "");
@@ -69,3 +70,44 @@ test("findLatestPinnableText: thinking blocks are not pinnable", () => {
 	];
 	assert.equal(findLatestPinnableText(blocks), "");
 });
+
+test("handleAgentEvent: agent_start clears stale adaptive blocking error", async () => {
+	initTheme("dark", false);
+	let cleared = false;
+	let requestedRender = false;
+	const host = {
+		isInitialized: true,
+		clearBlockingError: () => {
+			cleared = true;
+		},
+		retryEscapeHandler: undefined,
+		retryLoader: undefined,
+		loadingAnimation: undefined,
+		statusContainer: {
+			clear() {},
+			addChild() {},
+		},
+		ui: {
+			requestRender() {
+				requestedRender = true;
+			},
+		},
+		defaultEditor: {},
+		footer: {
+			invalidate() {},
+		},
+		settingsManager: {
+			getTimestampFormat() {
+				return "date-time-iso";
+			},
+		},
+		defaultWorkingMessage: "Working...",
+		pendingWorkingMessage: undefined,
+	} as any;
+
+	await handleAgentEvent(host, { type: "agent_start" } as any);
+	host.loadingAnimation?.stop();
+
+	assert.equal(cleared, true);
+	assert.equal(requestedRender, true);
+});

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -1,9 +1,14 @@
+// GSD-2 Interactive Chat Controller
 import { Loader, Markdown, Spacer, Text } from "@gsd/pi-tui";
 
 import type { InteractiveModeEvent, InteractiveModeStateHost } from "../interactive-mode-state.js";
 import { theme } from "../theme/theme.js";
 import { AssistantMessageComponent } from "../components/assistant-message.js";
-import { ToolExecutionComponent } from "../components/tool-execution.js";
+import {
+	ToolExecutionComponent,
+	ToolPhaseSummaryComponent,
+	type ToolExecutionPhase,
+} from "../components/tool-execution.js";
 import { DynamicBorder } from "../components/dynamic-border.js";
 import { appKey } from "../components/keybinding-hints.js";
 
@@ -100,6 +105,71 @@ let pinnedBorder: DynamicBorder | undefined;
 // Reference to the pinned markdown component below the border
 let pinnedTextComponent: Markdown | undefined;
 
+function mergeToolPhases(phases: ToolExecutionPhase[]): ToolExecutionPhase[] {
+	const merged: ToolExecutionPhase[] = [];
+	for (const phase of phases) {
+		const previous = merged[merged.length - 1];
+		if (previous?.label === phase.label) {
+			previous.count += phase.count;
+			previous.durationMs += phase.durationMs;
+		} else {
+			merged.push({ ...phase });
+		}
+	}
+	return merged;
+}
+
+function replaceCompactToolRowsWithPhaseSummary(
+	host: InteractiveModeStateHost & { ui: { requestRender: () => void } },
+): void {
+	let changed = false;
+	const nextRenderedSegments: RenderedSegment[] = [];
+	let rollupRun: Array<{ seg: Extract<RenderedSegment, { kind: "tool" }>; phase: ToolExecutionPhase }> = [];
+
+	const flushRollupRun = () => {
+		if (rollupRun.length < 2) {
+			nextRenderedSegments.push(...rollupRun.map((item) => item.seg));
+			rollupRun = [];
+			return;
+		}
+
+		const firstIndex = Math.max(0, host.chatContainer.children.indexOf(rollupRun[0].seg.component));
+		const summary = new ToolPhaseSummaryComponent(mergeToolPhases(rollupRun.map((item) => item.phase)));
+
+		for (const { seg } of rollupRun) {
+			host.chatContainer.removeChild(seg.component);
+		}
+
+		host.chatContainer.addChild(summary);
+		const summaryIndex = host.chatContainer.children.indexOf(summary);
+		if (summaryIndex !== -1 && summaryIndex !== firstIndex) {
+			host.chatContainer.children.splice(summaryIndex, 1);
+			host.chatContainer.children.splice(firstIndex, 0, summary);
+			(host.chatContainer as unknown as { _prevRender: string[] | null })._prevRender = null;
+		}
+
+		changed = true;
+		rollupRun = [];
+	};
+
+	for (const seg of renderedSegments) {
+		const phase = seg.kind === "tool" ? seg.component.getRollupPhase() : null;
+		if (seg.kind === "tool" && phase) {
+			rollupRun.push({ seg, phase });
+			continue;
+		}
+
+		flushRollupRun();
+		nextRenderedSegments.push(seg);
+	}
+	flushRollupRun();
+
+	if (changed) {
+		renderedSegments = nextRenderedSegments;
+		host.ui.requestRender();
+	}
+}
+
 export async function handleAgentEvent(host: InteractiveModeStateHost & {
 	init: () => Promise<void>;
 	getMarkdownThemeWithSettings: () => any;
@@ -177,6 +247,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					return;
 			}
 		case "agent_start":
+			host.clearBlockingError();
 			if (host.retryEscapeHandler) {
 				host.defaultEditor.onEscape = host.retryEscapeHandler;
 				host.retryEscapeHandler = undefined;
@@ -772,6 +843,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.streamingComponent.setShowMetadata(true);
 					host.streamingComponent.updateContent(host.streamingMessage);
 				}
+				replaceCompactToolRowsWithPhaseSummary(host);
 
 				if (host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error") {
 					if (!errorMessage) {
@@ -822,6 +894,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				component.setExpanded(host.toolOutputExpanded);
 				host.chatContainer.addChild(component);
 				host.pendingTools.set(event.toolCallId, component);
+				renderedSegments.push({ kind: "tool", contentIndex: Number.MAX_SAFE_INTEGER, component });
 				host.ui.requestRender();
 			}
 			break;
@@ -855,6 +928,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				host.streamingComponent.setShowMetadata(true);
 				host.streamingComponent.updateContent(host.streamingMessage);
 			}
+			replaceCompactToolRowsWithPhaseSummary(host);
 			host.streamingComponent = undefined;
 			host.streamingMessage = undefined;
 			renderedSegments = [];

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.test.ts

@@ -49,6 +49,7 @@ function createMockHost() {
 		isInitialized: true,
 		loadingAnimation: undefined,
 		pendingWorkingMessage: undefined,
+		clearBlockingError: () => {},
 		defaultWorkingMessage: "Working...",
 		streamingComponent: undefined,
 		streamingMessage: undefined,

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode-state.ts

@@ -20,6 +20,7 @@ export interface InteractiveModeStateHost {
 	isInitialized: boolean;
 	loadingAnimation?: any;
 	pendingWorkingMessage?: string;
+	clearBlockingError(): void;
 	defaultWorkingMessage: string;
 	streamingComponent?: any;
 	streamingMessage?: any;
@@ -37,4 +38,3 @@ export interface InteractiveModeStateHost {
 }
 
 export type InteractiveModeEvent = AgentSessionEvent;
-

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -64,6 +64,7 @@ import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/cha
 import { readClipboardImage } from "../../utils/clipboard-image.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
+import { AdaptiveLayoutComponent } from "./components/adaptive-layout.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
@@ -246,6 +247,7 @@ export class InteractiveMode {
 	private ui: TUI;
 	private chatContainer: Container;
 	private pendingMessagesContainer: Container;
+	private adaptiveLayout: AdaptiveLayoutComponent;
 	private statusContainer: Container;
 	private pinnedMessageContainer: Container;
 	private defaultEditor: CustomEditor;
@@ -261,6 +263,7 @@ export class InteractiveMode {
 	private loadingAnimation: Loader | undefined = undefined;
 	private pendingWorkingMessage: string | undefined = undefined;
 	private readonly defaultWorkingMessage = "Working...";
+	private lastBlockingError: string | undefined = undefined;
 
 	private lastSigintTime = 0;
 	private lastEscapeTime = 0;
@@ -367,6 +370,14 @@ export class InteractiveMode {
 		this.headerContainer = new Container();
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
+		this.adaptiveLayout = new AdaptiveLayoutComponent(() => ({
+			override: this.settingsManager.getAdaptiveMode(),
+			activeToolCount: this.pendingTools.size,
+			gsdPhase: this.pendingWorkingMessage,
+			lastError: this.lastBlockingError,
+			sessionName: this.sessionManager.getSessionName(),
+			cwd: process.cwd(),
+		}));
 		this.statusContainer = new Container();
 		this.pinnedMessageContainer = new Container();
 		this.widgetContainerAbove = new Container();
@@ -571,6 +582,7 @@ export class InteractiveMode {
 			}
 		}
 
+		this.ui.addChild(this.adaptiveLayout);
 		this.ui.addChild(this.chatContainer);
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
@@ -1221,6 +1233,7 @@ export class InteractiveMode {
 						this.streamingComponent = undefined;
 						this.streamingMessage = undefined;
 						this.pendingTools.clear();
+						this.clearBlockingError();
 
 						// Render any messages added via setup, or show empty session
 						this.renderInitialMessages();
@@ -2880,11 +2893,16 @@ export class InteractiveMode {
 	}
 
 	showError(errorMessage: string): void {
+		this.lastBlockingError = errorMessage;
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
 		this.ui.requestRender();
 	}
 
+	clearBlockingError(): void {
+		this.lastBlockingError = undefined;
+	}
+
 	showWarning(warningMessage: string): void {
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
@@ -3195,6 +3213,7 @@ export class InteractiveMode {
 					quietStartup: this.settingsManager.getQuietStartup(),
 					clearOnShrink: this.settingsManager.getClearOnShrink(),
 					timestampFormat: this.settingsManager.getTimestampFormat(),
+					adaptiveMode: this.settingsManager.getAdaptiveMode(),
 				},
 				{
 					onAutoCompactChange: (enabled) => {
@@ -3301,6 +3320,10 @@ export class InteractiveMode {
 					onTimestampFormatChange: (format) => {
 						this.settingsManager.setTimestampFormat(format);
 					},
+					onAdaptiveModeChange: (mode) => {
+						this.settingsManager.setAdaptiveMode(mode);
+						this.ui.requestRender();
+					},
 					onCancel: () => {
 						done();
 						this.ui.requestRender();
@@ -3689,6 +3712,7 @@ export class InteractiveMode {
 		this.streamingComponent = undefined;
 		this.streamingMessage = undefined;
 		this.pendingTools.clear();
+		this.clearBlockingError();
 
 		// Switch session via AgentSession (emits extension session events)
 		await this.session.switchSession(sessionPath);
@@ -4010,6 +4034,7 @@ export class InteractiveMode {
 		this.streamingMessage = undefined;
 		this.pendingTools.clear();
 		this.pendingImages.length = 0;
+		this.clearBlockingError();
 
 		// Reset contextual tips for the new session
 		this.contextualTips.reset();

package/packages/pi-coding-agent/src/modes/interactive/slash-command-handlers.test.ts

@@ -0,0 +1,95 @@
+// GSD2 - Slash command tests for interactive TUI settings commands
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { Container } from "@gsd/pi-tui";
+import { SettingsManager } from "../../core/settings-manager.js";
+import { dispatchSlashCommand, type SlashCommandContext } from "./slash-command-handlers.js";
+
+function makeContext(settingsManager = SettingsManager.inMemory()): SlashCommandContext {
+	const statuses: string[] = [];
+	const warnings: string[] = [];
+	const renders: string[] = [];
+	return {
+		session: {} as never,
+		ui: {} as never,
+		keybindings: {} as never,
+		chatContainer: new Container(),
+		statusContainer: new Container(),
+		editorContainer: new Container(),
+		headerContainer: new Container(),
+		pendingMessagesContainer: new Container(),
+		editor: {} as never,
+		defaultEditor: {} as never,
+		sessionManager: {} as never,
+		settingsManager,
+		invalidateFooter() {},
+		showStatus(message: string) {
+			statuses.push(message);
+		},
+		showError(message: string) {
+			throw new Error(message);
+		},
+		showWarning(message: string) {
+			warnings.push(message);
+		},
+		showSelector() {},
+		updateEditorBorderColor() {},
+		getMarkdownThemeWithSettings: () => ({} as never),
+		requestRender() {
+			renders.push("render");
+		},
+		updateTerminalTitle() {},
+		showSettingsSelector() {},
+		showModelsSelector: async () => {},
+		handleModelCommand: async () => {},
+		showUserMessageSelector() {},
+		showTreeSelector() {},
+		showProviderManager() {},
+		showOAuthSelector: async () => {},
+		showSessionSelector() {},
+		handleClearCommand: async () => {},
+		handleReloadCommand: async () => {},
+		handleDebugCommand() {},
+		shutdown: async () => {},
+		executeCompaction: async () => undefined,
+		handleBashCommand: async () => {},
+		_testStatuses: statuses,
+		_testWarnings: warnings,
+		_testRenders: renders,
+	} as SlashCommandContext & {
+		_testStatuses: string[];
+		_testWarnings: string[];
+		_testRenders: string[];
+	};
+}
+
+describe("dispatchSlashCommand /tui", () => {
+	it("persists /tui mode validation to terminal adaptive mode", async () => {
+		const settingsManager = SettingsManager.inMemory();
+		const ctx = makeContext(settingsManager) as SlashCommandContext & {
+			_testStatuses: string[];
+			_testRenders: string[];
+		};
+
+		const handled = await dispatchSlashCommand("/tui mode validation", ctx);
+
+		assert.equal(handled, true);
+		assert.equal(settingsManager.getAdaptiveMode(), "validation");
+		assert.deepEqual(ctx._testStatuses, ["TUI mode: validation"]);
+		assert.equal(ctx._testRenders.length, 1);
+	});
+
+	it("rejects unknown TUI modes without changing settings", async () => {
+		const settingsManager = SettingsManager.inMemory({ terminal: { adaptiveMode: "workflow" } });
+		const ctx = makeContext(settingsManager) as SlashCommandContext & {
+			_testWarnings: string[];
+		};
+
+		const handled = await dispatchSlashCommand("/tui mode poster", ctx);
+
+		assert.equal(handled, true);
+		assert.equal(settingsManager.getAdaptiveMode(), "workflow");
+		assert.match(ctx._testWarnings[0], /Usage: \/tui mode/);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/slash-command-handlers.ts

@@ -31,7 +31,7 @@ import {
 import type { AgentSession } from "../../core/agent-session.js";
 import type { AppAction, KeybindingsManager } from "../../core/keybindings.js";
 import type { SessionManager } from "../../core/session-manager.js";
-import type { SettingsManager } from "../../core/settings-manager.js";
+import type { AdaptiveTuiMode, SettingsManager } from "../../core/settings-manager.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
 import { ArminComponent } from "./components/armin.js";
@@ -235,6 +235,10 @@ export async function dispatchSlashCommand(
 		await ctx.handleBashCommand(command, { loginShell: true });
 		return true;
 	}
+	if (text === "/tui" || text.startsWith("/tui ")) {
+		handleTuiCommand(text, ctx);
+		return true;
+	}
 
 	return false;
 }
@@ -665,6 +669,25 @@ function handleEditModeCommand(arg: string | undefined, ctx: SlashCommandContext
 	ctx.showStatus(`Edit mode: ${next}${next === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
 }
 
+function handleTuiCommand(text: string, ctx: SlashCommandContext): void {
+	const parts = text.trim().split(/\s+/);
+	const mode = parts[1] === "mode" ? parts[2] : parts[1];
+	const valid: AdaptiveTuiMode[] = ["auto", "chat", "workflow", "validation", "debug", "compact"];
+
+	if (!mode) {
+		ctx.showStatus(`TUI mode: ${ctx.settingsManager.getAdaptiveMode()}`);
+		return;
+	}
+	if (!valid.includes(mode as AdaptiveTuiMode)) {
+		ctx.showWarning(`Usage: /tui mode ${valid.join("|")}`);
+		return;
+	}
+
+	ctx.settingsManager.setAdaptiveMode(mode as AdaptiveTuiMode);
+	ctx.showStatus(`TUI mode: ${mode}`);
+	ctx.requestRender();
+}
+
 function handleArminSaysHi(ctx: SlashCommandContext): void {
 	ctx.chatContainer.addChild(new Spacer(1));
 	ctx.chatContainer.addChild(new ArminComponent(ctx.ui));

package/packages/pi-coding-agent/src/modes/interactive/theme/theme-schema.ts

@@ -70,6 +70,19 @@ export const ThemeJsonSchema = Type.Object({
     thinkingXhigh: ColorValueSchema,
     // Bash Mode (1 color)
     bashMode: ColorValueSchema,
+    // Adaptive TUI semantic tokens (optional; defaults are derived from core colors)
+    surfaceBorder: Type.Optional(ColorValueSchema),
+    surfaceMuted: Type.Optional(ColorValueSchema),
+    surfaceTitle: Type.Optional(ColorValueSchema),
+    surfaceAccent: Type.Optional(ColorValueSchema),
+    toolRunning: Type.Optional(ColorValueSchema),
+    toolSuccess: Type.Optional(ColorValueSchema),
+    toolError: Type.Optional(ColorValueSchema),
+    toolMuted: Type.Optional(ColorValueSchema),
+    modeWorkflow: Type.Optional(ColorValueSchema),
+    modeValidation: Type.Optional(ColorValueSchema),
+    modeDebug: Type.Optional(ColorValueSchema),
+    modeCompact: Type.Optional(ColorValueSchema),
   }),
   export: Type.Optional(
     Type.Object({