@oh-my-pi/pi-coding-agent 16.0.10 → 16.0.11

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

@@ -0,0 +1,462 @@
+/**
+ * Builds transcript components from persisted session message entries — the
+ * file/remote-backed counterpart to {@link UiHelpers.addMessageToChat} (which is
+ * bound to the live InteractiveModeContext). Used by the fullscreen transcript
+ * viewer ({@link AgentTranscriptViewer}) to render a parked subagent / advisor /
+ * collab-guest transcript that has no live session.
+ *
+ * Unlike the old incremental hub sync, {@link ChatTranscriptBuilder.rebuild}
+ * always discards prior components and rebuilds the whole transcript from the
+ * supplied entries. Re-rendering a growing transcript is therefore O(n) in the
+ * entry count, but it cannot duplicate or misorder rows the way incremental
+ * component reuse could.
+ */
+import type { AgentMessage, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
+import { Text, type TUI } from "@oh-my-pi/pi-tui";
+import { formatBytes, formatDuration } from "@oh-my-pi/pi-utils";
+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 {
+	BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE,
+	type CustomMessage,
+	isSilentAbort,
+	LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE,
+	resolveAbortLabel,
+	SKILL_PROMPT_MESSAGE_TYPE,
+	type SkillPromptDetails,
+} from "../../session/messages";
+import type { SessionMessageEntry } from "../../session/session-entries";
+import { createIrcMessageCard } from "../../tools/irc";
+import { canonicalizeMessage } from "../../utils/thinking-display";
+import { theme } from "../theme/theme";
+import { createAdvisorMessageCard } from "./advisor-message";
+import { AssistantMessageComponent } from "./assistant-message";
+import { createBackgroundTanDispatchBlock } from "./background-tan-message";
+import { BashExecutionComponent } from "./bash-execution";
+import { BranchSummaryMessageComponent } from "./branch-summary-message";
+import { CollabPromptMessageComponent } from "./collab-prompt-message";
+import { CompactionSummaryMessageComponent, createHandoffSummaryMessageComponent } from "./compaction-summary-message";
+import { CustomMessageComponent } from "./custom-message";
+import { EvalExecutionComponent } from "./eval-execution";
+import { type LateDiagnosticsFile, LateDiagnosticsMessageComponent } from "./late-diagnostics-message";
+import { ReadToolGroupComponent, readArgsHaveTarget, readArgsTargetInternalUrl } from "./read-tool-group";
+import { SkillMessageComponent } from "./skill-message";
+import { ToolExecutionComponent } from "./tool-execution";
+import { TranscriptBlock, TranscriptContainer } from "./transcript-container";
+import { createUsageRowBlock } from "./usage-row";
+import { UserMessageComponent } from "./user-message";
+
+export interface ChatTranscriptBuilderDeps {
+	ui: TUI;
+	getTool?: (name: string) => AgentTool | undefined;
+	getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+	cwd: string;
+	hideThinkingBlock?: () => boolean;
+	requestRender: () => void;
+}
+
+/** Extracts the plain-text content of a user message (string or text blocks). */
+function userMessageText(message: Extract<AgentMessage, { role: "user" }>): string {
+	if (typeof message.content === "string") return message.content;
+	return message.content
+		.filter((block): block is { type: "text"; text: string } => block.type === "text")
+		.map(block => block.text)
+		.join("");
+}
+
+export class ChatTranscriptBuilder {
+	readonly container = new TranscriptContainer();
+	#pendingTools = new Map<string, ToolExecutionComponent | ReadToolGroupComponent>();
+	#readArgs = new Map<string, Record<string, unknown>>();
+	#readGroup: ReadToolGroupComponent | null = null;
+	#pendingUsage: Usage | undefined;
+	#waitingPoll: ToolExecutionComponent | null = null;
+	#expandables: Array<{ setExpanded(expanded: boolean): void }> = [];
+	#expanded = false;
+
+	constructor(private readonly deps: ChatTranscriptBuilderDeps) {}
+
+	/** Whether the transcript currently holds any rendered rows. */
+	get isEmpty(): boolean {
+		return this.container.children.length === 0;
+	}
+
+	/** Discard all components and rebuild the whole transcript from `entries`. */
+	rebuild(entries: SessionMessageEntry[]): void {
+		this.reset();
+		for (const entry of entries) this.#appendChatMessage(entry.message);
+		// Flush the trailing turn's usage row only once its tools are materialized
+		// (a read whose result has not arrived stays pending); otherwise the row
+		// would sit above its tools. The drain happens here at the end of the pass.
+		if (this.#readArgs.size === 0 && this.#pendingTools.size === 0) this.#flushPendingUsage();
+	}
+
+	/** Toggle tool-output expansion across every expandable component. */
+	setExpanded(expanded: boolean): void {
+		this.#expanded = expanded;
+		for (const component of this.#expandables) component.setExpanded(expanded);
+	}
+
+	get expanded(): boolean {
+		return this.#expanded;
+	}
+
+	/** Tear down components (sealing pending spinners) and clear build state. */
+	reset(): void {
+		for (const pending of this.#pendingTools.values()) pending.seal();
+		this.#pendingTools.clear();
+		this.#readArgs.clear();
+		this.#readGroup = null;
+		this.#pendingUsage = undefined;
+		this.#waitingPoll = null;
+		this.#expandables = [];
+		this.container.dispose();
+		this.container.clear();
+	}
+
+	dispose(): void {
+		this.reset();
+	}
+
+	#trackExpandable(component: { setExpanded(expanded: boolean): void }): void {
+		component.setExpanded(this.#expanded);
+		this.#expandables.push(component);
+	}
+
+	/** A `job` poll showing all-running is displaced by the next `job` call. */
+	#resolveWaitingPoll(nextToolName?: string): void {
+		const previous = this.#waitingPoll;
+		if (!previous) return;
+		this.#waitingPoll = null;
+		if (nextToolName === "job" && previous.isDisplaceableBlock()) {
+			this.container.removeChild(previous);
+		}
+		previous.seal();
+	}
+
+	#ensureReadGroup(): ReadToolGroupComponent {
+		if (!this.#readGroup) {
+			this.#readGroup = new ReadToolGroupComponent({
+				showContentPreview: settings.get("read.toolResultPreview"),
+			});
+			this.#trackExpandable(this.#readGroup);
+			this.container.addChild(this.#readGroup);
+		}
+		return this.#readGroup;
+	}
+
+	// The per-turn token-usage row must land below the turn's tool blocks, but
+	// normal `read` calls only materialize their group in #appendToolResult. Defer
+	// the row: stash it on the assistant message and flush once the turn's tools
+	// are placed, sealing the read run so the row sits under it.
+	#flushPendingUsage(): void {
+		if (!this.#pendingUsage) return;
+		this.#readGroup?.seal();
+		this.#readGroup = null;
+		this.container.addChild(createUsageRowBlock(this.#pendingUsage));
+		this.#pendingUsage = undefined;
+	}
+
+	#appendChatMessage(message: AgentMessage): void {
+		if (message.role !== "toolResult") this.#flushPendingUsage();
+		switch (message.role) {
+			case "assistant":
+				this.#appendAssistantMessage(message);
+				break;
+			case "toolResult":
+				this.#appendToolResult(message);
+				break;
+			case "user":
+			case "developer": {
+				// A user prompt closes the poll-displacement window, same as the live path.
+				if (message.role === "user") this.#resolveWaitingPoll();
+				const textContent = message.role === "user" ? userMessageText(message) : "";
+				if (textContent) {
+					const isSynthetic = message.role === "developer" ? true : (message.synthetic ?? false);
+					this.container.addChild(new UserMessageComponent(textContent, isSynthetic));
+				}
+				break;
+			}
+			case "bashExecution": {
+				const component = new BashExecutionComponent(message.command, this.deps.ui, message.excludeFromContext);
+				if (message.output) component.appendOutput(message.output);
+				component.setComplete(message.exitCode, message.cancelled, { truncation: message.meta?.truncation });
+				this.container.addChild(component);
+				break;
+			}
+			case "pythonExecution": {
+				const component = new EvalExecutionComponent(message.code, this.deps.ui, message.excludeFromContext);
+				if (message.output) component.appendOutput(message.output);
+				component.setComplete(message.exitCode, message.cancelled, { truncation: message.meta?.truncation });
+				this.container.addChild(component);
+				break;
+			}
+			case "hookMessage":
+			case "custom":
+				this.#appendCustomMessage(message);
+				break;
+			case "compactionSummary": {
+				const component = new CompactionSummaryMessageComponent(message);
+				this.#trackExpandable(component);
+				this.container.addChild(component);
+				break;
+			}
+			case "branchSummary": {
+				const component = new BranchSummaryMessageComponent(message);
+				this.#trackExpandable(component);
+				this.container.addChild(component);
+				break;
+			}
+			case "fileMention": {
+				const block = new TranscriptBlock();
+				for (const file of message.files) {
+					let suffix: string;
+					if (file.skippedReason === "tooLarge") {
+						const size = typeof file.byteSize === "number" ? formatBytes(file.byteSize) : "unknown size";
+						suffix = `(skipped: ${size})`;
+					} else {
+						suffix = file.image
+							? "(image)"
+							: file.lineCount === undefined
+								? "(unknown lines)"
+								: `(${file.lineCount} lines)`;
+					}
+					const text = `${theme.fg("dim", `${theme.tree.last} `)}${theme.fg("muted", "Read")} ${theme.fg(
+						"accent",
+						file.path,
+					)} ${theme.fg("dim", suffix)}`;
+					// Indent one column to match the transcript's other rows (the viewer renders
+					// body rows without an outer gutter; rows own their left pad).
+					block.addChild(new Text(text, 1, 0));
+				}
+				if (block.children.length > 0) this.container.addChild(block);
+				break;
+			}
+			default:
+				message satisfies never;
+		}
+	}
+
+	#appendAssistantMessage(message: Extract<AgentMessage, { role: "assistant" }>): void {
+		const assistantComponent = new AssistantMessageComponent(message, this.deps.hideThinkingBlock?.() ?? false, () =>
+			this.deps.requestRender(),
+		);
+		this.container.addChild(assistantComponent);
+
+		const hasVisibleAssistantContent = message.content.some(
+			content =>
+				(content.type === "text" && canonicalizeMessage(content.text)) ||
+				(content.type === "thinking" && canonicalizeMessage(content.thinking)),
+		);
+		if (hasVisibleAssistantContent) {
+			// New visible turn content closes the current read run (mirrors rebuild).
+			this.#readGroup?.seal();
+			this.#readGroup = null;
+		}
+
+		const isAbortedSilently = message.stopReason === "aborted" && isSilentAbort(message.errorMessage);
+		const hasErrorStop = !isAbortedSilently && (message.stopReason === "aborted" || message.stopReason === "error");
+		const errorMessage = hasErrorStop
+			? message.stopReason === "aborted"
+				? resolveAbortLabel(message.errorMessage)
+				: message.errorMessage || "Error"
+			: null;
+
+		for (const content of message.content) {
+			if (content.type !== "toolCall") continue;
+			this.#resolveWaitingPoll(content.name);
+
+			if (
+				content.name === "read" &&
+				readArgsHaveTarget(content.arguments) &&
+				!readArgsTargetInternalUrl(content.arguments)
+			) {
+				if (hasErrorStop && errorMessage) {
+					const group = this.#ensureReadGroup();
+					group.updateArgs(content.arguments, content.id);
+					group.updateResult(
+						{ content: [{ type: "text", text: errorMessage }], isError: true },
+						false,
+						content.id,
+					);
+				} else {
+					const normalizedArgs =
+						content.arguments && typeof content.arguments === "object" && !Array.isArray(content.arguments)
+							? (content.arguments as Record<string, unknown>)
+							: {};
+					this.#readArgs.set(content.id, normalizedArgs);
+				}
+				continue;
+			}
+
+			this.#readGroup?.seal();
+			this.#readGroup = null;
+			const component = new ToolExecutionComponent(
+				content.name,
+				content.arguments,
+				{
+					// Images can't be sliced through the scroll viewport; keep them off.
+					showImages: false,
+					editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
+					editAllowFuzzy: settings.get("edit.fuzzyMatch"),
+					liveRegion: this.container,
+				},
+				this.deps.getTool?.(content.name),
+				this.deps.ui,
+				this.deps.cwd,
+				content.id,
+			);
+			this.#trackExpandable(component);
+			this.container.addChild(component);
+
+			if (hasErrorStop && errorMessage) {
+				component.updateResult(
+					{ content: [{ type: "text", text: errorMessage }], isError: true },
+					false,
+					content.id,
+				);
+			} else {
+				this.#pendingTools.set(content.id, component);
+			}
+		}
+
+		this.#pendingUsage = settings.get("display.showTokenUsage") ? message.usage : undefined;
+	}
+
+	#appendToolResult(message: Extract<AgentMessage, { role: "toolResult" }>): void {
+		const pending = this.#pendingTools.get(message.toolCallId);
+		const isReadGroupResult = message.toolName === "read" && (!pending || pending instanceof ReadToolGroupComponent);
+		if (isReadGroupResult) {
+			let component = pending;
+			if (!component) {
+				const group = this.#ensureReadGroup();
+				const args = this.#readArgs.get(message.toolCallId);
+				if (args) group.updateArgs(args, message.toolCallId);
+				component = group;
+			}
+			component.updateResult(message, false, message.toolCallId);
+			this.#pendingTools.delete(message.toolCallId);
+			this.#readArgs.delete(message.toolCallId);
+			return;
+		}
+		if (!pending) return;
+		pending.updateResult(message, false, message.toolCallId);
+		this.#pendingTools.delete(message.toolCallId);
+		if (message.toolName === "job" && pending instanceof ToolExecutionComponent && pending.isDisplaceableBlock()) {
+			this.#waitingPoll = pending;
+		}
+	}
+
+	#appendCustomMessage(message: Extract<AgentMessage, { role: "custom" | "hookMessage" }>): void {
+		if (!message.display) return;
+		if (message.customType === "async-result") {
+			const details = (
+				message as CustomMessage<{
+					jobId?: string;
+					type?: "bash" | "task";
+					label?: string;
+					durationMs?: number;
+					jobs?: Array<{ jobId?: string; type?: "bash" | "task"; label?: string; durationMs?: number }>;
+				}>
+			).details;
+			const jobs =
+				details?.jobs && details.jobs.length > 0
+					? details.jobs
+					: [
+							{
+								jobId: details?.jobId,
+								type: details?.type,
+								label: details?.label,
+								durationMs: details?.durationMs,
+							},
+						];
+			const block = new TranscriptBlock();
+			for (const job of jobs) {
+				const jobId = job.jobId ?? "unknown";
+				const typeLabel = job.type ? `[${job.type}]` : "[job]";
+				const duration = typeof job.durationMs === "number" ? formatDuration(job.durationMs) : undefined;
+				const line = [
+					theme.fg("success", `${theme.status.done} Background job completed`),
+					theme.fg("dim", typeLabel),
+					theme.fg("accent", jobId),
+					duration ? theme.fg("dim", `(${duration})`) : undefined,
+				]
+					.filter(Boolean)
+					.join(" ");
+				block.addChild(new Text(line, 1, 0));
+			}
+			this.container.addChild(block);
+			return;
+		}
+		if (message.customType === LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE) {
+			const details = (message as CustomMessage<{ files?: LateDiagnosticsFile[] }>).details;
+			const component = new LateDiagnosticsMessageComponent(details?.files ?? []);
+			this.#trackExpandable(component);
+			this.container.addChild(component);
+			return;
+		}
+		if (message.customType === COLLAB_PROMPT_MESSAGE_TYPE) {
+			this.container.addChild(new CollabPromptMessageComponent(message as CustomMessage<CollabPromptDetails>));
+			return;
+		}
+		if (message.customType === SKILL_PROMPT_MESSAGE_TYPE) {
+			const component = new SkillMessageComponent(message as CustomMessage<SkillPromptDetails>);
+			this.#trackExpandable(component);
+			this.container.addChild(component);
+			return;
+		}
+		if (
+			message.customType === "irc:incoming" ||
+			message.customType === "irc:autoreply" ||
+			message.customType === "irc:relay"
+		) {
+			const details = (
+				message as CustomMessage<{ from?: string; to?: string; message?: string; body?: string; replyTo?: string }>
+			).details;
+			const kind =
+				message.customType === "irc:incoming"
+					? ("incoming" as const)
+					: message.customType === "irc:autoreply"
+						? ("autoreply" as const)
+						: ("relay" as const);
+			const card = createIrcMessageCard(
+				{
+					kind,
+					from: details?.from,
+					to: details?.to,
+					body: kind === "incoming" ? details?.message : details?.body,
+					replyTo: details?.replyTo,
+					timestamp: message.timestamp,
+				},
+				() => this.#expanded,
+				theme,
+			);
+			this.container.addChild(card);
+			return;
+		}
+		if (message.customType === "advisor") {
+			const details = (message as CustomMessage<AdvisorMessageDetails>).details;
+			this.container.addChild(createAdvisorMessageCard(details, () => this.#expanded, theme));
+			return;
+		}
+		if (message.customType === BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE) {
+			this.container.addChild(createBackgroundTanDispatchBlock(message as CustomMessage<unknown>));
+			return;
+		}
+		const handoffComponent = createHandoffSummaryMessageComponent(message as CustomMessage<unknown>, this.#expanded);
+		if (handoffComponent) {
+			this.#trackExpandable(handoffComponent);
+			this.container.addChild(handoffComponent);
+			return;
+		}
+		const component = new CustomMessageComponent(
+			message as CustomMessage<unknown>,
+			this.deps.getMessageRenderer?.(message.customType),
+		);
+		this.#trackExpandable(component);
+		this.container.addChild(component);
+	}
+}

package/src/modes/components/diff.ts

@@ -1,4 +1,4 @@
-import { getIndentation, sanitizeText } from "@oh-my-pi/pi-utils";
+import { DEFAULT_TAB_WIDTH, sanitizeText } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { getLanguageFromPath, highlightCode, theme } from "../../modes/theme/theme";
 import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../../tools/render-utils";
@@ -13,12 +13,12 @@ const DIM_OFF = "\x1b[22m";
  * before the first non-whitespace character; remaining tabs in code
  * content are replaced with spaces (like replaceTabs).
  */
-function visualizeIndent(text: string, filePath?: string): string {
+function visualizeIndent(text: string): string {
 	const match = text.match(/^([ \t]+)/);
-	if (!match) return replaceTabs(text, filePath);
+	if (!match) return replaceTabs(text);
 	const indent = match[1];
 	const rest = text.slice(indent.length);
-	const tabWidth = getIndentation(filePath);
+	const tabWidth = DEFAULT_TAB_WIDTH;
 	const leftPadding = Math.floor(tabWidth / 2);
 	const rightPadding = Math.max(0, tabWidth - leftPadding - 1);
 	const tabMarker = `${DIM}${" ".repeat(leftPadding)}→${" ".repeat(rightPadding)}${DIM_OFF}`;
@@ -30,7 +30,7 @@ function visualizeIndent(text: string, filePath?: string): string {
 			visible += `${DIM}·${DIM_OFF}`;
 		}
 	}
-	return `${visible}${replaceTabs(rest, filePath)}`;
+	return `${visible}${replaceTabs(rest)}`;
 }
 
 /**
@@ -153,7 +153,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			// unicode ellipsis.
 			const trimmed = line.trim();
 			const isGapRow = trimmed.length === 0 || trimmed === "..." || trimmed === "…";
-			result.push(theme.fg("toolDiffContext", isGapRow ? "…" : replaceTabs(line, options.filePath)));
+			result.push(theme.fg("toolDiffContext", isGapRow ? "…" : replaceTabs(line)));
 			i++;
 			continue;
 		}
@@ -184,47 +184,24 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 					replaceTabs(added.content),
 				);
 
-				result.push(
-					theme.fg(
-						"toolDiffRemoved",
-						formatLine("-", removed.lineNum, visualizeIndent(removedLine, options.filePath)),
-					),
-				);
-				result.push(
-					theme.fg("toolDiffAdded", formatLine("+", added.lineNum, visualizeIndent(addedLine, options.filePath))),
-				);
+				result.push(theme.fg("toolDiffRemoved", formatLine("-", removed.lineNum, visualizeIndent(removedLine))));
+				result.push(theme.fg("toolDiffAdded", formatLine("+", added.lineNum, visualizeIndent(addedLine))));
 			} else {
 				for (const removed of removedLines) {
 					result.push(
-						theme.fg(
-							"toolDiffRemoved",
-							formatLine("-", removed.lineNum, visualizeIndent(removed.content, options.filePath)),
-						),
+						theme.fg("toolDiffRemoved", formatLine("-", removed.lineNum, visualizeIndent(removed.content))),
 					);
 				}
 				for (const added of addedLines) {
-					result.push(
-						theme.fg(
-							"toolDiffAdded",
-							formatLine("+", added.lineNum, visualizeIndent(added.content, options.filePath)),
-						),
-					);
+					result.push(theme.fg("toolDiffAdded", formatLine("+", added.lineNum, visualizeIndent(added.content))));
 				}
 			}
 		} else if (parsed.prefix === "+") {
-			result.push(
-				theme.fg(
-					"toolDiffAdded",
-					formatLine("+", parsed.lineNum, visualizeIndent(parsed.content, options.filePath)),
-				),
-			);
+			result.push(theme.fg("toolDiffAdded", formatLine("+", parsed.lineNum, visualizeIndent(parsed.content))));
 			i++;
 		} else {
 			const highlighted = contextHighlights.get(i);
-			const content =
-				highlighted !== undefined
-					? replaceTabs(highlighted, options.filePath)
-					: visualizeIndent(parsed.content, options.filePath);
+			const content = highlighted !== undefined ? replaceTabs(highlighted) : visualizeIndent(parsed.content);
 			result.push(theme.fg("toolDiffContext", formatLine(" ", parsed.lineNum, content)));
 			i++;
 		}

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

@@ -38,6 +38,7 @@ import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage, OAuthAccountIdentity } from "../../session/auth-storage";
+import type { CompactMode } from "../../session/compact-modes";
 import type { NewSessionOptions } from "../../session/session-entries";
 import { formatShakeSummary, type ShakeMode, type ShakeResult } from "../../session/shake-types";
 import { limitMatchesActiveAccount } from "../../slash-commands/helpers/active-oauth-account";
@@ -1034,6 +1035,7 @@ export class CommandController {
 
 	async handleCompactCommand(
 		customInstructions?: string,
+		mode?: CompactMode,
 		beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>,
 	): Promise<CompactionOutcome> {
 		const entries = this.ctx.sessionManager.getEntries();
@@ -1044,7 +1046,7 @@ export class CommandController {
 			return "ok";
 		}
 
-		return this.executeCompaction(customInstructions, false, beforeFlush);
+		return this.executeCompaction(customInstructions, false, beforeFlush, mode);
 	}
 
 	/**
@@ -1090,6 +1092,7 @@ export class CommandController {
 		customInstructionsOrOptions?: string | CompactOptions,
 		isAuto = false,
 		beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>,
+		mode?: CompactMode,
 	): Promise<CompactionOutcome> {
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
@@ -1111,10 +1114,17 @@ export class CommandController {
 		let outcome: CompactionOutcome = "ok";
 		try {
 			const instructions = typeof customInstructionsOrOptions === "string" ? customInstructionsOrOptions : undefined;
-			const options =
+			const baseOptions =
 				customInstructionsOrOptions && typeof customInstructionsOrOptions === "object"
 					? customInstructionsOrOptions
 					: undefined;
+			// The slash path passes `mode` positionally; the extension path carries
+			// it inside the options object. Either source wins over no mode.
+			const effectiveMode = mode ?? baseOptions?.mode;
+			const options =
+				baseOptions || effectiveMode
+					? { ...baseOptions, ...(effectiveMode ? { mode: effectiveMode } : {}) }
+					: undefined;
 			await this.ctx.session.compact(instructions, options);
 
 			compactingLoader.stop();

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

@@ -1,6 +1,6 @@
-import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { type Component, Loader, TERMINAL } from "@oh-my-pi/pi-tui";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import { extractTextContent } from "../../commit/utils";
 import { settings } from "../../config/settings";
 import { getFileSnapshotStore } from "../../edit/file-snapshot-store";

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

@@ -1529,7 +1529,6 @@ export class InputController {
 		for (const child of this.ctx.chatContainer.children) {
 			if (child instanceof AssistantMessageComponent) {
 				child.setHideThinkingBlock(this.ctx.hideThinkingBlock);
-				child.invalidate();
 			}
 		}
 
@@ -1538,6 +1537,14 @@ export class InputController {
 			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
 		}
 
+		// Every block now carries the new flag, but on ED3-risk terminals the
+		// blocks that scrolled past the live region are frozen snapshots in
+		// committed scrollback — a plain repaint replays them stale, so scrolling
+		// up still shows the old thinking expanded. resetDisplay() retires those
+		// snapshots (it invalidates every block) and forces a full clear + replay
+		// of the whole transcript, matching setToolsExpanded()'s redraw.
+		this.ctx.ui.resetDisplay();
+
 		this.ctx.showStatus(`Thinking blocks: ${this.ctx.hideThinkingBlock ? "hidden" : "visible"}`);
 	}
 

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

@@ -320,9 +320,12 @@ export class SelectorController {
 				for (const child of this.ctx.chatContainer.children) {
 					if (child instanceof AssistantMessageComponent) {
 						child.setHideThinkingBlock(value as boolean);
-						child.invalidate();
 					}
 				}
+				// Full clear + replay so blocks frozen in committed scrollback on
+				// ED3-risk terminals retire their stale snapshots too (see
+				// InputController.toggleThinkingBlockVisibility).
+				this.ctx.ui.resetDisplay();
 				break;
 			case "tui.tight":
 				setTuiTight(value as boolean);

package/src/modes/interactive-mode.ts

@@ -82,6 +82,7 @@ import planModeCompactInstructionsPrompt from "../prompts/system/plan-mode-compa
 	type: "text",
 };
 import type { AgentSession, AgentSessionEvent, ResolvedRoleModel } from "../session/agent-session";
+import type { CompactMode } from "../session/compact-modes";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext } from "../session/session-context";
 import { getRecentSessions } from "../session/session-listing";
@@ -2350,7 +2351,7 @@ export class InteractiveMode implements InteractiveModeContext {
 				// the try/finally is idempotent and kept for the !compactBeforeExecute
 				// branch.
 				this.session.setPlanReferencePath(options.planFilePath);
-				compactOutcome = await this.handleCompactCommand(compactionPrompt, outcome =>
+				compactOutcome = await this.handleCompactCommand(compactionPrompt, undefined, outcome =>
 					this.#applyDeferredPlanModelTransition(outcome, options.executionModel),
 				);
 			}
@@ -3616,9 +3617,10 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	handleCompactCommand(
 		customInstructions?: string,
+		mode?: CompactMode,
 		beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>,
 	): Promise<CompactionOutcome> {
-		return this.#commandController.handleCompactCommand(customInstructions, beforeFlush);
+		return this.#commandController.handleCompactCommand(customInstructions, mode, beforeFlush);
 	}
 
 	handleHandoffCommand(customInstructions?: string): Promise<void> {