gsd-pi 2.70.1-dev.3e19108 → 2.70.1-dev.6504106

package/packages/pi-coding-agent/src/core/chat-controller-ordering.test.ts

@@ -42,13 +42,27 @@ function createHost() {
 		},
 	};
 
+	const pinnedMessageContainer = {
+		children: [] as any[],
+		addChild(component: any) {
+			this.children.push(component);
+		},
+		removeChild(component: any) {
+			const idx = this.children.indexOf(component);
+			if (idx !== -1) this.children.splice(idx, 1);
+		},
+		clear() {
+			this.children = [];
+		},
+	};
+
 	const host: any = {
 		isInitialized: true,
 		init: async () => {},
 		defaultEditor: { onEscape: undefined },
 		editor: {},
 		session: { retryAttempt: 0, abortCompaction: () => {}, abortRetry: () => {} },
-		ui: { requestRender: () => {} },
+		ui: { requestRender: () => {}, terminal: { rows: 50 } },
 		footer: { invalidate: () => {} },
 		keybindings: {},
 		statusContainer: { clear: () => {}, addChild: () => {} },
@@ -62,6 +76,7 @@ function createHost() {
 		compactionQueuedMessages: [],
 		editorContainer: {},
 		pendingMessagesContainer: { clear: () => {} },
+		pinnedMessageContainer,
 		addMessageToChat: () => {},
 		getMarkdownThemeWithSettings: () => ({}),
 		formatWebSearchResult: () => "",
@@ -150,3 +165,206 @@ test("chat-controller keeps tool output ahead of delayed assistant text for exte
 	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
 	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
 });
+
+test("chat-controller keeps serverToolUse output ahead of assistant text when external results arrive", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+	const toolId = "mcp-secure-1";
+	const serverToolUse = {
+		type: "serverToolUse",
+		id: toolId,
+		name: "mcp__gsd-workflow__secure_env_collect",
+		input: { projectDir: "/tmp/project", keys: [{ key: "SECURE_PASSWORD" }], destination: "dotenv" },
+	};
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: makeAssistant([serverToolUse]),
+			assistantMessageEvent: {
+				type: "server_tool_use",
+				contentIndex: 0,
+				partial: makeAssistant([serverToolUse]),
+			},
+		} as any,
+	);
+
+	assert.equal(host.streamingComponent, undefined, "assistant content should stay deferred while only tool content streams");
+	assert.equal(host.chatContainer.children.length, 1, "server tool block should render immediately");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
+
+	host.getMarkdownThemeWithSettings = () => ({});
+	const resultMessage = makeAssistant([
+		{
+			...serverToolUse,
+			externalResult: {
+				content: [{ type: "text", text: "secure_env_collect was cancelled by user." }],
+				details: {},
+				isError: true,
+			},
+		},
+		{ type: "text", text: "The secure password collection was cancelled." },
+	]);
+
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: resultMessage,
+			assistantMessageEvent: {
+				type: "server_tool_use",
+				contentIndex: 0,
+				partial: resultMessage,
+			},
+		} as any,
+	);
+
+	assert.equal(host.chatContainer.children.length, 2, "assistant text should render after existing server tool output");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
+	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
+});
+
+test("chat-controller pins latest assistant text above editor when tool calls are present", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+	const toolId = "tool-pin-1";
+	const toolCall = {
+		type: "toolCall",
+		id: toolId,
+		name: "exec_command",
+		arguments: { cmd: "echo hi" },
+	};
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	assert.equal(host.pinnedMessageContainer.children.length, 0, "pinned zone should be empty at message_start");
+
+	// Send a message with text followed by a tool call
+	host.getMarkdownThemeWithSettings = () => ({});
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: makeAssistant([
+				{ type: "text", text: "Looking at the files now." },
+				toolCall,
+			]),
+			assistantMessageEvent: {
+				type: "toolcall_end",
+				contentIndex: 1,
+				toolCall: {
+					...toolCall,
+					externalResult: {
+						content: [{ type: "text", text: "file contents" }],
+						details: {},
+						isError: false,
+					},
+				},
+				partial: makeAssistant([{ type: "text", text: "Looking at the files now." }, toolCall]),
+			},
+		} as any,
+	);
+
+	// Pinned zone should now have a DynamicBorder and a Markdown component
+	assert.equal(host.pinnedMessageContainer.children.length, 2, "pinned zone should have border + markdown");
+	assert.equal(host.pinnedMessageContainer.children[0]?.constructor?.name, "DynamicBorder");
+	assert.equal(host.pinnedMessageContainer.children[1]?.constructor?.name, "Markdown");
+});
+
+test("chat-controller clears pinned zone when a new assistant message starts", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+	const toolCall = {
+		type: "toolCall",
+		id: "tool-clear-1",
+		name: "exec_command",
+		arguments: { cmd: "echo hi" },
+	};
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	// Populate the pinned zone
+	host.getMarkdownThemeWithSettings = () => ({});
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: makeAssistant([{ type: "text", text: "Working on it." }, toolCall]),
+			assistantMessageEvent: {
+				type: "toolcall_end",
+				contentIndex: 1,
+				toolCall: {
+					...toolCall,
+					externalResult: {
+						content: [{ type: "text", text: "ok" }],
+						details: {},
+						isError: false,
+					},
+				},
+				partial: makeAssistant([{ type: "text", text: "Working on it." }, toolCall]),
+			},
+		} as any,
+	);
+
+	assert.ok(host.pinnedMessageContainer.children.length > 0, "pinned zone should be populated");
+
+	// Start a new assistant message — pinned zone should clear
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	assert.equal(host.pinnedMessageContainer.children.length, 0, "pinned zone should clear on new assistant message");
+});
+
+test("chat-controller does not pin when there are no tool calls", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	host.getMarkdownThemeWithSettings = () => ({});
+	await handleAgentEvent(
+		host,
+		{
+			type: "message_update",
+			message: makeAssistant([{ type: "text", text: "Just some text, no tools." }]),
+			assistantMessageEvent: {
+				type: "text_delta",
+				contentIndex: 0,
+				delta: "Just some text, no tools.",
+				partial: makeAssistant([{ type: "text", text: "Just some text, no tools." }]),
+			},
+		} as any,
+	);
+
+	assert.equal(host.pinnedMessageContainer.children.length, 0, "pinned zone should stay empty without tool calls");
+});

