gsd-pi 2.73.1 → 2.74.0-dev.16f2f3b

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

@@ -10,6 +10,27 @@ 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;
+		contentType: "text" | "thinking";
+		component: AssistantMessageComponent;
+	}
+	| { kind: "tool"; contentIndex: number; component: ToolExecutionComponent };
+
+let renderedSegments: RenderedSegment[] = [];
+// When providers reuse one assistant lifecycle across internal sub-turns,
+// a content[] shrink resets renderedSegments. Keep the displaced segments so
+// claude-code MCP pruning can remove stale provisional text later.
+let orphanedSegments: RenderedSegment[] = [];
+
 function hasVisibleAssistantContent(message: { content: Array<any> }): boolean {
 	return message.content.some(
 		(c) =>
@@ -78,8 +99,11 @@ 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 = [];
+		orphanedSegments = [];
 		if (pinnedBorder) pinnedBorder.stopSpinner();
 		pinnedBorder = undefined;
 		pinnedTextComponent = undefined;
@@ -99,6 +123,9 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.pinnedMessageContainer.clear();
 					lastPinnedText = "";
 					hasToolsInTurn = false;
+					renderedSegments = [];
+					orphanedSegments = [];
+					lastContentLength = 0;
 					if (pinnedBorder) pinnedBorder.stopSpinner();
 					pinnedBorder = undefined;
 					pinnedTextComponent = undefined;
@@ -202,12 +229,23 @@ 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) {
+					orphanedSegments = [...renderedSegments];
+					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") {
@@ -273,24 +311,191 @@ 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;
+					const isClaudeCodeProvider = host.streamingMessage.provider === "claude-code";
+					const hasMcpToolBlock = blocks.some((b: any) => {
+						if (b?.type === "toolCall") {
+							return typeof b?.mcpServer === "string" || String(b?.name ?? "").startsWith("mcp__");
+						}
+						if (b?.type === "serverToolUse") {
+							return typeof b?.mcpServer === "string" || String(b?.name ?? "").startsWith("mcp__");
+						}
+						return false;
+					});
+					const firstToolIdx = blocks.findIndex((b: any) => b.type === "toolCall" || b.type === "serverToolUse");
+					const hasPostToolText = firstToolIdx >= 0
+						&& blocks.some(
+							(b: any, idx: number) => (
+								idx > firstToolIdx
+								&& b?.type === "text"
+								&& typeof b?.text === "string"
+								&& b.text.trim().length > 0
+							),
+						);
+					// Only prune provisional pre-tool prose after post-tool prose exists,
+					// so MCP tool-only windows do not blank the assistant content.
+					const shouldDropPreToolProse = isClaudeCodeProvider && hasMcpToolBlock && hasPostToolText;
+					type DesiredSegment =
+						| { kind: "text-run"; startIndex: number; endIndex: number; contentType: "text" | "thinking" }
+						| { kind: "tool"; contentIndex: number; toolId: string };
+					const desired: DesiredSegment[] = [];
+					let runStart = -1;
+					let runEnd = -1;
+					let runType: "text" | "thinking" | undefined;
+					const closeRun = () => {
+						if (runStart !== -1 && runType) {
+							desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
+							runStart = -1;
+							runEnd = -1;
+							runType = undefined;
+						}
+					};
+					for (let i = 0; i < blocks.length; i++) {
+						const b = blocks[i];
+						const blockType = b.type === "text" || b.type === "thinking" ? b.type : undefined;
+						const isTextLike = blockType === "text" || blockType === "thinking";
+						const isTool = b.type === "toolCall" || b.type === "serverToolUse";
+						// For Claude Code MCP turns, prune only pre-tool prose, never thinking.
+						const shouldSkipProse = shouldDropPreToolProse && firstToolIdx >= 0 && i < firstToolIdx && blockType === "text";
+						if (shouldSkipProse) {
+							closeRun();
+							continue;
+						}
+						if (isTextLike) {
+							if (runStart === -1) {
+								runStart = i;
+								runEnd = i;
+								runType = blockType;
+							} else if (runType !== blockType) {
+								closeRun();
+								runStart = i;
+								runEnd = i;
+								runType = blockType;
+							} else {
+								runEnd = i;
+							}
+						} else {
+							closeRun();
+							if (isTool) {
+								desired.push({ kind: "tool", contentIndex: i, toolId: b.id });
+							}
+						}
+					}
+					closeRun();
+
+					// Claude Code MCP can emit provisional pre-tool prose that gets
+					// superseded by post-tool output. Prune stale text-run segments so
+					// the final assistant output remains below tool output.
+					if (shouldDropPreToolProse && firstToolIdx >= 0) {
+						if (orphanedSegments.length > 0) {
+							const remainingOrphans: RenderedSegment[] = [];
+							for (const orphan of orphanedSegments) {
+								if (orphan.kind === "text-run" && orphan.contentType === "text") {
+									host.chatContainer.removeChild(orphan.component);
+									if (host.streamingComponent === orphan.component) {
+										host.streamingComponent = undefined;
+									}
+									continue;
+								}
+								remainingOrphans.push(orphan);
+							}
+							orphanedSegments = remainingOrphans;
+						}
+						const desiredTextKeys = new Set(
+							desired
+								.filter((seg): seg is Extract<DesiredSegment, { kind: "text-run" }> => seg.kind === "text-run")
+								.map((seg) => `${seg.contentType}:${seg.startIndex}`),
+						);
+						const desiredToolIndices = new Set(
+							desired
+								.filter((seg): seg is Extract<DesiredSegment, { kind: "tool" }> => seg.kind === "tool")
+								.map((seg) => seg.contentIndex),
+						);
+						const nextRendered: RenderedSegment[] = [];
+						for (const seg of renderedSegments) {
+							if (
+								seg.kind === "text-run"
+								&& seg.contentType === "text"
+								&& !desiredTextKeys.has(`${seg.contentType}:${seg.startIndex}`)
+							) {
+								host.chatContainer.removeChild(seg.component);
+								if (host.streamingComponent === seg.component) {
+									host.streamingComponent = undefined;
+								}
+								continue;
+							}
+							if (seg.kind === "tool" && !desiredToolIndices.has(seg.contentIndex)) {
+								continue;
+							}
+							nextRendered.push(seg);
+						}
+						renderedSegments = nextRendered;
+					}
+
+					// 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 && s.contentType === seg.contentType,
+							);
+							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,
+									contentType: seg.contentType,
+									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 && ds.contentType === seg.contentType,
+							);
+							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.
@@ -376,6 +581,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 					host.chatContainer.addChild(host.streamingComponent);
 				}
 				if (host.streamingComponent) {
+					host.streamingComponent.setShowMetadata(true);
 					host.streamingComponent.updateContent(host.streamingMessage);
 				}
 
