gsd-pi 2.73.0-dev.e1c09f2 → 2.73.1-dev.088d28f

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.73.0",
+  "version": "2.73.1",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

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

@@ -94,7 +94,7 @@ function createHost() {
 	return host;
 }
 
-test("chat-controller keeps tool output ahead of delayed assistant text for external tool streams", async () => {
+test("chat-controller renders content blocks in content[] index order (tool-first stream)", async () => {
 	// ToolExecutionComponent uses the global theme singleton.
 	// Install a minimal no-op theme implementation for this unit test.
 	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
@@ -116,7 +116,6 @@ test("chat-controller keeps tool output ahead of delayed assistant text for exte
 
 	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
 
-	assert.equal(host.streamingComponent, undefined, "assistant component should be deferred at message_start");
 	assert.equal(host.chatContainer.children.length, 0, "nothing should render before content arrives");
 
 	await handleAgentEvent(
@@ -140,11 +139,10 @@ test("chat-controller keeps tool output ahead of delayed assistant text for exte
 		} as any,
 	);
 
-	assert.equal(host.streamingComponent, undefined, "assistant text container should remain deferred for tool-only updates");
+	// content[0] = toolCall → ToolExecutionComponent renders first
 	assert.equal(host.chatContainer.children.length, 1, "tool execution block should render immediately");
 	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
 
-	// Re-assert required host method before the text-bearing update path.
 	host.getMarkdownThemeWithSettings = () => ({});
 
 	await handleAgentEvent(
@@ -161,12 +159,13 @@ test("chat-controller keeps tool output ahead of delayed assistant text for exte
 		} as any,
 	);
 
-	assert.equal(host.chatContainer.children.length, 2, "assistant content should render after existing tool output");
+	// content[0]=toolCall, content[1]=text → order: tool, then text
+	assert.equal(host.chatContainer.children.length, 2, "text run should render after tool in content[] order");
 	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 () => {
+test("chat-controller renders serverToolUse before trailing text matching content[] index order", async () => {
 	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
 		fg: (_key: string, text: string) => text,
 		bg: (_key: string, text: string) => text,
@@ -199,7 +198,7 @@ test("chat-controller keeps serverToolUse output ahead of assistant text when ex
 		} as any,
 	);
 
-	assert.equal(host.streamingComponent, undefined, "assistant content should stay deferred while only tool content streams");
+	// content[0] = serverToolUse → ToolExecutionComponent renders first
 	assert.equal(host.chatContainer.children.length, 1, "server tool block should render immediately");
 	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
 
@@ -229,7 +228,8 @@ test("chat-controller keeps serverToolUse output ahead of assistant text when ex
 		} as any,
 	);
 
-	assert.equal(host.chatContainer.children.length, 2, "assistant text should render after existing server tool output");
+	// content[0]=serverToolUse, content[1]=text → order: tool, then text
+	assert.equal(host.chatContainer.children.length, 2, "text run should render after server tool in content[] order");
 	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolExecutionComponent");
 	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
 });
@@ -466,3 +466,350 @@ test("chat-controller does not pin when there are no tool calls", async () => {
 
 	assert.equal(host.pinnedMessageContainer.children.length, 0, "pinned zone should stay empty without tool calls");
 });
+
+// Regression test for issue #4144: interleaved text/tool content must render in content[] index order.
+// Stream: [text "A", toolCall T1, text "B", toolCall T2, text "C"]
+// Expected chatContainer order: textRun(A), toolExec(T1), textRun(B), toolExec(T2), textRun(C)
+// Each AssistantMessageComponent must render ONLY its own text — no duplication after message_end.
+test("chat-controller renders interleaved text and tool blocks in content[] index order (#4144)", 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();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	const t1 = { type: "toolCall", id: "t1", name: "tool_one", arguments: {} };
+	const t2 = { type: "toolCall", id: "t2", name: "tool_two", arguments: {} };
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	// Stream text "A" at index 0
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }]),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 0,
+			delta: "A",
+			partial: makeAssistant([{ type: "text", text: "A" }]),
+		},
+	} as any);
+
+	// Stream toolCall T1 at index 1
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1]),
+		assistantMessageEvent: {
+			type: "toolcall_end",
+			contentIndex: 1,
+			toolCall: {
+				...t1,
+				externalResult: { content: [{ type: "text", text: "result1" }], details: {}, isError: false },
+			},
+			partial: makeAssistant([{ type: "text", text: "A" }, t1]),
+		},
+	} as any);
+
+	// Stream text "B" at index 2
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }]),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 2,
+			delta: "B",
+			partial: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }]),
+		},
+	} as any);
+
+	// Stream toolCall T2 at index 3
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }, t2]),
+		assistantMessageEvent: {
+			type: "toolcall_end",
+			contentIndex: 3,
+			toolCall: {
+				...t2,
+				externalResult: { content: [{ type: "text", text: "result2" }], details: {}, isError: false },
+			},
+			partial: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }, t2]),
+		},
+	} as any);
+
+	// Stream text "C" at index 4
+	const finalContent = [
+		{ type: "text", text: "A" }, t1, { type: "text", text: "B" }, t2, { type: "text", text: "C" },
+	];
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant(finalContent),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 4,
+			delta: "C",
+			partial: makeAssistant(finalContent),
+		},
+	} as any);
+
+	// Finalize — exercises the message_end path where a buggy setRange(undefined) would cause duplication
+	await handleAgentEvent(host, { type: "message_end", message: makeAssistant(finalContent) } as any);
+
+	// Assert interleaved order: textRun(A), toolExec(T1), textRun(B), toolExec(T2), textRun(C)
+	assert.equal(host.chatContainer.children.length, 5, "should have 5 children in interleaved order");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "AssistantMessageComponent", "index 0: text run A");
+	assert.equal(host.chatContainer.children[1]?.constructor?.name, "ToolExecutionComponent", "index 1: tool T1");
+	assert.equal(host.chatContainer.children[2]?.constructor?.name, "AssistantMessageComponent", "index 2: text run B");
+	assert.equal(host.chatContainer.children[3]?.constructor?.name, "ToolExecutionComponent", "index 3: tool T2");
+	assert.equal(host.chatContainer.children[4]?.constructor?.name, "AssistantMessageComponent", "index 4: text run C");
+
+	// Helper: collect the text of all Markdown children inside an AssistantMessageComponent.
+	// Structure: AssistantMessageComponent (Container) -> contentContainer (children[0]) -> Markdown nodes.
+	function getRenderedTexts(comp: any): string[] {
+		const contentContainer = comp.children?.[0];
+		if (!contentContainer) return [];
+		return (contentContainer.children ?? [])
+			.filter((c: any) => c.constructor?.name === "Markdown")
+			.map((c: any) => (c as any).text as string);
+	}
+
+	// Each text-run component must contain only its own text — no cross-contamination after message_end
+	assert.deepEqual(getRenderedTexts(host.chatContainer.children[0]), ["A"], "text run A must contain only 'A'");
+	assert.deepEqual(getRenderedTexts(host.chatContainer.children[2]), ["B"], "text run B must contain only 'B'");
+	assert.deepEqual(getRenderedTexts(host.chatContainer.children[4]), ["C"], "text run C must contain only 'C'");
+});
+
+test("chat-controller does not duplicate text when content is [text, tool, text] (interleaved stream)", 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();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	const t1 = { type: "toolCall", id: "t1", name: "tool_one", arguments: {} };
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	// Step 1: text "A" at index 0
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }]),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 0,
+			delta: "A",
+			partial: makeAssistant([{ type: "text", text: "A" }]),
+		},
+	} as any);
+
+	// Step 2: toolCall at index 1
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1]),
+		assistantMessageEvent: {
+			type: "toolcall_end",
+			contentIndex: 1,
+			toolCall: {
+				...t1,
+				externalResult: { content: [{ type: "text", text: "result1" }], details: {}, isError: false },
+			},
+			partial: makeAssistant([{ type: "text", text: "A" }, t1]),
+		},
+	} as any);
+
+	// Step 3: text "B" at index 2
+	const finalContent = [{ type: "text", text: "A" }, t1, { type: "text", text: "B" }];
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant(finalContent),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 2,
+			delta: "B",
+			partial: makeAssistant(finalContent),
+		},
+	} as any);
+
+	assert.equal(host.chatContainer.children.length, 3);
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "AssistantMessageComponent");
+	assert.equal(host.chatContainer.children[1]?.constructor?.name, "ToolExecutionComponent");
+	assert.equal(host.chatContainer.children[2]?.constructor?.name, "AssistantMessageComponent");
+
+	const firstText = host.chatContainer.children[0];
+	const secondText = host.chatContainer.children[2];
+	assert.notEqual(firstText, secondText, "text-before-tool and text-after-tool must be separate component instances");
+	assert.deepEqual((firstText as any).range, { startIndex: 0, endIndex: 0 }, "first text-run covers only content[0]");
+	assert.deepEqual((secondText as any).range, { startIndex: 2, endIndex: 2 }, "second text-run covers only content[2]");
+
+	// Finalize — regression guard: range must NOT be cleared on message_end (would cause duplication)
+	await handleAgentEvent(host, { type: "message_end", message: makeAssistant(finalContent) } as any);
+
+	assert.deepEqual((secondText as any).range, { startIndex: 2, endIndex: 2 }, "range must not be cleared on message_end (would cause duplication)");
+});
+
+// Regression for the claude-code sub-turn bug that followed #4144:
+// an adapter can reset content[] back to 0/1 mid-lifecycle when a new provider
+// sub-turn begins. The segment walker must NOT update prior-sub-turn text-run
+// components in place (which would destroy earlier history) and must NOT reuse
+// stale tool registrations for a new tool at the same contentIndex. Prior
+// sub-turn children must stay frozen; new sub-turn segments must append after
+// them, and the pinned "Latest Output" mirror must re-evaluate for the new sub-turn.
+test("chat-controller freezes prior sub-turn and appends new segments when content shrinks", 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();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	const t1 = { type: "toolCall", id: "t1", name: "tool_one", arguments: {} };
+	const t2 = { type: "toolCall", id: "t2", name: "tool_two", arguments: {} };
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	// Sub-turn 1: grow to [A, T1, B]
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }]),
+		assistantMessageEvent: {
+			type: "text_delta", contentIndex: 0, delta: "A",
+			partial: makeAssistant([{ type: "text", text: "A" }]),
+		},
+	} as any);
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1]),
+		assistantMessageEvent: {
+			type: "toolcall_end", contentIndex: 1,
+			toolCall: { ...t1, externalResult: { content: [{ type: "text", text: "r1" }], details: {}, isError: false } },
+			partial: makeAssistant([{ type: "text", text: "A" }, t1]),
+		},
+	} as any);
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }]),
+		assistantMessageEvent: {
+			type: "text_delta", contentIndex: 2, delta: "B",
+			partial: makeAssistant([{ type: "text", text: "A" }, t1, { type: "text", text: "B" }]),
+		},
+	} as any);
+
+	assert.equal(host.chatContainer.children.length, 3, "sub-turn 1 renders 3 children");
+	const priorA = host.chatContainer.children[0];
+	const priorT1 = host.chatContainer.children[1];
+	const priorB = host.chatContainer.children[2];
+
+	// Sub-turn boundary: adapter resets content[] to [C]
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "C" }]),
+		assistantMessageEvent: {
+			type: "text_delta", contentIndex: 0, delta: "C",
+			partial: makeAssistant([{ type: "text", text: "C" }]),
+		},
+	} as any);
+
+	// Prior 3 children must still exist in DOM — and a NEW text-run for "C" appended after them.
+	assert.equal(host.chatContainer.children.length, 4, "shrink must append new segment, not replace prior history");
+	assert.equal(host.chatContainer.children[0], priorA, "prior A component stays at index 0");
+	assert.equal(host.chatContainer.children[1], priorT1, "prior T1 component stays at index 1");
+	assert.equal(host.chatContainer.children[2], priorB, "prior B component stays at index 2");
+	assert.notEqual(host.chatContainer.children[3], priorA, "new C text-run must be a different component from prior A");
+	assert.equal(host.chatContainer.children[3]?.constructor?.name, "AssistantMessageComponent");
+
+	// Prior A component must still render "A", not be overwritten with "C".
+	function getRenderedTexts(comp: any): string[] {
+		const contentContainer = comp.children?.[0];
+		if (!contentContainer) return [];
+		return (contentContainer.children ?? [])
+			.filter((c: any) => c.constructor?.name === "Markdown")
+			.map((c: any) => (c as any).text as string);
+	}
+	assert.deepEqual(getRenderedTexts(priorA), ["A"], "prior A text-run must still contain 'A' after shrink");
+	assert.deepEqual(getRenderedTexts(priorB), ["B"], "prior B text-run must still contain 'B' after shrink");
+	assert.deepEqual(getRenderedTexts(host.chatContainer.children[3]), ["C"], "new text-run must contain only 'C'");
+
+	// Sub-turn 2 grows with a new tool T2 at contentIndex=1.
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "C" }, t2]),
+		assistantMessageEvent: {
+			type: "toolcall_end", contentIndex: 1,
+			toolCall: { ...t2, externalResult: { content: [{ type: "text", text: "r2" }], details: {}, isError: false } },
+			partial: makeAssistant([{ type: "text", text: "C" }, t2]),
+		},
+	} as any);
+
+	// T2 must be appended after the new C text-run, not conflated with the stale T1 registration.
+	assert.equal(host.chatContainer.children.length, 5, "new tool appends after new text-run");
+	assert.equal(host.chatContainer.children[4]?.constructor?.name, "ToolExecutionComponent");
+	assert.notEqual(host.chatContainer.children[4], priorT1, "new T2 must be a different component from prior T1");
+
+	// Finalize so the module-level pinned spinner (setInterval) is torn down and the test process can exit.
+	await handleAgentEvent(host, { type: "message_end", message: makeAssistant([{ type: "text", text: "C" }, t2]) } as any);
+});
+
+// Regression: after a sub-turn shrink, lastPinnedText must be cleared so the
+// pinned "Latest Output" mirror can display text from the new sub-turn instead
+// of staying frozen on a stale snapshot (the "bottom green stays" symptom).
+test("chat-controller updates pinned zone after sub-turn shrink", 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();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	const t1 = { type: "toolCall", id: "t1", name: "tool_one", arguments: {} };
+	const t2 = { type: "toolCall", id: "t2", name: "tool_two", arguments: {} };
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+
+	// Sub-turn 1 with pinnable text before a tool → populates pinned zone with "first".
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "first" }, t1]),
+		assistantMessageEvent: {
+			type: "toolcall_end", contentIndex: 1,
+			toolCall: { ...t1, externalResult: { content: [{ type: "text", text: "r1" }], details: {}, isError: false } },
+			partial: makeAssistant([{ type: "text", text: "first" }, t1]),
+		},
+	} as any);
+	const pinnedMarkdown = host.pinnedMessageContainer.children[1];
+	assert.equal((pinnedMarkdown as any)?.text, "first", "pinned zone seeded with sub-turn 1 text");
+
+	// Sub-turn boundary: content resets to [second, t2].
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant([{ type: "text", text: "second" }, t2]),
+		assistantMessageEvent: {
+			type: "toolcall_end", contentIndex: 1,
+			toolCall: { ...t2, externalResult: { content: [{ type: "text", text: "r2" }], details: {}, isError: false } },
+			partial: makeAssistant([{ type: "text", text: "second" }, t2]),
+		},
+	} as any);
+
+	// Pinned markdown must now reflect the new sub-turn's text, not stay frozen on "first".
+	assert.equal((pinnedMarkdown as any)?.text, "second", "pinned zone must update after sub-turn shrink (#4144 regression)");
+
+	// Finalize so the module-level pinned spinner (setInterval) is torn down and the test process can exit.
+	await handleAgentEvent(host, { type: "message_end", message: makeAssistant([{ type: "text", text: "second" }, t2]) } as any);
+});