package/packages/pi-coding-agent/src/core/extensions/types.ts

@@ -88,6 +88,8 @@ export interface ExtensionUIDialogOptions {
 	timeout?: number;
 	/** When true, the user can select multiple options. The return type becomes `string[]`. */
 	allowMultiple?: boolean;
+	/** When true, text input dialogs should hide typed characters if supported by the client surface. */
+	secure?: boolean;
 }
 
 /** Placement for extension widgets. */

package/packages/pi-coding-agent/src/modes/interactive/components/dynamic-border.ts

@@ -1,8 +1,10 @@
-import type { Component } from "@gsd/pi-tui";
+import type { Component, TUI } from "@gsd/pi-tui";
+import { visibleWidth } from "@gsd/pi-tui";
 import { theme } from "../theme/theme.js";
 
 /**
  * Dynamic border component that adjusts to viewport width.
+ * Supports an optional animated spinner in the label area.
  *
  * Note: When used from extensions loaded via jiti, the global `theme` may be undefined
  * because jiti creates a separate module cache. Always pass an explicit color
@@ -10,11 +12,51 @@ import { theme } from "../theme/theme.js";
  */
 export class DynamicBorder implements Component {
 	private color: (str: string) => string;
+	private label?: string;
+	private spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+	private spinnerIndex = 0;
+	private spinnerInterval: NodeJS.Timeout | null = null;
+	private spinnerColorFn?: (str: string) => string;
 
 	constructor(color: (str: string) => string = (str) => {
 		try { return theme.fg("border", str); } catch { return str; }
-	}) {
+	}, label?: string) {
 		this.color = color;
+		this.label = label;
+	}
+
+	setLabel(label: string | undefined): void {
+		this.label = label;
+	}
+
+	/**
+	 * Start an animated spinner that prepends to the label.
+	 * The spinner rotates every 80ms and triggers a re-render via the TUI.
+	 */
+	startSpinner(ui: TUI, colorFn: (str: string) => string): void {
+		this.stopSpinner();
+		this.spinnerColorFn = colorFn;
+		this.spinnerIndex = 0;
+		this.spinnerInterval = setInterval(() => {
+			this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+			ui.requestRender();
+		}, 80);
+		ui.requestRender();
+	}
+
+	/**
+	 * Stop the spinner animation. The border reverts to a static label.
+	 */
+	stopSpinner(): void {
+		if (this.spinnerInterval) {
+			clearInterval(this.spinnerInterval);
+			this.spinnerInterval = null;
+		}
+		this.spinnerColorFn = undefined;
+	}
+
+	get isSpinning(): boolean {
+		return this.spinnerInterval !== null;
 	}
 
 	invalidate(): void {
@@ -22,6 +64,20 @@ export class DynamicBorder implements Component {
 	}
 
 	render(width: number): string[] {
+		const spinnerPrefix = this.spinnerInterval && this.spinnerColorFn
+			? this.spinnerColorFn(this.spinnerFrames[this.spinnerIndex]) + " "
+			: "";
+
+		if (this.label) {
+			const labelText = ` ${spinnerPrefix}${this.label} `;
+			const labelVisible = visibleWidth(labelText);
+			const leading = "── ";
+			const remaining = Math.max(0, width - labelVisible - leading.length);
+			const trailing = "─".repeat(Math.max(1, remaining));
+			// Color leading and trailing separately so embedded ANSI in the
+			// spinner/label doesn't bleed into the trailing dashes.
+			return [this.color(leading) + labelText + this.color(trailing)];
+		}
 		return [this.color("─".repeat(Math.max(1, width)))];
 	}
 }

