gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/packages/pi-coding-agent/src/modes/interactive/components/adaptive-layout.ts

@@ -0,0 +1,160 @@
+// GSD2 - Adaptive terminal mode dashboard for the interactive TUI
+
+import { style, truncateToWidth, visibleWidth, type Component } from "@gsd/pi-tui";
+import type { TuiAdaptiveMode, TuiMode } from "../tui-mode.js";
+import { resolveTuiMode } from "../tui-mode.js";
+import { theme, type ThemeColor } from "../theme/theme.js";
+
+export interface AdaptiveLayoutState {
+	override: TuiAdaptiveMode;
+	activeToolCount: number;
+	gsdPhase?: string;
+	lastError?: string;
+	sessionName?: string;
+	cwd: string;
+}
+
+export class AdaptiveLayoutComponent implements Component {
+	constructor(private readonly getState: () => AdaptiveLayoutState) {}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const state = this.getState();
+		const mode = resolveTuiMode({
+			terminalWidth: width,
+			override: state.override,
+			activeToolCount: state.activeToolCount,
+			gsdPhase: state.gsdPhase,
+			hasBlockingError: !!state.lastError,
+		});
+
+		if (state.override === "auto" && mode === "chat" && !state.gsdPhase && !state.lastError && state.activeToolCount === 0) {
+			return [];
+		}
+
+		if (mode === "compact" || width < 72) return this.renderCompact(width, mode, state);
+		if (mode === "debug") return this.renderDebug(width, state);
+		if (mode === "validation") return this.renderValidation(width, state);
+		if (mode === "workflow") return this.renderWorkflow(width, state);
+		return this.renderChat(width, state);
+	}
+
+	private renderWorkflow(width: number, state: AdaptiveLayoutState): string[] {
+		if (width < 112) return this.renderCompact(width, "workflow", state);
+
+		const leftWidth = Math.max(44, Math.floor(width * 0.56));
+		const rightWidth = Math.max(32, width - leftWidth - 2);
+		const phase = state.gsdPhase ?? "Ready";
+		const left = this.frame(
+			[
+				this.metric("Active", phase, "modeWorkflow"),
+				this.metric("Tools", state.activeToolCount > 0 ? `${state.activeToolCount} running` : "idle", "toolRunning"),
+				this.metric("Mode", state.override === "auto" ? "auto workflow" : state.override, "modeWorkflow"),
+			],
+			leftWidth,
+			"GSD Command Center",
+			"workflow",
+			"modeWorkflow",
+		);
+		const right = this.frame(
+			[
+				`Session ${state.sessionName ?? "current"}`,
+				`Path ${this.basename(state.cwd)}`,
+				`Next ${state.activeToolCount > 0 ? "watch tool output" : "continue from prompt"}`,
+			],
+			rightWidth,
+			"signals",
+			"inspector",
+			"surfaceAccent",
+		);
+		return this.columns(left, right, leftWidth);
+	}
+
+	private renderValidation(width: number, state: AdaptiveLayoutState): string[] {
+		const phase = state.gsdPhase ?? "Validation pending";
+		return this.frame(
+			[
+				this.metric("Focus", phase, "modeValidation"),
+				this.metric("Checks", state.activeToolCount > 0 ? `${state.activeToolCount} active` : "waiting", "toolRunning"),
+				this.metric("Timeline", state.lastError ? "blocked" : "ready for completion evidence", state.lastError ? "toolError" : "toolSuccess"),
+			],
+			width,
+			"validation",
+			state.override === "auto" ? "auto" : state.override,
+			"modeValidation",
+		);
+	}
+
+	private renderDebug(width: number, state: AdaptiveLayoutState): string[] {
+		const error = state.lastError ?? "Blocking error detected";
+		return this.frame(
+			[
+				this.metric("Failure", truncateToWidth(error, Math.max(20, width - 20), ""), "toolError"),
+				this.metric("Tools", state.activeToolCount > 0 ? `${state.activeToolCount} still running` : "none running", "toolRunning"),
+				this.metric("Next", "inspect the failed output, then retry the smallest step", "modeDebug"),
+			],
+			width,
+			"blocking failure",
+			"debug",
+			"modeDebug",
+		);
+	}
+
+	private renderChat(width: number, state: AdaptiveLayoutState): string[] {
+		return this.frame(
+			[
+				this.metric("Mode", state.override === "auto" ? "auto chat" : state.override, "surfaceAccent"),
+				this.metric("Tools", state.activeToolCount > 0 ? `${state.activeToolCount} active` : "compact rows", "toolMuted"),
+			],
+			width,
+			"chat",
+			state.sessionName ?? "conversation",
+			"surfaceAccent",
+		);
+	}
+
+	private renderCompact(width: number, mode: TuiMode, state: AdaptiveLayoutState): string[] {
+		const phase = state.lastError ?? state.gsdPhase ?? (state.activeToolCount > 0 ? `${state.activeToolCount} tools` : "ready");
+		const line = `${theme.fg("modeCompact", "GSD compact")} ${theme.fg("surfaceMuted", `${mode} · ${phase}`)}`;
+		return style()
+			.border("minimal")
+			.borderColor((text) => theme.fg("surfaceBorder", text))
+			.bodyGutter(" ")
+			.render([line], width);
+	}
+
+	private frame(lines: string[], width: number, title: string, rightTitle: string, accent: ThemeColor): string[] {
+		return style()
+			.border("rule")
+			.density("compact")
+			.toneColor((text) => theme.fg("surfaceMuted", text))
+			.borderColor((text) => theme.fg("surfaceBorder", text))
+			.title(theme.fg("surfaceTitle", title))
+			.rightTitle(theme.fg(accent, rightTitle))
+			.bodyGutter(theme.fg(accent, "│ "))
+			.render(lines, width);
+	}
+
+	private metric(label: string, value: string, color: ThemeColor): string {
+		return `${theme.fg("surfaceMuted", `${label.padEnd(8)} `)}${theme.fg(color, value)}`;
+	}
+
+	private columns(left: string[], right: string[], leftWidth: number): string[] {
+		const rows = Math.max(left.length, right.length);
+		const output: string[] = [];
+		for (let i = 0; i < rows; i++) {
+			const leftLine = left[i] ?? "";
+			const rightLine = right[i] ?? "";
+			const gap = " ".repeat(Math.max(2, leftWidth - visibleWidth(leftLine) + 2));
+			output.push(`${leftLine}${gap}${rightLine}`);
+		}
+		return output;
+	}
+
+	private basename(cwd: string): string {
+		const trimmed = cwd.replace(/\/+$/, "");
+		const slash = trimmed.lastIndexOf("/");
+		return slash === -1 ? trimmed : trimmed.slice(slash + 1);
+	}
+}

