gsd-pi 2.80.0 → 2.81.0

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

@@ -1,7 +1,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { Container } from "@gsd/pi-tui";
+import stripAnsi from "strip-ansi";
 
-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 +72,117 @@ 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);
+});
+
+test("handleAgentEvent: standalone completed tool events roll up incrementally", async () => {
+	initTheme("dark", false);
+	const chatContainer = new Container();
+	let renderCount = 0;
+	const host = {
+		isInitialized: true,
+		footer: { invalidate() {} },
+		settingsManager: {
+			getTimestampFormat() {
+				return "date-time-iso";
+			},
+			getShowImages() {
+				return false;
+			},
+		},
+		getRegisteredToolDefinition() {
+			return undefined;
+		},
+		chatContainer,
+		pendingTools: new Map(),
+		ui: {
+			requestRender() {
+				renderCount++;
+			},
+		},
+	} as any;
+
+	for (const [toolCallId, toolName] of [
+		["read-1", "read"],
+		["read-2", "read"],
+		["edit-1", "edit"],
+	] as const) {
+		const target =
+			toolName === "edit"
+				? {
+						kind: "file",
+						action: "edit",
+						inputPath: `src/${toolCallId}.txt`,
+						resolvedPath: `/tmp/project/src/${toolCallId}.txt`,
+						line: 10,
+					}
+				: {
+						kind: "file",
+						action: "read",
+						inputPath: `src/${toolCallId}.txt`,
+						resolvedPath: `/tmp/project/src/${toolCallId}.txt`,
+					};
+		await handleAgentEvent(host, {
+			type: "tool_execution_start",
+			toolCallId,
+			toolName,
+			args: { path: `src/${toolCallId}.txt` },
+		} as any);
+		await handleAgentEvent(host, {
+			type: "tool_execution_end",
+			toolCallId,
+			toolName,
+			result: { content: [], details: { target }, isError: false },
+			isError: false,
+		} as any);
+	}
+
+	const rendered = stripAnsi(chatContainer.render(100).join("\n"));
+	assert.match(rendered, /Context reads · 2 files\s+success · \d+(ms|s)/);
+	assert.match(rendered, /src\/read-1\.txt/);
+	assert.match(rendered, /src\/read-2\.txt/);
+	assert.match(rendered, /File changes · 1 file, 1 edit\s+success · \d+(ms|s)/);
+	assert.match(rendered, /src\/edit-1\.txt:10/);
+	assert.doesNotMatch(rendered, /^\s*│?\s*read\s+success ·/m);
+	assert.doesNotMatch(rendered, /^\s*│?\s*edit\s+success ·/m);
+	assert.ok(renderCount > 0);
+});

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";
 
@@ -23,7 +28,8 @@ type RenderedSegment =
 		contentType: "text" | "thinking";
 		component: AssistantMessageComponent;
 	}
-	| { kind: "tool"; contentIndex: number; component: ToolExecutionComponent };
+	| { kind: "tool"; contentIndex: number; component: ToolExecutionComponent }
+	| { kind: "tool-summary"; component: ToolPhaseSummaryComponent; phases: ToolExecutionPhase[] };
 
 let renderedSegments: RenderedSegment[] = [];
 // When providers reuse one assistant lifecycle across internal sub-turns,
@@ -100,6 +106,100 @@ 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;
+			previous.targets = mergeTargets(previous.targets, phase.targets);
+			if (previous.actionLabel !== phase.actionLabel) {
+				previous.actionLabel = undefined;
+			}
+		} else {
+			merged.push({ ...phase, targets: phase.targets ? [...phase.targets] : undefined });
+		}
+	}
+	return merged;
+}
+
+function mergeTargets(existing: string[] | undefined, incoming: string[] | undefined): string[] | undefined {
+	if (!existing && !incoming) return undefined;
+	const seen = new Set<string>();
+	const merged: string[] = [];
+	for (const target of [...(existing ?? []), ...(incoming ?? [])]) {
+		if (!target || seen.has(target)) continue;
+		seen.add(target);
+		merged.push(target);
+	}
+	return merged;
+}
+
+function replaceCompactToolRowsWithPhaseSummary(
+	host: InteractiveModeStateHost & { ui: { requestRender: () => void } },
+): void {
+	let changed = false;
+	const nextRenderedSegments: RenderedSegment[] = [];
+	let rollupRun: Array<{
+		seg: Extract<RenderedSegment, { kind: "tool" | "tool-summary" }>;
+		phases: ToolExecutionPhase[];
+	}> = [];
+
+	const flushRollupRun = () => {
+		const actionCount = rollupRun.reduce(
+			(total, item) => total + item.phases.reduce((sum, phase) => sum + phase.count, 0),
+			0,
+		);
+		if (actionCount < 2) {
+			nextRenderedSegments.push(...rollupRun.map((item) => item.seg));
+			rollupRun = [];
+			return;
+		}
+
+		const firstIndex = Math.max(0, host.chatContainer.children.indexOf(rollupRun[0].seg.component));
+		const phases = mergeToolPhases(rollupRun.flatMap((item) => item.phases));
+		const summary = new ToolPhaseSummaryComponent(phases);
+
+		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;
+		nextRenderedSegments.push({ kind: "tool-summary", component: summary, phases });
+		rollupRun = [];
+	};
+
+	for (const seg of renderedSegments) {
+		const phase = seg.kind === "tool" ? seg.component.getRollupPhase() : null;
+		if (seg.kind === "tool" && phase) {
+			rollupRun.push({ seg, phases: [phase] });
+			continue;
+		}
+		if (seg.kind === "tool-summary") {
+			rollupRun.push({ seg, phases: seg.component.getPhases() });
+			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 +277,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					return;
 			}
 		case "agent_start":
+			host.clearBlockingError();
 			if (host.retryEscapeHandler) {
 				host.defaultEditor.onEscape = host.retryEscapeHandler;
 				host.retryEscapeHandler = undefined;
@@ -338,6 +439,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 							details: externalToolResult.details,
 							isError: externalToolResult.isError,
 						});
+						replaceCompactToolRowsWithPhaseSummary(host);
 					}
 				}
 
