@oh-my-pi/pi-coding-agent 16.1.7 → 16.1.9

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);

package/src/modes/interactive-mode.ts

@@ -70,7 +70,12 @@ import type { Goal, GoalModeState } from "../goals/state";
 import { resolveLocalUrlToPath } from "../internal-urls";
 import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "../lsp/startup-events";
 import type { MCPManager } from "../mcp";
-import { formatMCPConnectingMessage, isMcpConnectingEvent, MCP_CONNECTING_EVENT_CHANNEL } from "../mcp/startup-events";
+import {
+	formatMCPConnectionStatusMessage,
+	isMcpConnectionStatusEvent,
+	MCP_CONNECTION_STATUS_EVENT_CHANNEL,
+	type McpConnectionStatusEvent,
+} from "../mcp/startup-events";
 import {
 	humanizePlanTitle,
 	type PlanApprovalDetails,
@@ -88,7 +93,7 @@ import type { SessionContext } from "../session/session-context";
 import { getRecentSessions } from "../session/session-listing";
 import type { SessionManager } from "../session/session-manager";
 import type { ShakeMode } from "../session/shake-types";
-import { BUILTIN_SLASH_COMMAND_RESERVED_NAMES, BUILTIN_SLASH_COMMANDS } from "../slash-commands/builtin-registry";
+import { BUILTIN_SLASH_COMMAND_RESERVED_NAMES, buildTuiBuiltinSlashCommands } from "../slash-commands/builtin-registry";
 import { formatDuration } from "../slash-commands/helpers/format";
 import { STTController, type SttState } from "../stt";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "../system-prompt";
@@ -401,6 +406,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#modelCycleClearTimer: NodeJS.Timeout | undefined;
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
+	proseOnlyThinking = true;
 	pendingImages: ImageContent[] = [];
 	pendingImageLinks: (string | undefined)[] = [];
 	compactionQueuedMessages: CompactionQueuedMessage[] = [];
@@ -506,6 +512,14 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.loadingAnimation.stop();
 			this.loadingAnimation = undefined;
 		}
+		if (this.autoCompactionLoader) {
+			this.autoCompactionLoader.stop();
+			this.autoCompactionLoader = undefined;
+		}
+		if (this.retryLoader) {
+			this.retryLoader.stop();
+			this.retryLoader = undefined;
+		}
 		this.statusContainer.clear();
 		this.pendingMessagesContainer.clear();
 		this.#cancelModelCycleClearTimer();
@@ -526,6 +540,10 @@ export class InteractiveMode implements InteractiveModeContext {
 	#observerRegistry: SessionObserverRegistry;
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
+	#mcpStatusOrder: string[] = [];
+	#mcpPendingServers = new Set<string>();
+	#mcpConnectedServers = new Set<string>();
+	#mcpFailedServers = new Map<string, string>();
 	#welcomeComponent?: WelcomeComponent;
 	readonly #chatHost: ChatBlockHost = { requestRender: () => this.ui.requestRender() };
 
@@ -559,13 +577,12 @@ export class InteractiveMode implements InteractiveModeContext {
 				}),
 			);
 			this.#eventBusUnsubscribers.push(
-				eventBus.on(MCP_CONNECTING_EVENT_CHANNEL, data => {
-					if (!isMcpConnectingEvent(data)) {
-						logger.warn("Ignoring malformed mcp:connecting event", { data });
+				eventBus.on(MCP_CONNECTION_STATUS_EVENT_CHANNEL, data => {
+					if (!isMcpConnectionStatusEvent(data)) {
+						logger.warn("Ignoring malformed mcp:connection-status event", { data });
 						return;
 					}
-					if (this.settings.get("startup.quiet")) return;
-					this.showStatus(formatMCPConnectingMessage(data.serverNames));
+					this.#handleMcpConnectionStatusEvent(data);
 				}),
 			);
 		}
@@ -618,6 +635,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.statusLine.setAutoCompactEnabled(session.autoCompactionEnabled);
 
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");
+		this.proseOnlyThinking = settings.get("proseOnlyThinking");
 
 		const hookCommands: SlashCommand[] = (
 			this.session.extensionRunner?.getRegisteredCommands(BUILTIN_SLASH_COMMAND_RESERVED_NAMES) ?? []
@@ -643,8 +661,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			}
 		}
 
+		const builtinCommands = buildTuiBuiltinSlashCommands({ ctx: this });
 		// Store pending commands for init() where file commands are loaded async
-		this.#pendingSlashCommands = [...BUILTIN_SLASH_COMMANDS, ...hookCommands, ...customCommands, ...skillCommandList];
+		this.#pendingSlashCommands = [...builtinCommands, ...hookCommands, ...customCommands, ...skillCommandList];
 
 		this.#uiHelpers = new UiHelpers(this);
 		this.#btwController = new BtwController(this);
