@oh-my-pi/pi-coding-agent 17.2.13 → 17.2.15

package/src/mcp/transports/http.ts

@@ -2,10 +2,11 @@
  * MCP HTTP transport (Streamable HTTP).
  *
  * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
- * Based on MCP spec 2025-03-26.
+ * The negotiated protocol revision is carried in the `MCP-Protocol-Version`
+ * header on every request (see `MCP_PROTOCOL_VERSION`).
  */
 import * as AIError from "@oh-my-pi/pi-ai/error";
-import { logger, readSseJson } from "@oh-my-pi/pi-utils";
+import { logger, readSseEvents, readSseJson } from "@oh-my-pi/pi-utils";
 import type {
 	JsonRpcError,
 	JsonRpcMessage,
@@ -19,9 +20,37 @@ import type {
 import { toJsonRpcError } from "../../mcp/types";
 import { RequestIdAllocator } from "../request-id";
 import { createMCPTimeout, getNeverAbortSignal, isMCPTimeoutEnabled, resolveMCPTimeoutMs } from "../timeout";
-import { type MCPFetchInit, mcpFetch } from "./header-policy";
+import { type MCPFetchInit, mcpFetch, withoutHeader } from "./header-policy";
 
 const HTTP_SSE_CONNECT_TIMEOUT_MS = 1_000;
+const DEFAULT_SSE_RETRY_MS = 3_000;
+
+interface SSEResumeState {
+	lastEventId: string | null;
+	retryMs: number;
+}
+
+/**
+ * Failure resuming an accepted request's logical SSE stream. Carries a
+ * never-replay contract: by resume time the server has accepted (and possibly
+ * executed) the originating POST, so auth-retry paths must not re-send it.
+ */
+class SSEResumeError extends Error {}
+
+/** Wait for the server-provided SSE retry interval while remaining abortable. */
+async function waitForSSERetry(ms: number, signal: AbortSignal): Promise<void> {
+	if (signal.aborted) throw signal.reason;
+	const { promise, resolve, reject } = Promise.withResolvers<void>();
+	const timer = setTimeout(resolve, ms);
+	const onAbort = (): void => reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		await promise;
+	} finally {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+	}
+}
 /**
  * Best-effort startup deadline for the optional Streamable HTTP GET SSE listener.
  *
@@ -45,6 +74,14 @@ export class HttpTransport implements MCPTransport {
 	#sessionId: string | null = null;
 	#sseConnection: AbortController | null = null;
 	readonly #requestIds = new RequestIdAllocator();
+	/**
+	 * Protocol version echoed in the `MCP-Protocol-Version` header. `null` until
+	 * the `initialize` response is negotiated (via {@link setProtocolVersion}):
+	 * the MCP spec requires the header only on requests *after* `initialize`, and
+	 * a server that supports only an older revision may reject a header carrying
+	 * a newer version sent before negotiation completes.
+	 */
+	#protocolVersion: string | null = null;
 
 	onClose?: () => void;
 	onError?: (error: Error) => void;
@@ -55,16 +92,32 @@ export class HttpTransport implements MCPTransport {
 
 	constructor(private config: MCPHttpServerConfig | MCPSseServerConfig) {}
 
-	/** Fetch the configured endpoint with header precedence and origin policy. */
+	/**
+	 * Fetch the configured endpoint with header precedence and origin policy.
+	 *
+	 * The transport fully owns `MCP-Protocol-Version`: it is stripped from
+	 * configured headers so a user's `mcp.json` can never inject it, and added
+	 * only once a version is negotiated (required by the MCP Streamable HTTP spec
+	 * after `initialize`). Before negotiation — the `initialize` request itself —
+	 * no protocol-version header is sent from either source.
+	 */
 	#fetch(init: MCPFetchInit, generated: Record<string, string>): Promise<Response> {
+		const configured = withoutHeader(this.config.headers, "MCP-Protocol-Version");
+		const withVersion =
+			this.#protocolVersion === null ? generated : { "MCP-Protocol-Version": this.#protocolVersion, ...generated };
 		return mcpFetch(
 			this.config.url,
 			init,
-			{ generated, configured: this.config.headers },
+			{ generated: withVersion, configured },
 			this.config.headerPolicy === "origin-locked",
 		);
 	}
 
+	/** Record the protocol version negotiated during `initialize`. */
+	setProtocolVersion(version: string): void {
+		this.#protocolVersion = version;
+	}
+
 	get connected(): boolean {
 		return this.#connected;
 	}
@@ -149,7 +202,7 @@ export class HttpTransport implements MCPTransport {
 		// If the stream ends unexpectedly (server restart, network drop),
 		// fire onClose so the manager can trigger reconnection.
 		const signal = connection.signal;
-		void this.#readSSEStream(response.body!, signal).finally(() => {
+		void this.#runSSEListener(response.body!, signal).finally(() => {
 			const wasConnected = this.#connected;
 			if (this.#sseConnection === connection) this.#sseConnection = null;
 			if (wasConnected) this.onClose?.();
@@ -169,6 +222,95 @@ export class HttpTransport implements MCPTransport {
 		}
 	}
 
+	/**
+	 * Read the long-lived GET SSE stream, resuming with `Last-Event-ID` when
+	 * the server closes the physical connection mid-stream (2025-11-25 permits
+	 * polling-style servers). Returns only when the logical stream ends — the
+	 * caller fires `onClose` and the manager's reconnect path takes over. A
+	 * resume cycle that delivers no events before dropping again ends the
+	 * stream rather than retrying forever against a broken server.
+	 */
+	async #runSSEListener(initialBody: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
+		const resume: SSEResumeState = { lastEventId: null, retryMs: DEFAULT_SSE_RETRY_MS };
+		let body = initialBody;
+		let progressed = true;
+		for (;;) {
+			try {
+				for await (const event of readSseEvents(body, signal)) {
+					progressed = true;
+					if (event.id !== undefined) resume.lastEventId = event.id || null;
+					if (event.retry !== undefined) resume.retryMs = event.retry;
+					if (event.data === "") continue;
+					if (!this.#connected) return;
+					this.#dispatchSSEMessage(JSON.parse(event.data) as JsonRpcMessage | JsonRpcMessage[]);
+				}
+			} catch (error) {
+				if (error instanceof Error && error.name === "AbortError") return;
+				logger.debug("HTTP SSE stream error", {
+					url: this.config.url,
+					error: error instanceof Error ? error.message : String(error),
+				});
+				if (resume.lastEventId === null) {
+					if (error instanceof Error) this.onError?.(error);
+					return;
+				}
+			}
+			if (!this.#connected || signal.aborted || resume.lastEventId === null || !progressed) return;
+			progressed = false;
+			try {
+				const response = await this.#fetchSSEResume(resume, signal);
+				body = response.body as ReadableStream<Uint8Array>;
+			} catch (error) {
+				if (!(error instanceof Error && error.name === "AbortError")) {
+					logger.debug("HTTP SSE listener resume failed", {
+						url: this.config.url,
+						error: error instanceof Error ? error.message : String(error),
+					});
+				}
+				return;
+			}
+		}
+	}
+
+	/**
+	 * Resume a logical SSE stream via GET + `Last-Event-ID`, honoring the
+	 * server-provided retry interval and refreshing auth once on 401/403.
+	 * Failures throw {@link SSEResumeError} so `request()` never replays the
+	 * originating POST in response.
+	 */
+	async #fetchSSEResume(resume: SSEResumeState, signal: AbortSignal): Promise<Response> {
+		if (resume.lastEventId === null) {
+			throw new SSEResumeError("SSE stream ended without a resumable event ID");
+		}
+		await waitForSSERetry(resume.retryMs, signal);
+		const generated: Record<string, string> = {
+			Accept: "text/event-stream",
+			"Last-Event-ID": resume.lastEventId,
+		};
+		if (this.#sessionId) generated["Mcp-Session-Id"] = this.#sessionId;
+		let response = await this.#fetch({ method: "GET", signal }, generated);
+		if (this.onAuthError && (response.status === 401 || response.status === 403)) {
+			await response.body?.cancel();
+			const newHeaders = await this.onAuthError();
+			if (!newHeaders) {
+				throw new SSEResumeError(`HTTP ${response.status} resuming MCP SSE stream: auth refresh failed`);
+			}
+			// Persist refreshed headers so subsequent requests use them directly
+			this.config = { ...this.config, headers: newHeaders };
+			response = await this.#fetch({ method: "GET", signal }, generated);
+		}
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new SSEResumeError(`HTTP ${response.status} resuming MCP SSE stream: ${text}`);
+		}
+		const contentType = response.headers.get("Content-Type") ?? "";
+		if (!contentType.includes("text/event-stream") || !response.body) {
+			await response.body?.cancel();
+			throw new SSEResumeError(`MCP SSE resume returned unsupported Content-Type: ${contentType || "(missing)"}`);
+		}
+		return response;
+	}
+
 	/** Route an SSE message (or batch) to the appropriate handler. */
 	#dispatchSSEMessage(message: JsonRpcMessage | JsonRpcMessage[]): void {
 		if (Array.isArray(message)) {
@@ -194,9 +336,12 @@ export class HttpTransport implements MCPTransport {
 		try {
 			return await this.#executeRequest<T>(method, params, options);
 		} catch (error) {
-			// Retry once on auth failure if onAuthError is wired
+			// Retry once on auth failure if onAuthError is wired. Never replay
+			// after an SSE resume failure: the server already accepted the
+			// original POST and may have executed it — replaying could run a
+			// state-changing tool twice.
 			const status = error instanceof Error ? AIError.status(error) : undefined;
-			if (this.onAuthError && (status === 401 || status === 403)) {
+			if (!(error instanceof SSEResumeError) && this.onAuthError && (status === 401 || status === 403)) {
 				const newHeaders = await this.onAuthError();
 				if (newHeaders) {
 					// Persist refreshed headers so subsequent requests use them directly
@@ -298,40 +443,60 @@ export class HttpTransport implements MCPTransport {
 		const signal = operation.signal ?? getNeverAbortSignal();
 
 		const { promise, resolve, reject } = Promise.withResolvers<T>();
+		const resume: SSEResumeState = { lastEventId: null, retryMs: DEFAULT_SSE_RETRY_MS };
 		let captured = false;
 
-		// Drain the SSE stream from a single iterator. We resolve the deferred
-		// promise as soon as the matching response arrives, then keep iterating
-		// in the background to pick up piggybacked notifications/requests.
-		// Re-reading `response.body` after `for await` breaks would lock the
-		// stream a second time and surface as "ReadableStream already has a
-		// controller", so we must not exit the loop early.
+		// Drain each physical SSE connection without leaving its iterator early.
+		// A server may close a connection without terminating the logical stream;
+		// when it supplied an event ID, resume that stream via GET + Last-Event-ID.
 		const drain = async (): Promise<void> => {
+			let current = response;
 			try {
-				for await (const raw of readSseJson<JsonRpcMessage | JsonRpcMessage[]>(response.body!, signal)) {
-					const messages = Array.isArray(raw) ? raw : [raw];
-					for (const message of messages) {
-						if (
-							!captured &&
-							"id" in message &&
-							message.id === expectedId &&
-							("result" in message || "error" in message)
-						) {
-							captured = true;
-							operation.clear();
-							if (message.error) {
-								reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
-							} else {
-								resolve(message.result as T);
+				for (;;) {
+					if (!current.body) throw new Error("SSE response did not include a body");
+					try {
+						for await (const event of readSseEvents(current.body, signal)) {
+							if (event.id !== undefined) resume.lastEventId = event.id || null;
+							if (event.retry !== undefined) resume.retryMs = event.retry;
+							if (event.data === "") continue;
+							const raw = JSON.parse(event.data) as JsonRpcMessage | JsonRpcMessage[];
+							const messages = Array.isArray(raw) ? raw : [raw];
+							for (const message of messages) {
+								if (
+									!captured &&
+									"id" in message &&
+									message.id === expectedId &&
+									("result" in message || "error" in message)
+								) {
+									captured = true;
+									operation.clear();
+									if (message.error) {
+										reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
+									} else {
+										resolve(message.result as T);
+									}
+									continue;
+								}
+								if (!this.#connected) continue;
+								this.#dispatchSSEMessage(message);
 							}
-							continue;
 						}
-						if (!this.#connected) continue;
-						this.#dispatchSSEMessage(message);
+					} catch (error) {
+						// An abrupt drop (socket reset, body-read failure) is as
+						// resumable as a server-initiated close once an event ID
+						// exists; the request timeout still bounds the total wait.
+						if (captured) return;
+						if (signal.aborted || resume.lastEventId === null) throw error;
+						logger.debug("MCP SSE response stream dropped; resuming", {
+							url: this.config.url,
+							error: error instanceof Error ? error.message : String(error),
+						});
 					}
-				}
-				if (!captured) {
-					reject(new Error(`No response received for request ID ${expectedId}`));
+					if (captured) return;
+					if (resume.lastEventId === null) {
+						throw new Error(`No response received for request ID ${expectedId}`);
+					}
+					current = await this.#fetchSSEResume(resume, signal);
 				}
 			} catch (error) {
 				if (captured) return;

package/src/mcp/types.ts

@@ -151,6 +151,19 @@ export interface MCPConfigFile {
 // MCP Protocol Types
 // =============================================================================
 
+/**
+ * Latest MCP protocol revision this client negotiates.
+ *
+ * Sent as `protocolVersion` in the `initialize` request and, for Streamable
+ * HTTP, echoed back to the server in the `MCP-Protocol-Version` header on every
+ * subsequent request (per the MCP HTTP transport spec). Must track the current
+ * stable revision: AWS Bedrock AgentCore Gateway refuses tool calls on an
+ * outbound per-user OAuth (`AUTHORIZATION_CODE`) target below `2025-11-25`, and
+ * it checks the version *before* consulting its token vault, so an older client
+ * is refused even for a caller whose consent is already stored.
+ */
+export const MCP_PROTOCOL_VERSION = "2025-11-25";
+
 /** MCP implementation info */
 export interface MCPImplementation {
 	name: string;
@@ -269,6 +282,14 @@ export interface MCPTransport {
 	/** Close the transport */
 	close(): Promise<void>;
 
+	/**
+	 * Record the protocol version negotiated in the `initialize` response.
+	 * Streamable HTTP transports echo it in the `MCP-Protocol-Version` header on
+	 * every subsequent request; transports that need no per-request version
+	 * (stdio) omit this.
+	 */
+	setProtocolVersion?(version: string): void;
+
 	/** Whether the transport is connected */
 	readonly connected: boolean;
 

package/src/modes/components/chat-transcript-builder.ts

@@ -18,6 +18,7 @@ import type { AdvisorMessageDetails } from "../../advisor";
 import { COLLAB_PROMPT_MESSAGE_TYPE, type CollabPromptDetails } from "../../collab/protocol";
 import { settings } from "../../config/settings";
 import type { MessageRenderer } from "../../extensibility/extensions/types";
+import { LAUNCH_COMPLETION_MESSAGE_TYPE } from "../../session/launch-completion";
 import {
 	BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE,
 	type CustomMessage,
@@ -53,6 +54,7 @@ import { EvalExecutionComponent } from "./eval-execution";
 import { type LateDiagnosticsFile, LateDiagnosticsMessageComponent } from "./late-diagnostics-message";
 import { groupedReadUsageCallIds, ReadToolGroupComponent, readArgsCollapseIntoGroup } from "./read-tool-group";
 import { SkillMessageComponent } from "./skill-message";
+import { ToolActivityContainer } from "./tool-activity";
 import { ToolExecutionComponent } from "./tool-execution";
 import { TranscriptContainer } from "./transcript-container";
 import { createUsageRowBlock } from "./usage-row";
@@ -95,7 +97,9 @@ export class ChatTranscriptBuilder {
 	#expandables: Array<{ setExpanded(expanded: boolean): void }> = [];
 	#expanded = false;
 
-	constructor(private readonly deps: ChatTranscriptBuilderDeps) {}
+	constructor(private readonly deps: ChatTranscriptBuilderDeps) {
+		this.container.setToolActivityVisible(!settings.get("display.hideToolActivity"));
+	}
 
 	/** Whether the transcript currently holds any rendered rows. */
 	get isEmpty(): boolean {
@@ -192,7 +196,6 @@ export class ChatTranscriptBuilder {
 			this.#readGroup = new ReadToolGroupComponent({
 				showContentPreview: settings.get("read.toolResultPreview"),
 			});
-			this.#readGroup.setToolActivityVisible(!settings.get("display.hideToolActivity"));
 			this.#trackExpandable(this.#readGroup);
 			this.container.addChild(this.#readGroup);
 		}
@@ -407,7 +410,6 @@ export class ChatTranscriptBuilder {
 				this.deps.cwd,
 				content.id,
 			);
-			component.setToolActivityVisible(!settings.get("display.hideToolActivity"));
 			this.#trackExpandable(component);
 			this.container.addChild(component);
 
@@ -464,11 +466,11 @@ export class ChatTranscriptBuilder {
 			this.#todoSnapshot = pending;
 		}
 	}
-
 	#appendCustomMessage(message: Extract<AgentMessage, { role: "custom" | "hookMessage" }>): void {
 		if (!message.display) return;
 		if (message.customType === "async-result") {
-			this.container.addChild(buildAsyncResultBlock(message));
+			const component = buildAsyncResultBlock(message);
+			this.container.addChild(component);
 			return;
 		}
 		if (message.customType === LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE) {
@@ -501,6 +503,16 @@ export class ChatTranscriptBuilder {
 			this.container.addChild(createAdvisorMessageCard(details, () => this.#expanded, theme));
 			return;
 		}
+		if (message.customType === LAUNCH_COMPLETION_MESSAGE_TYPE) {
+			const messageComponent = new CustomMessageComponent(
+				message as CustomMessage<unknown>,
+				this.deps.getMessageRenderer?.(message.customType),
+			);
+			this.#trackExpandable(messageComponent);
+			const component = new ToolActivityContainer(messageComponent);
+			this.container.addChild(component);
+			return;
+		}
 		if (message.customType === BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE) {
 			this.container.addChild(createBackgroundTanDispatchBlock(message as CustomMessage<unknown>));
 			return;

package/src/modes/components/late-diagnostics-message.ts

@@ -17,7 +17,7 @@ export interface LateDiagnosticsFile {
  */
 export class LateDiagnosticsMessageComponent extends Container {
 	#expanded = false;
-
+	#toolActivityVisible = true;
 	constructor(private readonly files: LateDiagnosticsFile[]) {
 		super();
 		this.#rebuild();
@@ -29,6 +29,17 @@ export class LateDiagnosticsMessageComponent extends Container {
 		this.#rebuild();
 	}
 
+	setToolActivityVisible(visible: boolean): void {
+		if (this.#toolActivityVisible === visible) return;
+		this.#toolActivityVisible = visible;
+		this.invalidate();
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#toolActivityVisible) return [];
+		return super.render(width);
+	}
+
 	override invalidate(): void {
 		super.invalidate();
 		this.#rebuild();

package/src/modes/components/todo-reminder.ts

@@ -10,6 +10,7 @@ import type { TodoItem } from "../../tools/todo";
  */
 export class TodoReminderComponent extends Container {
 	#box: Box;
+	#toolActivityVisible = true;
 
 	constructor(
 		private readonly todos: TodoItem[],
@@ -27,6 +28,17 @@ export class TodoReminderComponent extends Container {
 		this.#rebuild();
 	}
 
+	setToolActivityVisible(visible: boolean): void {
+		if (this.#toolActivityVisible === visible) return;
+		this.#toolActivityVisible = visible;
+		this.invalidate();
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#toolActivityVisible) return [];
+		return super.render(width);
+	}
+
 	#rebuild(): void {
 		this.#box.clear();
 

package/src/modes/components/tool-activity.ts

@@ -0,0 +1,45 @@
+import { type Component, Container } from "@oh-my-pi/pi-tui";
+
+export interface ToolActivityComponent {
+	setToolActivityVisible(visible: boolean): void;
+}
+
+export function isToolActivityComponent(component: Component): component is Component & ToolActivityComponent {
+	return typeof (component as Partial<ToolActivityComponent>).setToolActivityVisible === "function";
+}
+
+export class ToolActivityContainer extends Container implements ToolActivityComponent {
+	#visible = true;
+
+	constructor(component: Component | Component[]) {
+		super();
+		if (Array.isArray(component)) {
+			for (const child of component) this.addChild(child);
+		} else {
+			this.addChild(component);
+		}
+	}
+
+	setToolActivityVisible(visible: boolean): void {
+		if (this.#visible === visible) return;
+		this.#visible = visible;
+		this.invalidate();
+	}
+
+	/**
+	 * Forward Ctrl+O expansion to wrapped children. The transcript's expansion
+	 * traversal only visits top-level children, so the wrapper must proxy or
+	 * wrapped renderers would freeze at their insertion-time expansion state.
+	 */
+	setExpanded(expanded: boolean): void {
+		for (const child of this.children) {
+			const expandable = child as Partial<{ setExpanded(expanded: boolean): void }>;
+			if (typeof expandable.setExpanded === "function") expandable.setExpanded(expanded);
+		}
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#visible) return [];
+		return super.render(width);
+	}
+}

package/src/modes/components/transcript-container.ts

@@ -6,6 +6,7 @@ import {
 	type RenderStablePrefix,
 	type ViewportTailProvider,
 } from "@oh-my-pi/pi-tui";
+import { isToolActivityComponent } from "./tool-activity";
 
 /**
  * A transcript block that is still mutating (a foreground tool awaiting its
@@ -160,6 +161,7 @@ export class TranscriptContainer
 	extends Container
 	implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider
 {
+	#toolActivityVisible = true;
 	// Bumped to retire every block segment at once (theme change / clear); a
 	// segment is only reused when its stored generation matches.
 	#generation = 0;
@@ -182,6 +184,20 @@ export class TranscriptContainer
 	// consumes the report and re-bases the baseline). Out-of-band renders
 	// between engine frames lower it; they can never inflate it.
 	#stableRowsFloor = 0;
+	override addChild(component: Component): void {
+		if (isToolActivityComponent(component)) component.setToolActivityVisible(this.#toolActivityVisible);
+		super.addChild(component);
+	}
+
+	setToolActivityVisible(visible: boolean): void {
+		if (this.#toolActivityVisible === visible) return;
+		this.#toolActivityVisible = visible;
+		for (const child of this.children) {
+			if (isToolActivityComponent(child)) child.setToolActivityVisible(visible);
+		}
+		this.invalidate();
+	}
+
 	override invalidate(): void {
 		// Theme/global invalidation: retire every diff snapshot so stale styling
 		// is not diffed against the recolored render.

package/src/modes/components/ttsr-notification.ts

@@ -16,6 +16,7 @@ export class TtsrNotificationComponent extends Container {
 	#box: Box;
 	#expanded = false;
 	#rules: Rule[];
+	#toolActivityVisible = true;
 
 	constructor(rules: Rule[]) {
 		super();
@@ -31,6 +32,17 @@ export class TtsrNotificationComponent extends Container {
 		this.#rebuild();
 	}
 
+	setToolActivityVisible(visible: boolean): void {
+		if (this.#toolActivityVisible === visible) return;
+		this.#toolActivityVisible = visible;
+		this.invalidate();
+	}
+
+	override render(width: number): readonly string[] {
+		if (!this.#toolActivityVisible) return [];
+		return super.render(width);
+	}
+
 	/** Merge additional rules into this block (deduped by rule name). */
 	addRules(rules: Rule[]): void {
 		let changed = false;

package/src/modes/controllers/event-controller.ts

@@ -345,7 +345,6 @@ export class EventController {
 				showContentPreview: this.ctx.settings.get("read.toolResultPreview"),
 			});
 			group.setExpanded(this.ctx.toolOutputExpanded);
-			group.setToolActivityVisible(!this.ctx.hideToolActivity);
 			this.ctx.chatContainer.addChild(group);
 			this.#lastReadGroup = group;
 		}
@@ -1131,7 +1130,6 @@ export class EventController {
 						content.id,
 					);
 					component.setExpanded(this.ctx.toolOutputExpanded);
-					component.setToolActivityVisible(!this.ctx.hideToolActivity);
 					this.ctx.chatContainer.addChild(component);
 					this.ctx.pendingTools.set(content.id, component);
 					this.#toolTimelineComponents.set(content.id, component);
@@ -1384,7 +1382,6 @@ export class EventController {
 			);
 			component.setArgsComplete(event.toolCallId);
 			component.setExpanded(this.ctx.toolOutputExpanded);
-			component.setToolActivityVisible(!this.ctx.hideToolActivity);
 			this.ctx.chatContainer.addChild(component);
 			this.ctx.pendingTools.set(event.toolCallId, component);
 			this.#toolTimelineComponents.set(event.toolCallId, component);
@@ -1624,8 +1621,8 @@ export class EventController {
 			// This text can be a provider error copied verbatim off the wire (the
 			// Cursor todo bridge forwards the server's string), so it may carry
 			// ANSI escapes, other C0/C1 controls, tabs, newlines, or a line far
-			// wider than the terminal. `showWarning` renders through a plain
-			// `Text`, which strips none of that — an escape reaches the terminal
+			// wider than the terminal. `showWarning` renders through a plain `Text`,
+			// which strips none of that — an escape reaches the terminal
 			// and can repaint outside the row. `sanitizeText` drops the control
 			// sequences (and returns the same reference when there are none),
 			// then `previewLine` collapses the remaining whitespace and bounds
@@ -1637,6 +1634,7 @@ export class EventController {
 			const detail = textContent ? previewLine(sanitizeText(textContent), TRUNCATE_LENGTHS.LINE) : "";
 			this.ctx.showWarning(
 				`Todo update failed${detail ? `: ${detail}` : ". Progress may be stale until todo succeeds."}`,
+				{ hideWithToolActivity: true },
 			);
 		}
 		// Plan approval rides a `write` to xd://propose: the dispatch metadata on
@@ -2027,7 +2025,6 @@ export class EventController {
 		const component = new TodoReminderComponent(event.todos, event.attempt, event.maxAttempts);
 		this.ctx.present(component);
 	}
-
 	async #handleTodoAutoClear(_event: Extract<AgentSessionEvent, { type: "todo_auto_clear" }>): Promise<void> {
 		await this.ctx.reloadTodos();
 	}

package/src/modes/controllers/input-controller.ts

@@ -10,7 +10,6 @@ import { AssistantMessageComponent } from "../../modes/components/assistant-mess
 import { extractImagePathFromText } from "../../modes/components/custom-editor";
 import { ReadToolGroupComponent } from "../../modes/components/read-tool-group";
 import { renderSegmentTrack } from "../../modes/components/segment-track";
-import { StrippedToolCallsPlaceholder } from "../../modes/components/stripped-tool-calls-placeholder";
 import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-title-download-progress";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { TreeSelectorComponent } from "../../modes/components/tree-selector";
@@ -1925,15 +1924,16 @@ export class InputController {
 		}
 
 		for (const child of this.ctx.chatContainer.children) {
-			if (child instanceof ToolExecutionComponent || child instanceof ReadToolGroupComponent) {
-				if (!this.ctx.hideToolActivity) child.setExpanded(false);
-				child.setToolActivityVisible(!this.ctx.hideToolActivity);
+			if (
+				!this.ctx.hideToolActivity &&
+				(child instanceof ToolExecutionComponent || child instanceof ReadToolGroupComponent)
+			) {
+				child.setExpanded(false);
 			} else if (child instanceof AssistantMessageComponent) {
 				child.setToolResultImagesVisible(!this.ctx.hideToolActivity);
-			} else if (child instanceof StrippedToolCallsPlaceholder) {
-				child.setToolActivityVisible(!this.ctx.hideToolActivity);
 			}
 		}
+		this.ctx.chatContainer.setToolActivityVisible(!this.ctx.hideToolActivity);
 
 		if (this.ctx.hideToolActivity) this.ctx.ui.clearInlineImages();
 		this.ctx.ui.resetDisplay();