gsd-pi 2.73.0 → 2.73.1-dev.47ed32a

package/packages/pi-coding-agent/src/core/model-resolver.ts

@@ -3,45 +3,13 @@
  */
 
 import type { ThinkingLevel } from "@gsd/pi-agent-core";
-import { type Api, type KnownProvider, type Model, modelsAreEqual } from "@gsd/pi-ai";
+import { type Api, type Model, modelsAreEqual } from "@gsd/pi-ai";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
 import { isValidThinkingLevel } from "../cli/args.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import type { ModelRegistry } from "./model-registry.js";
 
-/** Default model IDs for each known provider */
-const defaultModelPerProvider: Record<KnownProvider, string> = {
-	"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
-	anthropic: "claude-opus-4-6",
-	"anthropic-vertex": "claude-sonnet-4-6",
-	openai: "gpt-5.4",
-	"azure-openai-responses": "gpt-5.2",
-	"openai-codex": "gpt-5.4",
-	google: "gemini-2.5-pro",
-	"google-gemini-cli": "gemini-2.5-pro",
-	"google-antigravity": "gemini-3.1-pro-high",
-	"google-vertex": "gemini-3-pro-preview",
-	"github-copilot": "gpt-4o",
-	openrouter: "openai/gpt-5.1-codex",
-	"vercel-ai-gateway": "anthropic/claude-opus-4-6",
-	xai: "grok-4-fast-non-reasoning",
-	groq: "openai/gpt-oss-120b",
-	cerebras: "zai-glm-4.6",
-	zai: "glm-4.6",
-	mistral: "devstral-medium-latest",
-	minimax: "MiniMax-M2.1",
-	"minimax-cn": "MiniMax-M2.1",
-	huggingface: "moonshotai/Kimi-K2.5",
-	opencode: "claude-opus-4-6",
-	"opencode-go": "kimi-k2.5",
-	"kimi-coding": "kimi-k2-thinking",
-	"alibaba-coding-plan": "qwen3.5-plus",
-	"alibaba-dashscope": "qwen3.5-plus",
-	ollama: "llama3.1:8b",
-	"ollama-cloud": "qwen3:32b",
-};
-
 export interface ScopedModel {
 	model: Model<Api>;
 	/** Thinking level if explicitly specified in pattern (e.g., "model:high"), undefined otherwise */
@@ -123,10 +91,11 @@ function buildFallbackModel(provider: string, modelId: string, availableModels:
 	const providerModels = availableModels.filter((m) => m.provider === provider);
 	if (providerModels.length === 0) return undefined;
 
-	const defaultId = defaultModelPerProvider[provider as KnownProvider];
-	const baseModel = defaultId
-		? (providerModels.find((m) => m.id === defaultId) ?? providerModels[0])
-		: providerModels[0];
+	// Use the first available model from this provider as a template for
+	// capabilities (context window, reasoning support, etc.). The user is
+	// explicitly providing a custom model id, so we just need any shape of
+	// model from the same provider to inherit from.
+	const baseModel = providerModels[0];
 
 	return {
 		...baseModel,
@@ -503,33 +472,19 @@ export async function findInitialModel(options: {
 		};
 	}
 
-	// 3. Try saved default from settings
-	if (defaultProvider && defaultModelId) {
-		// Guard against stale settings defaults: only use the saved provider/model
-		// if the provider is actually request-ready (auth/OAuth/CLI ready).
-		if (modelRegistry.isProviderRequestReady(defaultProvider)) {
-			const found = modelRegistry.find(defaultProvider, defaultModelId);
-			if (found) {
-				// Check if the provider's recommended default is a higher-capability variant
-				// of the saved model (e.g. saved "claude-opus-4-6" vs recommended "claude-opus-4-6-extended").
-				// If so, prefer the recommended variant to avoid using a smaller context window (#1125).
-				const recommendedId = defaultModelPerProvider[defaultProvider as KnownProvider];
-				if (recommendedId && recommendedId !== defaultModelId && recommendedId.startsWith(defaultModelId)) {
-					const recommended = modelRegistry.find(defaultProvider, recommendedId);
-					if (recommended) {
-						model = recommended;
-						if (defaultThinkingLevel) {
-							thinkingLevel = defaultThinkingLevel;
-						}
-						return { model, thinkingLevel, fallbackMessage: undefined };
-					}
-				}
-				model = found;
-				if (defaultThinkingLevel) {
-					thinkingLevel = defaultThinkingLevel;
-				}
-				return { model, thinkingLevel, fallbackMessage: undefined };
+	// 3. Try saved default from settings — use it exactly as configured.
+	// Whatever the user chose is what gets used; no silent substitution.
+	// Skip the saved default if its provider is not request-ready (no auth
+	// available) so we fall through to an actually-usable model instead of
+	// returning a stale selection every selector surface would display.
+	if (defaultProvider && defaultModelId && modelRegistry.isProviderRequestReady(defaultProvider)) {
+		const found = modelRegistry.find(defaultProvider, defaultModelId);
+		if (found) {
+			model = found;
+			if (defaultThinkingLevel) {
+				thinkingLevel = defaultThinkingLevel;
 			}
+			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}
 
@@ -537,16 +492,17 @@ export async function findInitialModel(options: {
 	const availableModels = await modelRegistry.getAvailable();
 
 	if (availableModels.length > 0) {
-		// Try to find a default model from known providers
-		for (const provider of Object.keys(defaultModelPerProvider) as KnownProvider[]) {
-			const defaultId = defaultModelPerProvider[provider];
-			const match = availableModels.find((m) => m.provider === provider && m.id === defaultId);
-			if (match) {
-				return { model: match, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
+		// Prefer a model from the user's saved provider if any is still available —
+		// provider stickiness, not a hard-coded Anthropic/OpenAI preference.
+		if (defaultProvider) {
+			const sameProvider = availableModels.find((m) => m.provider === defaultProvider);
+			if (sameProvider) {
+				return { model: sameProvider, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
 			}
 		}
 
-		// If no default found, use first available
+		// Otherwise use the first available — registry order reflects models.json
+		// order, which the user controls.
 		return { model: availableModels[0], thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
 	}
 

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

@@ -3,8 +3,15 @@ import { Container, Markdown, type MarkdownTheme, Spacer, Text } from "@gsd/pi-t
 import { getMarkdownTheme, theme } from "../theme/theme.js";
 import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
 
+export interface ContentRange {
+	startIndex: number;
+	endIndex: number;
+}
+
 /**
- * Component that renders a complete assistant message
+ * Component that renders a complete assistant message, or a sub-range of its content[].
+ * When `range` is provided, only content[startIndex..endIndex] (inclusive) is rendered.
+ * Non-text/thinking blocks within the range are silently skipped.
  */
 export class AssistantMessageComponent extends Container {
 	private contentContainer: Container;
@@ -12,18 +19,26 @@ export class AssistantMessageComponent extends Container {
 	private markdownTheme: MarkdownTheme;
 	private lastMessage?: AssistantMessage;
 	private timestampFormat: TimestampFormat;
+	private range?: ContentRange;
+	private showMetadata: boolean;
 
 	constructor(
 		message?: AssistantMessage,
 		hideThinkingBlock = false,
 		markdownTheme: MarkdownTheme = getMarkdownTheme(),
 		timestampFormat: TimestampFormat = "date-time-iso",
+		range?: ContentRange,
 	) {
 		super();
 
 		this.hideThinkingBlock = hideThinkingBlock;
 		this.markdownTheme = markdownTheme;
 		this.timestampFormat = timestampFormat;
+		this.range = range;
+		// No range = legacy full-message rendering; show metadata by default.
+		// Ranged (interleaved) instances start with metadata hidden; chat-controller
+		// calls setShowMetadata(true) on the last segment at message_end.
+		this.showMetadata = !range;
 
 		// Container for text/thinking content
 		this.contentContainer = new Container();
@@ -34,6 +49,20 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	setRange(range: ContentRange | undefined): void {
+		this.range = range;
+		if (this.lastMessage) {
+			this.updateContent(this.lastMessage);
+		}
+	}
+
+	setShowMetadata(show: boolean): void {
+		this.showMetadata = show;
+		if (this.lastMessage) {
+			this.updateContent(this.lastMessage);
+		}
+	}
+
 	override invalidate(): void {
 		super.invalidate();
 		if (this.lastMessage) {
@@ -51,7 +80,11 @@ export class AssistantMessageComponent extends Container {
 		// Clear content container
 		this.contentContainer.clear();
 
-		const hasVisibleContent = message.content.some(
+		const start = this.range?.startIndex ?? 0;
+		const end = this.range?.endIndex ?? message.content.length - 1;
+		const slice = message.content.slice(start, end + 1);
+
+		const hasVisibleContent = slice.some(
 			(c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
 		);
 
@@ -59,9 +92,9 @@ export class AssistantMessageComponent extends Container {
 			this.contentContainer.addChild(new Spacer(1));
 		}
 
-		// Render content in order
-		for (let i = 0; i < message.content.length; i++) {
-			const content = message.content[i];
+		// Render content in order; non-text/thinking blocks are silently skipped
+		for (let i = 0; i < slice.length; i++) {
+			const content = slice[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
@@ -69,7 +102,7 @@ export class AssistantMessageComponent extends Container {
 			} else if (content.type === "thinking" && content.thinking.trim()) {
 				// 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
+				const hasVisibleContentAfter = slice
 					.slice(i + 1)
 					.some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
 
@@ -94,30 +127,33 @@ export class AssistantMessageComponent extends Container {
 			}
 		}
 
-		// Check if aborted - show after partial content
-		// But only if there are no tool calls (tool execution components will show the error)
-		const hasToolCalls = message.content.some((c) => c.type === "toolCall");
-		if (!hasToolCalls) {
-			if (message.stopReason === "aborted") {
-				const abortMessage =
-					message.errorMessage && message.errorMessage !== "Request was aborted"
-						? message.errorMessage
-						: "Operation aborted";
-				if (hasVisibleContent) {
+		// Metadata (errors, timestamp): gated on showMetadata so ranged instances stay clean
+		// until chat-controller explicitly enables it on the last segment at message_end.
+		if (this.showMetadata) {
+			// Check if aborted - show after partial content
+			// But only if there are no tool calls (tool execution components will show the error)
+			const hasToolCalls = message.content.some((c) => c.type === "toolCall");
+			if (!hasToolCalls) {
+				if (message.stopReason === "aborted") {
+					const abortMessage =
+						message.errorMessage && message.errorMessage !== "Request was aborted"
+							? message.errorMessage
+							: "Operation aborted";
+					if (hasVisibleContent) {
+						this.contentContainer.addChild(new Spacer(1));
+					}
+					this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
+				} else if (message.stopReason === "error") {
+					const errorMsg = message.errorMessage || "Unknown error";
 					this.contentContainer.addChild(new Spacer(1));
+					this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 				}
-				this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
-			} else if (message.stopReason === "error") {
-				const errorMsg = message.errorMessage || "Unknown error";
-				this.contentContainer.addChild(new Spacer(1));
-				this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 			}
-		}
 
-		// Show timestamp when the message is complete (has a stop reason)
-		if (message.stopReason && message.timestamp) {
-			const timeStr = formatTimestamp(message.timestamp, this.timestampFormat);
-			this.contentContainer.addChild(new Text(theme.fg("dim", timeStr), 1, 0));
+			if (message.stopReason && message.timestamp) {
+				const timeStr = formatTimestamp(message.timestamp, this.timestampFormat);
+				this.contentContainer.addChild(new Text(theme.fg("dim", timeStr), 1, 0));
+			}
 		}
 	}
 }

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

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { findLatestPinnableText } from "./chat-controller.js";
+
+test("findLatestPinnableText: empty content returns empty string", () => {
+	assert.equal(findLatestPinnableText([]), "");
+});
+
+test("findLatestPinnableText: no tool calls returns empty string", () => {
+	const blocks = [
+		{ type: "text", text: "hello" },
+		{ type: "text", text: "world" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "");
+});
+
+test("findLatestPinnableText: returns text preceding a tool call", () => {
+	const blocks = [
+		{ type: "text", text: "doing the thing" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "doing the thing");
+});
+
+test("findLatestPinnableText: ignores trailing streaming text after the last tool call (regression: pinned mirror duplicated chat-container tokens)", () => {
+	const blocks = [
+		{ type: "text", text: "first prose" },
+		{ type: "toolCall", id: "1", name: "Read" },
+		{ type: "text", text: "second prose still streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "first prose");
+});
+
+test("findLatestPinnableText: with multiple tools, picks text before the most recent tool call", () => {
+	const blocks = [
+		{ type: "text", text: "first" },
+		{ type: "toolCall", id: "1", name: "Read" },
+		{ type: "text", text: "second" },
+		{ type: "toolCall", id: "2", name: "Grep" },
+		{ type: "text", text: "third streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "second");
+});
+
+test("findLatestPinnableText: treats serverToolUse the same as toolCall", () => {
+	const blocks = [
+		{ type: "text", text: "before web search" },
+		{ type: "serverToolUse", id: "ws1", name: "web_search" },
+		{ type: "text", text: "answer streaming" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "before web search");
+});
+
+test("findLatestPinnableText: skips empty/whitespace-only text blocks", () => {
+	const blocks = [
+		{ type: "text", text: "real prose" },
+		{ type: "text", text: "   " },
+		{ type: "text", text: "" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "real prose");
+});
+
+test("findLatestPinnableText: thinking blocks are not pinnable", () => {
+	const blocks = [
+		{ type: "thinking", thinking: "internal" },
+		{ type: "toolCall", id: "1", name: "Read" },
+	];
+	assert.equal(findLatestPinnableText(blocks), "");
+});

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

@@ -10,6 +10,17 @@ import { appKey } from "../components/keybinding-hints.js";
 // Tracks the last processed content index to avoid re-scanning all blocks on every message_update
 let lastProcessedContentIndex = 0;
 
+// Tracks the previous content[] length so we can detect when an adapter resets
+// the assistant content array for a new provider sub-turn within one lifecycle.
+let lastContentLength = 0;
+
+// --- Segment walker state (per streaming assistant turn) ---
+type RenderedSegment =
+	| { kind: "text-run"; startIndex: number; endIndex: number; component: AssistantMessageComponent }
+	| { kind: "tool"; contentIndex: number; component: ToolExecutionComponent };
+
+let renderedSegments: RenderedSegment[] = [];
+
 function hasVisibleAssistantContent(message: { content: Array<any> }): boolean {
 	return message.content.some(
 		(c) =>
@@ -22,6 +33,28 @@ function hasAssistantToolBlocks(message: { content: Array<any> }): boolean {
 	return message.content.some((c) => c.type === "toolCall" || c.type === "serverToolUse");
 }
 
+// Pick the latest non-empty text block that appears strictly before the most
+// recent tool call. Text blocks that come after the last tool call are still
+// streaming live into the chat container, so mirroring them into the pinned
+// "Latest Output" zone would render the same tokens twice.
+export function findLatestPinnableText(contentBlocks: Array<any>): string {
+	let lastToolIdx = -1;
+	for (let i = contentBlocks.length - 1; i >= 0; i--) {
+		const c = contentBlocks[i];
+		if (c?.type === "toolCall" || c?.type === "serverToolUse") {
+			lastToolIdx = i;
+			break;
+		}
+	}
+	for (let i = lastToolIdx - 1; i >= 0; i--) {
+		const c = contentBlocks[i];
+		if (c?.type === "text" && typeof c.text === "string" && c.text.trim()) {
+			return c.text.trim();
+		}
+	}
+	return "";
+}
+
 // 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)
@@ -56,8 +89,10 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 	// Reset content index tracker and pinned state when a new assistant message starts
 	if (event.type === "message_start" && event.message.role === "assistant") {
 		lastProcessedContentIndex = 0;
+		lastContentLength = 0;
 		lastPinnedText = "";
 		hasToolsInTurn = false;
+		renderedSegments = [];
 		if (pinnedBorder) pinnedBorder.stopSpinner();
 		pinnedBorder = undefined;
 		pinnedTextComponent = undefined;
@@ -77,6 +112,8 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.pinnedMessageContainer.clear();
 					lastPinnedText = "";
 					hasToolsInTurn = false;
+					renderedSegments = [];
+					lastContentLength = 0;
 					if (pinnedBorder) pinnedBorder.stopSpinner();
 					pinnedBorder = undefined;
 					pinnedTextComponent = undefined;
@@ -180,12 +217,22 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				}
 
 				const contentBlocks = host.streamingMessage.content;
-				// Some adapters reuse a single assistant lifecycle while internally
-				// spanning multiple provider turns. When a new turn starts, content
-				// length can shrink back to 0/1; reset scan index to avoid skipping.
-				if (lastProcessedContentIndex >= contentBlocks.length) {
+				// Some adapters (notably claude-code) reuse a single assistant
+				// lifecycle while internally spanning multiple provider sub-turns.
+				// When a new sub-turn starts, content[] length shrinks back to 0/1.
+				// The scan loop needs its index reset, AND the segment walker's
+				// renderedSegments map must be cleared so existing text-run
+				// components don't get overwritten in place with new sub-turn
+				// content (#4144 regression). Prior sub-turn children stay in
+				// chatContainer as frozen history; new segments append after them.
+				if (contentBlocks.length < lastContentLength) {
+					renderedSegments = [];
+					lastPinnedText = "";
+					lastProcessedContentIndex = 0;
+				} else if (lastProcessedContentIndex >= contentBlocks.length) {
 					lastProcessedContentIndex = 0;
 				}
+				lastContentLength = contentBlocks.length;
 				for (let i = lastProcessedContentIndex; i < contentBlocks.length; i++) {
 					const content = contentBlocks[i];
 					if (content.type === "toolCall") {
@@ -251,24 +298,88 @@ 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);
+				// Segment walker: render content blocks in stream order, append-only.
+				// Build desired segment plan from content[].
+				{
+					const blocks = host.streamingMessage.content;
+					type DesiredSegment =
+						| { kind: "text-run"; startIndex: number; endIndex: number }
+						| { kind: "tool"; contentIndex: number; toolId: string };
+					const desired: DesiredSegment[] = [];
+					let runStart = -1;
+					for (let i = 0; i < blocks.length; i++) {
+						const b = blocks[i];
+						const isText = b.type === "text" || b.type === "thinking";
+						const isTool = b.type === "toolCall" || b.type === "serverToolUse";
+						if (isText) {
+							if (runStart === -1) runStart = i;
+						} else {
+							if (runStart !== -1) {
+								desired.push({ kind: "text-run", startIndex: runStart, endIndex: i - 1 });
+								runStart = -1;
+							}
+							if (isTool) {
+								desired.push({ kind: "tool", contentIndex: i, toolId: b.id });
+							}
+						}
+					}
+					if (runStart !== -1) {
+						desired.push({ kind: "text-run", startIndex: runStart, endIndex: blocks.length - 1 });
+					}
+
+					// Append any newly needed segments (never reorder existing ones).
+					for (const seg of desired) {
+						if (seg.kind === "tool") {
+							// Tool segments are already handled above via pendingTools; just
+							// register them in renderedSegments if not yet tracked.
+							const existing = renderedSegments.find(
+								(s) => s.kind === "tool" && s.contentIndex === seg.contentIndex,
+							);
+							if (!existing) {
+								const comp = host.pendingTools.get(seg.toolId);
+								if (comp) {
+									renderedSegments.push({ kind: "tool", contentIndex: seg.contentIndex, component: comp });
+								}
+							}
+						} else {
+							// text-run segment
+							const existing = renderedSegments.find(
+								(s) => s.kind === "text-run" && s.startIndex === seg.startIndex,
+							);
+							if (!existing) {
+								const comp = new AssistantMessageComponent(
+									undefined,
+									host.hideThinkingBlock,
+									host.getMarkdownThemeWithSettings(),
+									host.settingsManager.getTimestampFormat(),
+									{ startIndex: seg.startIndex, endIndex: seg.endIndex },
+								);
+								host.chatContainer.addChild(comp);
+								renderedSegments.push({ kind: "text-run", startIndex: seg.startIndex, endIndex: seg.endIndex, component: comp });
+								host.streamingComponent = comp;
+							}
+						}
+					}
+
+					// Update all trailing text-run segments with the latest message so
+					// streaming text grows in place.
+					for (const seg of renderedSegments) {
+						if (seg.kind === "text-run") {
+							// Find corresponding desired segment to get current endIndex
+							const d = desired.find((ds) => ds.kind === "text-run" && ds.startIndex === seg.startIndex);
+							if (d && d.kind === "text-run" && d.endIndex !== seg.endIndex) {
+								seg.endIndex = d.endIndex;
+								seg.component.setRange({ startIndex: seg.startIndex, endIndex: seg.endIndex });
+							}
+							seg.component.updateContent(host.streamingMessage);
+						}
+					}
+
+					// Keep streamingComponent pointing at the last text-run for message_end compatibility.
+					const lastTextSeg = [...renderedSegments].reverse().find((s) => s.kind === "text-run");
+					if (lastTextSeg && lastTextSeg.kind === "text-run") {
+						host.streamingComponent = lastTextSeg.component;
 					}
-					host.streamingComponent.updateContent(host.streamingMessage);
 				}
 
 				// Update index: fully processed blocks won't need re-scanning.
@@ -286,15 +397,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				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;
-						}
-					}
+					const latestText = findLatestPinnableText(contentBlocks);
 
 					if (latestText && latestText !== lastPinnedText) {
 						lastPinnedText = latestText;
@@ -362,6 +465,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.chatContainer.addChild(host.streamingComponent);
 				}
 				if (host.streamingComponent) {
+					host.streamingComponent.setShowMetadata(true);
 					host.streamingComponent.updateContent(host.streamingMessage);
 				}
 
@@ -385,6 +489,8 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				}
 				host.streamingComponent = undefined;
 				host.streamingMessage = undefined;
+				renderedSegments = [];
+				lastContentLength = 0;
 				// Clear pinned output once the message is finalized in the chat
 				// container — prevents duplicate display when the agent continues
 				// (e.g. form elicitation) after the assistant message ends.

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

@@ -1402,7 +1402,9 @@ export class InteractiveMode {
 
 		// 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();
+		// Use detachChildren() (not clear()) — the extensionWidgetsAbove map owns
+		// disposal; clear() would dispose every mounted widget on every re-render.
+		this.widgetContainerAbove.detachChildren();
 		const pinned = this.pinnedMessageContainer;
 		this.widgetContainerAbove.addChild({
 			render: () => pinned.children.length > 0 ? [] : [""],
@@ -1422,7 +1424,9 @@ export class InteractiveMode {
 		spacerWhenEmpty: boolean,
 		leadingSpacer: boolean,
 	): void {
-		container.clear();
+		// Detach without disposing — the widgets map owns lifecycle; disposing
+		// here would kill refresh timers and subscriptions on every re-render.
+		container.detachChildren();
 
 		if (widgets.size === 0) {
 			if (spacerWhenEmpty) {

package/packages/pi-tui/dist/__tests__/tui.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { TUI } from "../tui.js";
+import { Container, TUI } from "../tui.js";
 function makeTerminal() {
     return {
         isTTY: true,
@@ -40,4 +40,33 @@ describe("TUI", () => {
         assert.equal(anyTui.inputBuffer, "");
     });
 });
+describe("Container", () => {
+    function makeDisposableChild(counter) {
+        return {
+            render: () => [],
+            invalidate() { },
+            dispose() {
+                counter.disposed++;
+            },
+        };
+    }
+    it("detachChildren() removes children without disposing them", () => {
+        const c = new Container();
+        const counter = { disposed: 0 };
+        c.addChild(makeDisposableChild(counter));
+        c.addChild(makeDisposableChild(counter));
+        c.detachChildren();
+        assert.equal(c.children.length, 0);
+        assert.equal(counter.disposed, 0);
+    });
+    it("clear() still disposes children (regression guard for detach/dispose split)", () => {
+        const c = new Container();
+        const counter = { disposed: 0 };
+        c.addChild(makeDisposableChild(counter));
+        c.addChild(makeDisposableChild(counter));
+        c.clear();
+        assert.equal(c.children.length, 0);
+        assert.equal(counter.disposed, 2);
+    });
+});
 //# sourceMappingURL=tui.test.js.map