@@ -660,6 +679,54 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#observerRegistry = new SessionObserverRegistry();
 	}
 
+	#handleMcpConnectionStatusEvent(event: McpConnectionStatusEvent): void {
+		if (this.settings.get("startup.quiet")) return;
+		if (event.type === "connecting") {
+			this.#mcpStatusOrder = [];
+			this.#mcpPendingServers.clear();
+			this.#mcpConnectedServers.clear();
+			this.#mcpFailedServers.clear();
+			for (const serverName of event.serverNames) {
+				this.#trackMcpStatusServer(serverName);
+				this.#mcpPendingServers.add(serverName);
+			}
+		} else if (event.type === "connected") {
+			this.#trackMcpStatusServer(event.serverName);
+			this.#mcpPendingServers.delete(event.serverName);
+			this.#mcpFailedServers.delete(event.serverName);
+			this.#mcpConnectedServers.add(event.serverName);
+		} else {
+			this.#trackMcpStatusServer(event.serverName);
+			this.#mcpPendingServers.delete(event.serverName);
+			this.#mcpConnectedServers.delete(event.serverName);
+			this.#mcpFailedServers.set(event.serverName, event.error);
+		}
+
+		const message = formatMCPConnectionStatusMessage({
+			pendingServers: this.#orderedMcpStatusServers(this.#mcpPendingServers),
+			connectedServers: this.#orderedMcpStatusServers(this.#mcpConnectedServers),
+			failedServers: this.#orderedMcpStatusFailures(),
+		});
+		if (message) this.showStatus(message);
+	}
+
+	#trackMcpStatusServer(serverName: string): void {
+		if (!this.#mcpStatusOrder.includes(serverName)) {
+			this.#mcpStatusOrder.push(serverName);
+		}
+	}
+
+	#orderedMcpStatusServers(servers: ReadonlySet<string>): string[] {
+		return this.#mcpStatusOrder.filter(serverName => servers.has(serverName));
+	}
+
+	#orderedMcpStatusFailures(): Array<{ serverName: string; error: string }> {
+		return this.#mcpStatusOrder.flatMap(serverName => {
+			const error = this.#mcpFailedServers.get(serverName);
+			return error === undefined ? [] : [{ serverName, error }];
+		});
+	}
+
 	playWelcomeIntro(): void {
 		const welcome = this.#welcomeComponent;
 		// Component-scoped: the intro only mutates the welcome box's own rows,
@@ -3424,7 +3491,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleExportCommand(text);
 	}
 
-	handleDumpCommand() {
+	async handleDumpCommand(): Promise<void> {
 		return this.#commandController.handleDumpCommand();
 	}
 
@@ -3769,6 +3836,14 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#btwController.handleBranch();
 	}
 
