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

package/src/internal-urls/filesystem-resource.ts

@@ -0,0 +1,34 @@
+import * as fs from "node:fs/promises";
+import type { InternalResource } from "./types";
+
+/**
+ * Builds a text resource for a filesystem directory resolved by an internal URL handler.
+ *
+ * The resource is flagged immutable so the read tool never mints hashline edit
+ * anchors against a directory listing — only file resources from the same
+ * handler stay editable.
+ */
+export async function buildDirectoryResource(
+	url: string,
+	directoryPath: string,
+	notes?: string[],
+): Promise<InternalResource> {
+	const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+	entries.sort((a, b) => {
+		const directoryOrder = Number(b.isDirectory()) - Number(a.isDirectory());
+		return directoryOrder || a.name.localeCompare(b.name);
+	});
+	const content =
+		entries.length === 0
+			? "(empty directory)"
+			: entries.map(e => `${e.name}${e.isDirectory() ? "/" : ""}`).join("\n");
+	return {
+		url,
+		content,
+		contentType: "text/plain",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: directoryPath,
+		immutable: true,
+		...(notes ? { notes } : {}),
+	};
+}

package/src/internal-urls/local-protocol.ts

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { AgentRegistry } from "../registry/agent-registry";
+import { buildDirectoryResource } from "./filesystem-resource";
 import { parseInternalUrl } from "./parse";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