package/packages/pi-coding-agent/src/core/compaction/utils.ts

@@ -218,7 +218,7 @@ export function serializeConversation(messages: Message[]): string {
 							.filter((c): c is { type: "text"; text: string } => c.type === "text")
 							.map((c) => c.text)
 							.join("");
-			if (content) parts.push(`[User]: ${content}`);
+			if (content) parts.push(`**User said:** ${content}`);
 		} else if (msg.role === "assistant") {
 			const textParts: string[] = [];
 			const thinkingParts: string[] = [];
@@ -239,13 +239,13 @@ export function serializeConversation(messages: Message[]): string {
 			}
 
 			if (thinkingParts.length > 0) {
-				parts.push(`[Assistant thinking]: ${thinkingParts.join("\n")}`);
+				parts.push(`**Assistant thinking:** ${thinkingParts.join("\n")}`);
 			}
 			if (textParts.length > 0) {
-				parts.push(`[Assistant]: ${textParts.join("\n")}`);
+				parts.push(`**Assistant responded:** ${textParts.join("\n")}`);
 			}
 			if (toolCalls.length > 0) {
-				parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+				parts.push(`**Assistant tool calls:** ${toolCalls.join("; ")}`);
 			}
 		} else if (msg.role === "toolResult") {
 			const content = msg.content
@@ -253,7 +253,7 @@ export function serializeConversation(messages: Message[]): string {
 				.map((c) => c.text)
 				.join("");
 			if (content) {
-				parts.push(`[Tool result]: ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
+				parts.push(`**Tool result:** ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
 			}
 		}
 	}

package/packages/pi-coding-agent/src/core/compaction-utils.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { Message } from "@gsd/pi-ai";
+
+import { serializeConversation } from "./compaction/index.js";
+
+test("serializeConversation uses narrative role markers instead of chat-style delimiters (#4054)", () => {
+	const messages: Message[] = [
+		{ role: "user", content: "Please refactor the parser." } as Message,
+		{
+			role: "assistant",
+			content: [
+				{ type: "thinking", thinking: "I should inspect the parser entry points first." },
+				{ type: "text", text: "I'll start with the parser entry points." },
+				{ type: "toolCall", id: "tool-1", name: "Read", arguments: { path: "src/parser.ts" } },
+			],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: Date.now(),
+		} as Message,
+		{
+			role: "toolResult",
+			content: [{ type: "text", text: "parser contents" }],
+			toolName: "Read",
+			toolCallId: "tool-1",
+		} as Message,
+	];
+
+	const serialized = serializeConversation(messages);
+
+	assert.match(serialized, /\*\*User said:\*\* Please refactor the parser\./);
+	assert.match(serialized, /\*\*Assistant thinking:\*\* I should inspect the parser entry points first\./);
+	assert.match(serialized, /\*\*Assistant responded:\*\* I'll start with the parser entry points\./);
+	assert.match(serialized, /\*\*Assistant tool calls:\*\* Read\(path="src\/parser\.ts"\)/);
+	assert.match(serialized, /\*\*Tool result:\*\* parser contents/);
+	assert.ok(!serialized.includes("[User]:"), "chat-style [User]: markers should not remain");
+	assert.ok(!serialized.includes("[Assistant]:"), "chat-style [Assistant]: markers should not remain");
+	assert.ok(!serialized.includes("[Tool result]:"), "chat-style [Tool result]: markers should not remain");
+});

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));
+			}
 		}
 	}
 }