@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.7

package/src/main.ts

@@ -140,7 +140,7 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"advisor.subagents",
 	"advisor.syncBacklog",
 	"advisor.immuneTurns",
-	"serviceTierAdvisor",
+	"tier.advisor",
 ];
 
 const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [

package/src/mcp/config-writer.ts

@@ -227,3 +227,124 @@ export async function setServerDisabled(filePath: string, name: string, disabled
 
 	await writeMCPConfigFile(filePath, updated);
 }
+
+/**
+ * Read the user-level force-enable list (allowlist that overrides a
+ * non-writable source config's `enabled: false`).
+ */
+export async function readEnabledServers(filePath: string): Promise<string[]> {
+	const config = await readMCPConfigFile(filePath);
+	return Array.isArray(config.enabledServers) ? config.enabledServers : [];
+}
+
+/**
+ * Add or remove a server name from the user-level force-enable list.
+ * The list overrides a discovered server's `enabled: false` flag but does
+ * NOT override the `disabledServers` denylist.
+ */
+export async function setServerForceEnabled(filePath: string, name: string, force: boolean): Promise<void> {
+	const config = await readMCPConfigFile(filePath);
+	const current = new Set(config.enabledServers ?? []);
+
+	if (force) {
+		current.add(name);
+	} else {
+		current.delete(name);
+	}
+
+	const updated: MCPConfigFile = {
+		...config,
+		enabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
+	};
+
+	if (!updated.enabledServers) {
+		delete updated.enabledServers;
+	}
+
+	await writeMCPConfigFile(filePath, updated);
+}
+
+/** Paths and target state for toggling one MCP server across known config files. */
+export interface SetMcpServerEnabledOptions {
+	userPath: string;
+	projectPath: string;
+	/**
+	 * Absolute path to the loaded row's source mcp.json. Provide ONLY for
+	 * formats this codebase owns (native `.omp/mcp.json` and `mcp-json`
+	 * `mcp.json`/`.mcp.json`). Tool-owned configs (opencode.json, claude.json,
+	 * settings.json …) MUST be omitted; we never mutate another tool's file.
+	 */
+	sourcePath?: string;
+	name: string;
+	enabled: boolean;
+}
+
+/**
+ * Flip a server's enabled/disabled state regardless of where it lives.
+ *
+ * Resolution order, mirroring `/mcp enable` / `/mcp disable` plus the dashboard
+ * fix for non-writable source configs:
+ *
+ * - Server found in `sourcePath` (writable) → write `enabled` on that entry.
+ * - Else server in project mcp.json → write `enabled` there.
+ * - Else server in user mcp.json → write `enabled` there.
+ * - Else (server defined in a tool-owned source like opencode.json, OR a
+ *   purely discovered server):
+ *   - Disable → add to the user-level `disabledServers` denylist.
+ *   - Enable → add to the user-level `enabledServers` allowlist so the
+ *     dashboard / runtime override the non-writable source's
+ *     `enabled: false` flag.
+ *
+ * Cleanup invariants — on every call:
+ * - Re-enable clears any stale denylist entry so a server disabled via
+ *   `/mcp disable` and re-enabled here doesn't stay suppressed.
+ * - Disable clears any stale allowlist entry so re-disabling a
+ *   force-enabled server actually takes effect.
+ */
+export async function setMcpServerEnabled(options: SetMcpServerEnabledOptions): Promise<void> {
+	const { userPath, projectPath, sourcePath, name, enabled } = options;
+	const candidatePaths = [...new Set([sourcePath, projectPath, userPath].filter(path => path !== undefined))];
+	let updatedInConfig = false;
+
+	for (const filePath of candidatePaths) {
+		const config = await readMCPConfigFile(filePath);
+		const server = config.mcpServers?.[name];
+		if (server === undefined) continue;
+
+		await updateMCPServer(filePath, name, { ...server, enabled });
+		updatedInConfig = true;
+		break;
+	}
+
+	if (enabled) {
+		// Either we just wrote `enabled: true` on a writable source, or the
+		// server lives in a non-writable source whose `enabled: false` flag we
+		// need to override via the user allowlist. Either way the denylist
+		// entry (if any) must clear so the row becomes active.
+		const denied = await readDisabledServers(userPath);
+		if (denied.includes(name)) {
+			await setServerDisabled(userPath, name, false);
+		}
+
+		const forced = await readEnabledServers(userPath);
+		const isForced = forced.includes(name);
+		if (!updatedInConfig && !isForced) {
+			await setServerForceEnabled(userPath, name, true);
+		} else if (updatedInConfig && isForced) {
+			// Writable source now carries `enabled: true`; the override is
+			// redundant. Drop it so the user's allowlist stays tidy.
+			await setServerForceEnabled(userPath, name, false);
+		}
+		return;
+	}
+
+	// Disable path. Clear any force-enable override regardless of source so the
+	// disable actually sticks.
+	const forced = await readEnabledServers(userPath);
+	if (forced.includes(name)) {
+		await setServerForceEnabled(userPath, name, false);
+	}
+	if (!updatedInConfig) {
+		await setServerDisabled(userPath, name, true);
+	}
+}

package/src/mcp/config.ts

@@ -9,7 +9,7 @@ import { mcpCapability } from "../capability/mcp";
 import type { SourceMeta } from "../capability/types";
 import type { MCPServer } from "../discovery";
 import { loadCapability } from "../discovery";
-import { readDisabledServers } from "./config-writer";
+import { readDisabledServers, readEnabledServers } from "./config-writer";
 import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
@@ -105,16 +105,20 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 		? result.items
 		: result.items.filter(server => server._source.level !== "project");
 
-	// Load user-level disabled servers list
-	const disabledServers = new Set(await readDisabledServers(getMCPConfigPath("user", cwd)));
+	// Load user-level disable/force-enable lists. The denylist always wins; the
+	// allowlist overrides a non-writable source config's `enabled: false`.
+	const userPath = getMCPConfigPath("user", cwd);
+	const [disabledServers, forcedEnabled] = await Promise.all([
+		readDisabledServers(userPath).then(list => new Set(list)),
+		readEnabledServers(userPath).then(list => new Set(list)),
+	]);
 	// Convert to legacy format and preserve source metadata
 	let configs: Record<string, MCPServerConfig> = {};
 	let sources: Record<string, SourceMeta> = {};
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
-		if (config.enabled === false || disabledServers.has(server.name)) {
-			continue;
-		}
+		if (disabledServers.has(server.name)) continue;
+		if (config.enabled === false && !forcedEnabled.has(server.name)) continue;
 		configs[server.name] = config;
 		sources[server.name] = server._source;
 	}