+	canCopyBtw(): boolean {
+		return this.#btwController.canCopy();
+	}
+
+	handleBtwCopyKey(): Promise<boolean> {
+		return this.#btwController.handleCopy();
+	}
+
 	async handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void> {
 		try {
 			const result = await this.session.branchFromBtw(question, assistantMessage);

package/src/modes/types.ts

@@ -148,6 +148,7 @@ export interface InteractiveModeContext {
 	loopLimit?: LoopLimitRuntime;
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
+	proseOnlyThinking: boolean;
 	pendingImages: ImageContent[];
 	pendingImageLinks: (string | undefined)[];
 	compactionQueuedMessages: CompactionQueuedMessage[];
@@ -289,7 +290,7 @@ export interface InteractiveModeContext {
 	handleHotkeysCommand(): void;
 	handleToolsCommand(): void;
 	handleContextCommand(): void;
-	handleDumpCommand(): void;
+	handleDumpCommand(): Promise<void>;
 	handleAdvisorDumpCommand(isRaw?: boolean): void;
 	handleDebugTranscriptCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
@@ -348,6 +349,8 @@ export interface InteractiveModeContext {
 	handleBtwEscape(): boolean;
 	handleBtwBranchKey(): Promise<boolean>;
 	canBranchBtw(): boolean;
+	canCopyBtw(): boolean;
+	handleBtwCopyKey(): Promise<boolean>;
 	handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
 	handleOmfgCommand(complaint: string): Promise<void>;
 	hasActiveOmfg(): boolean;

package/src/modes/utils/ui-helpers.ts

@@ -332,6 +332,7 @@ export class UiHelpers {
 					() => this.ctx.ui.requestRender(),
 					this.ctx.viewSession.extensionRunner?.getAssistantThinkingRenderers(),
 					this.ctx.ui.imageBudget,
+					this.ctx.proseOnlyThinking,
 				);
 				this.ctx.chatContainer.addChild(assistantComponent);
 				break;

package/src/prompts/advisor/system.md

@@ -24,7 +24,7 @@ Keep exploration lean:
 - Offer alternatives, not lectures.
 - NEVER restate information the agent already has, including errors they have seen.
 - Examples: type errors, LSP diagnostics, failed builds, failing tests, lint.
-- NEVER repeat advice you already gave.
+- NEVER repeat advice you already gave, and NEVER send the same advice twice.
 - NEVER nitpick about things user stated they are okay with. You are the advocate for the user.
 </communication>
 

package/src/prompts/system/side-channel-no-tools.md

@@ -0,0 +1,3 @@
+<system-reminder>
+This is an ephemeral side-channel turn that reuses the current conversation's context. The tool catalog stays attached only to keep the prompt cache warm — tools are NOT available on this turn. Do NOT emit any tool call; reply with plain text only. Any tool call you produce is discarded without executing.
+</system-reminder>

package/src/sdk.ts

@@ -87,7 +87,7 @@ import {
 	type MCPToolsLoadResult,
 	parseMCPToolName,
 } from "./mcp";
-import { MCP_CONNECTING_EVENT_CHANNEL, type McpConnectingEvent } from "./mcp/startup-events";
+import { MCP_CONNECTION_STATUS_EVENT_CHANNEL, type McpConnectionStatusEvent } from "./mcp/startup-events";
 import { createSessionMemoryRuntimeContext, resolveMemoryBackend } from "./memory-backend";
 import type { MnemopiSessionState } from "./mnemopi/state";
 import asyncResultTemplate from "./prompts/tools/async-result.md" with { type: "text" };
@@ -805,6 +805,7 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<BuildSystemPromptResult> {
+	const toolMap = options.tools ? new Map(options.tools.map(tool => [tool.name, tool])) : undefined;
 	return await buildSystemPromptInternal({
 		cwd: options.cwd,
 		customPrompt: options.customPrompt,
@@ -812,6 +813,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		contextFiles: options.contextFiles,
 		appendSystemPrompt: options.appendPrompt,
 		inlineToolDescriptors: options.inlineToolDescriptors,
+		toolNames: options.tools?.map(tool => tool.name),
+		tools: toolMap ? buildSystemPromptToolMetadata(toolMap) : undefined,
 	});
 }
 
@@ -1617,12 +1620,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			| ((liveSession: AgentSession, activation: DeferredMCPActivation) => void)
 			| undefined;
 		const startupQuiet = settings.get("startup.quiet");
-		const onMCPConnecting = (serverNames: string[]) => {
-			if (!options.hasUI || startupQuiet || serverNames.length === 0) return;
-			eventBus.emit(MCP_CONNECTING_EVENT_CHANNEL, { serverNames } satisfies McpConnectingEvent);
+		const onMCPStatus = (event: McpConnectionStatusEvent) => {
+			if (!options.hasUI || startupQuiet) return;
+			if (event.type === "connecting" && event.serverNames.length === 0) return;
+			eventBus.emit(MCP_CONNECTION_STATUS_EVENT_CHANNEL, event);
 		};
 		const mcpDiscoverOptions = {
-			onConnecting: onMCPConnecting,
+			onStatus: onMCPStatus,
 			enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
 			// Always filter Exa - we have native integration
 			filterExa: true,
@@ -2412,9 +2416,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				: undefined;
 		const transformProviderContext =
 			obfuscator || snapcompactInline
-				? (context: Context, transformModel: Model): Context => {
+				? async (context: Context, transformModel: Model): Promise<Context> => {
 						let transformed = obfuscator ? obfuscateProviderContext(obfuscator, context) : context;
-						if (snapcompactInline) transformed = snapcompactInline.transform(transformed, transformModel);
+						if (snapcompactInline) transformed = await snapcompactInline.transform(transformed, transformModel);
 						return transformed;
 					}
 				: undefined;
@@ -2474,7 +2478,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			presencePenalty: settings.get("presencePenalty") >= 0 ? settings.get("presencePenalty") : undefined,
 			repetitionPenalty: settings.get("repetitionPenalty") >= 0 ? settings.get("repetitionPenalty") : undefined,
 			serviceTier: initialServiceTier,
-			hideThinkingSummary: settings.get("hideThinkingBlock"),
+			hideThinkingSummary: settings.get("omitThinking"),
 			kimiApiFormat: settings.get("providers.kimiApiFormat") ?? "anthropic",
 			preferWebsockets: preferOpenAICodexWebsockets,
 			getToolContext: tc => toolContextStore.getContext(tc),