@@ -399,6 +605,9 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				}
 				host.streamingComponent = undefined;
 				host.streamingMessage = undefined;
+				renderedSegments = [];
+				orphanedSegments = [];
+				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.
@@ -454,11 +663,15 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 				host.loadingAnimation = undefined;
 				host.statusContainer.clear();
 			}
-			if (host.streamingComponent) {
-				host.chatContainer.removeChild(host.streamingComponent);
-				host.streamingComponent = undefined;
-				host.streamingMessage = undefined;
+			if (host.streamingComponent && host.streamingMessage) {
+				host.streamingComponent.setShowMetadata(true);
+				host.streamingComponent.updateContent(host.streamingMessage);
 			}
+			host.streamingComponent = undefined;
+			host.streamingMessage = undefined;
+			renderedSegments = [];
+			orphanedSegments = [];
+			lastContentLength = 0;
 			host.pendingTools.clear();
 			// Pinned output is only useful while work is actively streaming.
 			// Keep chat history as the single source after completion.

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

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { buildAssistantReplaySegments } from "./interactive-mode.js";
+
+test("buildAssistantReplaySegments preserves tool-first ordering", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "toolCall", id: "t1", name: "read", arguments: {} },
+		{ type: "text", text: "Done." },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "tool", contentIndex: 0 },
+		{ kind: "assistant", startIndex: 1, endIndex: 1 },
+	]);
+});
+
+test("buildAssistantReplaySegments preserves interleaved assistant-tool-assistant runs", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "text", text: "Let me check." },
+		{ type: "serverToolUse", id: "s1", name: "mcp__fs__glob", input: {} },
+		{ type: "thinking", thinking: "Tool result looks good." },
+		{ type: "text", text: "Here is the answer." },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "assistant", startIndex: 0, endIndex: 0 },
+		{ kind: "tool", contentIndex: 1 },
+		{ kind: "assistant", startIndex: 2, endIndex: 3 },
+	]);
+});
+
+test("buildAssistantReplaySegments ignores non-rendered non-tool blocks", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "text", text: "before" },
+		{ type: "webSearchResult", toolUseId: "s1", content: {} },
+		{ type: "text", text: "after" },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "assistant", startIndex: 0, endIndex: 0 },
+		{ kind: "assistant", startIndex: 2, endIndex: 2 },
+	]);
+});

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

