@oh-my-pi/pi-coding-agent 15.11.0 → 15.11.1

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

@@ -1,12 +1,18 @@
-import { type Component, Container, type NativeScrollbackLiveRegion, type RenderStablePrefix } from "@oh-my-pi/pi-tui";
+import {
+	type Component,
+	Container,
+	type NativeScrollbackCommittedRows,
+	type NativeScrollbackLiveRegion,
+	type RenderStablePrefix,
+} from "@oh-my-pi/pi-tui";
 
 const kSnapshot = Symbol("transcript.liveDiffSnapshot");
 
 /**
- * Per-block diff cache: the block's previous stripped contribution plus the
- * derived append-only state. Purely an input to {@link deriveLiveCommitState}
- * for still-live blocks — it is never replayed as render output. Every block
- * renders its current content on every frame.
+ * Per-block render cache: the block's previous stripped contribution plus the
+ * derived append-only state. Still-live blocks use it as input to
+ * {@link deriveLiveCommitState}; finalized blocks wholly inside already
+ * committed native scrollback can replay it without calling render().
  */
 interface LiveDiffSnapshot {
 	width: number;
@@ -47,6 +53,16 @@ interface SnapshotCarrier {
  */
 interface FinalizableBlock {
 	isTranscriptBlockFinalized?(): boolean;
+	/**
+	 * Monotonic content version for blocks that can still mutate *after*
+	 * reporting finalized (e.g. `AssistantMessageComponent`: the inline error
+	 * restored at the next turn's `agent_start`, late tool-result images). The
+	 * committed-scrollback render bypass only replays a block's previous rows
+	 * when the version is unchanged; without this signal a post-finalize
+	 * mutation would stay invisible until a global invalidation. Blocks that
+	 * never mutate post-finalize simply omit the method.
+	 */
+	getTranscriptBlockVersion?(): number;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -54,6 +70,11 @@ function isBlockFinalized(child: Component): boolean {
 	return fn ? fn.call(child) : true;
 }
 
+function getBlockVersion(child: Component): number | undefined {
+	const fn = (child as Component & FinalizableBlock).getTranscriptBlockVersion;
+	return fn ? fn.call(child) : undefined;
+}
+
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -87,11 +108,16 @@ interface BlockSegment {
 	rawRef: readonly string[];
 	contribution: readonly string[];
 	width: number;
+	generation: number;
 	/** Frame row of this block's first emitted row (the separator when present). */
 	startRow: number;
 	/** Rows emitted: separator + contribution (0 for empty contributions). */
 	rowCount: number;
 	sep: number;
+	/** Whether the block reported finalized when this segment was rendered. */
+	finalized: boolean;
+	/** Block version observed when this segment was rendered (see {@link FinalizableBlock}). */
+	version: number | undefined;
 }
 
 const EMPTY_SEGMENTS: BlockSegment[] = [];
@@ -369,7 +395,10 @@ function deriveLiveCommitState(
  * through {@link RenderStablePrefix} so the engine can skip marker scanning,
  * line preparation, and the committed-prefix audit for those rows.
  */
-export class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, RenderStablePrefix {
+export class TranscriptContainer
+	extends Container
+	implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix
+{
 	// Bumped to retire every block's diff snapshot at once (theme change /
 	// clear); a snapshot is only honored when its stored generation matches.
 	#generation = 0;
@@ -390,6 +419,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	#lines: string[] = [];
 	#segments: BlockSegment[] = EMPTY_SEGMENTS;
 	#renderWidth = -1;
+	// Local rows already committed to native scrollback by the previous frame.
+	// Finalized blocks wholly before this boundary are immutable on-screen history;
+	// their previous contribution can be replayed without calling render().
+	#committedRows = 0;
 	// Stable-prefix floor accumulated across renders since the last
 	// getRenderStablePrefixRows() read (see RenderStablePrefix: reading
 	// consumes the report and re-bases the baseline). Out-of-band renders
@@ -407,6 +440,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 		super.clear();
 	}
 
+	setNativeScrollbackCommittedRows(rows: number): void {
+		this.#committedRows = Number.isFinite(rows) ? Math.max(0, Math.trunc(rows)) : 0;
+	}
+
 	getRenderStablePrefixRows(): number {
 		const value = Math.min(this.#stableRowsFloor, this.#lines.length);
 		this.#stableRowsFloor = this.#lines.length;
@@ -497,21 +534,43 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 
 			// This child's contribution: its current render with plain-blank
 			// top/bottom edges stripped (the container owns inter-block gaps).
-			// Always the latest content — committed history keeps whatever bytes
-			// it was written with, but the window must reflect the present state
-			// (late tool results, post-finalize re-layouts, expand toggles).
-			// A block whose render returned the same array reference reuses the
-			// previously stripped contribution (same ref ⇒ identical rows).
+			// Finalized blocks wholly inside committed native scrollback can reuse
+			// their previous contribution without calling render(): those rows are
+			// immutable terminal history for the current width/generation. Blocks
+			// outside committed history still render normally so late results,
+			// post-finalize re-layouts, and expand toggles remain visible.
 			const previousSnapshot = child[kSnapshot];
-			const raw = child.render(width);
 			const previous = previousSegments[i];
-			const reusable =
+			const finalized = isBlockFinalized(child);
+			const version = getBlockVersion(child);
+			const committedReusable =
 				previous !== undefined &&
 				previous.component === child &&
-				previous.rawRef === raw &&
-				previous.width === width;
+				previous.width === width &&
+				previous.generation === this.#generation &&
+				previous.startRow === row &&
+				previous.startRow + previous.rowCount <= this.#committedRows &&
+				finalized &&
+				// Only replay bytes that were themselves produced by a finalized
+				// render: a block finalizing between frames may have changed content
+				// while its rows were already committed via the append-only live
+				// path, so the first post-transition frame must render. Defense in
+				// depth on the transcript side — the TUI commit policy should keep
+				// that window closed, but the safety must not live there alone.
+				previous.finalized &&
+				// Post-finalize mutations (inline error restore, late tool images)
+				// bump the block version; a mismatch forces a real render so the
+				// committed-prefix audit can observe and re-anchor the change.
+				previous.version === version;
+			const raw = committedReusable ? previous.rawRef : child.render(width);
+			const reusable =
+				committedReusable ||
+				(previous !== undefined &&
+					previous.component === child &&
+					previous.rawRef === raw &&
+					previous.width === width &&
+					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
-			const finalized = isBlockFinalized(child);
 			let liveCommitState: LiveCommitState | undefined;
 			if (i >= liveStartIndex && !finalized) {
 				liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
@@ -540,7 +599,18 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 					lines.length = row;
 				}
 				if (chainStable) stableRows = row;
-				segments[i] = { component: child, rawRef: raw, contribution, width, startRow: row, rowCount: 0, sep: 0 };
+				segments[i] = {
+					component: child,
+					rawRef: raw,
+					contribution,
+					width,
+					generation: this.#generation,
+					startRow: row,
+					rowCount: 0,
+					sep: 0,
+					finalized,
+					version,
+				};
 				continue;
 			}
 
@@ -584,7 +654,18 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 				if (!(finalized && safeLength >= contribution.length)) commitSafeOpen = false;
 			}
 
-			segments[i] = { component: child, rawRef: raw, contribution, width, startRow: row, rowCount, sep };
+			segments[i] = {
+				component: child,
+				rawRef: raw,
+				contribution,
+				width,
+				generation: this.#generation,
+				startRow: row,
+				rowCount,
+				sep,
+				finalized,
+				version,
+			};
 			row += rowCount;
 		}
 		// Trailing shrink: blocks removed from the tail leave stale rows behind

package/src/modes/components/tree-selector.ts

@@ -518,6 +518,7 @@ class TreeList implements Component {
 			const renderedIndent = Math.min(displayIndent, maxIndentLevels);
 			const scrollOffset = displayIndent - renderedIndent;
 			const connectorPositionDisplay = hasConnector ? renderedIndent - 1 : -1;
+			const chainGutter = !hasConnector ? flatNode.gutters[flatNode.gutters.length - 1] : undefined;
 
 			// Build prefix char by char, placing gutters and connector at their positions
 			const totalChars = renderedIndent * 3;
@@ -530,8 +531,12 @@ class TreeList implements Component {
 				// Check if there's a gutter at this level (translated to original tree depth)
 				const gutter = flatNode.gutters.find(g => g.position === originalLevel);
 				if (gutter) {
+					// Chain rows (no connector of their own) extend only their
+					// nearest connector gutter so the flattened conversation flow
+					// stays anchored without reviving unrelated `└─` ancestors (#2298).
+					const showVertical = gutter.show || gutter === chainGutter;
 					if (posInLevel === 0) {
-						prefixChars.push(gutter.show ? theme.tree.vertical : " ");
+						prefixChars.push(showVertical ? theme.tree.vertical : " ");
 					} else {
 						prefixChars.push(" ");
 					}

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

@@ -21,6 +21,7 @@ import { isSilentAbort, readPendingDisplayTag, resolveAbortLabel } from "../../s
 import type { ResolveToolDetails } from "../../tools/resolve";
 import { interruptHint } from "../shared";
 import { StreamingRevealController } from "./streaming-reveal";
+import { ToolArgsRevealController } from "./tool-args-reveal";
 
 type AgentSessionEventKind = AgentSessionEvent["type"];
 
@@ -86,6 +87,7 @@ export class EventController {
 	// rules into this block while it is still the (live-region) transcript tail.
 	#lastTtsrNotification: TtsrNotificationComponent | undefined = undefined;
 	#streamingReveal: StreamingRevealController;
+	#toolArgsReveal: ToolArgsRevealController;
 	#handlers: AgentSessionEventHandlers;
 
 	constructor(private ctx: InteractiveModeContext) {
@@ -94,6 +96,10 @@ export class EventController {
 			getHideThinkingBlock: () => this.ctx.hideThinkingBlock,
 			requestRender: () => this.ctx.ui.requestRender(),
 		});
+		this.#toolArgsReveal = new ToolArgsRevealController({
+			getSmoothStreaming: () => this.ctx.settings.get("display.smoothStreaming"),
+			requestRender: () => this.ctx.ui.requestRender(),
+		});
 		this.#handlers = {
 			agent_start: e => this.#handleAgentStart(e),
 			agent_end: e => this.#handleAgentEnd(e),
@@ -127,6 +133,7 @@ export class EventController {
 
 	dispose(): void {
 		this.#streamingReveal.stop();
+		this.#toolArgsReveal.stop();
 		this.#cancelIdleCompaction();
 		for (const timer of this.#ircExpiryTimers.values()) {
 			clearTimeout(timer);
@@ -492,10 +499,23 @@ export class EventController {
 
 				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
 				// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
-				const renderArgs =
-					"partialJson" in content
-						? { ...content.arguments, __partialJson: content.partialJson }
-						: content.arguments;
+				// While the JSON is still open, ToolArgsRevealController paces the
+				// reveal (write/edit/bash previews grow smoothly when a slow provider
+				// delivers large batches); once it closes, the final args render
+				// as-is — mirroring how assistant text snaps at message_end.
+				const partialJson = "partialJson" in content ? content.partialJson : undefined;
+				let renderArgs: Record<string, unknown>;
+				if (typeof partialJson === "string") {
+					renderArgs = this.#toolArgsReveal.setTarget(
+						content.id,
+						partialJson,
+						content.customWireName !== undefined,
+						content.arguments,
+					);
+				} else {
+					this.#toolArgsReveal.finish(content.id);
+					renderArgs = content.arguments;
+				}
 				if (!this.ctx.pendingTools.has(content.id)) {
 					this.#resolveDisplaceablePoll(content.name);
 					this.#resetReadGroup();
@@ -517,10 +537,12 @@ export class EventController {
 					component.setExpanded(this.ctx.toolOutputExpanded);
 					this.ctx.chatContainer.addChild(component);
 					this.ctx.pendingTools.set(content.id, component);
+					this.#toolArgsReveal.bind(content.id, component);
 				} else {
 					const component = this.ctx.pendingTools.get(content.id);
 					if (component) {
 						component.updateArgs(renderArgs, content.id);
+						this.#toolArgsReveal.bind(content.id, component);
 					}
 				}
 			}
@@ -555,6 +577,7 @@ export class EventController {
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
 			this.#streamingReveal.stop();
+			this.#toolArgsReveal.flushAll();
 			let errorMessage: string | undefined;
 			const aborted = this.ctx.streamingMessage.stopReason === "aborted";
 			const silentlyAborted = aborted && isSilentAbort(this.ctx.streamingMessage.errorMessage);
@@ -772,6 +795,7 @@ export class EventController {
 	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
 		this.#agentTurnActive = false;
 		this.#streamingReveal.stop();
+		this.#toolArgsReveal.flushAll();
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;

package/src/modes/controllers/mcp-command-controller.ts

@@ -127,6 +127,7 @@ interface OAuthFlowResult {
 	credentialId: string;
 	clientId?: string;
 	clientSecret?: string;
+	resource?: string;
 }
 
 type MCPAddScope = "user" | "project";
@@ -490,6 +491,7 @@ export class MCPCommandController {
 
 						try {
 							const oauthClientSecret = finalConfig.oauth?.clientSecret ?? "";
+							const oauthResource = oauth.resource ?? finalConfig.url;
 							const oauthResult = await this.#handleOAuthFlow(
 								oauth.authorizationUrl,
 								oauth.tokenUrl,
@@ -499,15 +501,18 @@ export class MCPCommandController {
 								finalConfig.oauth?.callbackPort,
 								finalConfig.oauth?.callbackPath,
 								finalConfig.oauth?.redirectUri,
+								oauthResource,
 							);
 							const persistedClientId = oauthResult.clientId ?? oauth.clientId ?? finalConfig.oauth?.clientId;
 							const persistedClientSecret = oauthResult.clientSecret ?? finalConfig.oauth?.clientSecret;
+							const persistedResource = oauthResult.resource ?? oauthResource;
 							finalConfig = {
 								...finalConfig,
 								auth: {
 									type: "oauth",
 									credentialId: oauthResult.credentialId,
 									tokenUrl: oauth.tokenUrl,
+									resource: persistedResource,
 									clientId: persistedClientId,
 									clientSecret: persistedClientSecret,
 								},
@@ -548,8 +553,25 @@ export class MCPCommandController {
 				done();
 				this.#handleWizardCancel();
 			},
-			async (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string) => {
-				return await this.#handleOAuthFlow(authUrl, tokenUrl, clientId, clientSecret, scopes);
+			async (
+				authUrl: string,
+				tokenUrl: string,
+				clientId: string,
+				clientSecret: string,
+				scopes: string,
+				resource?: string,
+			) => {
+				return await this.#handleOAuthFlow(
+					authUrl,
+					tokenUrl,
+					clientId,
+					clientSecret,
+					scopes,
+					undefined,
+					undefined,
+					undefined,
+					resource,
+				);
 			},
 			async (config: MCPServerConfig) => {
 				return await this.#handleTestConnection(config);
@@ -579,6 +601,7 @@ export class MCPCommandController {
 		callbackPort?: number,
 		callbackPath?: string,
 		redirectUri?: string,
+		resource?: string,
 	): Promise<OAuthFlowResult> {
 		const authStorage = this.ctx.session.modelRegistry.authStorage;
 		let parsedAuthUrl: URL;
@@ -617,6 +640,7 @@ export class MCPCommandController {
 					redirectUri,
 					callbackPort,
 					callbackPath,
+					resource,
 				},
 				{
 					onAuth: (info: { url: string; instructions?: string }) => {
@@ -704,6 +728,7 @@ export class MCPCommandController {
 				credentialId,
 				clientId: flow.resolvedClientId,
 				clientSecret: flow.registeredClientSecret,
+				resource: flow.resource,
 			};
 		} catch (error) {
 			const errorMsg = error instanceof Error ? error.message : String(error);
@@ -804,6 +829,7 @@ export class MCPCommandController {
 		tokenUrl: string;
 		clientId?: string;
 		scopes?: string;
+		resource?: string;
 	}> {
 		// First test if server actually needs auth by connecting without OAuth
 		let connectionSucceeded = false;
@@ -1415,6 +1441,9 @@ export class MCPCommandController {
 
 			this.#showMessage(["", theme.fg("muted", `Reauthorizing "${name}"...`), ""].join("\n"));
 
+			const oauthResource =
+				oauth.resource ?? currentAuth?.resource ?? ("url" in baseConfig ? baseConfig.url : undefined);
+
 			const oauthResult = await this.#handleOAuthFlow(
 				oauth.authorizationUrl,
 				oauth.tokenUrl,
@@ -1424,10 +1453,12 @@ export class MCPCommandController {
 				found.config.oauth?.callbackPort,
 				found.config.oauth?.callbackPath,
 				found.config.oauth?.redirectUri,
+				oauthResource,
 			);
 
 			const persistedClientId = oauthResult.clientId ?? oauth.clientId ?? found.config.oauth?.clientId;
 			const persistedClientSecret = oauthResult.clientSecret ?? (oauthClientSecret || undefined);
+			const persistedResource = oauthResult.resource ?? oauthResource;
 
 			const updated: MCPServerConfig = {
 				...baseConfig,
@@ -1435,6 +1466,7 @@ export class MCPCommandController {
 					type: "oauth",
 					credentialId: oauthResult.credentialId,
 					tokenUrl: oauth.tokenUrl,
+					resource: persistedResource,
 					clientId: persistedClientId,
 					clientSecret: persistedClientSecret,
 				},

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

@@ -120,6 +120,7 @@ export class SelectorController {
 								separator: settings.get("statusLine.separator"),
 								showHookStatus: settings.get("statusLine.showHookStatus"),
 								sessionAccent: settings.get("statusLine.sessionAccent"),
+								transparent: settings.get("statusLine.transparent"),
 								...previewSettings,
 							});
 							this.ctx.updateEditorTopBorder();
@@ -147,6 +148,7 @@ export class SelectorController {
 								separator: settings.get("statusLine.separator"),
 								showHookStatus: settings.get("statusLine.showHookStatus"),
 								sessionAccent: settings.get("statusLine.sessionAccent"),
+								transparent: settings.get("statusLine.transparent"),
 							});
 							this.ctx.updateEditorTopBorder();
 							this.ctx.ui.requestRender();
@@ -351,6 +353,7 @@ export class SelectorController {
 			case "statusLineShowHooks":
 			case "statusLine.showHookStatus":
 			case "statusLine.sessionAccent":
+			case "statusLine.transparent":
 			case "statusLineSegments":
 			case "statusLineModelThinking":
 			case "statusLinePathAbbreviate":
@@ -369,6 +372,7 @@ export class SelectorController {
 					separator: settings.get("statusLine.separator"),
 					showHookStatus: settings.get("statusLine.showHookStatus"),
 					sessionAccent: settings.get("statusLine.sessionAccent"),
+					transparent: settings.get("statusLine.transparent"),
 					segmentOptions: settings.get("statusLine.segmentOptions"),
 				};
 				this.ctx.statusLine.updateSettings(statusLineSettings);

package/src/modes/controllers/tool-args-reveal.ts

@@ -0,0 +1,174 @@
+import { parseStreamingJson } from "@oh-my-pi/pi-ai/utils/json-parse";
+import { nextStep, STREAMING_REVEAL_FRAME_MS } from "./streaming-reveal";
+
+/** Minimal component surface the reveal pushes frames into. */
+type ToolArgsRevealComponent = {
+	updateArgs(args: unknown, toolCallId?: string): void;
+};
+
+type ToolArgsRevealControllerOptions = {
+	getSmoothStreaming(): boolean;
+	requestRender(): void;
+};
+
+type RevealEntry = {
+	component: ToolArgsRevealComponent | undefined;
+	/** Latest raw streamed argument text (JSON for function tools, raw text for custom tools). */
+	target: string;
+	/** Revealed UTF-16 code units of `target`. */
+	revealed: number;
+	/** Custom-tool raw input: display args are `{ input: prefix }`, never parsed as JSON. */
+	rawInput: boolean;
+};
+
+/** Clamp a slice end into `text`, never splitting a surrogate pair: a prefix
+ *  ending on a high surrogate would feed a lone surrogate into the parsed
+ *  preview args (providers decode UTF-8 incrementally, so the raw stream
+ *  itself never contains one). */
+function clampSliceEnd(text: string, end: number): number {
+	if (end <= 0) return 0;
+	if (end >= text.length) return text.length;
+	const code = text.charCodeAt(end - 1);
+	return code >= 0xd800 && code <= 0xdbff ? end + 1 : end;
+}
+
+/** Display args for a revealed raw-stream prefix. Function-tool prefixes are
+ *  re-parsed with the same streaming-tolerant parser providers use, so every
+ *  frame is a state the provider itself could have produced; custom tools
+ *  mirror the provider's `{ input }` shape. `__partialJson` carries the
+ *  matching raw prefix for renderers that read it directly (bash env preview,
+ *  edit strategies). */
+function buildDisplayArgs(prefix: string, rawInput: boolean): Record<string, unknown> {
+	const base: Record<string, unknown> = rawInput ? { input: prefix } : parseStreamingJson(prefix);
+	return { ...base, __partialJson: prefix };
+}
+
+/**
+ * Paces streamed tool-call arguments the same way StreamingRevealController
+ * paces assistant text: providers that deliver `partialJson` in large batches
+ * (or throttle their partial parses) would otherwise make write/edit/bash
+ * streaming previews jump in chunks. Each pending tool call reveals its raw
+ * argument stream at the shared 30fps cadence with the same adaptive
+ * catch-up step, re-parsing the revealed prefix per frame.
+ *
+ * Reveal units are UTF-16 code units of the raw stream, not graphemes —
+ * the prefix goes through a JSON parser rather than straight to the screen,
+ * so only surrogate-pair integrity matters (see {@link clampSliceEnd}).
+ */
+export class ToolArgsRevealController {
+	readonly #getSmoothStreaming: () => boolean;
+	readonly #requestRender: () => void;
+	readonly #entries = new Map<string, RevealEntry>();
+	#timer: NodeJS.Timeout | undefined;
+
+	constructor(options: ToolArgsRevealControllerOptions) {
+		this.#getSmoothStreaming = options.getSmoothStreaming;
+		this.#requestRender = options.requestRender;
+	}
+
+	/**
+	 * Record the latest streamed argument text for a tool call and return the
+	 * args to render right now. With smoothing disabled the full target passes
+	 * through in the caller's legacy shape (`{ ...args, __partialJson }`).
+	 */
+	setTarget(
+		id: string,
+		partialJson: string,
+		rawInput: boolean,
+		fullArgs: Record<string, unknown>,
+	): Record<string, unknown> {
+		if (!this.#getSmoothStreaming()) {
+			// Toggle may flip mid-call: drop any live entry so ticks stop.
+			this.#entries.delete(id);
+			return { ...fullArgs, __partialJson: partialJson };
+		}
+		let entry = this.#entries.get(id);
+		if (!entry) {
+			entry = { component: undefined, target: partialJson, revealed: 0, rawInput };
+			this.#entries.set(id, entry);
+		} else {
+			// Streams only append; a non-prefix target means a rewind — snap into range.
+			if (!partialJson.startsWith(entry.target)) {
+				entry.revealed = Math.min(entry.revealed, partialJson.length);
+			}
+			entry.target = partialJson;
+		}
+		entry.revealed = clampSliceEnd(entry.target, entry.revealed);
+		this.#syncTimer();
+		return buildDisplayArgs(entry.target.slice(0, entry.revealed), entry.rawInput);
+	}
+
+	/** Attach the component future ticks push frames into. */
+	bind(id: string, component: ToolArgsRevealComponent): void {
+		const entry = this.#entries.get(id);
+		if (entry) entry.component = component;
+	}
+
+	/** Final arguments arrived (the JSON closed): drop the reveal so the
+	 *  caller's final-args render wins immediately, mirroring how assistant
+	 *  text snaps to the full message at message_end. */
+	finish(id: string): void {
+		this.#entries.delete(id);
+		if (this.#entries.size === 0) this.#stopTimer();
+	}
+
+	/** Snap every live entry to its full received stream and clear. Used at
+	 *  message_end (abort/error mid-stream) so sealed components freeze showing
+	 *  everything that arrived rather than a mid-reveal prefix. */
+	flushAll(): void {
+		for (const [id, entry] of this.#entries) {
+			if (entry.component && entry.revealed < entry.target.length) {
+				entry.component.updateArgs(buildDisplayArgs(entry.target, entry.rawInput), id);
+			}
+		}
+		this.#entries.clear();
+		this.#stopTimer();
+	}
+
+	/** Clear without pushing (teardown). */
+	stop(): void {
+		this.#entries.clear();
+		this.#stopTimer();
+	}
+
+	#syncTimer(): void {
+		for (const entry of this.#entries.values()) {
+			if (entry.revealed < entry.target.length) {
+				this.#startTimer();
+				return;
+			}
+		}
+		this.#stopTimer();
+	}
+
+	#startTimer(): void {
+		if (this.#timer) return;
+		this.#timer = setInterval(() => {
+			this.#tick();
+		}, STREAMING_REVEAL_FRAME_MS);
+		this.#timer.unref?.();
+	}
+
+	#stopTimer(): void {
+		if (!this.#timer) return;
+		clearInterval(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#tick(): void {
+		let advanced = false;
+		for (const [id, entry] of this.#entries) {
+			const backlog = entry.target.length - entry.revealed;
+			if (backlog <= 0 || !entry.component) continue;
+			entry.revealed = clampSliceEnd(entry.target, entry.revealed + nextStep(backlog));
+			entry.component.updateArgs(buildDisplayArgs(entry.target.slice(0, entry.revealed), entry.rawInput), id);
+			advanced = true;
+		}
+		if (advanced) {
+			this.#requestRender();
+		} else {
+			// Every entry caught up (or unbound); setTarget restarts on growth.
+			this.#stopTimer();
+		}
+	}
+}

package/src/modes/interactive-mode.ts

@@ -496,8 +496,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	playWelcomeIntro(): void {
-		this.#welcomeComponent?.playIntro(() => this.ui.requestRender());
+		const welcome = this.#welcomeComponent;
+		// Component-scoped: the intro only mutates the welcome box's own rows,
+		// so a resumed long transcript is not re-walked per animation frame.
+		welcome?.playIntro(() => this.ui.requestComponentRender(welcome));
 	}
+
 	async init(options: InteractiveModeInitOptions = {}): Promise<void> {
 		if (this.isInitialized) return;
 
@@ -1050,6 +1054,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			separator: settings.get("statusLine.separator"),
 			showHookStatus: settings.get("statusLine.showHookStatus"),
 			sessionAccent: settings.get("statusLine.sessionAccent"),
+			transparent: settings.get("statusLine.transparent"),
 			segmentOptions: settings.get("statusLine.segmentOptions"),
 		});
 	}
@@ -3036,7 +3041,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#voiceAnimationInterval = setInterval(() => {
 			this.#voiceHue = (this.#voiceHue + 8) % 360;
 			this.#updateMicIcon();
-			this.ui.requestRender();
+			// Component-scoped: the hue sweep only recolors the editor's cursor
+			// glyph, so the transcript subtree is reused per animation frame.
+			this.ui.requestComponentRender(this.editor);
 		}, 60);
 	}