package/src/mcp/oauth-flow.ts

@@ -75,6 +75,10 @@ export interface MCPStoredOAuthCredential extends OAuthCredential {
 const DEFAULT_PORT = 3000;
 const CALLBACK_PATH = "/callback";
 
+function hasOAuthScope(scopes: string | null | undefined, scope: string): boolean {
+	return !!scopes && scopes.split(/\s+/).includes(scope);
+}
+
 function isLoopbackHostname(hostname: string): boolean {
 	return hostname === "localhost" || hostname === "127.0.0.1";
 }
@@ -225,12 +229,10 @@ export interface MCPOAuthConfig {
 	/** OAuth scopes (space-separated) */
 	scopes?: string;
 	/**
-	 * `prompt` parameter for the authorization request. Defaults to `"consent"`
-	 * so the provider always shows its authorize screen instead of silently
-	 * re-approving the browser's current session — without it, reauthorizing to
-	 * switch accounts/workspaces is impossible once a session cookie exists
-	 * (RFC 6749 §3.1 requires servers to ignore the param when unsupported).
-	 * Set to `""` to omit the parameter entirely.
+	 * `prompt` parameter for the authorization request. By default the parameter
+	 * is omitted, matching the reference MCP SDK, except for `offline_access`
+	 * requests where OIDC Core requires `prompt=consent` to issue refresh-token
+	 * access. Set to `""` to omit the parameter entirely.
 	 */
 	prompt?: string;
 	/** Exact redirect URI to advertise to the provider */
@@ -325,7 +327,7 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		if (this.config.scopes && !params.get("scope")) {
 			params.set("scope", this.config.scopes);
 		}
-		const prompt = this.config.prompt ?? "consent";
+		const prompt = this.config.prompt ?? (hasOAuthScope(params.get("scope"), "offline_access") ? "consent" : "");
 		if (prompt && !params.get("prompt")) {
 			params.set("prompt", prompt);
 		}
@@ -494,7 +496,7 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 					Accept: "application/json",
 				},
 				body: JSON.stringify({
-					client_name: "Codex",
+					client_name: "oh-my-pi",
 					redirect_uris: [redirectUri],
 					grant_types: ["authorization_code", "refresh_token"],
 					response_types: ["code"],

package/src/mcp/transports/stdio.ts

@@ -147,21 +147,6 @@ function resolveWindowsShimPath(value: string, shimDir: string): string | null {
 	return path.join(shimDir, ...suffix.split(/[\\/]+/).filter(Boolean));
 }
 
-function extractWindowsNpmShimTarget(content: string): string | null {
-	const match = /"%_prog%"\s+"([^"]+)"\s+%\*/i.exec(content);
-	return match?.[1] ?? null;
-}
-
-/**
- * Extract the shim's PATH-fallback interpreter (`SET "_prog=node"`). The
- * `IF EXIST` branch assigns a `%dp0%`-prefixed value, so requiring a
- * non-`%`-leading value picks the bare program name.
- */
-function extractWindowsNpmShimProg(content: string): string | null {
-	const match = /SET\s+"_prog=([^%"][^"]*)"/i.exec(content);
-	return match?.[1] ?? null;
-}
-
 async function resolveWindowsNpmShimCommand(
 	command: string,
 	args: readonly string[],
@@ -171,6 +156,11 @@ async function resolveWindowsNpmShimCommand(
 	if (!isWindowsBatchCommand(command)) return null;
 	if (!hasPathSegment(command)) return null;
 	const commandPath = path.resolve(cwd, command);
+	const commandName = path
+		.basename(commandPath)
+		.replace(/\.cmd$/i, "")
+		.toLowerCase();
+	if (commandName === "npx") return null;
 
 	let content: string;
 	try {
@@ -181,7 +171,9 @@ async function resolveWindowsNpmShimCommand(
 
 	// cmd-shim emits the same invocation line for every interpreter; only
 	// bypass cmd.exe when the shim's fallback interpreter is actually node.
-	const prog = extractWindowsNpmShimProg(content);
+	// The IF EXIST branch assigns a %dp0%-prefixed value, so requiring a
+	// non-%-leading SET value picks the bare PATH-fallback program name.
+	const prog = /SET\s+"_prog=([^%"][^"]*)"/i.exec(content)?.[1];
 	if (
 		!prog ||
 		path
@@ -191,7 +183,7 @@ async function resolveWindowsNpmShimCommand(
 	)
 		return null;
 
-	const rawTarget = extractWindowsNpmShimTarget(content);
+	const rawTarget = /"%_prog%"\s+"([^"]+)"\s+%\*/i.exec(content)?.[1];
 	if (!rawTarget) return null;
 
 	const target = resolveWindowsShimPath(rawTarget, path.dirname(commandPath));

package/src/mcp/types.ts

@@ -111,7 +111,10 @@ export const MCP_CONFIG_SCHEMA_URL =
 export interface MCPConfigFile {
 	$schema?: string;
 	mcpServers?: Record<string, MCPServerConfig>;
+	/** Names to hide regardless of any source `enabled` flag. Highest precedence. */
 	disabledServers?: string[];
+	/** Names to force-enable when a non-writable source reports `enabled: false`. */
+	enabledServers?: string[];
 }
 
 // =============================================================================

package/src/modes/components/extensions/extension-dashboard.ts

@@ -24,7 +24,9 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import { getMCPConfigPath, logger } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../../config/settings";
+import { setMcpServerEnabled } from "../../../mcp/config-writer";
 import { getTabBarTheme } from "../../../modes/shared";
 import { theme } from "../../../modes/theme/theme";
 import { matchesAppInterrupt } from "../../../modes/utils/keybinding-matchers";
@@ -263,6 +265,14 @@ export class ExtensionDashboard implements Component {
 		const sm = this.settings ?? Settings.instance;
 		if (!sm) return;
 
+		// MCP toggles route through the canonical denylist in
+		// `~/.omp/agent/mcp.json` so `/mcp list`, the MCP runtime, and this
+		// dashboard agree on every server's enabled state (issue #3827).
+		if (extensionId.startsWith("mcp:")) {
+			void this.#toggleMcpExtension(extensionId, enabled, sm);
+			return;
+		}
+
 		const disabled = ((sm.get("disabledExtensions") as string[]) ?? []).slice();
 		if (enabled) {
 			const index = disabled.indexOf(extensionId);
@@ -281,6 +291,42 @@ export class ExtensionDashboard implements Component {
 		void this.#refreshFromState();
 	}
 
+	async #toggleMcpExtension(extensionId: string, enabled: boolean, sm: Settings): Promise<void> {
+		const name = extensionId.slice("mcp:".length);
+		try {
+			await setMcpServerEnabled({
+				userPath: getMCPConfigPath("user", this.cwd),
+				projectPath: getMCPConfigPath("project", this.cwd),
+				sourcePath: this.#writableMcpSourcePath(extensionId),
+				name,
+				enabled,
+			});
+		} catch (error) {
+			logger.warn("Failed to persist MCP toggle", { name, enabled, error: String(error) });
+		}
+
+		// Reconcile `settings.disabledExtensions` with the canonical mcp.json
+		// state so a legacy `mcp:<name>` flag from before this routing change
+		// doesn't keep the server marked disabled after the user re-enables it
+		// via the UI.
+		const stored = ((sm.get("disabledExtensions") as string[]) ?? []).slice();
+		const had = stored.indexOf(extensionId);
+		if (enabled && had !== -1) {
+			stored.splice(had, 1);
+			sm.set("disabledExtensions", stored);
+			this.#applyDisabledExtensions(stored);
+		}
+
+		await this.#refreshFromState();
+	}
+
+	#writableMcpSourcePath(extensionId: string): string | undefined {
+		const extension = this.#state.extensions.find(ext => ext.id === extensionId);
+		if (!extension) return undefined;
+		if (extension.source.provider !== "native" && extension.source.provider !== "mcp-json") return undefined;
+		return extension.path;
+	}
+
 	async #refreshFromState(): Promise<void> {
 		const refreshToken = ++this.#refreshToken;
 		// Remember the current tab so it survives the re-sort.

package/src/modes/components/extensions/state-manager.ts

@@ -4,7 +4,7 @@
  */
 import * as path from "node:path";
 import { fuzzyMatch } from "@oh-my-pi/pi-tui";
-import { logger } from "@oh-my-pi/pi-utils";
+import { getMCPConfigPath, logger } from "@oh-my-pi/pi-utils";
 import type { ContextFile } from "../../../capability/context-file";
 import type { ExtensionModule } from "../../../capability/extension-module";
 import type { Hook } from "../../../capability/hook";
@@ -22,6 +22,7 @@ import {
 	isProviderEnabled,
 	loadCapability,
 } from "../../../discovery";
+import { readDisabledServers, readEnabledServers } from "../../../mcp/config-writer";
 import type {
 	DashboardState,
 	Extension,
@@ -141,12 +142,32 @@ export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): P
 		logger.warn("Failed to load extension-modules capability", { error: String(error) });
 	}
 
-	// Load MCP servers
+	// Load MCP servers. The dashboard mirrors `/mcp list` (issue #3827) by
+	// honoring the same disable signals: the dashboard-private settings list,
+	// the per-server `enabled: false` flag, and the user-level `disabledServers`
+	// denylist that `/mcp disable` writes through `setServerDisabled`. The
+	// user-level `enabledServers` allowlist overrides a non-writable source's
+	// `enabled: false` (e.g. opencode.json) but never the denylist.
 	try {
+		const userMcpPath = cwd ? getMCPConfigPath("user", cwd) : undefined;
+		const [mcpDisabledNames, mcpForcedEnabled] = await Promise.all([
+			userMcpPath
+				? readDisabledServers(userMcpPath)
+						.then(list => new Set(list))
+						.catch(() => new Set<string>())
+				: Promise.resolve(new Set<string>()),
+			userMcpPath
+				? readEnabledServers(userMcpPath)
+						.then(list => new Set(list))
+						.catch(() => new Set<string>())
+				: Promise.resolve(new Set<string>()),
+		]);
 		const mcps = await loadCapability<MCPServer>("mcps", loadOpts);
 		for (const server of mcps.all) {
 			const id = makeExtensionId("mcp", server.name);
-			const isDisabled = disabledExtensions.has(id);
+			const forced = mcpForcedEnabled.has(server.name);
+			const sourceSaysDisabled = server.enabled === false && !forced;
+			const isDisabled = mcpDisabledNames.has(server.name) || disabledExtensions.has(id) || sourceSaysDisabled;
 			const isShadowed = (server as { _shadowed?: boolean })._shadowed;
 			const providerEnabled = isProviderEnabled(server._source.provider);
 

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

@@ -50,6 +50,15 @@ const MAX_LIVE_IRC_CARDS = 4;
 const IDLE_RECAP_MIN_SECONDS = 1;
 const IDLE_RECAP_MAX_SECONDS = 3600;
 
+const RAW_PARTIAL_JSON_RENDERERS: Record<string, true> = { bash: true, edit: true, apply_patch: true };
+
+function exposesRawPartialJson(toolName: string, rawInput: boolean, tool: unknown): boolean {
+	if (rawInput) return true;
+	if (RAW_PARTIAL_JSON_RENDERERS[toolName]) return true;
+	if (tool === null || typeof tool !== "object" || !("renderCall" in tool)) return false;
+	return typeof tool.renderCall === "function";
+}
+
 type AgentSessionEventHandlers = {
 	[E in AgentSessionEventKind]: (event: Extract<AgentSessionEvent, { type: E }>) => Promise<void>;
 };
@@ -623,7 +632,7 @@ export class EventController {
 					// Internal URL read falls through to ToolExecutionComponent below.
 				}
 
-				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
+				// Preserve the raw partial JSON only 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.
 				// While the JSON is still open, ToolArgsRevealController paces the
 				// reveal (write/edit/bash previews grow smoothly when a slow provider
@@ -631,13 +640,14 @@ export class EventController {
 				// as-is — mirroring how assistant text snaps at message_end.
 				let renderArgs: Record<string, unknown>;
 				const partialJson = getStreamingPartialJson(content);
+				const rawInput = content.customWireName !== undefined;
+				const tool = this.ctx.viewSession.getToolByName(content.name);
 				if (partialJson) {
-					renderArgs = this.#toolArgsReveal.setTarget(
-						content.id,
-						partialJson,
-						content.customWireName !== undefined,
-						content.arguments,
-					);
+					renderArgs = this.#toolArgsReveal.setTarget(content.id, partialJson, {
+						rawInput,
+						exposeRawPartialJson: exposesRawPartialJson(content.name, rawInput, tool),
+						fullArgs: content.arguments,
+					});
 				} else {
 					this.#toolArgsReveal.finish(content.id);
 					renderArgs = content.arguments;
@@ -645,7 +655,6 @@ export class EventController {
 				if (!this.ctx.pendingTools.has(content.id)) {
 					this.#resolveDisplaceablePoll(content.name);
 					this.#resetReadGroup();
-					const tool = this.ctx.viewSession.getToolByName(content.name);
 					const component = new ToolExecutionComponent(
 						content.name,
 						renderArgs,
@@ -881,6 +890,13 @@ export class EventController {
 	}
 
 	async #handleToolExecutionEnd(event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>): Promise<void> {
+		// A transient overlay (auto-compaction / auto-retry / handoff) that ran
+		// between this tool's start and end could have detached the working
+		// loader. `tool_execution_update` already reconciles this so the spinner
+		// reappears mid-tool; mirror it here so subagent (`task`) completions —
+		// which only fire `tool_execution_end`, never `_update` — do not leave
+		// the UI looking idle while the session keeps streaming (#3857).
+		this.#ensureWorkingLoaderWhileStreaming();
 		if (event.toolName === "read") {
 			if (this.#inlineReadToolImages(event.toolCallId, event.result)) {
 				const component = this.ctx.pendingTools.get(event.toolCallId);

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

@@ -1,4 +1,4 @@
-import { parseStreamingJson } from "@oh-my-pi/pi-utils";
+import { parseStreamingJson, parseStreamingJsonThrottled, STREAMING_JSON_PARSE_MIN_GROWTH } from "@oh-my-pi/pi-utils";
 import { nextStep, STREAMING_REVEAL_FRAME_MS } from "./streaming-reveal";
 
 /** Minimal component surface the reveal pushes frames into. */
@@ -19,6 +19,16 @@ type RevealEntry = {
 	revealed: number;
 	/** Custom-tool raw input: display args are `{ input: prefix }`, never parsed as JSON. */
 	rawInput: boolean;
+	/** Whether the renderer observes fresh raw JSON prefixes directly. */
+	exposeRawPartialJson: boolean;
+	/** Last parsed JSON args from the revealed prefix. */
+	parsedArgs: Record<string, unknown>;
+	/** Prefix length covered by `parsedArgs`. */
+	parsedLen: number;
+	/** Last object handed to a component; reused when visible args have not changed. */
+	displayArgs: Record<string, unknown>;
+	/** Raw prefix carried by `displayArgs.__partialJson`. */
+	displayPrefix: string;
 };
 
 /** Clamp a slice end into `text`, never splitting a surrogate pair: a prefix
@@ -32,15 +42,64 @@ function clampSliceEnd(text: string, end: number): number {
 	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 };
+type ToolArgsRevealTarget = {
+	rawInput: boolean;
+	exposeRawPartialJson: boolean;
+	fullArgs: Record<string, unknown>;
+};
+
+type DisplayArgsStep = {
+	args: Record<string, unknown>;
+	changed: boolean;
+};
+
+function initialDisplayArgs(): Record<string, unknown> {
+	return { __partialJson: "" };
+}
+
+function resetDisplayState(entry: RevealEntry): void {
+	entry.parsedArgs = {};
+	entry.parsedLen = 0;
+	entry.displayArgs = initialDisplayArgs();
+	entry.displayPrefix = "";
+}
+
+/** Display args for a revealed prefix. Function-tool JSON is parsed at the same
+ * growth-throttled cadence providers use, so a long `write` payload cannot make
+ * the reveal loop re-parse the whole growing buffer every frame. Renderers that
+ * read raw JSON directly still receive fresh `__partialJson` prefixes; other
+ * renderers get a stable object reference while parsed fields are unchanged. */
+function displayArgsForPrefix(entry: RevealEntry, prefix: string, forceParse = false): DisplayArgsStep {
+	if (entry.rawInput) {
+		if (prefix === entry.displayPrefix) return { args: entry.displayArgs, changed: false };
+		const args = { input: prefix, __partialJson: prefix };
+		entry.displayArgs = args;
+		entry.displayPrefix = prefix;
+		return { args, changed: true };
+	}
+
+	let parsedChanged = false;
+	if (forceParse || (prefix.length > 0 && prefix.length < STREAMING_JSON_PARSE_MIN_GROWTH)) {
+		entry.parsedArgs = parseStreamingJson<Record<string, unknown>>(prefix);
+		entry.parsedLen = prefix.length;
+		parsedChanged = true;
+	} else {
+		const throttled = parseStreamingJsonThrottled<Record<string, unknown>>(prefix, entry.parsedLen);
+		if (throttled) {
+			entry.parsedArgs = throttled.value;
+			entry.parsedLen = throttled.parsedLen;
+			parsedChanged = true;
+		}
+	}
+
+	const rawPrefixChanged = entry.exposeRawPartialJson && prefix !== entry.displayPrefix;
+	if (!parsedChanged && !rawPrefixChanged) return { args: entry.displayArgs, changed: false };
+
+	const displayPrefix = entry.exposeRawPartialJson || parsedChanged ? prefix : entry.displayPrefix;
+	const args = { ...entry.parsedArgs, __partialJson: displayPrefix };
+	entry.displayArgs = args;
+	entry.displayPrefix = displayPrefix;
+	return { args, changed: true };
 }
 
 /**
@@ -49,7 +108,9 @@ function buildDisplayArgs(prefix: string, rawInput: boolean): Record<string, unk
  * (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.
+ * catch-up step. JSON prefixes are parsed only when enough new bytes arrive to
+ * change renderer-visible fields, while raw-prefix consumers still receive
+ * fresh `__partialJson` on every reveal 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,
@@ -71,12 +132,8 @@ export class ToolArgsRevealController {
 	 * 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> {
+	setTarget(id: string, partialJson: string, target: ToolArgsRevealTarget): Record<string, unknown> {
+		const { rawInput, exposeRawPartialJson, fullArgs } = target;
 		if (!this.#getSmoothStreaming()) {
 			// Toggle may flip mid-call: drop any live entry so ticks stop.
 			this.#entries.delete(id);
@@ -84,18 +141,34 @@ export class ToolArgsRevealController {
 		}
 		let entry = this.#entries.get(id);
 		if (!entry) {
-			entry = { component: undefined, target: partialJson, revealed: 0, rawInput };
+			entry = {
+				component: undefined,
+				target: partialJson,
+				revealed: 0,
+				rawInput,
+				exposeRawPartialJson,
+				parsedArgs: {},
+				parsedLen: 0,
+				displayArgs: initialDisplayArgs(),
+				displayPrefix: "",
+			};
 			this.#entries.set(id, entry);
 		} else {
+			if (entry.rawInput !== rawInput || entry.exposeRawPartialJson !== exposeRawPartialJson) {
+				entry.rawInput = rawInput;
+				entry.exposeRawPartialJson = exposeRawPartialJson;
+				resetDisplayState(entry);
+			}
 			// 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);
+				resetDisplayState(entry);
 			}
 			entry.target = partialJson;
 		}
 		entry.revealed = clampSliceEnd(entry.target, entry.revealed);
 		this.#syncTimer();
-		return buildDisplayArgs(entry.target.slice(0, entry.revealed), entry.rawInput);
+		return displayArgsForPrefix(entry, entry.target.slice(0, entry.revealed)).args;
 	}
 
 	/** Attach the component future ticks push frames into. */
@@ -118,7 +191,7 @@ export class ToolArgsRevealController {
 	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);
+				entry.component.updateArgs(displayArgsForPrefix(entry, entry.target, true).args, id);
 			}
 		}
 		this.#entries.clear();
@@ -157,15 +230,20 @@ export class ToolArgsRevealController {
 
 	#tick(): void {
 		let advanced = false;
+		let rendered = 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);
+			const display = displayArgsForPrefix(entry, entry.target.slice(0, entry.revealed));
+			if (display.changed) {
+				entry.component.updateArgs(display.args, id);
+				rendered = true;
+			}
 			advanced = true;
 		}
 		if (advanced) {
-			this.#requestRender();
+			if (rendered) this.#requestRender();
 		} else {
 			// Every entry caught up (or unbound); setTarget restarts on growth.
 			this.#stopTimer();

package/src/modes/utils/transcript-render-helpers.ts

@@ -99,9 +99,9 @@ export function buildFileMentionBlock(files: FileMentionMessage["files"], indent
 	const block = new TranscriptBlock();
 	for (const file of files) {
 		let suffix: string;
-		if (file.skippedReason === "tooLarge") {
+		if (file.skippedReason === "tooLarge" || file.skippedReason === "binary") {
 			const size = typeof file.byteSize === "number" ? formatBytes(file.byteSize) : "unknown size";
-			suffix = `(skipped: ${size})`;
+			suffix = file.skippedReason === "binary" ? `(skipped: binary, ${size})` : `(skipped: ${size})`;
 		} else {
 			suffix = file.image
 				? "(image)"