@@ -790,6 +892,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					for (const [, component] of host.pendingTools.entries()) {
 						component.setArgsComplete();
 					}
+					replaceCompactToolRowsWithPhaseSummary(host);
 				}
 				host.streamingComponent = undefined;
 				host.streamingMessage = undefined;
@@ -822,6 +925,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;
@@ -839,7 +943,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 			const component = host.pendingTools.get(event.toolCallId);
 			if (component) {
 				component.updateResult({ ...event.result, isError: event.isError });
-				host.pendingTools.delete(event.toolCallId);
+				replaceCompactToolRowsWithPhaseSummary(host);
 				host.ui.requestRender();
 			}
 			break;
@@ -855,6 +959,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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Interactive TUI mode and session UI rendering.
+// GSD2 - Interactive TUI mode for coding-agent sessions.
 /**
  * Interactive mode for the coding agent.
  * Handles TUI rendering and user interaction, delegating business logic to AgentSession.
@@ -64,6 +67,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";
@@ -170,6 +174,55 @@ type CompactionQueuedMessage = {
 	mode: "steer" | "followUp";
 };
 
+export type ExtensionNotifyType = "info" | "warning" | "error" | "success" | undefined;
+
+export function shouldRenderExtensionNotifyInChat(type: ExtensionNotifyType): boolean {
+	return type !== "warning";
+}
+
+export interface ExtensionNotifyRenderResult {
+	rendered: boolean;
+	statusSpacer?: Spacer;
+	statusText?: Text;
+}
+
+export function renderExtensionNotifyInChat(
+	chatContainer: Container,
+	message: string,
+	type?: ExtensionNotifyType,
+): ExtensionNotifyRenderResult {
+	if (!shouldRenderExtensionNotifyInChat(type)) {
+		return { rendered: false };
+	}
+
+	const spacer = new Spacer(1);
+	chatContainer.addChild(spacer);
+
+	if (type === "error") {
+		chatContainer.addChild(new Text(theme.fg("error", `Error: ${message}`), 1, 0));
+		return { rendered: true };
+	}
+	if (type === "success") {
+		chatContainer.addChild(new DynamicBorder((text) => theme.fg("success", text)));
+		chatContainer.addChild(new Text(theme.fg("success", message), 1, 0));
+		chatContainer.addChild(new DynamicBorder((text) => theme.fg("success", text)));
+		chatContainer.addChild(new Spacer(1));
+		return { rendered: true };
+	}
+
+	const statusText = new Text(theme.fg("dim", message), 1, 0);
+	chatContainer.addChild(statusText);
+	return { rendered: true, statusSpacer: spacer, statusText };
+}
+
+export function renderBlockingErrorBanner(container: Container, message: string | undefined): void {
+	container.clear();
+	if (message === undefined) return;
+
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(theme.fg("error", `Error: ${message}`), 1, 0));
+}
+
 /**
  * Options for InteractiveMode initialization.
  */
