@oh-my-pi/pi-coding-agent 3.32.0 → 3.34.0

package/src/core/title-generator.ts

@@ -2,17 +2,54 @@
  * Generate session titles using a smol, fast model.
  */
 
-import type { Model } from "@mariozechner/pi-ai";
-import { completeSimple } from "@mariozechner/pi-ai";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
 import titleSystemPrompt from "../prompts/title-system.md" with { type: "text" };
 import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
-import { findSmolModel } from "./model-resolver";
+import { parseModelString, SMOL_MODEL_PRIORITY } from "./model-resolver";
 
 const TITLE_SYSTEM_PROMPT = titleSystemPrompt;
 
 const MAX_INPUT_CHARS = 2000;
 
+function getTitleModelCandidates(registry: ModelRegistry, savedSmolModel?: string): Model<Api>[] {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return [];
+
+	const candidates: Model<Api>[] = [];
+	const addCandidate = (model?: Model<Api>): void => {
+		if (!model) return;
+		const exists = candidates.some((candidate) => candidate.provider === model.provider && candidate.id === model.id);
+		if (!exists) {
+			candidates.push(model);
+		}
+	};
+
+	if (savedSmolModel) {
+		const parsed = parseModelString(savedSmolModel);
+		if (parsed) {
+			const match = availableModels.find((model) => model.provider === parsed.provider && model.id === parsed.id);
+			addCandidate(match);
+		}
+	}
+
+	for (const pattern of SMOL_MODEL_PRIORITY) {
+		const needle = pattern.toLowerCase();
+		const exactMatch = availableModels.find((model) => model.id.toLowerCase() === needle);
+		addCandidate(exactMatch);
+
+		const fuzzyMatch = availableModels.find((model) => model.id.toLowerCase().includes(needle));
+		addCandidate(fuzzyMatch);
+	}
+
+	for (const model of availableModels) {
+		addCandidate(model);
+	}
+
+	return candidates;
+}
+
 /**
  * Find the best available model for title generation.
  * Uses the configured smol model if set, otherwise auto-discovers using priority chain.
@@ -20,9 +57,9 @@ const MAX_INPUT_CHARS = 2000;
  * @param registry Model registry
  * @param savedSmolModel Optional saved smol model from settings (provider/modelId format)
  */