package/packages/pi-coding-agent/src/modes/interactive/components/assistant-message.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI - Assistant message card renderer for interactive terminal sessions.
 import type { AssistantMessage } from "@gsd/pi-ai";
 import { Container, Markdown, type MarkdownTheme, Spacer, Text } from "@gsd/pi-tui";
 import { getMarkdownTheme, theme } from "../theme/theme.js";

package/packages/pi-coding-agent/src/modes/interactive/components/chat-frame.ts

@@ -1,4 +1,5 @@
-import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+// GSD2 TUI - Shared chat frame renderer for assistant, user, and system cards.
+import { style, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { theme } from "../theme/theme.js";
 import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
 
@@ -34,7 +35,7 @@ export function renderChatFrame(
 				: "borderAccent";
 	const borderMuted = isPurple ? "customMessageLabel" : "borderMuted";
 	const border = (s: string) => theme.fg(borderColor, s);
-	const leftRaw = `• ${opts.label}`;
+	const leftRaw = opts.label;
 	const rightRaw =
 		opts.showTimestamp === false || !opts.timestamp
 			? ""
@@ -67,21 +68,21 @@ export function renderChatFrame(
 	const headerRow = `${leftStyled}${" ".repeat(gap)}${rightStyled}`;
 	const headerPad = Math.max(0, outerWidth - visibleWidth(headerRow));
 
-	const sourceLines = trimOuterBlankLines(contentLines);
 	const bodyColor =
 		opts.tone === "user"
 			? "userMessageText"
 			: isPurple
 				? "customMessageText"
 				: "assistantMessageText";
+	const sourceLines = trimOuterBlankLines(contentLines);
 	const bodyLines = (sourceLines.length > 0 ? sourceLines : [""]).map((line) => {
 		const clipped = truncateToWidth(line, contentWidth, "");
-		return border("│ ") + theme.fg(bodyColor, clipped);
+		return theme.fg(bodyColor, clipped);
 	});
 
-	return [
-		theme.fg(borderMuted, "─".repeat(outerWidth)),
-		headerRow + " ".repeat(headerPad),
-		...bodyLines,
-	];
+	return style()
+		.border("rule")
+		.borderColor((line) => (line.startsWith("─") ? theme.fg(borderMuted, line) : border(line)))
+		.title(headerRow + " ".repeat(headerPad))
+		.render(bodyLines, outerWidth);
 }

package/packages/pi-coding-agent/src/modes/interactive/components/settings-selector.ts

@@ -1,5 +1,6 @@
 import type { ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Transport } from "@gsd/pi-ai";
+import type { AdaptiveTuiMode } from "../../../core/settings-manager.js";
 import {
 	Container,
 	getCapabilities,
@@ -46,6 +47,7 @@ export interface SettingsConfig {
 	quietStartup: boolean;
 	clearOnShrink: boolean;
 	timestampFormat: "date-time-iso" | "date-time-us";
+	adaptiveMode: AdaptiveTuiMode;
 }
 
 export interface SettingsCallbacks {
@@ -71,6 +73,7 @@ export interface SettingsCallbacks {
 	onQuietStartupChange: (enabled: boolean) => void;
 	onClearOnShrinkChange: (enabled: boolean) => void;
 	onTimestampFormatChange: (format: "date-time-iso" | "date-time-us") => void;
+	onAdaptiveModeChange: (mode: AdaptiveTuiMode) => void;
 	onCancel: () => void;
 }
 
@@ -367,6 +370,15 @@ export class SettingsSelectorComponent extends Container {
 			values: ["date-time-iso", "date-time-us"],
 		});
 
+		const timestampIndex = items.findIndex((item) => item.id === "timestamp-format");
+		items.splice(timestampIndex + 1, 0, {
+			id: "adaptive-mode",
+			label: "TUI adaptive mode",
+			description: "Auto-select or force the terminal layout mode",
+			currentValue: config.adaptiveMode,
+			values: ["auto", "chat", "workflow", "validation", "debug", "compact"],
+		});
+
 		// Add borders
 		this.addChild(new DynamicBorder());
 
@@ -435,6 +447,9 @@ export class SettingsSelectorComponent extends Container {
 					case "timestamp-format":
 						callbacks.onTimestampFormatChange(newValue as "date-time-iso" | "date-time-us");
 						break;
+					case "adaptive-mode":
+						callbacks.onAdaptiveModeChange(newValue as AdaptiveTuiMode);
+						break;
 				}
 			},
 			callbacks.onCancel,

package/packages/pi-coding-agent/src/modes/interactive/components/tool-card-cleanup-and-success-runtime.test.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI Tests - Runtime coverage for tool-card cleanup and success notification rendering.
 // Runtime regression tests for the post-compaction tool-card cleanup and the
 // green-bordered success-notification rendering. Replaces the source-grep
 // `src/tests/tui-running-and-success-box.test.ts` that was deleted in #4875
@@ -17,6 +18,7 @@ import { Container, Text } from "@gsd/pi-tui";
 import stripAnsi from "strip-ansi";
 
 import { initTheme, theme } from "../theme/theme.js";
+import { renderExtensionNotifyInChat, shouldRenderExtensionNotifyInChat } from "../interactive-mode.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { ToolExecutionComponent } from "./tool-execution.js";
 
@@ -26,6 +28,36 @@ before(() => {
 	initTheme("dark");
 });
 
+describe("Extension warning notifications", () => {
+	it("do not render into chat output", () => {
+		assert.equal(shouldRenderExtensionNotifyInChat("warning"), false);
+		assert.equal(shouldRenderExtensionNotifyInChat("error"), true);
+		assert.equal(shouldRenderExtensionNotifyInChat("success"), true);
+		assert.equal(shouldRenderExtensionNotifyInChat("info"), true);
+		assert.equal(shouldRenderExtensionNotifyInChat(undefined), true);
+
+		const warningChat = new Container();
+		const warningResult = renderExtensionNotifyInChat(warningChat, "extension warning", "warning");
+		assert.equal(warningResult.rendered, false);
+		assert.equal(
+			warningChat.render(80).map(stripAnsi).join("\n"),
+			"",
+			"warning notifications must not add chat output",
+		);
+
+		for (const type of ["error", "success", "info"] as const) {
+			const chat = new Container();
+			const result = renderExtensionNotifyInChat(chat, `${type} notification`, type);
+			assert.equal(result.rendered, true, `${type} notification should render`);
+			assert.match(
+				chat.render(80).map(stripAnsi).join("\n"),
+				new RegExp(`${type} notification`),
+				`${type} notification text should appear in chat output`,
+			);
+		}
+	});
+});
+
 interface MockTui {
 	renderCount: number;
 	requestRender(): void;
@@ -43,7 +75,7 @@ function makeMockTUI(): MockTui {
 // ─── Bug 1: tool cards stuck in "Running" after compaction ──────────────
 
 describe("ToolExecutionComponent post-compaction cleanup", () => {
-	it("renders 'Running' status while the tool call has no result", () => {
+	it("renders 'running' status while the tool call has no result", () => {
 		// Baseline: a freshly-constructed component (mid-stream) must show
 		// the running badge — this is the state we need to flip OUT of when
 		// compaction removes the result message.
@@ -57,12 +89,12 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 		);
 		const rendered = c.render(60).map(stripAnsi).join("\n");
 		assert.ok(
-			rendered.includes("Running"),
-			"freshly constructed component should render 'Running' badge",
+			rendered.includes("running"),
+			"freshly constructed component should render 'running' badge",
 		);
 	});
 
-	it("markHistoricalNoResult flips a stuck tool card OUT of 'Running'", () => {
+	it("markHistoricalNoResult flips a stuck tool card OUT of 'running'", () => {
 		// Real bug: after session-history replay (post-compaction or session
 		// switch), tool calls without matching tool_result messages stay in
 		// isPartial = true forever. markHistoricalNoResult must produce a
@@ -80,13 +112,13 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 
 		const rendered = c.render(60).map(stripAnsi).join("\n");
 		assert.ok(
-			!rendered.includes("Running"),
-			"after markHistoricalNoResult, the tool card must NOT render 'Running' — got:\n" +
+			!rendered.includes("running"),
+			"after markHistoricalNoResult, the tool card must NOT render 'running' -- got:\n" +
 				rendered,
 		);
 		assert.ok(
-			rendered.includes("Done"),
-			"flipped card should render 'Done' status (no-result success)",
+			rendered.includes("success"),
+			"flipped card should render 'success' status (no-result success)",
 		);
 	});
 
@@ -114,7 +146,7 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 		);
 
 		const before = c.render(60).map(stripAnsi).join("\n");
-		assert.ok(before.includes("Done"), "after complete(), card shows 'Done'");
+		assert.ok(before.includes("success"), "after complete(), card shows 'success'");
 
 		c.markHistoricalNoResult(); // must early-return
 		const after = c.render(60).map(stripAnsi).join("\n");

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;
@@ -619,8 +699,13 @@ export class ToolExecutionComponent extends Container {
 			// Render result component if we have a result
 			if (this.result && this.toolDefinition.renderResult) {
 				try {
+					const rendererResult = {
+						content: this.result.content as any,
+						details: this.result.details,
+						isError: this.result.isError,
+					};
 					const resultComponent = this.toolDefinition.renderResult(
-						{ content: this.result.content as any, details: this.result.details },
+						rendererResult,
 						{ expanded: this.expanded, isPartial: this.isPartial },
 						theme,
 					);
@@ -1196,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);
+});