package/packages/pi-coding-agent/src/modes/interactive/components/extension-input.ts

@@ -11,6 +11,7 @@ import { keyHint } from "./keybinding-hints.js";
 export interface ExtensionInputOptions {
 	tui?: TUI;
 	timeout?: number;
+	secure?: boolean;
 }
 
 export class ExtensionInputComponent extends Container implements Focusable {
@@ -61,6 +62,7 @@ export class ExtensionInputComponent extends Container implements Focusable {
 		}
 
 		this.input = new Input();
+		this.input.secure = opts?.secure === true;
 		if (placeholder) {
 			this.input.placeholder = placeholder;
 		}

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

@@ -1,9 +1,10 @@
-import { Loader, Spacer, Text } from "@gsd/pi-tui";
+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 { DynamicBorder } from "../components/dynamic-border.js";
 import { appKey } from "../components/keybinding-hints.js";
 
 // Tracks the last processed content index to avoid re-scanning all blocks on every message_update
@@ -21,6 +22,15 @@ function hasAssistantToolBlocks(message: { content: Array<any> }): boolean {
 	return message.content.some((c) => c.type === "toolCall" || c.type === "serverToolUse");
 }
 
+// Tracks the latest assistant text for the pinned message zone
+let lastPinnedText = "";
+// Whether any tool execution has been added in this assistant turn (triggers pinned display)
+let hasToolsInTurn = false;
+// Reference to the pinned border so we can toggle its label between working/idle
+let pinnedBorder: DynamicBorder | undefined;
+// Reference to the pinned markdown component below the border
+let pinnedTextComponent: Markdown | undefined;
+
 export async function handleAgentEvent(host: InteractiveModeStateHost & {
 	init: () => Promise<void>;
 	getMarkdownThemeWithSettings: () => any;
@@ -43,9 +53,15 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 
 	host.footer.invalidate();
 
-	// Reset content index tracker when a new assistant message starts
+	// Reset content index tracker and pinned state when a new assistant message starts
 	if (event.type === "message_start" && event.message.role === "assistant") {
 		lastProcessedContentIndex = 0;
+		lastPinnedText = "";
+		hasToolsInTurn = false;
+		if (pinnedBorder) pinnedBorder.stopSpinner();
+		pinnedBorder = undefined;
+		pinnedTextComponent = undefined;
+		host.pinnedMessageContainer.clear();
 	}
 
 	switch (event.type) {
@@ -58,6 +74,12 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.streamingMessage = undefined;
 					host.pendingTools.clear();
 					host.pendingMessagesContainer.clear();
+					host.pinnedMessageContainer.clear();
+					lastPinnedText = "";
+					hasToolsInTurn = false;
+					if (pinnedBorder) pinnedBorder.stopSpinner();
+					pinnedBorder = undefined;
+					pinnedTextComponent = undefined;
 					host.compactionQueuedMessages = [];
 					host.rebuildChatFromMessages();
 					host.updatePendingMessagesDisplay();
@@ -129,19 +151,6 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				host.streamingMessage = event.message;
 				const innerEvent = event.assistantMessageEvent;
 
-				if (!host.streamingComponent && hasVisibleAssistantContent(host.streamingMessage)) {
-					host.streamingComponent = new AssistantMessageComponent(
-						undefined,
-						host.hideThinkingBlock,
-						host.getMarkdownThemeWithSettings(),
-						host.settingsManager.getTimestampFormat(),
-					);
-					host.chatContainer.addChild(host.streamingComponent);
-				}
-				if (host.streamingComponent) {
-					host.streamingComponent.updateContent(host.streamingMessage);
-				}
-
 				let externalToolResult:
 					| { toolCallId: string; content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>; details: Record<string, unknown>; isError: boolean }
 					| undefined;
@@ -156,6 +165,18 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 							isError: ext.isError ?? false,
 						};
 					}
+				} else if (innerEvent.type === "server_tool_use") {
+					const idx = typeof innerEvent.contentIndex === "number" ? innerEvent.contentIndex : -1;
+					const block = idx >= 0 ? (host.streamingMessage.content[idx] as any) : undefined;
+					const ext = block?.externalResult;
+					if (block?.id && ext) {
+						externalToolResult = {
+							toolCallId: block.id,
+							content: ext.content ?? [{ type: "text", text: "" }],
+							details: ext.details ?? {},
+							isError: ext.isError ?? false,
+						};
+					}
 				}
 
 				const contentBlocks = host.streamingMessage.content;
@@ -230,12 +251,85 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					}
 				}
 
