@oh-my-pi/pi-coding-agent 16.1.6 → 16.1.8

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

@@ -31,7 +31,13 @@ import {
 	JSON_TREE_SCALAR_LEN_EXPANDED,
 	renderJsonTreeLines,
 } from "../../tools/json-tree";
-import { formatExpandHint, replaceTabs, resolveImageOptions, truncateToWidth } from "../../tools/render-utils";
+import {
+	formatExpandHint,
+	formatStatusIcon,
+	replaceTabs,
+	resolveImageOptions,
+	truncateToWidth,
+} from "../../tools/render-utils";
 import { toolRenderers } from "../../tools/renderers";
 import { TODO_STRIKE_TOTAL_FRAMES } from "../../tools/todo";
 import { isFramedBlockComponent, renderStatusLine, WidthAwareText } from "../../tui";
@@ -865,9 +871,11 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 					this.#multiFileBoxes.push(pendingSpacer);
 					this.addChild(pendingSpacer);
 					const pendingBox = new Box(0, 0);
+					const spinner =
+						this.#spinnerFrame !== undefined ? formatStatusIcon("running", theme, this.#spinnerFrame) : "";
 					const pendingText = renderStatusLine(
 						{
-							icon: "pending",
+							iconOverride: spinner,
 							title: "Edit",
 							description: theme.fg("dim", `${remaining} more file${remaining > 1 ? "s" : ""} pending…`),
 						},

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

@@ -1,6 +1,7 @@
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import btwUserPrompt from "../../prompts/system/btw-user.md" with { type: "text" };
+import { copyToClipboard } from "../../utils/clipboard";
 import { BtwPanelComponent } from "../components/btw-panel";
 import type { InteractiveModeContext } from "../types";
 
@@ -39,6 +40,8 @@ export class BtwController {
 	#lastAssistantMessage: AssistantMessage | undefined;
 	#lastLeafId: string | null | undefined;
 	#branchInFlight = false;
+	#lastCopyText: string | undefined;
+	#copyInFlight = false;
 
 	constructor(private readonly ctx: InteractiveModeContext) {}
 
@@ -58,6 +61,27 @@ export class BtwController {
 		);
 	}
 
+	canCopy(): boolean {
+		return (
+			!this.#copyInFlight && this.#activeRequest?.component.isCopyable() === true && this.#lastCopyText !== undefined
+		);
+	}
+
+	async handleCopy(): Promise<boolean> {
+		if (!this.canCopy() || this.#lastCopyText === undefined) return false;
+		this.#copyInFlight = true;
+		try {
+			await copyToClipboard(this.#lastCopyText);
+			this.ctx.showStatus("Copied /btw answer to clipboard");
+			return true;
+		} catch (error) {
+			this.ctx.showError(error instanceof Error ? error.message : String(error));
+			return true;
+		} finally {
+			this.#copyInFlight = false;
+		}
+	}
+
 	async handleBranch(): Promise<boolean> {
 		if (!this.canBranch() || !this.#lastQuestion || !this.#lastAssistantMessage) return false;
 		this.#branchInFlight = true;
@@ -123,17 +147,17 @@ export class BtwController {
 			if (!this.#isActiveRequest(request)) {
 				return;
 			}
-			if (replyText) {
-				request.component.setAnswer(replyText);
-			}
+			request.component.setAnswer(replyText);
 			request.component.markComplete();
-			if (request.component.isBranchable()) {
+			const copyText = request.component.getCopyText();
+			if (copyText !== undefined) {
 				this.#lastQuestion = request.question;
 				this.#lastReplyText = replyText;
+				this.#lastCopyText = copyText;
 				this.#lastAssistantMessage = assistantMessageWithReplyText(assistantMessage, replyText);
 				this.#lastLeafId = request.leafId;
 			} else {
-				this.#clearBranchState();
+				this.#clearCompletedState();
 			}
 		} catch (error) {
 			if (!this.#isActiveRequest(request)) {
@@ -151,7 +175,7 @@ export class BtwController {
 		const request = this.#activeRequest;
 		if (!request) return;
 		this.#activeRequest = undefined;
-		this.#clearBranchState();
+		this.#clearCompletedState();
 		if (options.abort) {
 			request.abortController.abort();
 		}
@@ -160,10 +184,11 @@ export class BtwController {
 		this.ctx.ui.requestRender();
 	}
 
-	#clearBranchState(): void {
+	#clearCompletedState(): void {
 		this.#lastQuestion = undefined;
 		this.#lastReplyText = undefined;
 		this.#lastAssistantMessage = undefined;
+		this.#lastCopyText = undefined;
 		this.#lastLeafId = undefined;
 	}
 

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

@@ -87,6 +87,7 @@ export class EventController {
 		this.#streamingReveal = new StreamingRevealController({
 			getSmoothStreaming: () => this.ctx.settings.get("display.smoothStreaming"),
 			getHideThinkingBlock: () => this.ctx.hideThinkingBlock,
+			getProseOnlyThinking: () => this.ctx.proseOnlyThinking,
 			requestRender: () => this.ctx.ui.requestRender(),
 		});
 		this.#toolArgsReveal = new ToolArgsRevealController({
@@ -333,6 +334,7 @@ export class EventController {
 				() => this.ctx.ui.requestRender(),
 				this.ctx.viewSession.extensionRunner?.getAssistantThinkingRenderers(),
 				this.ctx.ui.imageBudget,
+				this.ctx.proseOnlyThinking,
 			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
@@ -920,6 +922,17 @@ export class EventController {
 		}
 	}
 
+	/**
+	 * Trailing Esc hint for live maintenance loaders. While a subagent is
+	 * focused, Esc returns to main instead of cancelling its maintenance
+	 * (#2819), so the loader drops the hint entirely rather than advertise a
+	 * cancel that no longer happens. Includes the leading space so the focused
+	 * label carries no dangling whitespace.
+	 */
+	#maintenanceEscHint(): string {
+		return this.ctx.focusedAgentId ? "" : " (esc to cancel)";
+	}
+
 	async #handleAutoCompactionStart(
 		event: Extract<AgentSessionEvent, { type: "auto_compaction_start" }>,
 	): Promise<void> {
@@ -939,12 +952,14 @@ export class EventController {
 				? "Auto-handoff"
 				: event.action === "shake"
 					? "Auto-shake"
-					: "Auto context-full maintenance";
+					: event.action === "snapcompact"
+						? "Auto-snapcompact"
+						: "Auto context-full maintenance";
 		this.ctx.autoCompactionLoader = new Loader(
 			this.ctx.ui,
 			spinner => theme.fg("accent", spinner),
 			text => theme.fg("muted", text),
-			`${reasonText}${actionLabel}… (esc to cancel)`,
+			`${reasonText}${actionLabel}…${this.#maintenanceEscHint()}`,
 			getSymbolTheme().spinnerFrames,
 		);
 		this.ctx.statusContainer.addChild(this.ctx.autoCompactionLoader);
@@ -960,13 +975,16 @@ export class EventController {
 		}
 		const isHandoffAction = event.action === "handoff";
 		const isShakeAction = event.action === "shake";
+		const isSnapcompactAction = event.action === "snapcompact";
 		if (event.aborted) {
 			this.ctx.showStatus(
 				isHandoffAction
 					? "Auto-handoff cancelled"
 					: isShakeAction
 						? "Auto-shake cancelled"
-						: "Auto context-full maintenance cancelled",
+						: isSnapcompactAction
+							? "Auto-snapcompact cancelled"
+							: "Auto context-full maintenance cancelled",
 			);
 		} else if (isShakeAction) {
 			// Shake produces no CompactionResult; rebuild on success, suppress benign skips.
@@ -1005,6 +1023,8 @@ export class EventController {
 		} else if (event.skipped) {
 			// Benign skip: no model selected, no candidate models available, or nothing
 			// to compact yet. Not a failure — suppress the warning.
+		} else if (isSnapcompactAction) {
+			this.ctx.showWarning("Auto-snapcompact maintenance failed; continuing without maintenance");
 		} else {
 			this.ctx.showWarning("Auto context-full maintenance failed; continuing without maintenance");
 		}
@@ -1027,7 +1047,7 @@ export class EventController {
 			this.ctx.ui,
 			spinner => theme.fg("warning", spinner),
 			text => theme.fg("muted", text),
-			`Retrying (${event.attempt}/${event.maxAttempts}) in ${delaySeconds}s… (esc to cancel)`,
+			`Retrying (${event.attempt}/${event.maxAttempts}) in ${delaySeconds}s…${this.#maintenanceEscHint()}`,
 			getSymbolTheme().spinnerFrames,
 		);
 		this.ctx.statusContainer.addChild(this.ctx.retryLoader);

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

@@ -99,6 +99,7 @@ export class InputController {
 	#enhancedPaste?: EnhancedPasteController;
 	#focusedLeftTapListenerInstalled = false;
 	#btwBranchListenerInstalled = false;
+	#btwCopyListenerInstalled = false;
 	// Tap counter for the double-← gesture; reset whenever a quiet gap
 	// (>= LEFT_DOUBLE_TAP_MAX_GAP_MS) starts a fresh sequence. See
 	// #detectLeftDoubleTap.
@@ -169,11 +170,23 @@ export class InputController {
 			this.ctx.ui.addInputListener(data => {
 				if (!matchesKey(data, "b")) return undefined;
 				if (!this.ctx.canBranchBtw()) return undefined;
+				if (this.ctx.ui.getFocused() !== this.ctx.editor) return undefined;
 				if (this.ctx.editor.getText().trim()) return undefined;
 				void this.ctx.handleBtwBranchKey();
 				return { consume: true };
 			});
 		}
+		if (!this.#btwCopyListenerInstalled) {
+			this.#btwCopyListenerInstalled = true;
+			this.ctx.ui.addInputListener(data => {
+				if (!matchesKey(data, "c")) return undefined;
+				if (!this.ctx.canCopyBtw()) return undefined;
+				if (this.ctx.ui.getFocused() !== this.ctx.editor) return undefined;
+				if (this.ctx.editor.getText().trim()) return undefined;
+				void this.ctx.handleBtwCopyKey();
+				return { consume: true };
+			});
+		}
 		this.ctx.editor.onEscape = () => {
 			// Active context maintenance owns Esc: auto/manual compaction,
 			// handoff generation, and auto-retry backoff all advertise
@@ -182,27 +195,37 @@ export class InputController {
 			// to clobber the single saved-handler slot (auto-compaction start
 			// → /compact → auto end → manual finally), leaving Esc wired to a
 			// stale no-op closure until restart.
-			const viewSession = this.ctx.viewSession;
-			let aborted = false;
-			if (viewSession.isCompacting) {
-				try {
-					viewSession.abortCompaction();
-				} catch {}
-				aborted = true;
-			}
-			if (viewSession.isGeneratingHandoff) {
-				try {
-					viewSession.abortHandoff();
-				} catch {}
-				aborted = true;
-			}
-			if (viewSession.isRetrying) {
-				try {
-					viewSession.abortRetry();
-				} catch {}
-				aborted = true;
+			//
+			// While a subagent is focused, Esc honors the advertised view action
+			// ("Esc returns to main") instead of cancelling maintenance —
+			// accidentally killing a focused subagent's compaction on the way out
+			// was #2819. The auto-maintenance loaders relabel their hint to match
+			// (see EventController). Main-session maintenance still owns Esc and
+			// stays cancellable from the main view (focused submit gates /compact
+			// and handoff, so manual maintenance is main-only anyway).
+			if (!this.ctx.focusedAgentId) {
+				const viewSession = this.ctx.viewSession;
+				let aborted = false;
+				if (viewSession.isCompacting) {
+					try {
+						viewSession.abortCompaction();
+					} catch {}
+					aborted = true;
+				}
+				if (viewSession.isGeneratingHandoff) {
+					try {
+						viewSession.abortHandoff();
+					} catch {}
+					aborted = true;
+				}
+				if (viewSession.isRetrying) {
+					try {
+						viewSession.abortRetry();
+					} catch {}
+					aborted = true;
+				}
+				if (aborted) return;
 			}
-			if (aborted) return;
 
 			if (this.ctx.loopModeEnabled) {
 				this.ctx.pauseLoop();
@@ -1524,7 +1547,6 @@ export class InputController {
 	toggleThinkingBlockVisibility(): void {
 		this.ctx.hideThinkingBlock = !this.ctx.hideThinkingBlock;
 		this.ctx.settings.set("hideThinkingBlock", this.ctx.hideThinkingBlock);
-		this.ctx.session.agent.hideThinkingSummary = this.ctx.hideThinkingBlock;
 
 		for (const child of this.ctx.chatContainer.children) {
 			if (child instanceof AssistantMessageComponent) {

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

@@ -71,6 +71,10 @@ import { buildCopyTargets } from "../utils/copy-targets";
 
 const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect URL>.";
 
+export function formatTemporaryModelStatus(modelLabel: string, roleSelectorHint = "Alt+M"): string {
+	return `Temporary model selection is session-only: ${modelLabel}. Use ${roleSelectorHint} or /model for role models (default/smol/plan/task/slow/custom roles).`;
+}
+
 export class SelectorController {
 	constructor(private ctx: InteractiveModeContext) {}
 
@@ -314,9 +318,8 @@ export class SelectorController {
 					}
 				}
 				break;
-			case "hideThinking":
+			case "hideThinkingBlock":
 				this.ctx.hideThinkingBlock = value as boolean;
-				this.ctx.session.agent.hideThinkingSummary = value as boolean;
 				for (const child of this.ctx.chatContainer.children) {
 					if (child instanceof AssistantMessageComponent) {
 						child.setHideThinkingBlock(value as boolean);
@@ -327,6 +330,18 @@ export class SelectorController {
 				// InputController.toggleThinkingBlockVisibility).
 				this.ctx.ui.resetDisplay();
 				break;
+			case "proseOnlyThinking":
+				this.ctx.proseOnlyThinking = value as boolean;
+				for (const child of this.ctx.chatContainer.children) {
+					if (child instanceof AssistantMessageComponent) {
+						child.setProseOnlyThinking(value as boolean);
+					}
+				}
+				this.ctx.ui.resetDisplay();
+				break;
+			case "omitThinking":
+				this.ctx.session.agent.hideThinkingSummary = value as boolean;
+				break;
 			case "display.cacheMissMarker":
 				// Rebuild re-runs the usage-based detection under the new setting so
 				// markers appear/disappear; full reset retires any already committed
@@ -483,7 +498,8 @@ export class SelectorController {
 							}
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();
-							this.ctx.showStatus(`Temporary model: ${selector ?? model.id}`);
+							const roleSelectorHint = this.ctx.keybindings.getKeys("app.model.select")[0] ?? "Alt+M";
+							this.ctx.showStatus(formatTemporaryModelStatus(selector ?? model.id, roleSelectorHint));
 							done();
 							this.ctx.ui.requestRender();
 						} else if (role === "default") {
@@ -817,14 +833,9 @@ export class SelectorController {
 			this.ctx.sessionManager.getCwd(),
 			this.ctx.sessionManager.getSessionDir(),
 		);
-		// Current folder has no sessions: preload the global list so the picker
-		// can open straight into all-projects scope instead of dead-ending.
-		let allSessions: SessionInfo[] | undefined;
-		let startInAllScope = false;
-		if (sessions.length === 0) {
-			allSessions = await SessionManager.listAll();
-			startInAllScope = allSessions.length > 0;
-		}
+		// Always open in current-folder scope; the empty-state hint in SessionList
+		// invites the user to Tab into all-projects rather than silently surfacing
+		// every project's history when the cwd has nothing to resume. See #3099.
 		const historyStorage = this.ctx.historyStorage;
 		const historyMatcher = historyStorage ? (query: string) => historyStorage.matchingSessionIds(query) : undefined;
 		this.showSelector(done => {
@@ -858,8 +869,6 @@ export class SelectorController {
 					},
 					historyMatcher,
 					loadAllSessions: () => SessionManager.listAll(),
-					allSessions,
-					startInAllScope,
 					getTerminalRows: () => this.ctx.ui.terminal.rows,
 				},
 			);
@@ -1264,6 +1273,7 @@ export class SelectorController {
 			getMessageRenderer: type => this.ctx.session.extensionRunner?.getMessageRenderer(type),
 			cwd: this.ctx.sessionManager.getCwd(),
 			hideThinkingBlock: () => this.ctx.hideThinkingBlock,
+			proseOnlyThinking: () => this.ctx.proseOnlyThinking,
 			focusAgent: id => this.ctx.focusAgentSession(id),
 			sessionFile: this.ctx.sessionManager.getSessionFile() ?? null,
 		});

package/src/modes/controllers/streaming-reveal.ts

@@ -1,7 +1,7 @@
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { getSegmenter } from "@oh-my-pi/pi-tui";
 import { LRUCache } from "lru-cache/raw";
-import { canonicalizeMessage } from "../../utils/thinking-display";
+import { formatThinkingForDisplay, hasDisplayableThinking } from "../../utils/thinking-display";
 import type { AssistantMessageComponent } from "../components/assistant-message";
 
 export const STREAMING_REVEAL_FRAME_MS = 1000 / 30;
@@ -9,11 +9,13 @@ export const MIN_STEP = 3;
 export const CATCHUP_FRAMES = 8;
 
 type AssistantContentBlock = AssistantMessage["content"][number];
+type DisplayThinkingContentBlock = Extract<AssistantContentBlock, { type: "thinking" }> & { rawThinking?: string };
 type StreamingRevealComponent = Pick<AssistantMessageComponent, "updateContent">;
 
 type StreamingRevealControllerOptions = {
 	getSmoothStreaming(): boolean;
 	getHideThinkingBlock(): boolean;
+	getProseOnlyThinking(): boolean;
 	requestRender(): void;
 };
 
@@ -83,13 +85,16 @@ function sliceGraphemes(text: string, units: number): string {
 	return text;
 }
 
-export function visibleUnits(message: AssistantMessage, hideThinking: boolean): number {
+export function visibleUnits(message: AssistantMessage, hideThinking: boolean, proseOnly = true): number {
 	let total = 0;
 	for (const block of message.content) {
 		if (block.type === "text") {
 			total += countGraphemes(block.text);
-		} else if (block.type === "thinking" && !hideThinking && canonicalizeMessage(block.thinking)) {
-			total += countGraphemes(block.thinking);
+		} else if (block.type === "thinking" && !hideThinking) {
+			const formatted = formatThinkingForDisplay(block.thinking, proseOnly);
+			if (hasDisplayableThinking(block.thinking, formatted)) {
+				total += countGraphemes(formatted);
+			}
 		}
 	}
 	return total;
@@ -119,6 +124,7 @@ export function buildDisplayMessage(
 	target: AssistantMessage,
 	revealed: number,
 	hideThinking: boolean,
+	proseOnly = true,
 	countOf: (index: number, text: string) => number = (_index, text) => countGraphemes(text),
 ): AssistantMessage {
 	let remaining = Math.max(0, Math.floor(revealed));
@@ -129,10 +135,20 @@ export function buildDisplayMessage(
 			const units = countOf(i, block.text);
 			content.push(revealTextBlock(block, remaining, units));
 			remaining = Math.max(0, remaining - units);
-		} else if (block.type === "thinking" && !hideThinking && canonicalizeMessage(block.thinking)) {
-			const units = countOf(i, block.thinking);
-			content.push(revealThinkingBlock(block, remaining, units));
-			remaining = Math.max(0, remaining - units);
+		} else if (block.type === "thinking" && !hideThinking) {
+			const formatted = formatThinkingForDisplay(block.thinking, proseOnly);
+			if (hasDisplayableThinking(block.thinking, formatted)) {
+				const units = countOf(i, formatted);
+				const displayBlock: DisplayThinkingContentBlock = {
+					...block,
+					thinking: formatted,
+					rawThinking: block.thinking,
+				};
+				content.push(revealThinkingBlock(displayBlock, remaining, units));
+				remaining = Math.max(0, remaining - units);
+			} else {
+				content.push(block);
+			}
 		} else {
 			content.push(block);
 		}
@@ -147,12 +163,14 @@ export function nextStep(backlog: number): number {
 export class StreamingRevealController {
 	readonly #getSmoothStreaming: () => boolean;
 	readonly #getHideThinkingBlock: () => boolean;
+	readonly #getProseOnlyThinking: () => boolean;
 	readonly #requestRender: () => void;
 	#target: AssistantMessage | undefined;
 	#component: StreamingRevealComponent | undefined;
 	#timer: NodeJS.Timeout | undefined;
 	#revealed = 0;
 	#hideThinkingBlock = false;
+	#proseOnlyThinking = true;
 	#smoothStreaming = true;
 	readonly #unitCounter = new BlockUnitCounter();
 	readonly #countOf = (index: number, text: string): number => this.#unitCounter.count(index, text);
@@ -160,6 +178,7 @@ export class StreamingRevealController {
 	constructor(options: StreamingRevealControllerOptions) {
 		this.#getSmoothStreaming = options.getSmoothStreaming;
 		this.#getHideThinkingBlock = options.getHideThinkingBlock;
+		this.#getProseOnlyThinking = options.getProseOnlyThinking;
 		this.#requestRender = options.requestRender;
 	}
 
@@ -169,9 +188,14 @@ export class StreamingRevealController {
 		this.#target = message;
 		this.#revealed = 0;
 		this.#hideThinkingBlock = this.#getHideThinkingBlock();
+		this.#proseOnlyThinking = this.#getProseOnlyThinking();
 		this.#smoothStreaming = this.#getSmoothStreaming();
 		if (!this.#smoothStreaming) {
-			component.updateContent(message, { transient: true });
+			const total = this.#visibleUnits(message);
+			component.updateContent(
+				buildDisplayMessage(message, total, this.#hideThinkingBlock, this.#proseOnlyThinking, this.#countOf),
+				{ transient: true },
+			);
 			return;
 		}
 		const total = this.#visibleUnits(message);
@@ -179,9 +203,18 @@ export class StreamingRevealController {
 			// A tool call is a transcript-order boundary: finish any leading
 			// assistant text before EventController renders the separate tool card.
 			this.#revealed = total;
-			component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
-				transient: true,
-			});
+			component.updateContent(
+				buildDisplayMessage(
+					message,
+					this.#revealed,
+					this.#hideThinkingBlock,
+					this.#proseOnlyThinking,
+					this.#countOf,
+				),
+				{
+					transient: true,
+				},
+			);
 			return;
 		}
 		this.#renderCurrent();
@@ -190,9 +223,16 @@ export class StreamingRevealController {
 
 	setTarget(message: AssistantMessage): void {
 		this.#target = message;
+		this.#hideThinkingBlock = this.#getHideThinkingBlock();
+		this.#proseOnlyThinking = this.#getProseOnlyThinking();
+		this.#smoothStreaming = this.#getSmoothStreaming();
 		if (!this.#component) return;
 		if (!this.#smoothStreaming) {
-			this.#component.updateContent(message, { transient: true });
+			const total = this.#visibleUnits(message);
+			this.#component.updateContent(
+				buildDisplayMessage(message, total, this.#hideThinkingBlock, this.#proseOnlyThinking, this.#countOf),
+				{ transient: true },
+			);
 			return;
 		}
 		const total = this.#visibleUnits(message);
@@ -202,7 +242,13 @@ export class StreamingRevealController {
 			this.#revealed = total;
 			this.#stopTimer();
 			this.#component.updateContent(
-				buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf),
+				buildDisplayMessage(
+					message,
+					this.#revealed,
+					this.#hideThinkingBlock,
+					this.#proseOnlyThinking,
+					this.#countOf,
+				),
 				{
 					transient: true,
 				},
@@ -231,8 +277,11 @@ export class StreamingRevealController {
 			const block = message.content[i]!;
 			if (block.type === "text") {
 				total += this.#unitCounter.count(i, block.text);
-			} else if (block.type === "thinking" && !this.#hideThinkingBlock && canonicalizeMessage(block.thinking)) {
-				total += this.#unitCounter.count(i, block.thinking);
+			} else if (block.type === "thinking" && !this.#hideThinkingBlock) {
+				const formatted = formatThinkingForDisplay(block.thinking, this.#proseOnlyThinking);
+				if (hasDisplayableThinking(block.thinking, formatted)) {
+					total += this.#unitCounter.count(i, formatted);
+				}
 			}
 		}
 		return total;
@@ -244,7 +293,13 @@ export class StreamingRevealController {
 		// smooth reveal has temporarily caught up to the current target. The
 		// message_end handler performs the only stable non-transient render.
 		this.#component.updateContent(
-			buildDisplayMessage(this.#target, this.#revealed, this.#hideThinkingBlock, this.#countOf),
+			buildDisplayMessage(
+				this.#target,
+				this.#revealed,
+				this.#hideThinkingBlock,
+				this.#proseOnlyThinking,
+				this.#countOf,
+			),
 			{ transient: true },
 		);
 	}
@@ -284,9 +339,12 @@ export class StreamingRevealController {
 			return;
 		}
 		this.#revealed = Math.min(total, this.#revealed + nextStep(total - this.#revealed));
-		component.updateContent(buildDisplayMessage(target, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
-			transient: true,
-		});
+		component.updateContent(
+			buildDisplayMessage(target, this.#revealed, this.#hideThinkingBlock, this.#proseOnlyThinking, this.#countOf),
+			{
+				transient: true,
+			},
+		);
 		this.#requestRender();
 		if (this.#revealed >= total) {
 			this.#stopTimer();

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

@@ -1,10 +1,10 @@
 import * as fs from "node:fs/promises";
-import { resolveToCwd } from "../../tools/path-utils";
 import {
 	applyOpsToPhases,
 	getLatestTodoPhasesFromEntries,
 	markdownToPhases,
 	phasesToMarkdown,
+	resolveTodoMarkdownPath,
 	type TodoItem,
 	type TodoPhase,
 	USER_TODO_EDIT_CUSTOM_TYPE,
@@ -18,8 +18,8 @@ const USAGE = [
 	"  /todo                              Show current todos",
 	"  /todo edit                         Open todos in $EDITOR",
 	"  /todo copy                         Copy todos as Markdown to clipboard",
-	"  /todo export <path>                Write todos as Markdown to <path>",
-	"  /todo import <path>                Replace todos from Markdown at <path>",
+	"  /todo export [<path>]              Write todos to file (default: TODO.md)",
+	"  /todo import [<path>]              Replace todos from file (default: TODO.md)",
 	"  /todo append [<phase>] <task...>   Append a task; phase fuzzy-matched or auto-created",
 	"  /todo start  <task>                Mark task in_progress (fuzzy content match)",
 	"  /todo done   [<task|phase>]        Mark task/phase/all completed",
@@ -214,9 +214,7 @@ export class TodoCommandController {
 	}
 
 	#resolveTodoPath(rest: string): string {
-		const trimmed = rest.trim();
-		const raw = trimmed || "TODO.md";
-		return resolveToCwd(raw, this.ctx.sessionManager.getCwd());
+		return resolveTodoMarkdownPath(rest, this.ctx.sessionManager.getCwd());
 	}
 
 	async #exportToFile(rest: string): Promise<void> {
@@ -225,22 +223,23 @@ export class TodoCommandController {
 			this.ctx.showWarning("No todos to export.");
 			return;
 		}
-		const target = this.#resolveTodoPath(rest);
 		try {
+			const target = this.#resolveTodoPath(rest);
 			await fs.writeFile(target, phasesToMarkdown(phases), "utf8");
 			this.ctx.showStatus(`Wrote todos to ${target}`);
 		} catch (error) {
-			this.ctx.showError(`Failed to write ${target}: ${error instanceof Error ? error.message : String(error)}`);
+			this.ctx.showError(`Failed to write todos: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
 
 	async #importFromFile(rest: string): Promise<void> {
-		const source = this.#resolveTodoPath(rest);
+		let source = "";
 		let content: string;
 		try {
+			source = this.#resolveTodoPath(rest);
 			content = await fs.readFile(source, "utf8");
 		} catch (error) {
-			this.ctx.showError(`Failed to read ${source}: ${error instanceof Error ? error.message : String(error)}`);
+			this.ctx.showError(`Failed to read todos: ${error instanceof Error ? error.message : String(error)}`);
 			return;
 		}
 		const { phases, errors } = markdownToPhases(content);