@@ -127,6 +127,45 @@ function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 
+export type AssistantReplaySegment =
+	| { kind: "assistant"; startIndex: number; endIndex: number }
+	| { kind: "tool"; contentIndex: number };
+
+/**
+ * Build replay segments for historical assistant messages so rebuild paths
+ * preserve the original content[] ordering between assistant prose and tools.
+ */
+export function buildAssistantReplaySegments(contentBlocks: Array<any>): AssistantReplaySegment[] {
+	const segments: AssistantReplaySegment[] = [];
+	let runStart = -1;
+
+	for (let i = 0; i < contentBlocks.length; i++) {
+		const block = contentBlocks[i];
+		const isAssistantText = block?.type === "text" || block?.type === "thinking";
+		const isTool = block?.type === "toolCall" || block?.type === "serverToolUse";
+
+		if (isAssistantText) {
+			if (runStart === -1) runStart = i;
+			continue;
+		}
+
+		if (runStart !== -1) {
+			segments.push({ kind: "assistant", startIndex: runStart, endIndex: i - 1 });
+			runStart = -1;
+		}
+
+		if (isTool) {
+			segments.push({ kind: "tool", contentIndex: i });
+		}
+	}
+
+	if (runStart !== -1) {
+		segments.push({ kind: "assistant", startIndex: runStart, endIndex: contentBlocks.length - 1 });
+	}
+
+	return segments;
+}
+
 type CompactionQueuedMessage = {
 	text: string;
 	mode: "steer" | "followUp";
@@ -1402,7 +1441,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 +1463,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) {
@@ -2197,9 +2240,30 @@ export class InteractiveMode {
 		for (const message of sessionContext.messages) {
 			// Assistant messages need special handling for tool calls
 			if (message.role === "assistant") {
-				this.addMessageToChat(message);
-				// Render tool call components
-				for (const content of message.content) {
+				const hasToolBlocks = message.content.some((c) => c.type === "toolCall" || c.type === "serverToolUse");
+				if (!hasToolBlocks) {
+					this.addMessageToChat(message);
+					continue;
+				}
+
+				const assistantSegments: AssistantMessageComponent[] = [];
+				const replaySegments = buildAssistantReplaySegments(message.content);
+
+				for (const segment of replaySegments) {
+					if (segment.kind === "assistant") {
+						const assistantComponent = new AssistantMessageComponent(
+							message,
+							this.hideThinkingBlock,
+							this.getMarkdownThemeWithSettings(),
+							this.settingsManager.getTimestampFormat(),
+							{ startIndex: segment.startIndex, endIndex: segment.endIndex },
+						);
+						this.chatContainer.addChild(assistantComponent);
+						assistantSegments.push(assistantComponent);
+						continue;
+					}
+
+					const content = message.content[segment.contentIndex];
 					if (content.type === "toolCall") {
 						const component = new ToolExecutionComponent(
 							content.name,
@@ -2255,6 +2319,11 @@ export class InteractiveMode {
 						}
 					}
 				}
+
+				// Match streaming-mode behavior: show metadata once on the final
+				// assistant prose segment for this message.
+				const lastAssistantSegment = assistantSegments[assistantSegments.length - 1];
+				lastAssistantSegment?.setShowMetadata(true);
 			} else if (message.role === "toolResult") {
 				// Match tool results to pending tool components
 				const component = this.pendingTools.get(message.toolCallId);
@@ -2302,9 +2371,13 @@ export class InteractiveMode {
 
 	private rebuildChatFromMessages(): void {
 		this.chatContainer.clear();
+		this.pinnedMessageContainer.clear();
 		const context = this.sessionManager.buildSessionContext();
 		this.renderSessionContext(context);
-		this.populatePinnedFromMessages(context.messages);
+		// Pinned content NOT re-populated here — the streaming lifecycle in
+		// chat-controller.ts manages the pinned zone during active work.
+		// populatePinnedFromMessages() remains in renderInitialMessages()
+		// for the session-resume case at startup.
 	}
 
 	/**

package/packages/pi-coding-agent/src/types/ambient-modules.d.ts

@@ -0,0 +1,69 @@
+declare module "proper-lockfile" {
+	export interface RetryOptions {
+		retries?: number;
+		factor?: number;
+		minTimeout?: number;
+		maxTimeout?: number;
+		randomize?: boolean;
+	}
+
+	export interface LockOptions {
+		realpath?: boolean;
+		retries?: number | RetryOptions;
+		stale?: number;
+		onCompromised?: (err: Error) => void;
+	}
+
+	export type ReleaseSync = () => void;
+	export type ReleaseAsync = () => Promise<void>;
+
+	export interface ProperLockfileApi {
+		lockSync(path: string, options?: LockOptions): ReleaseSync;
+		lock(path: string, options?: LockOptions): Promise<ReleaseAsync>;
+	}
+
+	const lockfile: ProperLockfileApi;
+	export default lockfile;
+}
+
+declare module "sql.js" {
+	export interface Statement {
+		bind(values: (string | number | null | Uint8Array)[]): void;
+		step(): boolean;
+		getAsObject(): Record<string, unknown>;
+		free(): void;
+	}
+
+	export interface Database {
+		run(sql: string, params?: unknown[]): void;
+		prepare(sql: string): Statement;
+		export(): Uint8Array;
+		close(): void;
+	}
+
+	export interface SqlJsStatic {
+		Database: new (data?: Uint8Array | ArrayBuffer | Buffer) => Database;
+	}
+
+	export interface SqlJsConfig {
+		locateFile?: (file: string) => string;
+	}
+
+	export default function initSqlJs(config?: SqlJsConfig): Promise<SqlJsStatic>;
+}
+
+declare module "hosted-git-info" {
+	export interface HostedGitInfo {
+		domain?: string;
+		user?: string;
+		project?: string;
+		committish?: string;
+	}
+
+	export interface HostedGitInfoApi {
+		fromUrl(url: string): HostedGitInfo | undefined;
+	}
+
+	const hostedGitInfo: HostedGitInfoApi;
+	export default hostedGitInfo;
+}

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

@@ -6,6 +6,7 @@
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "incremental": true,
     "forceConsistentCasingInFileNames": true,
     "declaration": true,
     "declarationMap": true,
@@ -22,6 +23,6 @@
     "outDir": "./dist",
     "rootDir": "./src"
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "**/*.d.ts", "src/**/*.d.ts"]
+  "include": ["src/**/*.ts", "src/**/*.d.ts"],
+  "exclude": ["node_modules", "dist"]
 }