+				// Render assistant text/thinking after tool components so mixed
+				// streams keep chronological ordering in the chat container.
+				const hasToolBlocks = hasAssistantToolBlocks(host.streamingMessage);
+				if (!host.streamingComponent && hasVisibleAssistantContent(host.streamingMessage)) {
+					host.streamingComponent = new AssistantMessageComponent(
+						undefined,
+						host.hideThinkingBlock,
+						host.getMarkdownThemeWithSettings(),
+						host.settingsManager.getTimestampFormat(),
+					);
+					host.chatContainer.addChild(host.streamingComponent);
+				}
+				if (host.streamingComponent) {
+					if (hasToolBlocks) {
+						host.chatContainer.removeChild(host.streamingComponent);
+						host.chatContainer.addChild(host.streamingComponent);
+					}
+					host.streamingComponent.updateContent(host.streamingMessage);
+				}
+
 				// Update index: fully processed blocks won't need re-scanning.
 				// Keep the last block's index (it may still be accumulating data),
 				// so we re-check it next time but skip all earlier ones.
 				if (contentBlocks.length > 0) {
 					lastProcessedContentIndex = Math.max(0, contentBlocks.length - 1);
 				}
+
+				// Pinned message: mirror the latest assistant text above the editor
+				// when tool executions push it out of the viewport.
+				const hasTools = contentBlocks.some(
+					(c: any) => c.type === "toolCall" || c.type === "serverToolUse",
+				);
+				if (hasTools) hasToolsInTurn = true;
+
+				if (hasToolsInTurn) {
+					// Collect the latest text block(s) from the assistant message
+					let latestText = "";
+					for (let i = contentBlocks.length - 1; i >= 0; i--) {
+						const c = contentBlocks[i] as any;
+						if (c.type === "text" && c.text?.trim()) {
+							latestText = c.text.trim();
+							break;
+						}
+					}
+
+					if (latestText && latestText !== lastPinnedText) {
+						lastPinnedText = latestText;
+
+						if (!pinnedBorder) {
+							// First time: create border + text component
+							host.pinnedMessageContainer.clear();
+							pinnedBorder = new DynamicBorder(
+								(str: string) => theme.fg("dim", str),
+								"Working · Latest Output",
+							);
+							pinnedBorder.startSpinner(host.ui, (str: string) => theme.fg("accent", str));
+							host.pinnedMessageContainer.addChild(pinnedBorder);
+							pinnedTextComponent = new Markdown(latestText, 1, 0, host.getMarkdownThemeWithSettings());
+							// Cap pinned content to ~40% of terminal height so tall output
+							// doesn't exceed the viewport and cause render flashing.
+							pinnedTextComponent.maxLines = Math.max(3, Math.floor(host.ui.terminal.rows * 0.4));
+							host.pinnedMessageContainer.addChild(pinnedTextComponent);
+							// Hide the separate status loader — the pinned zone replaces it
+							if (host.loadingAnimation) {
+								host.loadingAnimation.stop();
+								host.loadingAnimation = undefined;
+							}
+							host.statusContainer.clear();
+						} else {
+							// Update existing markdown component in-place
+							pinnedTextComponent?.setText(latestText);
+							// Refresh maxLines in case terminal was resized
+							if (pinnedTextComponent) {
+								pinnedTextComponent.maxLines = Math.max(3, Math.floor(host.ui.terminal.rows * 0.4));
+							}
+						}
+					}
+				}
+
 				host.ui.requestRender();
 			}
 			break;