@@ -205,8 +258,10 @@ export class InteractiveMode {
 	private ui: TUI;
 	private chatContainer: Container;
 	private pendingMessagesContainer: Container;
+	private adaptiveLayout: AdaptiveLayoutComponent;
 	private statusContainer: Container;
 	private pinnedMessageContainer: Container;
+	private blockingErrorContainer: Container;
 	private defaultEditor: CustomEditor;
 	private editor: EditorComponent;
 	private autocompleteProvider: CombinedAutocompleteProvider | undefined;
@@ -220,6 +275,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;
@@ -326,8 +382,17 @@ 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.blockingErrorContainer = new Container();
 		this.widgetContainerAbove = new Container();
 		this.widgetContainerBelow = new Container();
 		this.keybindings = KeybindingsManager.create();
@@ -530,10 +595,12 @@ export class InteractiveMode {
 			}
 		}
 
+		this.ui.addChild(this.adaptiveLayout);
 		this.ui.addChild(this.chatContainer);
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
 		this.ui.addChild(this.pinnedMessageContainer);
+		this.ui.addChild(this.blockingErrorContainer);
 		this.renderWidgets(); // Initialize with default spacer
 		this.ui.addChild(this.widgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
@@ -1180,6 +1247,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();
@@ -1304,7 +1372,7 @@ export class InteractiveMode {
 			modelRegistry: this.session.modelRegistry,
 			model: this.session.model,
 			isIdle: () => !this.session.isStreaming,
-			abort: () => this.session.abort(),
+				abort: () => this.session.abort({ origin: "user" }),
 			hasPendingMessages: () => this.session.pendingMessageCount > 0,
 			shutdown: () => {
 				this.shutdownRequested = true;
@@ -1324,6 +1392,9 @@ export class InteractiveMode {
 				})();
 			},
 			getSystemPrompt: () => this.session.systemPrompt,
+			setCompactionThresholdOverride: (percent) => {
+				this.session.settingsManager.setCompactionThresholdOverride(percent);
+			},
 		});
 
 		// Set up the extension shortcut handler on the default editor
@@ -1833,16 +1904,20 @@ export class InteractiveMode {
 	/**
 	 * Show a notification for extensions.
 	 */
-	private showExtensionNotify(message: string, type?: "info" | "warning" | "error" | "success"): void {
+	private showExtensionNotify(message: string, type?: ExtensionNotifyType): void {
 		if (type === "error") {
-			this.showError(message);
-		} else if (type === "warning") {
-			this.showWarning(message);
-		} else if (type === "success") {
-			this.showSuccess(message);
-		} else {
-			this.showStatus(message, { append: true });
+			this.lastBlockingError = message;
+			renderBlockingErrorBanner(this.blockingErrorContainer, this.lastBlockingError);
+		}
+		const result = renderExtensionNotifyInChat(this.chatContainer, message, type);
+		if (!result.rendered) {
+			return;
 		}
+		if (result.statusSpacer && result.statusText) {
+			this.lastStatusSpacer = result.statusSpacer;
+			this.lastStatusText = result.statusText;
+		}
+		this.ui.requestRender();
 	}
 
 	/** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
@@ -2839,11 +2914,19 @@ export class InteractiveMode {
 	}
 
 	showError(errorMessage: string): void {
+		this.lastBlockingError = errorMessage;
+		renderBlockingErrorBanner(this.blockingErrorContainer, this.lastBlockingError);
 		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;
+		renderBlockingErrorBanner(this.blockingErrorContainer, undefined);
+		this.ui.requestRender();
+	}
+
 	showWarning(warningMessage: string): void {
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
@@ -2954,7 +3037,7 @@ export class InteractiveMode {
 		if (allQueued.length === 0) {
 			this.updatePendingMessagesDisplay();
 			if (options?.abort) {
-				this.agent.abort();
+					this.agent.abort("user");
 			}
 			return 0;
 		}
@@ -2964,7 +3047,7 @@ export class InteractiveMode {
 		this.editor.setText(combinedText);
 		this.updatePendingMessagesDisplay();
 		if (options?.abort) {
-			this.agent.abort();
+				this.agent.abort("user");
 		}
 		return allQueued.length;
 	}
@@ -3154,6 +3237,7 @@ export class InteractiveMode {
 					quietStartup: this.settingsManager.getQuietStartup(),
 					clearOnShrink: this.settingsManager.getClearOnShrink(),
 					timestampFormat: this.settingsManager.getTimestampFormat(),
+					adaptiveMode: this.settingsManager.getAdaptiveMode(),
 				},
 				{
 					onAutoCompactChange: (enabled) => {
@@ -3260,6 +3344,10 @@ export class InteractiveMode {
 					onTimestampFormatChange: (format) => {
 						this.settingsManager.setTimestampFormat(format);
 					},
+					onAdaptiveModeChange: (mode) => {
+						this.settingsManager.setAdaptiveMode(mode);
+						this.ui.requestRender();
+					},
 					onCancel: () => {
 						done();
 						this.ui.requestRender();
@@ -3648,6 +3736,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);
@@ -3969,6 +4058,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/);
+	});
+});