@@ -279,8 +280,13 @@ export class LocalProtocolHandler implements ProtocolHandler {
 		ensureWithinRoot(realTargetPath, resolvedRoot);
 
 		const stat = await fs.stat(realTargetPath);
+		if (stat.isDirectory()) {
+			return buildDirectoryResource(url.href, realTargetPath, [
+				"Use write path local://<file> to persist large intermediate artifacts across turns.",
+			]);
+		}
 		if (!stat.isFile()) {
-			throw new Error(`local:// URL must resolve to a file: ${url.href}`);
+			throw new Error(`local:// URL must resolve to a file or directory: ${url.href}`);
 		}
 
 		const content = await Bun.file(realTargetPath).text();

package/src/internal-urls/memory-protocol.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
 import { getMemoryRoot } from "../memories";
 import { AgentRegistry } from "../registry/agent-registry";
+import { buildDirectoryResource } from "./filesystem-resource";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
@@ -102,8 +103,11 @@ async function tryResolveInRoot(url: InternalUrl, memoryRoot: string): Promise<I
 	ensureWithinRoot(realTargetPath, resolvedRoot);
 
 	const stat = await fs.stat(realTargetPath);
+	if (stat.isDirectory()) {
+		return buildDirectoryResource(url.href, realTargetPath);
+	}
 	if (!stat.isFile()) {
-		throw new Error(`memory:// URL must resolve to a file: ${url.href}`);
+		throw new Error(`memory:// URL must resolve to a file or directory: ${url.href}`);
 	}
 
 	const content = await Bun.file(realTargetPath).text();

package/src/internal-urls/skill-protocol.ts

@@ -7,8 +7,12 @@
  * - skill://<name> - Reads SKILL.md
  * - skill://<name>/<path> - Reads relative path within skill's baseDir
  */
+import type * as fsTypes from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import { getActiveSkills } from "../extensibility/skills";
+import { buildDirectoryResource } from "./filesystem-resource";
 import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
@@ -71,12 +75,24 @@ export class SkillProtocolHandler implements ProtocolHandler {
 			targetPath = skill.filePath;
 		}
 
-		const file = Bun.file(targetPath);
-		if (!(await file.exists())) {
-			throw new Error(`File not found: ${targetPath}`);
+		let stats: fsTypes.Stats;
+		try {
+			stats = await fs.stat(targetPath);
+		} catch (error) {
+			if (isEnoent(error)) {
+				throw new Error(`File not found: ${targetPath}`);
+			}
+			throw error;
+		}
+
+		if (stats.isDirectory()) {
+			return buildDirectoryResource(url.href, targetPath);
+		}
+		if (!stats.isFile()) {
+			throw new Error(`skill:// URL must resolve to a file or directory: ${url.href}`);
 		}
 
-		const content = await file.text();
+		const content = await Bun.file(targetPath).text();
 		return {
 			url: url.href,
 			content,

package/src/internal-urls/vault-protocol.ts

@@ -822,7 +822,7 @@ export class VaultProtocolHandler implements ProtocolHandler {
 	}
 
 	async #listDir(
-		parsed: Extract<ParsedVaultUrl, { kind: "fs-dir" }>,
+		parsed: Extract<ParsedVaultUrl, { kind: "fs-dir" | "fs-file" }>,
 		context?: ResolveContext,
 	): Promise<InternalResource> {
 		const { root, targetPath } = await this.#resolveFsTarget(parsed, context);
@@ -878,8 +878,11 @@ export class VaultProtocolHandler implements ProtocolHandler {
 		}
 		ensureWithinRoot(realTargetPath, root);
 		const stat = await fs.promises.stat(realTargetPath);
+		if (stat.isDirectory()) {
+			return this.#listDir(parsed, context);
+		}
 		if (!stat.isFile()) {
-			throw new Error(`vault:// URL must resolve to a file: ${parsed.url}`);
+			throw new Error(`vault:// URL must resolve to a file or directory: ${parsed.url}`);
 		}
 
 		const content = await Bun.file(realTargetPath).text();

package/src/main.ts

@@ -1056,11 +1056,11 @@ export async function runRootCommand(
 	}
 
 	// --print-thoughts (single-shot print mode) must surface reasoning, so un-hide
-	// thinking before the session is built — otherwise a passive hideThinkingBlock
+	// thinking before the session is built — otherwise a passive omitThinking
 	// setting makes the provider omit summaries and the flag prints nothing. An
-	// explicit --hide-thinking below still wins.
+	// explicit --hide-thinking block display option still wins for output display.
 	if (parsedArgs.printThoughts && !isProtocolMode && !isInteractive) {
-		settingsInstance.override("hideThinkingBlock", false);
+		settingsInstance.override("omitThinking", false);
 	}
 	// Apply --hide-thinking CLI flag (ephemeral, not persisted)
 	if (parsedArgs.hideThinking) {
@@ -1130,21 +1130,21 @@ export async function runRootCommand(
 	if (parsedArgs.resume === true && !parsedArgs.fork) {
 		const folderSessions = await logger.time("SessionManager.list", SessionManager.list, cwd, parsedArgs.sessionDir);
 		let preloadedAllSessions: SessionInfo[] | undefined;
-		let startInAllScope = false;
 		if (folderSessions.length === 0) {
-			// Nothing in the current folder — fall back to a global scan so the
-			// picker can still open in all-projects scope instead of dead-ending.
+			// Probe globally so we can exit fast when the user has no sessions at
+			// all, but never auto-switch the picker into all-projects scope — that
+			// silently surfaced other projects' history when the cwd was empty
+			// (issue #3099). The preloaded list also makes the user's Tab switch
+			// instant on the way in.
 			preloadedAllSessions = await logger.time("SessionManager.listAll", SessionManager.listAll);
 			if (preloadedAllSessions.length === 0) {
 				writeStartupNotice(parsedArgs, `${chalk.dim("No sessions found")}\n`);
 				return;
 			}
-			startInAllScope = true;
 		}
 		pauseStartupWatchdog();
 		const selected = await logger.time("selectSession", selectSession, folderSessions, {
 			allSessions: preloadedAllSessions,
-			startInAllScope,
 		});
 		resumeStartupWatchdog();
 		if (!selected) {

package/src/mcp/loader.ts

@@ -8,6 +8,7 @@ import type { LoadedCustomTool } from "../extensibility/custom-tools/types";
 import { AgentStorage } from "../session/agent-storage";
 import type { AuthStorage } from "../session/auth-storage";
 import { type MCPLoadResult, MCPManager } from "./manager";
+import type { McpConnectionStatusEvent } from "./startup-events";
 import { MCPToolCache } from "./tool-cache";
 
 /** Result from loading MCP tools */
@@ -26,8 +27,8 @@ export interface MCPToolsLoadResult {
 
 /** Options for loading MCP tools */
 export interface MCPToolsLoadOptions {
-	/** Called when starting to connect to servers */
-	onConnecting?: (serverNames: string[]) => void;
+	/** Called when MCP server connection state changes. */
+	onStatus?: (event: McpConnectionStatusEvent) => void;
 	/** Whether to load project-level config (default: true) */
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
@@ -68,7 +69,7 @@ export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoa
 	let result: MCPLoadResult;
 	try {
 		result = await manager.discoverAndConnect({
-			onConnecting: options?.onConnecting,
+			onStatus: options?.onStatus,
 			enableProjectConfig: options?.enableProjectConfig,
 			filterExa: options?.filterExa,
 			filterBrowser: options?.filterBrowser,

package/src/mcp/manager.ts

@@ -26,13 +26,14 @@ import {
 	subscribeToResources,
 	unsubscribeFromResources,
 } from "./client";
-import { loadAllMCPConfigs, validateServerConfig } from "./config";
+import { type LoadMCPConfigsResult, loadAllMCPConfigs, validateServerConfig } from "./config";
 import {
 	lookupMcpOAuthCredential,
 	type MCPOAuthCredentialLookup,
 	selectMcpOAuthRefreshMaterial,
 } from "./oauth-credentials";
 import { type MCPStoredOAuthCredential, refreshMCPOAuthToken } from "./oauth-flow";
+import type { McpConnectionStatusEvent } from "./startup-events";
 import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
@@ -148,8 +149,8 @@ export interface MCPDiscoverOptions {
 	filterExa?: boolean;
 	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
 	filterBrowser?: boolean;
-	/** Called when starting to connect to servers */
-	onConnecting?: (serverNames: string[]) => void;
+	/** Called when MCP server connection state changes. */
+	onStatus?: (event: McpConnectionStatusEvent) => void;
 }
 
 /**
@@ -309,12 +310,20 @@ export class MCPManager {
 	 * Returns tools and any connection errors.
 	 */
 	async discoverAndConnect(options?: MCPDiscoverOptions): Promise<MCPLoadResult> {
-		const { configs, exaApiKeys, sources } = await loadAllMCPConfigs(this.cwd, {
-			enableProjectConfig: options?.enableProjectConfig,
-			filterExa: options?.filterExa,
-			filterBrowser: options?.filterBrowser,
-		});
-		const result = await this.connectServers(configs, sources, options?.onConnecting);
+		let loadedConfigs: LoadMCPConfigsResult;
+		try {
+			loadedConfigs = await loadAllMCPConfigs(this.cwd, {
+				enableProjectConfig: options?.enableProjectConfig,
+				filterExa: options?.filterExa,
+				filterBrowser: options?.filterBrowser,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			options?.onStatus?.({ type: "failed", serverName: ".mcp.json", error: message });
+			throw error;
+		}
+		const { configs, exaApiKeys, sources } = loadedConfigs;
+		const result = await this.connectServers(configs, sources, options?.onStatus);
 		result.exaApiKeys = exaApiKeys;
 		return result;
 	}
@@ -326,7 +335,7 @@ export class MCPManager {
 	async connectServers(
 		configs: Record<string, MCPServerConfig>,
 		sources: Record<string, SourceMeta>,
-		onConnecting?: (serverNames: string[]) => void,
+		onStatus?: (event: McpConnectionStatusEvent) => void,
 	): Promise<MCPLoadResult> {
 		type ConnectionTask = {
 			name: string;
@@ -340,6 +349,8 @@ export class MCPManager {
 		const allTools: CustomTool<TSchema, MCPToolDetails>[] = [];
 		const reportedErrors = new Set<string>();
 		let allowBackgroundLogging = false;
+		const statusServerNames: string[] = [];
+		const validationFailures: Array<{ name: string; message: string }> = [];
 
 		// Prepare connection tasks
 		const connectionTasks: ConnectionTask[] = [];
@@ -367,10 +378,14 @@ export class MCPManager {
 				continue;
 			}
 
+			statusServerNames.push(name);
+
 			// Validate config
 			const validationErrors = validateServerConfig(name, config);
 			if (validationErrors.length > 0) {
-				errors.set(name, validationErrors.join("; "));
+				const message = validationErrors.join("; ");
+				errors.set(name, message);
+				validationFailures.push({ name, message });
 				reportedErrors.add(name);
 				continue;
 			}
@@ -458,20 +473,25 @@ export class MCPManager {
 					this.#onToolsChanged?.(this.#tools);
 					void this.toolCache?.set(name, config, serverTools);
 
+					onStatus?.({ type: "connected", serverName: name });
 					await this.#loadServerResourcesAndPrompts(name, connection);
 				})
 				.catch(error => {
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
 					this.#pendingToolLoads.delete(name);
-					if (!allowBackgroundLogging || reportedErrors.has(name)) return;
 					const message = error instanceof Error ? error.message : String(error);
+					onStatus?.({ type: "failed", serverName: name, error: message });
+					if (!allowBackgroundLogging || reportedErrors.has(name)) return;
 					logger.error("MCP tool load failed", { path: `mcp:${name}`, error: message });
 				});
 		}
 
-		// Notify about servers we're connecting to
-		if (connectionTasks.length > 0 && onConnecting) {
-			onConnecting(connectionTasks.map(task => task.name));
+		// Notify about servers we're connecting to, including configs that fail fast.
+		if (statusServerNames.length > 0 && onStatus) {
+			onStatus({ type: "connecting", serverNames: statusServerNames });
+			for (const { name, message } of validationFailures) {
+				onStatus({ type: "failed", serverName: name, error: message });
+			}
 		}
 
 		if (connectionTasks.length > 0) {

package/src/mcp/startup-events.ts

@@ -1,9 +1,99 @@
-export const MCP_CONNECTING_EVENT_CHANNEL = "mcp:connecting";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { replaceTabs, shortenPath, TRUNCATE_LENGTHS, truncateToWidth } from "../tools/render-utils";
 
-export type McpConnectingEvent = { serverNames: string[] };
+export const MCP_CONNECTION_STATUS_EVENT_CHANNEL = "mcp:connection-status";
 
-export function formatMCPConnectingMessage(serverNames: string[]): string {
-	return `Connecting to MCP servers: ${serverNames.join(", ")}…`;
+export type McpConnectionStatusEvent =
+	| { type: "connecting"; serverNames: string[] }
+	| { type: "connected"; serverName: string }
+	| { type: "failed"; serverName: string; error: string };
+
+export type McpConnectionStatusSnapshot = {
+	pendingServers: readonly string[];
+	connectedServers: readonly string[];
+	failedServers: readonly { serverName: string; error: string }[];
+};
+
+function sanitizeMcpStatusText(value: string, maxWidth: number): string {
+	const text = shortenEmbeddedPaths(
+		replaceTabs(sanitizeText(value))
+			.replace(/[\r\n]+/g, " ")
+			.trim(),
+	);
+	return truncateToWidth(text.length > 0 ? text : "(unnamed)", maxWidth);
+}
+
+function sanitizeMcpServerName(serverName: string): string {
+	return sanitizeMcpStatusText(serverName, TRUNCATE_LENGTHS.SHORT);
+}
+
+function formatServerList(serverNames: readonly string[]): string {
+	return serverNames.map(sanitizeMcpServerName).join(", ");
+}
+
+function formatServerCount(count: number): string {
+	return count === 1 ? "server" : "servers";
+}
+function sanitizeMcpStatusError(error: string): string {
+	return sanitizeMcpStatusText(error, TRUNCATE_LENGTHS.CONTENT);
+}
+
+function shortenEmbeddedPaths(text: string): string {
+	return text
+		.split(" ")
+		.map(segment => {
+			const leading = segment.match(/^[("'`[]*/)?.[0] ?? "";
+			const trailing = segment.match(/[)"'`,.;:\]]*$/)?.[0] ?? "";
+			const end = segment.length - trailing.length;
+			if (leading.length >= end) return segment;
+			return `${leading}${shortenPath(segment.slice(leading.length, end))}${trailing}`;
+		})
+		.join(" ");
+}
+
+export function formatMCPConnectingMessage(serverNames: readonly string[]): string {
+	return `Connecting to MCP servers: ${formatServerList(serverNames)}…`;
+}
+
+function formatFailedServer({ serverName, error }: { serverName: string; error: string }): string {
+	return `${sanitizeMcpServerName(serverName)}: ${sanitizeMcpStatusError(error)}`;
+}
+
+export function formatMCPConnectionStatusMessage(snapshot: McpConnectionStatusSnapshot): string {
+	const { pendingServers, connectedServers, failedServers } = snapshot;
+	if (pendingServers.length > 0) {
+		if (connectedServers.length === 0 && failedServers.length === 0) {
+			return formatMCPConnectingMessage(pendingServers);
+		}
+		const parts: string[] = [];
+		if (connectedServers.length > 0) {
+			parts.push(`Connected: ${formatServerList(connectedServers)}.`);
+		}
+		if (failedServers.length > 0) {
+			parts.push(`Failed: ${failedServers.map(formatFailedServer).join("; ")}.`);
+		}
+		parts.push(`Still connecting: ${formatServerList(pendingServers)}…`);
+		return parts.join(" ");
+	}
+	if (failedServers.length > 0) {
+		const failureText = failedServers.map(formatFailedServer).join("; ");
+		if (connectedServers.length === 0) {
+			return `MCP ${formatServerCount(failedServers.length)} failed to connect: ${failureText}`;
+		}
+		return `MCP finished with failures. Connected: ${formatServerList(connectedServers)}. Failed: ${failureText}`;
+	}
+	if (connectedServers.length > 0) {
+		return `Connected to MCP ${formatServerCount(connectedServers.length)}: ${formatServerList(connectedServers)}.`;
+	}
+	return "";
+}
+
+function isRecord(data: unknown): data is Record<string, unknown> {
+	return typeof data === "object" && data !== null;
+}
+
+function isStringArray(data: unknown): data is string[] {
+	return Array.isArray(data) && data.every(item => typeof item === "string");
 }
 
 /**
@@ -11,11 +101,16 @@ export function formatMCPConnectingMessage(serverNames: string[]): string {
  * untyped at runtime, so the subscriber verifies the shape before formatting
  * rather than trusting a cast — a malformed emit is ignored instead of throwing.
  */
-export function isMcpConnectingEvent(data: unknown): data is McpConnectingEvent {
-	return (
-		typeof data === "object" &&
-		data !== null &&
-		Array.isArray((data as { serverNames?: unknown }).serverNames) &&
-		(data as { serverNames: unknown[] }).serverNames.every(name => typeof name === "string")
-	);
+export function isMcpConnectionStatusEvent(data: unknown): data is McpConnectionStatusEvent {
+	if (!isRecord(data) || typeof data.type !== "string") return false;
+	switch (data.type) {
+		case "connecting":
+			return isStringArray(data.serverNames);
+		case "connected":
+			return typeof data.serverName === "string";
+		case "failed":
+			return typeof data.serverName === "string" && typeof data.error === "string";
+		default:
+			return false;
+	}
 }

package/src/mnemopi/config.ts

@@ -26,6 +26,7 @@ export interface MnemopiBackendConfig {
 	autoRetain: boolean;
 	polyphonicRecall: boolean;
 	enhancedRecall: boolean;
+	proactiveLinking: boolean;
 	retainEveryNTurns: number;
 	recallLimit: number;
 	recallContextTurns: number;
@@ -71,6 +72,7 @@ export function loadMnemopiConfig(settings: Settings, agentDir: string): Mnemopi
 		autoRetain: settings.get("mnemopi.autoRetain"),
 		polyphonicRecall: settings.get("mnemopi.polyphonicRecall"),
 		enhancedRecall: settings.get("mnemopi.enhancedRecall"),
+		proactiveLinking: settings.get("mnemopi.proactiveLinking"),
 		retainEveryNTurns: Math.max(1, Math.floor(settings.get("mnemopi.retainEveryNTurns"))),
 		recallLimit: Math.max(1, Math.floor(settings.get("mnemopi.recallLimit"))),
 		recallContextTurns: Math.max(1, Math.floor(settings.get("mnemopi.recallContextTurns"))),

package/src/mnemopi/state.ts

@@ -450,7 +450,8 @@ export class MnemopiSessionState {
 // shared bank, then merging recall results while keeping writes project-local.
 function createScopedResources(config: MnemopiBackendConfig): MnemopiScopedResources {
 	// Env vars (MNEMOPI_POLYPHONIC_RECALL / MNEMOPI_ENHANCED_RECALL) still override
-	// these config-driven defaults inside the core gates.
+	// these config-driven defaults inside the core gates. Proactive linking is
+	// per-memory instance below so concurrent sessions cannot clobber each other.
 	requireMnemopi().configureRecallFeatures({
 		polyphonicRecall: config.polyphonicRecall,
 		enhancedRecall: config.enhancedRecall,
@@ -576,6 +577,7 @@ function createMemory(config: MnemopiBackendConfig, bank: string): Mnemopi {
 		authorType: "agent",
 		channelId: bank,
 		...providerOptions,
+		proactiveLinking: config.proactiveLinking,
 	} as ConstructorParameters<typeof Mnemopi>[0]);
 }
 

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

@@ -157,6 +157,7 @@ export interface AgentHubDeps {
 	cwd?: string;
 	/** Mirrors the main transcript's thinking-block visibility. */
 	hideThinkingBlock?: () => boolean;
+	proseOnlyThinking?: () => boolean;
 	/** Keys toggling tool output expansion (app.tools.expand). */
 	expandKeys?: KeyId[];
 	/** Focus the main view on this agent's live session (ctx.focusAgentSession). When absent (collab guest, tests), Enter opens the in-hub chat view instead. */
@@ -194,6 +195,7 @@ export class AgentHubOverlayComponent extends Container {
 	#getMessageRenderer: ((customType: string) => MessageRenderer | undefined) | undefined;
 	#cwd: string;
 	#hideThinkingBlock: (() => boolean) | undefined;
+	#proseOnlyThinking: (() => boolean) | undefined;
 	#expandKeys: KeyId[];
 	#focusAgent: ((id: string) => Promise<void>) | undefined;
 
@@ -223,6 +225,7 @@ export class AgentHubOverlayComponent extends Container {
 		this.#getMessageRenderer = deps.getMessageRenderer;
 		this.#cwd = deps.cwd ?? getProjectDir();
 		this.#hideThinkingBlock = deps.hideThinkingBlock;
+		this.#proseOnlyThinking = deps.proseOnlyThinking;
 		this.#expandKeys = deps.expandKeys ?? ["ctrl+o"];
 		this.#focusAgent = deps.focusAgent;
 
@@ -291,6 +294,7 @@ export class AgentHubOverlayComponent extends Container {
 			getMessageRenderer: this.#getMessageRenderer,
 			cwd: this.#cwd,
 			hideThinkingBlock: this.#hideThinkingBlock,
+			proseOnlyThinking: this.#proseOnlyThinking,
 			expandKeys: this.#expandKeys,
 			hubKeys: this.#hubKeys,
 			requestRender: this.#requestRender,

package/src/modes/components/agent-transcript-viewer.ts

@@ -50,6 +50,7 @@ export interface AgentTranscriptViewerDeps {
 	getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
 	cwd: string;
 	hideThinkingBlock?: () => boolean;
+	proseOnlyThinking?: () => boolean;
 	expandKeys: KeyId[];
 	/** Keys that toggle the whole hub closed (app.agents.hub + app.session.observe). */
 	hubKeys: KeyId[];
@@ -105,6 +106,7 @@ export class AgentTranscriptViewer implements Component {
 			getMessageRenderer: deps.getMessageRenderer,
 			cwd: deps.cwd,
 			hideThinkingBlock: deps.hideThinkingBlock,
+			proseOnlyThinking: deps.proseOnlyThinking,
 			requestRender: deps.requestRender,
 		});
 		this.#scrollView = new ScrollView([], {