@@ -338,6 +432,16 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				host.streamingMessage = undefined;
 			}
 			host.pendingTools.clear();
+			// Stop spinner on pinned border and switch label from "Working · Latest Output" to "Latest Output"
+			if (pinnedBorder) {
+				pinnedBorder.stopSpinner();
+				pinnedBorder.setLabel("Latest Output");
+			}
+			// Keep pinned message visible until the next assistant turn starts.
+			lastPinnedText = "";
+			hasToolsInTurn = false;
+			pinnedBorder = undefined;
+			pinnedTextComponent = undefined;
 			await host.checkShutdownRequested();
 			host.ui.requestRender();
 			break;

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

@@ -9,6 +9,7 @@ export interface InteractiveModeStateHost {
 	keybindings: any;
 	statusContainer: any;
 	chatContainer: any;
+	pinnedMessageContainer: any;
 	settingsManager: any;
 	pendingTools: Map<string, any>;
 	toolOutputExpanded: boolean;

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

@@ -168,6 +168,7 @@ export class InteractiveMode {
 	private chatContainer: Container;
 	private pendingMessagesContainer: Container;
 	private statusContainer: Container;
+	private pinnedMessageContainer: Container;
 	private defaultEditor: CustomEditor;
 	private editor: EditorComponent;
 	private autocompleteProvider: CombinedAutocompleteProvider | undefined;
@@ -285,6 +286,7 @@ export class InteractiveMode {
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
 		this.statusContainer = new Container();
+		this.pinnedMessageContainer = new Container();
 		this.widgetContainerAbove = new Container();
 		this.widgetContainerBelow = new Container();
 		this.keybindings = KeybindingsManager.create();
@@ -490,6 +492,7 @@ export class InteractiveMode {
 		this.ui.addChild(this.chatContainer);
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
+		this.ui.addChild(this.pinnedMessageContainer);
 		this.renderWidgets(); // Initialize with default spacer
 		this.ui.addChild(this.widgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
@@ -1396,7 +1399,19 @@ export class InteractiveMode {
 	 */
 	private renderWidgets(): void {
 		if (!this.widgetContainerAbove || !this.widgetContainerBelow) return;
-		this.renderWidgetContainer(this.widgetContainerAbove, this.extensionWidgetsAbove, true, true);
+
+		// widgetContainerAbove: spacer collapses when pinned content is visible
+		// so there's no extra blank line between pinned output and the editor border.
+		this.widgetContainerAbove.clear();
+		const pinned = this.pinnedMessageContainer;
+		this.widgetContainerAbove.addChild({
+			render: () => pinned.children.length > 0 ? [] : [""],
+			invalidate: () => {},
+		});
+		for (const component of this.extensionWidgetsAbove.values()) {
+			this.widgetContainerAbove.addChild(component);
+		}
+
 		this.renderWidgetContainer(this.widgetContainerBelow, this.extensionWidgetsBelow, false, false);
 		this.ui.requestRender();
 	}
@@ -1631,7 +1646,7 @@ export class InteractiveMode {
 					this.hideExtensionInput();
 					resolve(undefined);
 				},
-				{ tui: this.ui, timeout: opts?.timeout },
+				{ tui: this.ui, timeout: opts?.timeout, secure: opts?.secure },
 			);
 
 			this.editorContainer.clear();
@@ -2264,6 +2279,7 @@ export class InteractiveMode {
 			updateFooter: true,
 			populateHistory: true,
 		});
+		this.populatePinnedFromMessages(context.messages);
 
 		// Show compaction info if session was compacted
 		const allEntries = this.sessionManager.getEntries();
@@ -2287,6 +2303,54 @@ export class InteractiveMode {
 		this.chatContainer.clear();
 		const context = this.sessionManager.buildSessionContext();
 		this.renderSessionContext(context);
+		this.populatePinnedFromMessages(context.messages);
+	}
+
+	/**
+	 * After rebuilding chat from messages, pin the last assistant text above the
+	 * editor if tool results would otherwise push it out of the viewport.
+	 */
+	private populatePinnedFromMessages(messages: AgentMessage[]): void {
+		this.pinnedMessageContainer.clear();
+
+		// Walk backwards to find the last assistant message
+		let lastAssistant: AssistantMessage | undefined;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (msg && "role" in msg && msg.role === "assistant") {
+				lastAssistant = msg as AssistantMessage;
+				break;
+			}
+		}
+		if (!lastAssistant) return;
+
+		// Check if any tool calls follow the last text block
+		const content = lastAssistant.content;
+		let lastTextIndex = -1;
+		let hasToolAfterText = false;
+		for (let i = 0; i < content.length; i++) {
+			if (content[i].type === "text") lastTextIndex = i;
+		}
+		if (lastTextIndex >= 0) {
+			for (let i = lastTextIndex + 1; i < content.length; i++) {
+				if (content[i].type === "toolCall" || content[i].type === "serverToolUse") {
+					hasToolAfterText = true;
+					break;
+				}
+			}
+		}
+		if (!hasToolAfterText || lastTextIndex < 0) return;
+
+		const textBlock = content[lastTextIndex] as { type: "text"; text: string };
+		const text = textBlock.text?.trim();
+		if (!text) return;
+
+		this.pinnedMessageContainer.addChild(
+			new DynamicBorder((str: string) => theme.fg("dim", str), "Latest Output"),
+		);
+		this.pinnedMessageContainer.addChild(
+			new Markdown(text, 1, 0, this.getMarkdownThemeWithSettings()),
+		);
 	}
 
 	// =========================================================================

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

@@ -224,7 +224,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			),
 
 		input: (title, placeholder, opts) =>
-			createDialogPromise(opts, undefined, { method: "input", title, placeholder, timeout: opts?.timeout }, (r) =>
+			createDialogPromise(opts, undefined, { method: "input", title, placeholder, timeout: opts?.timeout, secure: opts?.secure }, (r) =>
 				"cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined,
 			),
 

package/packages/pi-coding-agent/src/modes/rpc/rpc-types.ts

@@ -291,6 +291,7 @@ export type RpcExtensionUIRequest =
 			title: string;
 			placeholder?: string;
 			timeout?: number;
+			secure?: boolean;
 	  }
 	| { type: "extension_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
 	| {