@oh-my-pi/pi-coding-agent 15.13.2 → 16.0.0

package/src/main.ts

@@ -140,6 +140,10 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	// memory should opt in explicitly through their own settings layer.
 	"memory.backend",
 	"memories.enabled",
+	// Advisor is interactive-session assistance. Protocol hosts opt in explicitly
+	// instead of inheriting a user's globally-enabled local preference.
+	"advisor.enabled",
+	"advisor.subagents",
 ];
 
 const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [
@@ -274,7 +278,19 @@ export async function submitInteractiveInput(
 
 	try {
 		using _keepalive = new EventLoopKeepalive();
-		const streamingBehavior = session.isStreaming ? ("followUp" as const) : undefined;
+		// Honor the submission's queue intent, defaulting to followUp. Reading
+		// `session.isStreaming` to decide queue-vs-fresh is NOT atomic with the
+		// eventual `agent.prompt()` call inside `session.prompt()`: a background turn
+		// (queued-message drain, idle compaction, goal/loop continuation timer) can
+		// flip the agent busy in the gap, and a bare prompt() would then throw
+		// AgentBusyError straight to an error toast even though the UI shows no
+		// "Working…". Passing a behavior unconditionally is a no-op when the session
+		// is genuinely idle (a fresh turn runs and the option is ignored) and queues
+		// the message instead of erroring when a turn is already underway. Normal
+		// user Enter carries "steer" (interrupt, matching the streaming-branch Enter);
+		// background/continuation submits omit it and fall back to "followUp". The
+		// synthetic branch below opts out by design.
+		const streamingBehavior = input.streamingBehavior ?? ("followUp" as const);
 		// Continue shortcuts submit an already-started synthetic developer prompt with
 		// no optimistic user message.
 		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
@@ -287,9 +303,7 @@ export async function submitInteractiveInput(
 				display: input.display ?? false,
 				attribution: "agent" as const,
 			};
-			await (streamingBehavior
-				? session.promptCustomMessage(message, { streamingBehavior })
-				: session.promptCustomMessage(message));
+			await session.promptCustomMessage(message, { streamingBehavior });
 		} else if (input.synthetic) {
 			// Synthetic continue shortcuts are hidden developer prompts. The streaming
 			// queue (#queueUserMessage) only carries user-attributed messages, so we do
@@ -299,7 +313,7 @@ export async function submitInteractiveInput(
 			// its role.
 			await session.prompt(input.text, { synthetic: true, expandPromptTemplates: false });
 		} else {
-			await session.prompt(input.text, { images: input.images, ...(streamingBehavior && { streamingBehavior }) });
+			await session.prompt(input.text, { images: input.images, streamingBehavior });
 		}
 	} catch (error: unknown) {
 		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";

package/src/modes/acp/acp-agent.ts

@@ -72,7 +72,7 @@ import { AUTO_THINKING, parseConfiguredThinkingLevel } from "../../thinking";
 import { normalizeLocalScheme } from "../../tools/path-utils";
 import { runResolveInvocation } from "../../tools/resolve";
 import { ToolError } from "../../tools/tool-errors";
-import { getVisibleThinkingText } from "../../utils/thinking-display";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 import { createAcpClientBridge } from "./acp-client-bridge";
 import {
 	buildToolCallStartUpdate,
@@ -1907,7 +1907,7 @@ export class AcpAgent implements Agent {
 					continue;
 				}
 				if (item.type === "thinking" && "thinking" in item && typeof item.thinking === "string") {
-					const thinking = getVisibleThinkingText(item);
+					const thinking = canonicalizeMessage(item.thinking);
 					if (thinking.length === 0) continue;
 					notifications.push({
 						sessionId,

package/src/modes/acp/acp-event-mapper.ts

@@ -9,7 +9,7 @@ import type {
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { resolveToCwd } from "../../tools/path-utils";
 import type { TodoStatus } from "../../tools/todo";
-import { hasVisibleThinking } from "../../utils/thinking-display";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 
 interface MessageProgress {
 	textEmitted: boolean;
@@ -259,7 +259,7 @@ function mapAssistantMessageUpdate(
 			break;
 		case "thinking_delta": {
 			const block = event.assistantMessageEvent.partial?.content?.[event.assistantMessageEvent.contentIndex];
-			if (block?.type === "thinking" && !hasVisibleThinking(block)) return [];
+			if (block?.type === "thinking" && !canonicalizeMessage(block.thinking)) return [];
 			sessionUpdate = "agent_thought_chunk";
 			text = event.assistantMessageEvent.delta;
 			if (text.length > 0 && progress) {

package/src/modes/components/advisor-message.ts

@@ -0,0 +1,99 @@
+import { type Component, visibleWidth } from "@oh-my-pi/pi-tui";
+import type { AdvisorMessageDetails, AdvisorSeverity } from "../../advisor";
+import {
+	createCachedComponent,
+	formatBadge,
+	replaceTabs,
+	type ToolUIColor,
+	wrapTextWithAnsi,
+} from "../../tools/render-utils";
+import { Ellipsis, renderStatusLine, truncateToWidth } from "../../tui";
+import type { Theme } from "../theme/theme";
+
+const COLLAPSED_NOTES = 3;
+const NOTE_LINE_WIDTH = 110;
+
+function wrapVarying(text: string, w1: number, w2: number): string[] {
+	if (text.length === 0) return [];
+	const firstWrap = wrapTextWithAnsi(text, w1);
+	if (firstWrap.length <= 1) {
+		return firstWrap;
+	}
+	const firstLine = firstWrap[0];
+	const idx = text.indexOf(firstLine);
+	if (idx === -1) {
+		return wrapTextWithAnsi(text, w2);
+	}
+	const remainder = text.slice(idx + firstLine.length).trimStart();
+	const restWrap = wrapTextWithAnsi(remainder, w2);
+	return [firstLine, ...restWrap];
+}
+
+function severityColor(severity: AdvisorSeverity | undefined): ToolUIColor {
+	switch (severity) {
+		case "blocker":
+			return "error";
+		case "concern":
+			return "warning";
+		default:
+			return "muted";
+	}
+}
+
+/**
+ * Display-only transcript card for advisor notes injected into the primary
+ * session. Mirrors the IRC card's glyph + quote-border conventions so passive
+ * advice reads as a distinct, non-interrupting aside rather than a user turn.
+ */
+export function createAdvisorMessageCard(
+	details: AdvisorMessageDetails | undefined,
+	getExpanded: () => boolean,
+	uiTheme: Theme,
+): Component {
+	const notes = details?.notes ?? [];
+	const blockers = notes.filter(note => note.severity === "blocker").length;
+	const meta: string[] = [`${notes.length} ${notes.length === 1 ? "note" : "notes"}`];
+	if (blockers > 0) meta.push(uiTheme.fg("error", `${blockers} blocker${blockers === 1 ? "" : "s"}`));
+
+	return createCachedComponent(
+		getExpanded,
+		(width, expanded) => {
+			const glyph = uiTheme.styledSymbol("status.info", "accent");
+			const lines = [renderStatusLine({ iconOverride: glyph, title: "Advisor", meta }, uiTheme)];
+			const quote = uiTheme.fg("dim", uiTheme.md.quoteBorder);
+			const shown = expanded ? notes : notes.slice(0, COLLAPSED_NOTES);
+			for (const entry of shown) {
+				const badge = entry.severity
+					? `${formatBadge(entry.severity, severityColor(entry.severity), uiTheme)} `
+					: "";
+				const quotePrefix = `  ${quote} `;
+				const quoteWidth = visibleWidth(quotePrefix);
+				const badgeWidth = visibleWidth(badge);
+				const w1 = Math.max(10, Math.min(NOTE_LINE_WIDTH, width) - quoteWidth - badgeWidth);
+				const w2 = Math.max(10, Math.min(NOTE_LINE_WIDTH, width) - quoteWidth);
+
+				const paragraphs = entry.note.split("\n").filter(p => p.trim());
+				const bodyLines: string[] = [];
+				for (let i = 0; i < paragraphs.length; i++) {
+					const p = paragraphs[i];
+					if (i === 0) {
+						bodyLines.push(...wrapVarying(p, w1, w2));
+					} else {
+						bodyLines.push(...wrapTextWithAnsi(p, w2));
+					}
+				}
+
+				bodyLines.forEach((line, index) => {
+					const prefix = index === 0 ? badge : "";
+					lines.push(`  ${quote} ${prefix}${uiTheme.fg("toolOutput", replaceTabs(line))}`);
+				});
+			}
+			const hidden = notes.length - shown.length;
+			if (hidden > 0) {
+				lines.push(`  ${quote} ${uiTheme.fg("dim", `… +${hidden} more ${hidden === 1 ? "note" : "notes"}`)}`);
+			}
+			return lines.map(line => truncateToWidth(line, width, Ellipsis.Unicode));
+		},
+		{ paddingX: 1 },
+	);
+}

package/src/modes/components/agent-hub.ts

@@ -19,6 +19,7 @@ import type { AgentMessage, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { Container, Editor, matchesKey, ScrollView, Text, type TUI } from "@oh-my-pi/pi-tui";
 import { formatAge, formatBytes, formatDuration, formatNumber, getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import type { AdvisorMessageDetails } from "../../advisor";
 import { COLLAB_PROMPT_MESSAGE_TYPE, type CollabPromptDetails } from "../../collab/protocol";
 import type { KeyId } from "../../config/keybindings";
 import { settings } from "../../config/settings";
@@ -41,10 +42,11 @@ import type { SessionMessageEntry } from "../../session/session-entries";
 import { parseSessionEntries } from "../../session/session-loader";
 import { createIrcMessageCard } from "../../tools/irc";
 import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../../tools/render-utils";
-import { hasVisibleThinking } from "../../utils/thinking-display";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { getEditorTheme, theme } from "../theme/theme";
 import { matchesSelectDown, matchesSelectUp } from "../utils/keybinding-matchers";
+import { createAdvisorMessageCard } from "./advisor-message";
 import { AssistantMessageComponent } from "./assistant-message";
 import { createBackgroundTanDispatchBlock } from "./background-tan-message";
 import { BashExecutionComponent } from "./bash-execution";
@@ -193,6 +195,8 @@ export class AgentHubOverlayComponent extends Container {
 	#rows: AgentRef[] = [];
 	#selectedRow = 0;
 	#notice: string | undefined;
+	/** Captured row order from the first refresh; keeps the hub stable while open. */
+	#rowOrder: Map<string, number> | undefined;
 
 	// Chat state
 	#chatAgentId: string | undefined;
@@ -349,10 +353,32 @@ export class AgentHubOverlayComponent extends Container {
 
 	#refreshRows(): void {
 		const selectedId = this.#rows[this.#selectedRow]?.id;
-		this.#rows = this.#registry
-			.list()
-			.filter(ref => ref.id !== MAIN_AGENT_ID)
-			.sort((a, b) => STATUS_ORDER[a.status] - STATUS_ORDER[b.status] || b.lastActivity - a.lastActivity);
+		const refs = this.#registry.list().filter(ref => ref.id !== MAIN_AGENT_ID);
+
+		if (!this.#rowOrder) {
+			// First refresh (usually the constructor): order by status, then recency.
+			this.#rows = refs.sort(
+				(a, b) => STATUS_ORDER[a.status] - STATUS_ORDER[b.status] || b.lastActivity - a.lastActivity,
+			);
+			this.#rowOrder = new Map(this.#rows.map((ref, i) => [ref.id, i]));
+		} else {
+			// After the hub is open, freeze the relative order so keyboard selection
+			// does not jump around as agents heartbeat or update activity. New agents
+			// are appended at the end and then stay put.
+			this.#rows = refs.sort((a, b) => {
+				const statusDiff = STATUS_ORDER[a.status] - STATUS_ORDER[b.status];
+				if (statusDiff !== 0) return statusDiff;
+				const aOrder = this.#rowOrder!.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+				const bOrder = this.#rowOrder!.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+				return aOrder - bOrder;
+			});
+			for (const ref of this.#rows) {
+				if (!this.#rowOrder.has(ref.id)) {
+					this.#rowOrder.set(ref.id, this.#rowOrder.size);
+				}
+			}
+		}
+
 		const keptIndex = selectedId ? this.#rows.findIndex(ref => ref.id === selectedId) : -1;
 		this.#selectedRow = keptIndex >= 0 ? keptIndex : Math.min(this.#selectedRow, Math.max(0, this.#rows.length - 1));
 	}
@@ -1028,8 +1054,8 @@ export class AgentHubOverlayComponent extends Container {
 
 		const hasVisibleAssistantContent = message.content.some(
 			content =>
-				(content.type === "text" && content.text.trim().length > 0) ||
-				(content.type === "thinking" && hasVisibleThinking(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).
@@ -1217,6 +1243,11 @@ export class AgentHubOverlayComponent extends Container {
 			this.#chatLog.addChild(card);
 			return;
 		}
+		if (message.customType === "advisor") {
+			const details = (message as CustomMessage<AdvisorMessageDetails>).details;
+			this.#chatLog.addChild(createAdvisorMessageCard(details, () => this.#chatExpanded, theme));
+			return;
+		}
 		if (message.customType === BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE) {
 			this.#chatLog.addChild(createBackgroundTanDispatchBlock(message as CustomMessage<unknown>));
 			return;

package/src/modes/components/assistant-message.ts

@@ -4,7 +4,7 @@ import type { AssistantThinkingRenderer } from "../../extensibility/extensions/t
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
 import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
-import { getVisibleThinkingText, hasVisibleThinking } from "../../utils/thinking-display";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 
 /**
  * Max lines of a turn-ending provider error rendered inline in the transcript.
@@ -15,6 +15,15 @@ import { getVisibleThinkingText, hasVisibleThinking } from "../../utils/thinking
  */
 const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
+/**
+ * Frames for the streaming "thinking" pulse rendered in place of a hidden
+ * thinking block while the model is still producing it. A single fixed-width
+ * glyph that rises ▁▃▄▃ so the indicator animates without shifting the line.
+ * Advanced every {@link THINKING_DOTS_FRAME_MS}.
+ */
+const THINKING_DOTS_FRAMES = ["▁", "▃", "▄", "▃"] as const;
+const THINKING_DOTS_FRAME_MS = 320;
+
 /**
  * Component that renders a complete assistant message
  */
@@ -50,6 +59,11 @@ export class AssistantMessageComponent extends Container {
 	#fastPathItems:
 		| Array<{ md: Markdown; contentIndex: number; blockType: "text" | "thinking"; lastText: string }>
 		| undefined;
+	/** Live "thinking" pulse shown in place of a hidden thinking block while it
+	 *  streams; undefined when not animating. Driven by {@link #thinkingDotsTimer}. */
+	#thinkingDots: Text | undefined;
+	#thinkingDotsTimer: NodeJS.Timeout | undefined;
+	#thinkingDotsFrame = 0;
 
 	constructor(
 		message?: AssistantMessage,
@@ -87,6 +101,60 @@ export class AssistantMessageComponent extends Container {
 		this.hideThinkingBlock = hide;
 	}
 
+	override dispose(): void {
+		this.#stopThinkingAnimation();
+		super.dispose();
+	}
+
+	/**
+	 * Whether to render the animated "thinking" pulse in place of the suppressed
+	 * reasoning: only while this block is still streaming (not yet finalized — the
+	 * in-flight message always carries `stopReason: "stop"`, so finalization is the
+	 * only reliable live signal), thinking is hidden, no tool call has started, and
+	 * the active tail block is a thinking block (the model is reasoning right now).
+	 * Once text starts, a tool call streams, or the block is sealed, the pulse ends.
+	 */
+	#shouldAnimateThinking(message: AssistantMessage): boolean {
+		if (!this.hideThinkingBlock || this.#transcriptBlockFinalized) return false;
+		let tail: "text" | "thinking" | undefined;
+		for (const content of message.content) {
+			if (content.type === "toolCall") return false;
+			if (content.type === "text" && canonicalizeMessage(content.text)) tail = "text";
+			else if (content.type === "thinking" && canonicalizeMessage(content.thinking)) tail = "thinking";
+		}
+		return tail === "thinking";
+	}
+
+	#thinkingDotsLabel(): string {
+		const glyph = THINKING_DOTS_FRAMES[this.#thinkingDotsFrame % THINKING_DOTS_FRAMES.length] ?? "…";
+		return theme.fg("thinkingText", glyph);
+	}
+
+	#startThinkingAnimation(): void {
+		if (this.#thinkingDotsTimer) return;
+		this.#thinkingDotsTimer = setInterval(() => this.#advanceThinkingDots(), THINKING_DOTS_FRAME_MS);
+		this.#thinkingDotsTimer.unref?.();
+	}
+
+	#advanceThinkingDots(): void {
+		if (!this.#thinkingDots) {
+			this.#stopThinkingAnimation();
+			return;
+		}
+		this.#thinkingDotsFrame = (this.#thinkingDotsFrame + 1) % THINKING_DOTS_FRAMES.length;
+		if (this.#thinkingDots.setText(this.#thinkingDotsLabel())) {
+			this.onImageUpdate?.();
+		}
+	}
+
+	#stopThinkingAnimation(): void {
+		if (this.#thinkingDotsTimer) {
+			clearInterval(this.#thinkingDotsTimer);
+			this.#thinkingDotsTimer = undefined;
+		}
+		this.#thinkingDotsFrame = 0;
+	}
+
 	/**
 	 * Toggle suppression of the inline `Error: …` line while the same error is
 	 * pinned in the banner above the editor. Re-renders so the change is visible.
@@ -109,6 +177,14 @@ export class AssistantMessageComponent extends Container {
 
 	markTranscriptBlockFinalized(): void {
 		this.#transcriptBlockFinalized = true;
+		this.#stopThinkingAnimation();
+		// If the live pulse was on screen when the block sealed, drop the fast path
+		// and rebuild so the placeholder is removed — finalized blocks never animate.
+		if (this.#thinkingDots) {
+			this.#fastPathKey = undefined;
+			this.#fastPathItems = undefined;
+			if (this.#lastMessage) this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
+		}
 	}
 
 	/**
@@ -232,9 +308,10 @@ export class AssistantMessageComponent extends Container {
 		const parts: string[] = [`htb:${this.hideThinkingBlock ? 1 : 0}`];
 		for (const content of message.content) {
 			if (content.type === "text") {
-				parts.push(content.text.trim() ? "T1" : "T0");
+				parts.push(canonicalizeMessage(content.text) ? "T1" : "T0");
 			} else if (content.type === "thinking") {
-				if (!hasVisibleThinking(content)) parts.push("K0");
+				const canon = canonicalizeMessage(content.thinking);
+				if (!canon) parts.push("K0");
 				else if (this.hideThinkingBlock) parts.push("KH");
 				else parts.push("KV");
 			} else {
@@ -267,7 +344,8 @@ export class AssistantMessageComponent extends Container {
 			for (const item of this.#fastPathItems) {
 				if (item.blockType === "thinking") {
 					const content = message.content[item.contentIndex];
-					if (content?.type === "thinking" && getVisibleThinkingText(content) !== item.lastText) return false;
+					if (content?.type === "thinking" && canonicalizeMessage(content.thinking) !== item.lastText)
+						return false;
 				}
 			}
 		}
@@ -291,13 +369,17 @@ export class AssistantMessageComponent extends Container {
 		for (const item of this.#fastPathItems) {
 			item.md.transientRenderCache = transient;
 			const content = message.content[item.contentIndex];
+			if (!content) {
+				this.#fastPathKey = undefined;
+				this.#fastPathItems = undefined;
+				return false;
+			}
 			let newText: string;
-			if (item.blockType === "text" && content?.type === "text") {
+			if (item.blockType === "text" && content.type === "text") {
 				newText = content.text.trim();
-			} else if (item.blockType === "thinking" && content?.type === "thinking") {
-				newText = getVisibleThinkingText(content);
+			} else if (item.blockType === "thinking" && content.type === "thinking") {
+				newText = canonicalizeMessage(content.thinking);
 			} else {
-				// Block at this index is gone or changed type (index shift) — fail closed.
 				this.#fastPathKey = undefined;
 				this.#fastPathItems = undefined;
 				return false;
@@ -320,6 +402,7 @@ export class AssistantMessageComponent extends Container {
 
 		// Clear content container
 		this.#contentContainer.clear();
+		this.#thinkingDots = undefined;
 
 		// Determine if we should capture Markdown instances for next fast path
 		const shouldCapture = this.#canFastPath(message);
@@ -329,24 +412,23 @@ export class AssistantMessageComponent extends Container {
 
 		const hasVisibleContent = message.content.some(
 			c =>
-				(c.type === "text" && c.text.trim()) ||
-				(!this.hideThinkingBlock && c.type === "thinking" && hasVisibleThinking(c)),
+				(c.type === "text" && canonicalizeMessage(c.text)) ||
+				(!this.hideThinkingBlock && c.type === "thinking" && canonicalizeMessage(c.thinking)),
 		);
 
 		// Render content in order
 		let thinkingIndex = 0;
 		for (let i = 0; i < message.content.length; i++) {
 			const content = message.content[i];
-			if (content.type === "text" && content.text.trim()) {
-				// Assistant text messages with no background - trim the text
+			if (content.type === "text" && canonicalizeMessage(content.text)) {
 				// Set paddingY=0 to avoid extra spacing before tool executions
 				const trimmed = content.text.trim();
 				const md = new Markdown(trimmed, 1, 0, getMarkdownTheme());
 				md.transientRenderCache = this.#lastUpdateTransient;
 				this.#contentContainer.addChild(md);
 				captureItems?.push({ md, contentIndex: i, blockType: "text", lastText: trimmed });
-			} else if (content.type === "thinking" && hasVisibleThinking(content)) {
-				const thinkingText = getVisibleThinkingText(content);
+			} else if (content.type === "thinking" && canonicalizeMessage(content.thinking)) {
+				const thinkingText = canonicalizeMessage(content.thinking);
 				if (this.hideThinkingBlock) {
 					thinkingIndex += 1;
 					continue;
@@ -355,7 +437,11 @@ export class AssistantMessageComponent extends Container {
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
 				const hasVisibleContentAfter = message.content
 					.slice(i + 1)
-					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && hasVisibleThinking(c)));
+					.some(
+						c =>
+							(c.type === "text" && canonicalizeMessage(c.text)) ||
+							(c.type === "thinking" && canonicalizeMessage(c.thinking)),
+					);
 
 				// Thinking traces in thinkingText color, italic
 				const md = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
@@ -373,6 +459,15 @@ export class AssistantMessageComponent extends Container {
 			}
 		}
 
+		if (this.#shouldAnimateThinking(message)) {
+			if (hasVisibleContent) this.#contentContainer.addChild(new Spacer(1));
+			this.#thinkingDots = new Text(this.#thinkingDotsLabel(), 1, 0);
+			this.#contentContainer.addChild(this.#thinkingDots);
+			this.#startThinkingAnimation();
+		} else {
+			this.#stopThinkingAnimation();
+		}
+
 		this.#renderToolImages();
 		// Check if aborted - show after partial content
 		// But only if there are no tool calls (tool execution components will show the error)

package/src/modes/components/snapcompact-shape-preview-doc.md

@@ -1,8 +1,8 @@
 [User]: Fix the settings overlay crash. Wheeling past the last row throws.
 
-[Assistant tool calls]: read(path="src/select-list.ts:140-180")
+[Tool Call]: read(path="src/select-list.ts:140-180")
 
-[Tool result]: 162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
+[Tool Result]: 162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
 
 [Assistant]: Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
 

package/src/modes/components/snapcompact-shape-preview.ts

@@ -38,10 +38,10 @@ const ZOOM_SCALE = 4;
 const MAX_IMAGE_COLS = 28;
 const MAX_IMAGE_ROWS = 14;
 
-/** Sample transcript with `[Tool result]:` bodies wrapped in dim-ink toggles. */
+/** Sample transcript with `[Tool Result]:` bodies wrapped in dim-ink toggles. */
 const PREVIEW_TEXT = sampleDoc
 	.trim()
-	.replace(/\[Tool result\]: ([^[]*)/g, (_match, body: string) => `[Tool result]: ${DIM_ON}${body}${DIM_OFF}`);
+	.replace(/\[Tool Result\]: ([^[]*)/g, (_match, body: string) => `[Tool Result]: ${DIM_ON}${body}${DIM_OFF}`);
 
 type PreviewEntry =
 	| { state: "rendering" }

package/src/modes/components/status-line/segments.ts

@@ -86,32 +86,45 @@ const modelSegment: StatusLineSegment = {
 			modelName = modelName.slice(7);
 		}
 
-		let content = withIcon(theme.icon.model, modelName);
-
+		// Fast-mode icon and thinking-level suffix trail the model name and are
+		// colored together with it as `statusLineModel`. The advisor "++" badge
+		// sits between the name and that tail in `accent`, so it reads as a
+		// distinct marker. theme.fg resets only the fg, so the spans are
+		// concatenated (not nested) to keep each color intact.
+		let tail = "";
 		if (ctx.session.isFastModeActive() && theme.icon.fast) {
-			content += ` ${theme.icon.fast}`;
+			tail += ` ${theme.icon.fast}`;
 		}
 
-		// Add thinking level with dot separator
 		if (opts.showThinkingLevel !== false && state.model?.thinking) {
 			if (ctx.session.isAutoThinking) {
 				// Pending (no turn classified yet / classifying) shows a symbol-theme
 				// question-box marker; once resolved it shows `<level>`.
 				const resolved = ctx.session.autoResolvedThinkingLevel();
 				const resolvedText = resolved ? (theme.thinking[resolved as keyof typeof theme.thinking] ?? resolved) : "";
-				content += `${theme.sep.dot}${resolved ? resolvedText : `${theme.thinking.autoPending} auto`}`;
+				tail += `${theme.sep.dot}${resolved ? resolvedText : `${theme.thinking.autoPending} auto`}`;
 			} else {
 				const level = state.thinkingLevel ?? ThinkingLevel.Off;
 				if (level !== ThinkingLevel.Off) {
 					const thinkingText = theme.thinking[level as keyof typeof theme.thinking];
 					if (thinkingText) {
-						content += `${theme.sep.dot}${thinkingText}`;
+						tail += `${theme.sep.dot}${thinkingText}`;
 					}
 				}
 			}
 		}
 
-		return { content: theme.fg("statusLineModel", content), visible: true };
+		// `statusLineModel` is aliased to `accent` in many themes, so the badge
+		// uses `success` to stay visibly distinct from the model name color.
+		let content = theme.fg("statusLineModel", withIcon(theme.icon.model, modelName));
+		if (ctx.session.isAdvisorActive()) {
+			content += theme.fg("success", "++");
+		}
+		if (tail) {
+			content += theme.fg("statusLineModel", tail);
+		}
+
+		return { content, visible: true };
 	},
 };
 

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

@@ -18,6 +18,7 @@ import { matchesAppInterrupt, matchesSelectDown, matchesSelectUp } from "../../m
 import type { SessionTreeNode } from "../../session/session-entries";
 import { shortenPath } from "../../tools/render-utils";
 import { toPathList } from "../../tools/search";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 import { DynamicBorder } from "./dynamic-border";
 
 /** Gutter info: position (displayIndent where connector was) and whether to show │ */
@@ -702,12 +703,12 @@ class TreeList implements Component {
 	}
 
 	#hasTextContent(content: unknown): boolean {
-		if (typeof content === "string") return content.trim().length > 0;
+		if (typeof content === "string") return Boolean(canonicalizeMessage(content));
 		if (Array.isArray(content)) {
 			for (const c of content) {
 				if (typeof c === "object" && c !== null && "type" in c && c.type === "text") {
 					const text = (c as { text?: string }).text;
-					if (text && text.trim().length > 0) return true;
+					if (text && canonicalizeMessage(text)) return true;
 				}
 			}
 		}