-export async function findTitleModel(registry: ModelRegistry, savedSmolModel?: string): Promise<Model<any> | null> {
-	const model = await findSmolModel(registry, savedSmolModel);
-	return model ?? null;
+export async function findTitleModel(registry: ModelRegistry, savedSmolModel?: string): Promise<Model<Api> | null> {
+	const candidates = getTitleModelCandidates(registry, savedSmolModel);
+	return candidates[0] ?? null;
 }
 
 /**
@@ -37,68 +74,85 @@ export async function generateSessionTitle(
 	registry: ModelRegistry,
 	savedSmolModel?: string,
 ): Promise<string | null> {
-	const model = await findTitleModel(registry, savedSmolModel);
-	if (!model) {
+	const candidates = getTitleModelCandidates(registry, savedSmolModel);
+	if (candidates.length === 0) {
 		logger.debug("title-generator: no smol model found");
 		return null;
 	}
 
-	const apiKey = await registry.getApiKey(model);
-	if (!apiKey) {
-		logger.debug("title-generator: no API key for model", { provider: model.provider, id: model.id });
-		return null;
-	}
-
 	// Truncate message if too long
 	const truncatedMessage =
 		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
+	const userMessage = `<user-message>\n${truncatedMessage}\n</user-message>`;
 
-	const request = {
-		model: `${model.provider}/${model.id}`,
-		systemPrompt: TITLE_SYSTEM_PROMPT,
-		userMessage: `<user-message>\n${truncatedMessage}\n</user-message>`,
-		maxTokens: 30,
-	};
-	logger.debug("title-generator: request", request);
-
-	try {
-		const response = await completeSimple(
-			model,
-			{
-				systemPrompt: request.systemPrompt,
-				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
-			},
-			{
-				apiKey,
-				maxTokens: 30,
-			},
-		);
-
-		// Extract title from response text content
-		let title = "";
-		for (const content of response.content) {
-			if (content.type === "text") {
-				title += content.text;
-			}
+	for (const model of candidates) {
+		const apiKey = await registry.getApiKey(model);
+		if (!apiKey) {
+			logger.debug("title-generator: no API key for model", { provider: model.provider, id: model.id });
+			continue;
 		}
-		title = title.trim();
 
-		logger.debug("title-generator: response", {
-			title,
-			usage: response.usage,
-			stopReason: response.stopReason,
-		});
+		const request = {
+			model: `${model.provider}/${model.id}`,
+			systemPrompt: TITLE_SYSTEM_PROMPT,
+			userMessage,
+			maxTokens: 30,
+		};
+		logger.debug("title-generator: request", request);
 
-		if (!title) {
-			return null;
-		}
+		try {
+			const response = await completeSimple(
+				model,
+				{
+					systemPrompt: request.systemPrompt,
+					messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+				},
+				{
+					apiKey,
+					maxTokens: 30,
+				},
+			);
 
-		// Clean up: remove quotes, trailing punctuation
-		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
-	} catch (err) {
-		logger.debug("title-generator: error", { error: err instanceof Error ? err.message : String(err) });
-		return null;
+			if (response.stopReason === "error") {
+				logger.debug("title-generator: response error", {
+					model: request.model,
+					stopReason: response.stopReason,
+					errorMessage: response.errorMessage,
+				});
+				continue;
+			}
+
+			// Extract title from response text content
+			let title = "";
+			for (const content of response.content) {
+				if (content.type === "text") {
+					title += content.text;
+				}
+			}
+			title = title.trim();
+
+			logger.debug("title-generator: response", {
+				model: request.model,
+				title,
+				usage: response.usage,
+				stopReason: response.stopReason,
+			});
+
+			if (!title) {
+				continue;
+			}
+
+			// Clean up: remove quotes, trailing punctuation
+			return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+		} catch (err) {
+			logger.debug("title-generator: error", {
+				model: request.model,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
 	}
+
+	return null;
 }
 
 /**

package/src/core/tools/index.test.ts

@@ -162,6 +162,7 @@ describe("createTools", () => {
 		const expectedTools = [
 			"ask",
 			"bash",
+			"ssh",
 			"edit",
 			"find",
 			"git",

package/src/core/tools/index.ts

@@ -26,6 +26,7 @@ export { createOutputTool, type OutputToolDetails } from "./output";
 export { createReadTool, type ReadToolDetails } from "./read";
 export { reportFindingTool, type SubmitReviewDetails } from "./review";
 export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
+export { createSshTool, type SSHToolDetails } from "./ssh";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
 export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
@@ -68,6 +69,7 @@ import { createOutputTool } from "./output";
 import { createReadTool } from "./read";
 import { reportFindingTool } from "./review";
 import { createRulebookTool } from "./rulebook";
+import { createSshTool } from "./ssh";
 import { createTaskTool } from "./task/index";
 import { createWebFetchTool } from "./web-fetch";
 import { createWebSearchTool } from "./web-search/index";
@@ -115,6 +117,7 @@ type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: createAskTool,
 	bash: createBashTool,
+	ssh: createSshTool,
 	edit: createEditTool,
 	find: createFindTool,
 	git: createGitTool,

package/src/core/tools/output.ts

@@ -6,8 +6,8 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -189,11 +189,46 @@ function parseOutputProvenance(id: string): OutputProvenance | undefined {
 function extractPreviewLines(content: string, maxLines: number): string[] {
 	const lines = content.split("\n");
 	const preview: string[] = [];
+	const structuralTokens = new Set(["{", "}", "[", "]"]);
+
+	const isStructuralLine = (line: string): boolean => {
+		const trimmed = line.trim();
+		if (!trimmed) return true;
+		const cleaned = trimmed.replace(/,+$/, "");
+		return structuralTokens.has(cleaned);
+	};
+
+	const trimmedContent = content.trim();
+	const firstMeaningful = lines.find((line) => line.trim());
+	if (
+		firstMeaningful &&
+		isStructuralLine(firstMeaningful) &&
+		(trimmedContent.startsWith("{") || trimmedContent.startsWith("[")) &&
+		trimmedContent.length <= 200_000
+	) {
+		try {
+			const parsed = JSON.parse(trimmedContent);
+			const minified = JSON.stringify(parsed);
+			if (minified) return [minified];
+		} catch {
+			// Fall back to line-based previews.
+		}
+	}
+
 	for (const line of lines) {
-		if (!line.trim()) continue;
+		if (isStructuralLine(line)) continue;
 		preview.push(line);
 		if (preview.length >= maxLines) break;
 	}
+
+	if (preview.length === 0) {
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			preview.push(line);
+			if (preview.length >= maxLines) break;
+		}
+	}
+
 	return preview;
 }
 

package/src/core/tools/read.ts

@@ -1,9 +1,11 @@
+import { homedir } from "node:os";
 import path from "node:path";
-import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { CONFIG_DIR_NAME } from "../../config";
 import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/interactive/theme/theme";
 import readDescription from "../../prompts/tools/read.md" with { type: "text" };
 import { formatDimensionNote, resizeImage } from "../../utils/image-resize";
@@ -27,6 +29,13 @@ import {
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
 
+// Remote mount path prefix (sshfs mounts) - skip fuzzy matching to avoid hangs
+const REMOTE_MOUNT_PREFIX = path.join(homedir(), CONFIG_DIR_NAME, "remote") + path.sep;
+
+function isRemoteMountPath(absolutePath: string): boolean {
+	return absolutePath.startsWith(REMOTE_MOUNT_PREFIX);
+}
+
 // Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 const MAX_FUZZY_RESULTS = 5;
@@ -438,19 +447,23 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 					isDirectory = stat.isDirectory();
 				} catch (error) {
 					if (isNotFoundError(error)) {
-						const suggestions = await findReadPathSuggestions(readPath, session.cwd, signal);
 						let message = `File not found: ${readPath}`;
 
-						if (suggestions?.suggestions.length) {
-							const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
-							message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions.map((match) => `- ${match}`).join("\n")}`;
-							if (suggestions.truncated) {
-								message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+						// Skip fuzzy matching for remote mounts (sshfs) to avoid hangs
+						if (!isRemoteMountPath(absolutePath)) {
+							const suggestions = await findReadPathSuggestions(readPath, session.cwd, signal);
+
+							if (suggestions?.suggestions.length) {
+								const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
+								message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions.map((match) => `- ${match}`).join("\n")}`;
+								if (suggestions.truncated) {
+									message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+								}
+							} else if (suggestions?.error) {
+								message += `\n\nFuzzy match failed: ${suggestions.error}`;
+							} else if (suggestions?.scopeLabel) {
+								message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
 							}
-						} else if (suggestions?.error) {
-							message += `\n\nFuzzy match failed: ${suggestions.error}`;
-						} else if (suggestions?.scopeLabel) {
-							message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
 						}
 
 						throw new Error(message);

package/src/core/tools/renderers.ts

@@ -17,6 +17,7 @@ import { lspToolRenderer } from "./lsp/render";
 import { notebookToolRenderer } from "./notebook";
 import { outputToolRenderer } from "./output";
 import { readToolRenderer } from "./read";
+import { sshToolRenderer } from "./ssh";
 import { taskToolRenderer } from "./task/render";
 import { webFetchToolRenderer } from "./web-fetch";
 import { webSearchToolRenderer } from "./web-search/render";
@@ -43,6 +44,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	notebook: notebookToolRenderer as ToolRenderer,
 	output: outputToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
+	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,
 	web_fetch: webFetchToolRenderer as ToolRenderer,
 	web_search: webSearchToolRenderer as ToolRenderer,

package/src/core/tools/ssh.ts

@@ -0,0 +1,302 @@
+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 type { SSHHost } from "../../capability/ssh";
+import { sshCapability } from "../../capability/ssh";
+import { loadSync } from "../../discovery/index";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import sshDescriptionBase from "../../prompts/tools/ssh.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { SSHHostInfo } from "../ssh/connection-manager";
+import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
+import { executeSSH } from "../ssh/ssh-executor";
+import type { ToolSession } from "./index";
+import { createToolUIKit } from "./render-utils";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+
+const sshSchema = Type.Object({
+	host: Type.String({ description: "Host name from ssh.json or .ssh.json" }),
+	command: Type.String({ description: "Command to execute on the remote host" }),
+	cwd: Type.Optional(Type.String({ description: "Remote working directory (optional)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+
+export interface SSHToolDetails {
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+function formatHostEntry(host: SSHHost): string {
+	const info = getHostInfoForHost(host);
+
+	let shell: string;
+	if (!info) {
+		shell = "detecting...";
+	} else if (info.os === "windows") {
+		if (info.compatEnabled) {
+			const compatShell = info.compatShell || "bash";
+			shell = `windows/${compatShell}`;
+		} else if (info.shell === "powershell") {
+			shell = "windows/powershell";
+		} else {
+			shell = "windows/cmd";
+		}
+	} else if (info.os === "linux") {
+		shell = `linux/${info.shell}`;
+	} else if (info.os === "macos") {
+		shell = `macos/${info.shell}`;
+	} else {
+		shell = `unknown/${info.shell}`;
+	}
+
+	return `- ${host.name} (${host.host}) | ${shell}`;
+}
+
+function formatDescription(hosts: SSHHost[]): string {
+	if (hosts.length === 0) {
+		return sshDescriptionBase;
+	}
+	const hostList = hosts.map(formatHostEntry).join("\n");
+	return `${sshDescriptionBase}\n\nAvailable hosts:\n${hostList}`;
+}
+
+function quoteRemotePath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "'\\''");
+	return `'${escaped}'`;
+}
+
+function quotePowerShellPath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "''");
+	return `'${escaped}'`;
+}
+
+function quoteCmdPath(value: string): string {
+	const escaped = value.replace(/"/g, '""');
+	return `"${escaped}"`;
+}
+
+function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHHostInfo): string {
+	if (!cwd) return command;
+
+	if (info.os === "windows" && !info.compatEnabled) {
+		if (info.shell === "powershell") {
+			return `Set-Location -Path ${quotePowerShellPath(cwd)}; ${command}`;
+		}
+		return `cd /d ${quoteCmdPath(cwd)} && ${command}`;
+	}
+
+	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
+}
+
+function loadHosts(session: ToolSession): {
+	hostNames: string[];
+	hostsByName: Map<string, SSHHost>;
+} {
+	const result = loadSync<SSHHost>(sshCapability.id, { cwd: session.cwd });
+	const hostsByName = new Map<string, SSHHost>();
+	for (const host of result.items) {
+		if (!hostsByName.has(host.name)) {
+			hostsByName.set(host.name, host);
+		}
+	}
+	const hostNames = Array.from(hostsByName.keys()).sort();
+	return { hostNames, hostsByName };
+}
+
+export function createSshTool(session: ToolSession): AgentTool<typeof sshSchema> | null {
+	const { hostNames, hostsByName } = loadHosts(session);
+	if (hostNames.length === 0) {
+		return null;
+	}
+
+	const allowedHosts = new Set(hostNames);
+
+	const descriptionHosts = hostNames
+		.map((name) => hostsByName.get(name))
+		.filter((host): host is SSHHost => host !== undefined);
+
+	return {
+		name: "ssh",
+		label: "SSH",
+		description: formatDescription(descriptionHosts),
+		parameters: sshSchema,
+		execute: async (
+			_toolCallId: string,
+			{ host, command, cwd, timeout }: { host: string; command: string; cwd?: string; timeout?: number },
+			signal?: AbortSignal,
+			onUpdate?,
+			_ctx?: AgentToolContext,
+		) => {
+			if (!allowedHosts.has(host)) {
+				throw new Error(`Unknown SSH host: ${host}. Available hosts: ${hostNames.join(", ")}`);
+			}
+
+			const hostConfig = hostsByName.get(host);
+			if (!hostConfig) {
+				throw new Error(`SSH host not loaded: ${host}`);
+			}
+
+			const hostInfo = await ensureHostInfo(hostConfig);
+			const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
+			let currentOutput = "";
+
+			const result = await executeSSH(hostConfig, remoteCommand, {
+				timeout: timeout ? timeout * 1000 : undefined,
+				signal,
+				compatEnabled: hostInfo.compatEnabled,
+				onChunk: (chunk) => {
+					currentOutput += chunk;
+					if (onUpdate) {
+						const truncation = truncateTail(currentOutput);
+						onUpdate({
+							content: [{ type: "text", text: truncation.content || "" }],
+							details: {
+								truncation: truncation.truncated ? truncation : undefined,
+							},
+						});
+					}
+				},
+			});
+
+			if (result.cancelled) {
+				throw new Error(result.output || "Command aborted");
+			}
+
+			const truncation = truncateTail(result.output);
+			let outputText = truncation.content || "(no output)";
+
+			let details: SSHToolDetails | undefined;
+
+			if (truncation.truncated) {
+				details = {
+					truncation,
+					fullOutputPath: result.fullOutputPath,
+				};
+
+				const startLine = truncation.totalLines - truncation.outputLines + 1;
+				const endLine = truncation.totalLines;
+
+				if (truncation.lastLinePartial) {
+					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
+					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
+				} else if (truncation.truncatedBy === "lines") {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
+				} else {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
+				}
+			}
+
+			if (result.exitCode !== 0 && result.exitCode !== undefined) {
+				outputText += `\n\nCommand exited with code ${result.exitCode}`;
+				throw new Error(outputText);
+			}
+
+			return { content: [{ type: "text", text: outputText }], details };
+		},
+	};
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface SshRenderArgs {
+	host?: string;
+	command?: string;
+	timeout?: number;
+}
+
+interface SshRenderContext {
+	/** Visual lines for truncated output (pre-computed by tool-execution) */
+	visualLines?: string[];
+	/** Number of lines skipped */
+	skippedCount?: number;
+	/** Total visual lines */
+	totalVisualLines?: number;
+}
+
+export const sshToolRenderer = {
+	renderCall(args: SshRenderArgs, uiTheme: Theme): Component {
+		const ui = createToolUIKit(uiTheme);
+		const host = args.host || uiTheme.format.ellipsis;
+		const command = args.command || uiTheme.format.ellipsis;
+		const text = ui.title(`[${host}] $ ${command}`);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: {
+			content: Array<{ type: string; text?: string }>;
+			details?: SSHToolDetails;
+		},
+		options: RenderResultOptions & { renderContext?: SshRenderContext },
+		uiTheme: Theme,
+	): Component {
+		const ui = createToolUIKit(uiTheme);
+		const { expanded, renderContext } = options;
+		const details = result.details;
+		const lines: string[] = [];
+
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+		const output = textContent.trim();
+
+		if (output) {
+			if (expanded) {
+				const styledOutput = output
+					.split("\n")
+					.map((line) => uiTheme.fg("toolOutput", line))
+					.join("\n");
+				lines.push(styledOutput);
+			} else if (renderContext?.visualLines) {
+				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 {
+				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)`));
+				}
+			}
+		}
+
+		const truncation = details?.truncation;
+		const fullOutputPath = details?.fullOutputPath;
+		if (truncation?.truncated || fullOutputPath) {
+			const warnings: string[] = [];
+			if (fullOutputPath) {
+				warnings.push(`Full output: ${fullOutputPath}`);
+			}
+			if (truncation?.truncated) {
+				if (truncation.truncatedBy === "lines") {
+					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+				} else {
+					warnings.push(
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+					);
+				}
+			}
+			lines.push(uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". "))));
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};

package/src/core/tools/task/index.ts

@@ -13,8 +13,8 @@
  *   - Session artifacts for debugging
  */
 
-import type { Usage } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../../modes/interactive/theme/theme";
 import taskDescriptionTemplate from "../../../prompts/tools/task.md" with { type: "text" };
 import { formatDuration } from "../render-utils";