lsd-pi 1.1.4 → 1.1.6

package/packages/pi-coding-agent/src/core/tools/pty.ts

@@ -0,0 +1,354 @@
+import { randomUUID } from "node:crypto";
+import type { AgentTool } from "@gsd/pi-agent-core";
+import { type Static, Type } from "@sinclair/typebox";
+import { executeBashInPty, type PtyExecutionSession } from "../pty-executor.js";
+import {
+	createHeadlessTerminal,
+	snapshotTerminalBufferText,
+	snapshotTerminalViewportText,
+	type HeadlessTerminal,
+} from "../../utils/terminal-screen.js";
+
+const ptyStartSchema = Type.Object({
+	command: Type.String({ description: "Shell command to start inside the PTY" }),
+	cols: Type.Optional(Type.Number({ description: "Terminal width in columns (default 80)" })),
+	rows: Type.Optional(Type.Number({ description: "Terminal height in rows (default 24)" })),
+	loginShell: Type.Optional(Type.Boolean({ description: "Whether to run the command in a login shell" })),
+});
+
+const ptySendSchema = Type.Object({
+	sessionId: Type.String({ description: "PTY session id from pty_start" }),
+	input: Type.String({ description: "Text or control sequence to send, e.g. \"y\\r\" or \"\\u001b[A\"" }),
+});
+
+const ptyReadSchema = Type.Object({
+	sessionId: Type.String({ description: "PTY session id from pty_start" }),
+	view: Type.Optional(Type.Union([
+		Type.Literal("viewport"),
+		Type.Literal("buffer"),
+	], { description: "Read the visible screen (viewport) or the full logical buffer" })),
+});
+
+const ptyWaitSchema = Type.Object({
+	sessionId: Type.String({ description: "PTY session id from pty_start" }),
+	text: Type.Optional(Type.String({ description: "Wait until the viewport or buffer contains this text" })),
+	view: Type.Optional(Type.Union([
+		Type.Literal("viewport"),
+		Type.Literal("buffer"),
+	], { description: "Where to search for the text (default viewport)" })),
+	timeoutMs: Type.Optional(Type.Number({ description: "How long to wait before timing out (default 30000)" })),
+	stableMs: Type.Optional(Type.Number({ description: "If text is omitted, wait until the screen stops changing for this long (default 800)" })),
+});
+
+const ptyResizeSchema = Type.Object({
+	sessionId: Type.String({ description: "PTY session id from pty_start" }),
+	cols: Type.Number({ description: "Terminal width in columns" }),
+	rows: Type.Number({ description: "Terminal height in rows" }),
+});
+
+const ptyKillSchema = Type.Object({
+	sessionId: Type.String({ description: "PTY session id from pty_start" }),
+});
+
+export type PtyStartInput = Static<typeof ptyStartSchema>;
+export type PtySendInput = Static<typeof ptySendSchema>;
+export type PtyReadInput = Static<typeof ptyReadSchema>;
+export type PtyWaitInput = Static<typeof ptyWaitSchema>;
+export type PtyResizeInput = Static<typeof ptyResizeSchema>;
+export type PtyKillInput = Static<typeof ptyKillSchema>;
+
+interface ManagedPtySession {
+	id: string;
+	command: string;
+	pty: PtyExecutionSession;
+	terminal: HeadlessTerminal;
+	writeChain: Promise<void>;
+	completed: boolean;
+	cancelled: boolean;
+	exitCode?: number;
+	createdAt: number;
+	lastUpdateAt: number;
+}
+
+export interface PtyToolDetails {
+	sessionId: string;
+	pid?: number;
+	completed?: boolean;
+	cancelled?: boolean;
+	exitCode?: number;
+	view?: "viewport" | "buffer";
+	screenText?: string;
+}
+
+class PtySessionManager {
+	private sessions = new Map<string, ManagedPtySession>();
+
+	constructor(private cwd: string) {}
+
+	async start(command: string, options?: { cols?: number; rows?: number; loginShell?: boolean }): Promise<ManagedPtySession> {
+		const id = `pty_${randomUUID().slice(0, 8)}`;
+		const terminal = createHeadlessTerminal(options?.cols ?? 80, options?.rows ?? 24, 10000);
+		const session: ManagedPtySession = {
+			id,
+			command,
+			pty: undefined as unknown as PtyExecutionSession,
+			terminal,
+			writeChain: Promise.resolve(),
+			completed: false,
+			cancelled: false,
+			createdAt: Date.now(),
+			lastUpdateAt: Date.now(),
+		};
+		this.sessions.set(id, session);
+
+		let pty: PtyExecutionSession;
+		try {
+			pty = await executeBashInPty(command, {
+				cols: options?.cols,
+				rows: options?.rows,
+				cwd: this.cwd,
+				loginShell: options?.loginShell,
+				onChunk: (chunk) => {
+					const current = this.sessions.get(id);
+					if (!current) return;
+					current.lastUpdateAt = Date.now();
+					current.writeChain = current.writeChain.then(
+						() =>
+							new Promise<void>((resolve) => {
+								current.terminal.write(chunk, () => resolve());
+							}),
+					);
+				},
+			});
+		} catch (error) {
+			this.sessions.delete(id);
+			throw error;
+		}
+		session.pty = pty;
+
+		pty.result
+			.then((result) => {
+				const current = this.sessions.get(id);
+				if (!current) return;
+				current.completed = true;
+				current.cancelled = result.cancelled;
+				current.exitCode = result.exitCode;
+				current.lastUpdateAt = Date.now();
+			})
+			.catch(() => {
+				const current = this.sessions.get(id);
+				if (!current) return;
+				current.completed = true;
+				current.lastUpdateAt = Date.now();
+			});
+
+		return session;
+	}
+
+	get(sessionId: string): ManagedPtySession {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			throw new Error(`PTY session not found: ${sessionId}`);
+		}
+		return session;
+	}
+
+	async send(sessionId: string, input: string): Promise<ManagedPtySession> {
+		const session = this.get(sessionId);
+		if (session.completed || !session.pty.handle.isActive()) {
+			throw new Error(`PTY session is no longer active: ${sessionId}`);
+		}
+		session.pty.handle.write(input);
+		session.lastUpdateAt = Date.now();
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		return session;
+	}
+
+	async resize(sessionId: string, cols: number, rows: number): Promise<ManagedPtySession> {
+		const session = this.get(sessionId);
+		const safeCols = Math.max(20, cols);
+		const safeRows = Math.max(5, rows);
+		session.pty.handle.resize(safeCols, safeRows);
+		session.terminal.resize(safeCols, safeRows);
+		session.lastUpdateAt = Date.now();
+		return session;
+	}
+
+	async kill(sessionId: string): Promise<ManagedPtySession> {
+		const session = this.get(sessionId);
+		if (session.pty.handle.isActive()) {
+			session.pty.handle.kill();
+		}
+		session.cancelled = true;
+		session.completed = true;
+		session.lastUpdateAt = Date.now();
+		return session;
+	}
+
+	async read(sessionId: string, view: "viewport" | "buffer" = "viewport"): Promise<{ session: ManagedPtySession; text: string }> {
+		const session = this.get(sessionId);
+		await session.writeChain;
+		const text = view === "buffer"
+			? snapshotTerminalBufferText(session.terminal)
+			: snapshotTerminalViewportText(session.terminal);
+		return { session, text };
+	}
+
+	async wait(
+		sessionId: string,
+		options?: { text?: string; view?: "viewport" | "buffer"; timeoutMs?: number; stableMs?: number },
+	): Promise<{ session: ManagedPtySession; text: string }> {
+		const timeoutMs = Math.max(50, options?.timeoutMs ?? 30000);
+		const stableMs = Math.max(50, options?.stableMs ?? 800);
+		const view = options?.view ?? "viewport";
+		const start = Date.now();
+		let lastSnapshot = "";
+		let stableSince = Date.now();
+
+		while (Date.now() - start < timeoutMs) {
+			const { text } = await this.read(sessionId, view);
+			if (options?.text) {
+				if (text.includes(options.text)) {
+					return { session: this.get(sessionId), text };
+				}
+				if (this.get(sessionId).completed) {
+					return { session: this.get(sessionId), text };
+				}
+			} else {
+				if (text !== lastSnapshot) {
+					lastSnapshot = text;
+					stableSince = Date.now();
+				} else if (Date.now() - stableSince >= stableMs || this.get(sessionId).completed) {
+					return { session: this.get(sessionId), text };
+				}
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+
+		await this.read(sessionId, view);
+		throw new Error(
+			options?.text
+				? `Timed out waiting for text in PTY session ${sessionId}: ${options.text}`
+				: `Timed out waiting for PTY session ${sessionId} to stabilize`,
+		);
+	}
+}
+
+function formatSessionSummary(session: ManagedPtySession): string {
+	const bits = [`session ${session.id}`, `pid ${session.pty.handle.pid}`];
+	if (session.completed) {
+		bits.push(session.cancelled ? "cancelled" : `completed${session.exitCode !== undefined ? ` exit ${session.exitCode}` : ""}`);
+	} else {
+		bits.push("running");
+	}
+	return bits.join(" · ");
+}
+
+function buildReadText(session: ManagedPtySession, view: "viewport" | "buffer", text: string): string {
+	const header = `[${formatSessionSummary(session)} · ${view}]`;
+	return text ? `${header}\n${text}` : `${header}\n(no visible text)`;
+}
+
+export function createPtyTools(cwd: string): Record<string, AgentTool<any, PtyToolDetails>> {
+	const manager = new PtySessionManager(cwd);
+
+	const ptyStartTool: AgentTool<typeof ptyStartSchema, PtyToolDetails> = {
+		name: "pty_start",
+		label: "pty_start",
+		description: "Start an agent-controlled interactive PTY session. Use this when a command requires terminal interaction, prompts, or a full-screen TUI. Returns a sessionId for follow-up pty_send/pty_read/pty_wait/pty_kill calls.",
+		parameters: ptyStartSchema,
+		execute: async (_toolCallId, { command, cols, rows, loginShell }) => {
+			const session = await manager.start(command, { cols, rows, loginShell });
+			const { text } = await manager.read(session.id, "viewport");
+			return {
+				content: [{ type: "text", text: `Started PTY session ${session.id} for: ${command}\n${buildReadText(session, "viewport", text)}` }],
+				details: { sessionId: session.id, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode, view: "viewport", screenText: text },
+			};
+		},
+	};
+
+	const ptySendTool: AgentTool<typeof ptySendSchema, PtyToolDetails> = {
+		name: "pty_send",
+		label: "pty_send",
+		description: "Send text or control sequences to an existing PTY session, e.g. \"y\\r\" or \"\\u001b[A\".",
+		parameters: ptySendSchema,
+		execute: async (_toolCallId, { sessionId, input }) => {
+			const session = await manager.send(sessionId, input);
+			const { text } = await manager.read(sessionId, "viewport");
+			return {
+				content: [{ type: "text", text: `Sent input to ${sessionId}: ${JSON.stringify(input)}\n${buildReadText(session, "viewport", text)}` }],
+				details: { sessionId, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode, view: "viewport", screenText: text },
+			};
+		},
+	};
+
+	const ptyReadTool: AgentTool<typeof ptyReadSchema, PtyToolDetails> = {
+		name: "pty_read",
+		label: "pty_read",
+		description: "Read the current PTY screen state. Use view='viewport' for the visible screen or view='buffer' for the full logical buffer.",
+		parameters: ptyReadSchema,
+		execute: async (_toolCallId, { sessionId, view }) => {
+			const effectiveView = view ?? "viewport";
+			const { session, text } = await manager.read(sessionId, effectiveView);
+			return {
+				content: [{ type: "text", text: buildReadText(session, effectiveView, text) }],
+				details: { sessionId, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode, view: effectiveView, screenText: text },
+			};
+		},
+	};
+
+	const ptyWaitTool: AgentTool<typeof ptyWaitSchema, PtyToolDetails> = {
+		name: "pty_wait",
+		label: "pty_wait",
+		description: "Wait until text appears in a PTY session or until the PTY screen stops changing. Useful between pty_send calls.",
+		parameters: ptyWaitSchema,
+		execute: async (_toolCallId, { sessionId, text, view, timeoutMs, stableMs }) => {
+			const effectiveView = view ?? "viewport";
+			const result = await manager.wait(sessionId, { text, view: effectiveView, timeoutMs, stableMs });
+			return {
+				content: [{ type: "text", text: buildReadText(result.session, effectiveView, result.text) }],
+				details: { sessionId, pid: result.session.pty.handle.pid, completed: result.session.completed, cancelled: result.session.cancelled, exitCode: result.session.exitCode, view: effectiveView, screenText: result.text },
+			};
+		},
+	};
+
+	const ptyResizeTool: AgentTool<typeof ptyResizeSchema, PtyToolDetails> = {
+		name: "pty_resize",
+		label: "pty_resize",
+		description: "Resize an active PTY session to the given terminal dimensions.",
+		parameters: ptyResizeSchema,
+		execute: async (_toolCallId, { sessionId, cols, rows }) => {
+			const session = await manager.resize(sessionId, cols, rows);
+			const { text } = await manager.read(sessionId, "viewport");
+			return {
+				content: [{ type: "text", text: `Resized ${sessionId} to ${cols}x${rows}\n${buildReadText(session, "viewport", text)}` }],
+				details: { sessionId, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode, view: "viewport", screenText: text },
+			};
+		},
+	};
+
+	const ptyKillTool: AgentTool<typeof ptyKillSchema, PtyToolDetails> = {
+		name: "pty_kill",
+		label: "pty_kill",
+		description: "Terminate an agent-controlled PTY session.",
+		parameters: ptyKillSchema,
+		execute: async (_toolCallId, { sessionId }) => {
+			const session = await manager.kill(sessionId);
+			return {
+				content: [{ type: "text", text: `Terminated PTY session ${sessionId}. ${formatSessionSummary(session)}` }],
+				details: { sessionId, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode },
+			};
+		},
+	};
+
+	return {
+		pty_start: ptyStartTool,
+		pty_send: ptySendTool,
+		pty_read: ptyReadTool,
+		pty_wait: ptyWaitTool,
+		pty_resize: ptyResizeTool,
+		pty_kill: ptyKillTool,
+	};
+}
+
+export const ptyToolNames = ["pty_start", "pty_send", "pty_read", "pty_wait", "pty_resize", "pty_kill"] as const;

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

@@ -9,6 +9,7 @@ import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
 export class AssistantMessageComponent extends Container {
 	private contentContainer: Container;
 	private hideThinkingBlock: boolean;
+	private thinkingLevel: string;
 	private markdownTheme: MarkdownTheme;
 	private lastMessage?: AssistantMessage;
 	private timestampFormat: TimestampFormat;
@@ -18,10 +19,12 @@ export class AssistantMessageComponent extends Container {
 		hideThinkingBlock = false,
 		markdownTheme: MarkdownTheme = getMarkdownTheme(),
 		timestampFormat: TimestampFormat = "date-time-iso",
+		thinkingLevel = "off",
 	) {
 		super();
 
 		this.hideThinkingBlock = hideThinkingBlock;
+		this.thinkingLevel = thinkingLevel;
 		this.markdownTheme = markdownTheme;
 		this.timestampFormat = timestampFormat;
 
@@ -45,51 +48,61 @@ export class AssistantMessageComponent extends Container {
 		this.hideThinkingBlock = hide;
 	}
 
+	setThinkingLevel(level: string): void {
+		this.thinkingLevel = level;
+	}
+
 	updateContent(message: AssistantMessage): void {
 		this.lastMessage = message;
 
 		// Clear content container
 		this.contentContainer.clear();
 
-		const hasVisibleContent = message.content.some(
-			(c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
-		);
+		const hasVisibleContent = message.content.some((c) => {
+			if (c.type === "text") return Boolean(c.text.trim());
+			if (c.type === "thinking") return !this.hideThinkingBlock && Boolean(c.thinking.trim());
+			return false;
+		});
 
 		if (hasVisibleContent) {
 			this.contentContainer.addChild(new Spacer(1));
 		}
 
 		// Render content in order
+		let markerAdded = false;
+		const responseMarker = `${theme.fg("accent", "●")} `;
 		for (let i = 0; i < message.content.length; i++) {
 			const content = message.content[i];
 			if (content.type === "text" && content.text.trim()) {
 				// Assistant text messages with no background - trim the text
 				// Set paddingY=0 to avoid extra spacing before tool executions
-				this.contentContainer.addChild(new Markdown(content.text.trim(), 1, 0, this.markdownTheme));
+				const text = content.text.trim();
+				const withMarker = markerAdded ? text : `${responseMarker}${text}`;
+				this.contentContainer.addChild(new Markdown(withMarker, 1, 0, this.markdownTheme));
+				markerAdded = true;
 			} else if (content.type === "thinking" && content.thinking.trim()) {
+				if (this.hideThinkingBlock) {
+					// Hide thinking content entirely when hide-thinking is enabled.
+					continue;
+				}
+
 				// Add spacing only when another visible assistant content block follows.
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
-				const hasVisibleContentAfter = message.content
-					.slice(i + 1)
-					.some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
+				const hasVisibleContentAfter = message.content.slice(i + 1).some((c) => {
+					if (c.type === "text") return Boolean(c.text.trim());
+					if (c.type === "thinking") return !this.hideThinkingBlock && Boolean(c.thinking.trim());
+					return false;
+				});
 
-				if (this.hideThinkingBlock) {
-					// Show static "Thinking..." label when hidden
-					this.contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", "Thinking...")), 1, 0));
-					if (hasVisibleContentAfter) {
-						this.contentContainer.addChild(new Spacer(1));
-					}
-				} else {
-					// Thinking traces in thinkingText color, italic
-					this.contentContainer.addChild(
-						new Markdown(content.thinking.trim(), 1, 0, this.markdownTheme, {
-							color: (text: string) => theme.fg("thinkingText", text),
-							italic: true,
-						}),
-					);
-					if (hasVisibleContentAfter) {
-						this.contentContainer.addChild(new Spacer(1));
-					}
+				// Thinking traces in thinkingText color, italic
+				this.contentContainer.addChild(
+					new Markdown(content.thinking.trim(), 1, 0, this.markdownTheme, {
+						color: (text: string) => theme.fg("thinkingText", text),
+						italic: true,
+					}),
+				);
+				if (hasVisibleContentAfter) {
+					this.contentContainer.addChild(new Spacer(1));
 				}
 			}
 		}

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

@@ -3,21 +3,17 @@
  */
 
 import { Container, Loader, Text, type TUI } from "@gsd/pi-tui";
-import stripAnsi from "strip-ansi";
 import {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
 	type TruncationResult,
 	truncateTail,
 } from "../../../core/tools/truncate.js";
+import { renderTerminalLines } from "../../../utils/terminal-serializer.js";
 import { theme, type ThemeColor } from "../theme/theme.js";
-import { DynamicBorder } from "./dynamic-border.js";
 import { editorKey, keyHint } from "./keybinding-hints.js";
 import { truncateToVisualLines } from "./visual-truncate.js";
 
-// Flash interval for RTK badge animation (ms)
-const RTK_FLASH_INTERVAL_MS = 400;
-
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
 
@@ -26,6 +22,7 @@ type ToolOutputMode = "minimal" | "normal";
 export class BashExecutionComponent extends Container {
 	private command: string;
 	private outputLines: string[] = [];
+	private rawOutput = "";
 	private status: "running" | "complete" | "cancelled" | "error" = "running";
 	private exitCode: number | undefined = undefined;
 	private loader: Loader;
@@ -37,10 +34,7 @@ export class BashExecutionComponent extends Container {
 	private ui: TUI;
 	private colorKey: ThemeColor;
 	private sandboxed: boolean;
-	private rtkActive: boolean;
-	private rtkFlashOn = true;
-	private rtkFlashTimer: NodeJS.Timeout | null = null;
-	// Dedicated header node — updated in-place to avoid full container rebuild on flash tick
+	// Dedicated header node
 	private headerText: Text;
 
 	constructor(
@@ -48,28 +42,23 @@ export class BashExecutionComponent extends Container {
 		ui: TUI,
 		excludeFromContext = false,
 		renderMode: ToolOutputMode = "normal",
-		rtkActive = false,
+		_rtkActive = false,
 		sandboxed = false,
 	) {
 		super();
 		this.command = command;
 		this.ui = ui;
 		this.renderMode = renderMode;
-		this.rtkActive = rtkActive;
 		this.sandboxed = sandboxed;
 
-		// Use dim border for excluded-from-context commands (!! prefix)
+		// Use dim tone for excluded-from-context commands (!! prefix)
 		this.colorKey = (excludeFromContext ? "dim" : "bashMode") as ThemeColor;
-		const borderColor = (str: string) => theme.fg(this.colorKey, str);
-
-		// Top border
-		this.addChild(new DynamicBorder(borderColor));
 
-		// Content container (holds dynamic content between borders)
+		// Content container
 		this.contentContainer = new Container();
 		this.addChild(this.contentContainer);
 
-		// Dedicated header Text node — updated directly for flash without full rebuild
+		// Header Text node
 		this.headerText = new Text(this.buildHeaderText(), 1, 0);
 		this.contentContainer.addChild(this.headerText);
 
@@ -81,33 +70,14 @@ export class BashExecutionComponent extends Container {
 			`Running... (${editorKey("selectCancel")} to cancel)`, // Plain text for loader
 		);
 		this.contentContainer.addChild(this.loader);
-
-		// Bottom border
-		this.addChild(new DynamicBorder(borderColor));
-
-		// Start RTK flash animation if active
-		if (this.rtkActive) {
-			this.rtkFlashTimer = setInterval(() => {
-				this.rtkFlashOn = !this.rtkFlashOn;
-				// Only update the header node — no full container rebuild
-				this.headerText.setText(this.buildHeaderText());
-				this.ui.requestRender();
-			}, RTK_FLASH_INTERVAL_MS);
-		}
 	}
 
-	/** Build the header line text including the RTK badge when active. */
+	/** Build the header line text. */
 	private buildHeaderText(): string {
-		let text = theme.fg(this.colorKey, theme.bold(`$ ${this.command}`));
+		let text = `${theme.fg("toolTitle", theme.bold("bash"))} ${theme.fg(this.colorKey, theme.bold(`$ ${this.command}`))}`;
 		if (this.sandboxed) {
 			text += `  ${theme.fg("success", "[sandboxed]")}`;
 		}
-		if (this.rtkActive) {
-			const badge = this.rtkFlashOn
-				? theme.fg("accent", "$ RTK")
-				: theme.fg("dim", "$ RTK");
-			text = `${text}  ${badge}`;
-		}
 		return text;
 	}
 
@@ -116,10 +86,6 @@ export class BashExecutionComponent extends Container {
 	 * from the tree before setComplete() has been called (e.g. on clear/cancel).
 	 */
 	dispose(): void {
-		if (this.rtkFlashTimer) {
-			clearInterval(this.rtkFlashTimer);
-			this.rtkFlashTimer = null;
-		}
 		this.loader.dispose();
 	}
 
@@ -144,20 +110,9 @@ export class BashExecutionComponent extends Container {
 	}
 
 	appendOutput(chunk: string): void {
-		// Strip ANSI codes and normalize line endings
-		// Note: binary data is already sanitized in tui-renderer.ts executeBashCommand
-		const clean = stripAnsi(chunk).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-
-		// Append to output lines
-		const newLines = clean.split("\n");
-		if (this.outputLines.length > 0 && newLines.length > 0) {
-			// Append first chunk to last line (incomplete line continuation)
-			this.outputLines[this.outputLines.length - 1] += newLines[0];
-			this.outputLines.push(...newLines.slice(1));
-		} else {
-			this.outputLines.push(...newLines);
-		}
-
+		// Strip ANSI codes and preserve carriage-return semantics for display.
+		this.rawOutput += chunk;
+		this.outputLines = renderTerminalLines(this.rawOutput);
 		this.updateDisplay();
 	}
 
@@ -183,15 +138,6 @@ export class BashExecutionComponent extends Container {
 		// Stop loader
 		this.loader.stop();
 
-		// Stop RTK flash — settle to steady dim state
-		if (this.rtkFlashTimer) {
-			clearInterval(this.rtkFlashTimer);
-			this.rtkFlashTimer = null;
-			this.rtkFlashOn = false;
-			// Final header update to ensure dim badge is shown
-			this.headerText.setText(this.buildHeaderText());
-		}
-
 		this.updateDisplay();
 	}
 
@@ -223,7 +169,7 @@ export class BashExecutionComponent extends Container {
 				const displayText = availableLines.map((line) => theme.fg("muted", line)).join("\n");
 				this.contentContainer.addChild(new Text(`\n${displayText}`, 1, 0));
 			} else if (this.renderMode === "minimal") {
-				this.contentContainer.addChild(new Text(`\n${theme.fg("muted", `(${keyHint("expandTools", "to expand")})`)}`, 1, 0));
+				// collapsed — no inline hint needed (shown in editor bottom border)
 			} else {
 				// Use shared visual truncation utility
 				const styledOutput = previewLogicalLines.map((line) => theme.fg("muted", line)).join("\n");
@@ -243,14 +189,20 @@ export class BashExecutionComponent extends Container {
 		} else {
 			const statusParts: string[] = [];
 
-			// Show how many lines are hidden (collapsed preview)
-			if (hiddenLineCount > 0) {
+			// Show expand/collapse hint whenever there is output
+			if (availableLines.length > 0) {
 				if (this.expanded) {
 					statusParts.push(`(${keyHint("expandTools", "to collapse")})`);
-				} else {
+				} else if (this.renderMode === "minimal") {
+					statusParts.push(`(${keyHint("expandTools", "to expand")})`);
+				} else if (hiddenLineCount > 0) {
+					// Normal mode: show line count + hint
 					statusParts.push(
 						`${theme.fg("muted", `... ${hiddenLineCount} more lines`)} (${keyHint("expandTools", "to expand")})`,
 					);
+				} else {
+					// Normal mode: all preview lines visible, still offer expand
+					statusParts.push(`(${keyHint("expandTools", "to expand")})`);
 				}
 			}
 

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

@@ -46,9 +46,7 @@ export class BranchSummaryMessageComponent extends Box {
 		} else {
 			this.addChild(
 				new Text(
-					theme.fg("customMessageText", "Branch summary (") +
-						theme.fg("dim", editorKey("expandTools")) +
-						theme.fg("customMessageText", " to expand)"),
+					theme.fg("customMessageText", "Branch summary"),
 					0,
 					0,
 				),

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

@@ -47,9 +47,7 @@ export class CompactionSummaryMessageComponent extends Box {
 		} else {
 			this.addChild(
 				new Text(
-					theme.fg("customMessageText", `Compacted from ${tokenStr} tokens (`) +
-						theme.fg("dim", editorKey("expandTools")) +
-						theme.fg("customMessageText", " to expand)"),
+					theme.fg("customMessageText", `Compacted from ${tokenStr} tokens`),
 					0,
 					0,
 				),