@oh-my-pi/pi-coding-agent 3.37.1 → 4.0.1

package/src/core/sdk.ts

@@ -27,8 +27,8 @@
  */
 
 import { join } from "node:path";
-import { Agent, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Message, Model } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
 // Import discovery to register all providers on startup
@@ -51,9 +51,10 @@ import {
 	type ExtensionContext,
 	type ExtensionFactory,
 	ExtensionRunner,
+	type ExtensionUIContext,
 	type LoadExtensionsResult,
-	type LoadedExtension,
 	loadExtensionFromFactory,
+	loadExtensions,
 	type ToolDefinition,
 	wrapRegisteredTools,
 	wrapToolWithExtensions,
@@ -66,7 +67,7 @@ import { formatModelString, parseModelString } from "./model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./prompt-templates";
 import { SessionManager } from "./session-manager";
 import { type Settings, SettingsManager, type SkillsSettings } from "./settings-manager";
-import { loadSkills as loadSkillsInternal, type Skill } from "./skills";
+import { loadSkills as loadSkillsInternal, type Skill, type SkillWarning } from "./skills";
 import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
@@ -129,11 +130,13 @@ export interface CreateAgentSessionOptions {
 	extensions?: ExtensionFactory[];
 	/** Additional extension paths to load (merged with discovery). */
 	additionalExtensionPaths?: string[];
+	/** Disable extension discovery (explicit paths still load). */
+	disableExtensionDiscovery?: boolean;
 	/**
 	 * Pre-loaded extensions (skips file discovery).
 	 * @internal Used by CLI when extensions are loaded early to parse custom flags.
 	 */
-	preloadedExtensions?: LoadedExtension[];
+	preloadedExtensions?: LoadExtensionsResult;
 
 	/** Shared event bus for tool/extension communication. Default: creates new bus. */
 	eventBus?: EventBus;
@@ -172,8 +175,10 @@ export interface CreateAgentSessionOptions {
 export interface CreateAgentSessionResult {
 	/** The created session */
 	session: AgentSession;
-	/** Extensions result (for UI context setup in interactive mode) */
+	/** Extensions result (loaded extensions + runtime) */
 	extensionsResult: LoadExtensionsResult;
+	/** Update tool UI context (interactive mode) */
+	setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
 	/** MCP manager for server lifecycle management (undefined if MCP disabled) */
 	mcpManager?: MCPManager;
 	/** Warning if session was restored with a different model than saved */
@@ -274,12 +279,15 @@ export async function discoverExtensions(cwd?: string): Promise<LoadExtensionsRe
 /**
  * Discover skills from cwd and agentDir.
  */
-export function discoverSkills(cwd?: string, _agentDir?: string, settings?: SkillsSettings): Skill[] {
-	const { skills } = loadSkillsInternal({
+export function discoverSkills(
+	cwd?: string,
+	_agentDir?: string,
+	settings?: SkillsSettings,
+): { skills: Skill[]; warnings: SkillWarning[] } {
+	return loadSkillsInternal({
 		...settings,
 		cwd: cwd ?? process.cwd(),
 	});
-	return skills;
 }
 
 /**
@@ -380,6 +388,7 @@ export function loadSettings(cwd?: string, agentDir?: string): Settings {
 		extensions: manager.getExtensionPaths(),
 		skills: manager.getSkillsSettings(),
 		terminal: { showImages: manager.getShowImages() },
+		images: { autoResize: manager.getImageAutoResize(), blockImages: manager.getBlockImages() },
 	};
 }
 
@@ -614,7 +623,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingLevel = "off";
 	}
 
-	const skills = options.skills ?? discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
+	let skills: Skill[];
+	let skillWarnings: SkillWarning[];
+	if (options.skills !== undefined) {
+		skills = options.skills;
+		skillWarnings = [];
+	} else {
+		const discovered = discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
+		skills = discovered.skills;
+		skillWarnings = discovered.warnings;
+	}
 	time("discoverSkills");
 
 	// Discover rules
@@ -723,12 +741,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Load extensions (discovers from standard locations + configured paths)
 	let extensionsResult: LoadExtensionsResult;
-	if (options.preloadedExtensions !== undefined && options.preloadedExtensions.length > 0) {
-		extensionsResult = {
-			extensions: options.preloadedExtensions,
-			errors: [],
-			setUIContext: () => {},
-		};
+	if (options.disableExtensionDiscovery) {
+		const configuredPaths = options.additionalExtensionPaths ?? [];
+		extensionsResult = await loadExtensions(configuredPaths, cwd, eventBus);
+		time("loadExtensions");
+		for (const { path, error } of extensionsResult.errors) {
+			logger.error("Failed to load extension", { path, error });
+		}
+	} else if (options.preloadedExtensions) {
+		extensionsResult = options.preloadedExtensions;
 	} else {
 		// Merge CLI extension paths with settings extension paths
 		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...settingsManager.getExtensionPaths()];
@@ -746,36 +767,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Load inline extensions from factories
 	if (inlineExtensions.length > 0) {
-		const uiHolder: { ui: any; hasUI: boolean } = {
-			ui: {
-				select: async () => undefined,
-				confirm: async () => false,
-				input: async () => undefined,
-				notify: () => {},
-				setStatus: () => {},
-				setWidget: () => {},
-				setTitle: () => {},
-				custom: async () => undefined as never,
-				setEditorText: () => {},
-				getEditorText: () => "",
-				editor: async () => undefined,
-				get theme() {
-					return {} as any;
-				},
-			},
-			hasUI: false,
-		};
 		for (let i = 0; i < inlineExtensions.length; i++) {
 			const factory = inlineExtensions[i];
-			const loaded = loadExtensionFromFactory(factory, cwd, eventBus, uiHolder, `<inline-${i}>`);
+			const loaded = await loadExtensionFromFactory(
+				factory,
+				cwd,
+				eventBus,
+				extensionsResult.runtime,
+				`<inline-${i}>`,
+			);
 			extensionsResult.extensions.push(loaded);
 		}
-		const originalSetUIContext = extensionsResult.setUIContext;
-		extensionsResult.setUIContext = (uiContext, hasUI) => {
-			originalSetUIContext(uiContext, hasUI);
-			uiHolder.ui = uiContext;
-			uiHolder.hasUI = hasUI;
-		};
 	}
 
 	// Discover custom commands (TypeScript slash commands)
@@ -787,7 +789,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	let extensionRunner: ExtensionRunner | undefined;
 	if (extensionsResult.extensions.length > 0) {
-		extensionRunner = new ExtensionRunner(extensionsResult.extensions, cwd, sessionManager, modelRegistry);
+		extensionRunner = new ExtensionRunner(
+			extensionsResult.extensions,
+			extensionsResult.runtime,
+			cwd,
+			sessionManager,
+			modelRegistry,
+		);
 	}
 
 	const getSessionContext = () => ({
@@ -810,35 +818,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return { definition, extensionPath: "<sdk>" };
 		}) ?? []),
 	];
-	const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, () => ({
-		ui: extensionRunner?.getUIContext() ?? {
-			select: async () => undefined,
-			confirm: async () => false,
-			input: async () => undefined,
-			notify: () => {},
-			setStatus: () => {},
-			setWidget: () => {},
-			setTitle: () => {},
-			custom: async () => undefined as never,
-			setEditorText: () => {},
-			getEditorText: () => "",
-			editor: async () => undefined,
-			get theme() {
-				return {} as any;
-			},
-		},
-		hasUI: extensionRunner?.getHasUI() ?? false,
-		cwd,
-		sessionManager,
-		modelRegistry,
-		model: agent.state.model,
-		isIdle: () => !session.isStreaming,
-		abort: () => {
-			session.abort();
-		},
-		hasPendingMessages: () => session.queuedMessageCount > 0,
-		hasQueuedMessages: () => session.queuedMessageCount > 0,
-	}));
+	const wrappedExtensionTools = extensionRunner ? wrapRegisteredTools(allCustomTools, extensionRunner) : [];
 
 	// All built-in tools are active (conditional tools like git/ask return null from factory if disabled)
 	const toolRegistry = new Map<string, AgentTool>();
@@ -894,9 +874,44 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const slashCommands = options.slashCommands ?? discoverSlashCommands(cwd);
 	time("discoverSlashCommands");
 
-	const baseSetUIContext = extensionsResult.setUIContext;
-	extensionsResult.setUIContext = (uiContext, hasUI) => {
-		baseSetUIContext(uiContext, hasUI);
+	// Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
+	const convertToLlmWithBlockImages = (messages: AgentMessage[]): Message[] => {
+		const converted = convertToLlm(messages);
+		// Check setting dynamically so mid-session changes take effect
+		if (!settingsManager.getBlockImages()) {
+			return converted;
+		}
+		// Filter out ImageContent from all messages, replacing with text placeholder
+		return converted.map((msg) => {
+			if (msg.role === "user" || msg.role === "toolResult") {
+				const content = msg.content;
+				if (Array.isArray(content)) {
+					const hasImages = content.some((c) => c.type === "image");
+					if (hasImages) {
+						const filteredContent = content
+							.map((c) =>
+								c.type === "image" ? { type: "text" as const, text: "Image reading is disabled." } : c,
+							)
+							.filter(
+								(c, i, arr) =>
+									// Dedupe consecutive "Image reading is disabled." texts
+									!(
+										c.type === "text" &&
+										c.text === "Image reading is disabled." &&
+										i > 0 &&
+										arr[i - 1].type === "text" &&
+										(arr[i - 1] as { type: "text"; text: string }).text === "Image reading is disabled."
+									),
+							);
+						return { ...msg, content: filteredContent };
+					}
+				}
+			}
+			return msg;
+		});
+	};
+
+	const setToolUIContext = (uiContext: ExtensionUIContext, hasUI: boolean) => {
 		toolContextStore.setUIContext(uiContext, hasUI);
 	};
 
@@ -907,7 +922,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			thinkingLevel,
 			tools: Array.from(toolRegistry.values()),
 		},
-		convertToLlm,
+		convertToLlm: convertToLlmWithBlockImages,
+		sessionId: sessionManager.getSessionId(),
 		transformContext: extensionRunner
 			? async (messages) => {
 					return extensionRunner.emitContext(messages);
@@ -916,6 +932,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		steeringMode: settingsManager.getSteeringMode(),
 		followUpMode: settingsManager.getFollowUpMode(),
 		interruptMode: settingsManager.getInterruptMode(),
+		thinkingBudgets: settingsManager.getThinkingBudgets(),
 		getToolContext: toolContextStore.getContext,
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
@@ -951,6 +968,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		slashCommands,
 		extensionRunner,
 		customCommands: customCommandsResult.commands,
+		skills,
+		skillWarnings,
 		skillsSettings: settingsManager.getSkillsSettings(),
 		modelRegistry,
 		toolRegistry,
@@ -980,6 +999,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	return {
 		session,
 		extensionsResult,
+		setToolUIContext,
 		mcpManager,
 		modelFallbackMessage,
 		lspServers,

package/src/core/settings-manager.ts

@@ -45,6 +45,14 @@ export interface TerminalSettings {
 
 export interface ImageSettings {
 	autoResize?: boolean; // default: true (resize images to 2000x2000 max for better model compatibility)
+	blockImages?: boolean; // default: false - when true, prevents all images from being sent to LLM providers
+}
+
+export interface ThinkingBudgetsSettings {
+	minimal?: number;
+	low?: number;
+	medium?: number;
+	high?: number;
 }
 
 export type NotificationMethod = "bell" | "osc99" | "osc9" | "auto" | "off";
@@ -179,6 +187,7 @@ export interface Settings {
 	shellPath?: string; // Custom shell path (e.g., for Cygwin users on Windows)
 	collapseChangelog?: boolean; // Show condensed changelog after update (use /changelog for full)
 	doubleEscapeAction?: "branch" | "tree"; // Action for double-escape with empty editor (default: "tree")
+	thinkingBudgets?: ThinkingBudgetsSettings; // Custom token budgets for thinking levels
 	/** Environment variables to set automatically on startup */
 	env?: Record<string, string>;
 	extensions?: string[]; // Array of extension file paths
@@ -489,23 +498,29 @@ export class SettingsManager {
 	}
 
 	private save(): void {
-		if (!this.persist || !this.settingsPath) return;
-
-		try {
-			const dir = dirname(this.settingsPath);
-			if (!existsSync(dir)) {
-				mkdirSync(dir, { recursive: true });
-			}
+		if (this.persist && this.settingsPath) {
+			try {
+				const dir = dirname(this.settingsPath);
+				if (!existsSync(dir)) {
+					mkdirSync(dir, { recursive: true });
+				}
 
-			// Save only global settings (project settings are read-only)
-			writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
+				// Re-read current file to preserve any settings added externally while running
+				const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);
+				// Merge: file settings as base, globalSettings (in-memory changes) as overrides
+				const mergedSettings = deepMergeSettings(currentFileSettings, this.globalSettings);
+				this.globalSettings = mergedSettings;
 
-			// Re-merge project settings into active settings (preserve overrides)
-			const projectSettings = this.loadProjectSettings();
-			this.rebuildSettings(projectSettings);
-		} catch (error) {
-			console.error(`Warning: Could not save settings file: ${error}`);
+				// Save merged settings (project settings are read-only)
+				writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
+			} catch (error) {
+				console.error(`Warning: Could not save settings file: ${error}`);
+			}
 		}
+
+		// Always re-merge to update active settings (needed for both file and inMemory modes)
+		const projectSettings = this.loadProjectSettings();
+		this.rebuildSettings(projectSettings);
 	}
 
 	getLastChangelogVersion(): string | undefined {
@@ -668,6 +683,10 @@ export class SettingsManager {
 		};
 	}
 
+	getThinkingBudgets(): ThinkingBudgetsSettings | undefined {
+		return this.settings.thinkingBudgets;
+	}
+
 	getHideThinkingBlock(): boolean {
 		return this.settings.hideThinkingBlock ?? false;
 	}
@@ -773,6 +792,18 @@ export class SettingsManager {
 		this.save();
 	}
 
+	getBlockImages(): boolean {
+		return this.settings.images?.blockImages ?? false;
+	}
+
+	setBlockImages(blocked: boolean): void {
+		if (!this.globalSettings.images) {
+			this.globalSettings.images = {};
+		}
+		this.globalSettings.images.blockImages = blocked;
+		this.save();
+	}
+
 	getEnabledModels(): string[] | undefined {
 		return this.settings.enabledModels;
 	}

package/src/core/system-prompt.ts

@@ -9,7 +9,6 @@ import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
 import type { Rule } from "../capability/rule";
 import { systemPromptCapability } from "../capability/system-prompt";
-import { getDocsPath, getExamplesPath, getReadmePath } from "../config";
 import { type ContextFile, loadSync, type SystemPrompt as SystemPromptFile } from "../discovery/index";
 import systemPromptTemplate from "../prompts/system-prompt.md" with { type: "text" };
 import type { SkillsSettings } from "./settings-manager";
@@ -772,7 +771,11 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const contextFiles = providedContextFiles ?? loadProjectContextFiles({ cwd: resolvedCwd });
 
 	// Build tools list based on selected tools
-	const toolsList = toolNames?.map((name) => `- ${name}: ${toolDescriptions[name as ToolName]}`).join("\n") ?? "";
+	const selectedToolNames = toolNames ?? (["read", "bash", "edit", "write"] as ToolName[]);
+	const toolsList =
+		selectedToolNames.length > 0
+			? selectedToolNames.map((name) => `- ${name}: ${toolDescriptions[name as ToolName]}`).join("\n")
+			: "(none)";
 
 	// Resolve skills: use provided or discover
 	const skills =
@@ -804,11 +807,6 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		return prompt;
 	}
 
-	// Get absolute paths to documentation and examples
-	const readmePath = getReadmePath();
-	const docsPath = getDocsPath();
-	const examplesPath = getExamplesPath();
-
 	// Generate anti-bash rules (returns null if not applicable)
 	const antiBashSection = generateAntiBashRules(Array.from(tools?.keys() ?? []));
 	const environmentInfo = formatEnvironmentInfo();
@@ -821,11 +819,6 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const hasWrite = tools?.has("write");
 	const hasRead = tools?.has("read");
 
-	// Read-only mode notice (no bash, edit, or write)
-	if (!hasBash && !hasEdit && !hasWrite) {
-		guidelinesList.push("You are in READ-ONLY mode - you cannot modify files or execute arbitrary commands");
-	}
-
 	// Bash without edit/write = read-only bash mode
 	if (hasBash && !hasEdit && !hasWrite) {
 		guidelinesList.push(
@@ -870,9 +863,6 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		antiBashSection: antiBashBlock,
 		guidelines,
 		environmentInfo,
-		readmePath,
-		docsPath,
-		examplesPath,
 	});
 
 	prompt = appendBlock(prompt, resolvedAppendPrompt);

package/src/core/tools/bash.ts

@@ -3,12 +3,14 @@ import type { AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
-import { executeBash } from "../bash-executor";
+import { type BashExecutorOptions, executeBash, executeBashWithOperations } from "../bash-executor";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
 import type { ToolSession } from "./index";
+import { resolveToCwd } from "./path-utils";
 import { createToolUIKit } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
 
@@ -25,7 +27,28 @@ export interface BashToolDetails {
 	fullOutputPath?: string;
 }
 
-export function createBashTool(session: ToolSession): AgentTool<typeof bashSchema> {
+/**
+ * Pluggable operations for bash execution.
+ * Override to delegate command execution to remote systems.
+ */
+export interface BashOperations {
+	exec: (
+		command: string,
+		cwd: string,
+		options: {
+			onData: (data: Buffer) => void;
+			signal?: AbortSignal;
+			timeout?: number;
+		},
+	) => Promise<{ exitCode: number | null }>;
+}
+
+export interface BashToolOptions {
+	/** Custom operations for command execution. Default: local shell */
+	operations?: BashOperations;
+}
+
+export function createBashTool(session: ToolSession, options?: BashToolOptions): AgentTool<typeof bashSchema> {
 	return {
 		name: "bash",
 		label: "Bash",
@@ -53,11 +76,22 @@ export function createBashTool(session: ToolSession): AgentTool<typeof bashSchem
 				}
 			}
 
+			const commandCwd = workdir ? resolveToCwd(workdir, session.cwd) : session.cwd;
+			let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
+			try {
+				cwdStat = await Bun.file(commandCwd).stat();
+			} catch {
+				throw new Error(`Working directory does not exist: ${commandCwd}`);
+			}
+			if (!cwdStat.isDirectory()) {
+				throw new Error(`Working directory is not a directory: ${commandCwd}`);
+			}
+
 			// Track output for streaming updates
 			let currentOutput = "";
 
-			const result = await executeBash(command, {
-				cwd: workdir ?? session.cwd,
+			const executorOptions: BashExecutorOptions = {
+				cwd: commandCwd,
 				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
 				signal,
 				onChunk: (chunk) => {
@@ -72,7 +106,12 @@ export function createBashTool(session: ToolSession): AgentTool<typeof bashSchem
 						});
 					}
 				},
-			});
+			};
+
+			// Use custom operations if provided, otherwise use default local executor
+			const result = options?.operations
+				? await executeBashWithOperations(command, commandCwd, options.operations, executorOptions)
+				: await executeBash(command, executorOptions);
 
 			// Handle errors
 			if (result.cancelled) {
@@ -125,12 +164,12 @@ interface BashRenderArgs {
 }
 
 interface BashRenderContext {
-	/** Visual lines for truncated output (pre-computed by tool-execution) */
-	visualLines?: string[];
-	/** Number of lines skipped */
-	skippedCount?: number;
-	/** Total visual lines */
-	totalVisualLines?: number;
+	/** Raw output text */
+	output?: string;
+	/** Whether output is expanded */
+	expanded?: boolean;
+	/** Number of preview lines when collapsed */
+	previewLines?: number;
 }
 
 export const bashToolRenderer = {
@@ -171,51 +210,18 @@ export const bashToolRenderer = {
 		uiTheme: Theme,
 	): Component {
 		const ui = createToolUIKit(uiTheme);
-		const { expanded, renderContext } = options;
+		const { renderContext } = options;
 		const details = result.details;
-		const lines: string[] = [];
-
-		// Get output text
-		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
-		const output = textContent.trim();
-
-		if (output) {
-			if (expanded) {
-				// Show all lines when expanded
-				const styledOutput = output
-					.split("\n")
-					.map((line) => uiTheme.fg("toolOutput", line))
-					.join("\n");
-				lines.push(styledOutput);
-			} else if (renderContext?.visualLines) {
-				// Use pre-computed visual lines from tool-execution
-				const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
-				if (skippedCount > 0) {
-					lines.push(
-						uiTheme.fg(
-							"dim",
-							`${uiTheme.format.ellipsis} (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
-						),
-					);
-				}
-				lines.push(...visualLines);
-			} else {
-				// Fallback: show first few lines
-				const outputLines = output.split("\n");
-				const maxLines = 5;
-				const displayLines = outputLines.slice(0, maxLines);
-				const remaining = outputLines.length - maxLines;
-
-				lines.push(...displayLines.map((line) => uiTheme.fg("toolOutput", line)));
-				if (remaining > 0) {
-					lines.push(uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${remaining} more lines) (ctrl+o to expand)`));
-				}
-			}
-		}
 
-		// Truncation warnings
+		// Get output from context (preferred) or fall back to result content
+		const output = renderContext?.output ?? (result.content?.find((c) => c.type === "text")?.text ?? "").trim();
+		const expanded = renderContext?.expanded ?? options.expanded;
+		const previewLines = renderContext?.previewLines ?? 5;
+
+		// Build truncation warning lines (static, doesn't depend on width)
 		const truncation = details?.truncation;
 		const fullOutputPath = details?.fullOutputPath;
+		let warningLine: string | undefined;
 		if (truncation?.truncated || fullOutputPath) {
 			const warnings: string[] = [];
 			if (fullOutputPath) {
@@ -230,9 +236,64 @@ export const bashToolRenderer = {
 					);
 				}
 			}
-			lines.push(uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". "))));
+			warningLine = uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". ")));
+		}
+
+		if (!output) {
+			// No output - just show warning if any
+			return new Text(warningLine ?? "", 0, 0);
+		}
+
+		if (expanded) {
+			// Show all lines when expanded
+			const styledOutput = output
+				.split("\n")
+				.map((line) => uiTheme.fg("toolOutput", line))
+				.join("\n");
+			const lines = warningLine ? [styledOutput, warningLine] : [styledOutput];
+			return new Text(lines.join("\n"), 0, 0);
 		}
 
-		return new Text(lines.join("\n"), 0, 0);
+		// Collapsed: use width-aware caching component
+		const styledOutput = output
+			.split("\n")
+			.map((line) => uiTheme.fg("toolOutput", line))
+			.join("\n");
+		const textContent = `\n${styledOutput}`;
+
+		let cachedWidth: number | undefined;
+		let cachedLines: string[] | undefined;
+		let cachedSkipped: number | undefined;
+
+		return {
+			render: (width: number): string[] => {
+				if (cachedLines === undefined || cachedWidth !== width) {
+					const result = truncateToVisualLines(textContent, previewLines, width);
+					cachedLines = result.visualLines;
+					cachedSkipped = result.skippedCount;
+					cachedWidth = width;
+				}
+				const outputLines: string[] = [];
+				if (cachedSkipped && cachedSkipped > 0) {
+					outputLines.push("");
+					outputLines.push(
+						uiTheme.fg(
+							"dim",
+							`${uiTheme.format.ellipsis} (${cachedSkipped} earlier lines, showing ${cachedLines.length} of ${cachedSkipped + cachedLines.length}) (ctrl+o to expand)`,
+						),
+					);
+				}
+				outputLines.push(...cachedLines);
+				if (warningLine) {
+					outputLines.push(warningLine);
+				}
+				return outputLines;
+			},
+			invalidate: () => {
+				cachedWidth = undefined;
+				cachedLines = undefined;
+				cachedSkipped = undefined;
+			},
+		};
 	},
 };