@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.0

package/src/{core/tools → tools}/render-utils.ts

@@ -6,7 +6,7 @@
  */
 
 import { homedir } from "node:os";
-import type { Theme } from "../../modes/interactive/theme/theme";
+import type { Theme } from "$c/modes/theme/theme";
 
 // =============================================================================
 // Standardized Display Constants

package/src/{core/tools → tools}/renderers.ts

@@ -5,25 +5,24 @@
  */
 
 import type { Component } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import type { RenderResultOptions } from "../custom-tools/types";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { lspToolRenderer } from "$c/lsp/render";
+import type { Theme } from "$c/modes/theme/theme";
+import { editToolRenderer } from "$c/patch";
+import { taskToolRenderer } from "$c/task/render";
+import { webSearchToolRenderer } from "$c/web/search/render";
 import { askToolRenderer } from "./ask";
 import { bashToolRenderer } from "./bash";
 import { calculatorToolRenderer } from "./calculator";
+import { fetchToolRenderer } from "./fetch";
 import { findToolRenderer } from "./find";
 import { grepToolRenderer } from "./grep";
 import { lsToolRenderer } from "./ls";
-import { lspToolRenderer } from "./lsp/render";
 import { notebookToolRenderer } from "./notebook";
-import { outputToolRenderer } from "./output";
-import { editToolRenderer } from "./patch";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { sshToolRenderer } from "./ssh";
-import { taskToolRenderer } from "./task/render";
 import { todoWriteToolRenderer } from "./todo-write";
-import { webFetchToolRenderer } from "./web-fetch";
-import { webSearchToolRenderer } from "./web-search/render";
 import { writeToolRenderer } from "./write";
 
 export interface RenderCallOptions {
@@ -54,12 +53,11 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	ls: lsToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	notebook: notebookToolRenderer as ToolRenderer,
-	output: outputToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,
 	todo_write: todoWriteToolRenderer as ToolRenderer,
-	web_fetch: webFetchToolRenderer as ToolRenderer,
+	fetch: fetchToolRenderer as ToolRenderer,
 	web_search: webSearchToolRenderer as ToolRenderer,
 	write: writeToolRenderer as ToolRenderer,
 };

package/src/{core/tools → tools}/review.ts

@@ -10,7 +10,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import type { Theme, ThemeColor } from "../../modes/interactive/theme/theme";
+import type { Theme, ThemeColor } from "$c/modes/theme/theme";
 
 export type FindingPriority = "P0" | "P1" | "P2" | "P3";
 
@@ -151,7 +151,7 @@ export type { ReportFindingDetails };
 
 import path from "node:path";
 import { StringEnum } from "@oh-my-pi/pi-ai";
-import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
+import { subprocessToolRegistry } from "$c/task/subprocess-tool-registry";
 
 // Register report_finding handler
 subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {

package/src/{core/tools → tools}/ssh.ts

@@ -2,30 +2,33 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 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 { loadCapability } 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 { renderPromptTemplate } from "../prompt-templates";
-import type { SSHHostInfo } from "../ssh/connection-manager";
-import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
-import { executeSSH } from "../ssh/ssh-executor";
+import type { SSHHost } from "$c/capability/ssh";
+import { sshCapability } from "$c/capability/ssh";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import { loadCapability } from "$c/discovery/index";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import type { Theme } from "$c/modes/theme/theme";
+import sshDescriptionBase from "$c/prompts/tools/ssh.md" with { type: "text" };
+import type { SSHHostInfo } from "$c/ssh/connection-manager";
+import { ensureHostInfo, getHostInfoForHost } from "$c/ssh/connection-manager";
+import { executeSSH } from "$c/ssh/ssh-executor";
+import type { OutputMeta } from "$c/tools/output-meta";
+import { ToolError } from "$c/tools/tool-errors";
 import type { ToolSession } from "./index";
+import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
 import { ToolUIKit } from "./render-utils";
-import { formatTailTruncationNotice, type TruncationResult, truncateTail } from "./truncate";
+import { toolResult } from "./tool-result";
+import { DEFAULT_MAX_BYTES } 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)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 60)" })),
 });
 
 export interface SSHToolDetails {
-	truncation?: TruncationResult;
-	fullOutputPath?: string;
+	meta?: OutputMeta;
 }
 
 function formatHostEntry(host: SSHHost): string {
@@ -125,11 +128,14 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	public readonly description: string;
 	public readonly parameters = sshSchema;
 
+	private readonly session: ToolSession;
+
 	private readonly allowedHosts: Set<string>;
 	private readonly hostsByName: Map<string, SSHHost>;
 	private readonly hostNames: string[];
 
-	constructor(hostNames: string[], hostsByName: Map<string, SSHHost>) {
+	constructor(session: ToolSession, hostNames: string[], hostsByName: Map<string, SSHHost>) {
+		this.session = session;
 		this.hostNames = hostNames;
 		this.hostsByName = hostsByName;
 		this.allowedHosts = new Set(hostNames);
@@ -143,68 +149,62 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 
 	public async execute(
 		_toolCallId: string,
-		{ host, command, cwd, timeout }: SshToolParams,
+		{ host, command, cwd, timeout: rawTimeout = 60 }: SshToolParams,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<SSHToolDetails>,
 		_ctx?: AgentToolContext,
 	): Promise<AgentToolResult<SSHToolDetails>> {
 		if (!this.allowedHosts.has(host)) {
-			throw new Error(`Unknown SSH host: ${host}. Available hosts: ${this.hostNames.join(", ")}`);
+			throw new ToolError(`Unknown SSH host: ${host}. Available hosts: ${this.hostNames.join(", ")}`);
 		}
 
 		const hostConfig = this.hostsByName.get(host);
 		if (!hostConfig) {
-			throw new Error(`SSH host not loaded: ${host}`);
+			throw new ToolError(`SSH host not loaded: ${host}`);
 		}
 
 		const hostInfo = await ensureHostInfo(hostConfig);
 		const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
-		let currentOutput = "";
+
+		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
+		let timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
+		// Clamp to reasonable range: 1s - 3600s (1 hour)
+		timeoutSec = Math.max(1, Math.min(3600, timeoutSec));
+		const timeoutMs = timeoutSec * 1000;
+
+		const tailBuffer = createTailBuffer(DEFAULT_MAX_BYTES);
+		const { artifactPath, artifactId } = await allocateOutputArtifact(this.session, "ssh");
 
 		const result = await executeSSH(hostConfig, remoteCommand, {
-			timeout: timeout ? timeout * 1000 : undefined,
+			timeout: timeoutMs,
 			signal,
 			compatEnabled: hostInfo.compatEnabled,
+			artifactPath,
+			artifactId,
 			onChunk: (chunk) => {
-				currentOutput += chunk;
+				tailBuffer.append(chunk);
 				if (onUpdate) {
-					const truncation = truncateTail(currentOutput);
 					onUpdate({
-						content: [{ type: "text", text: truncation.content || "" }],
-						details: {
-							truncation: truncation.truncated ? truncation : undefined,
-						},
+						content: [{ type: "text", text: tailBuffer.text() }],
+						details: {},
 					});
 				}
 			},
 		});
 
 		if (result.cancelled) {
-			throw new Error(result.output || "Command aborted");
+			throw new ToolError(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,
-			};
-			outputText += formatTailTruncationNotice(truncation, {
-				fullOutputPath: result.fullOutputPath,
-				originalContent: result.output,
-			});
-		}
+		const outputText = result.output || "(no output)";
+		const details: SSHToolDetails = {};
+		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
 
 		if (result.exitCode !== 0 && result.exitCode !== undefined) {
-			outputText += `\n\nCommand exited with code ${result.exitCode}`;
-			throw new Error(outputText);
+			throw new ToolError(`${outputText}\n\nCommand exited with code ${result.exitCode}`);
 		}
 
-		return { content: [{ type: "text", text: outputText }], details: details ?? {} };
+		return resultBuilder.done();
 	}
 }
 
@@ -213,7 +213,7 @@ export async function loadSshTool(session: ToolSession): Promise<SshTool | null>
 	if (hostNames.length === 0) {
 		return null;
 	}
-	return new SshTool(hostNames, hostsByName);
+	return new SshTool(session, hostNames, hostsByName);
 }
 
 // =============================================================================
@@ -291,21 +291,18 @@ export const sshToolRenderer = {
 			}
 		}
 
-		const truncation = details?.truncation;
-		const fullOutputPath = details?.fullOutputPath;
-		if (truncation?.truncated || fullOutputPath) {
+		const truncation = details?.meta?.truncation;
+		if (truncation) {
 			const warnings: string[] = [];
-			if (fullOutputPath) {
-				warnings.push(`Full output: ${fullOutputPath}`);
+			if (truncation.artifactId) {
+				warnings.push(`Full output: artifact://${truncation.artifactId}`);
 			}
-			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)} limit)`,
-					);
-				}
+			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.outputBytes)} limit)`,
+				);
 			}
 			lines.push(uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". "))));
 		}

package/src/{core/tools → tools}/todo-write.ts

@@ -7,18 +7,17 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import chalk from "chalk";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import todoWriteDescription from "../../prompts/tools/todo-write.md" with { type: "text" };
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
-import type { ToolSession } from "../sdk";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import type { Theme } from "$c/modes/theme/theme";
+import todoWriteDescription from "$c/prompts/tools/todo-write.md" with { type: "text" };
+import type { ToolSession } from "$c/sdk";
 
 const todoWriteSchema = Type.Object({
 	todos: Type.Array(
 		Type.Object({
 			id: Type.Optional(Type.String({ description: "Stable todo id" })),
-			content: Type.String({ description: "Imperative task description (e.g., 'Run tests')" }),
-			activeForm: Type.String({ description: "Present continuous form (e.g., 'Running tests')" }),
+			content: Type.String({ description: "Task description (e.g., 'Run tests')" }),
 			status: StringEnum(["pending", "in_progress", "completed"]),
 		}),
 		{ description: "The updated todo list" },
@@ -30,7 +29,6 @@ type TodoStatus = "pending" | "in_progress" | "completed";
 export interface TodoItem {
 	id: string;
 	content: string;
-	activeForm: string;
 	status: TodoStatus;
 }
 
@@ -47,7 +45,7 @@ export interface TodoWriteToolDetails {
 
 const TODO_FILE_NAME = "todos.json";
 
-type TodoWriteParams = { todos: Array<{ id?: string; content?: string; activeForm?: string; status?: string }> };
+type TodoWriteParams = { todos: Array<{ id?: string; content?: string; status?: string }> };
 
 function normalizeTodoStatus(status?: string): TodoStatus {
 	switch (status) {
@@ -62,25 +60,18 @@ function normalizeTodoStatus(status?: string): TodoStatus {
 	}
 }
 
-function normalizeTodos(
-	items: Array<{ id?: string; content?: string; activeForm?: string; status?: string }>,
-): TodoItem[] {
+function normalizeTodos(items: Array<{ id?: string; content?: string; status?: string }>): TodoItem[] {
 	return items.map((item) => {
-		if (!item.content || !item.activeForm) {
-			throw new Error("Todo content and activeForm are required.");
+		if (!item.content) {
+			throw new Error("Todo content is required.");
 		}
 		const content = item.content.trim();
-		const activeForm = item.activeForm.trim();
 		if (!content) {
 			throw new Error("Todo content cannot be empty.");
 		}
-		if (!activeForm) {
-			throw new Error("Todo activeForm cannot be empty.");
-		}
 		return {
 			id: item.id && item.id.trim().length > 0 ? item.id : randomUUID(),
 			content,
-			activeForm,
 			status: normalizeTodoStatus(item.status),
 		};
 	});
@@ -143,13 +134,11 @@ function formatTodoSummary(todos: TodoItem[]): string {
 
 function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
 	const checkbox = uiTheme.checkbox;
-	const displayText =
-		item.status === "in_progress" && item.activeForm !== item.content ? item.activeForm : item.content;
 	switch (item.status) {
 		case "completed":
 			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
 		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${displayText}`);
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
 		default:
 			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
 	}
@@ -222,7 +211,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 // =============================================================================
 
 interface TodoWriteRenderArgs {
-	todos?: Array<{ id?: string; content?: string; activeForm?: string; status?: string }>;
+	todos?: Array<{ id?: string; content?: string; status?: string }>;
 }
 
 export const todoWriteToolRenderer = {

package/src/tools/tool-errors.ts

@@ -0,0 +1,95 @@
+/**
+ * Standardized error types for tool execution.
+ *
+ * Tools should throw these instead of returning error text.
+ * The agent loop catches and renders them appropriately.
+ */
+
+/**
+ * Base error for tool execution failures.
+ * Override render() for custom LLM-facing formatting.
+ */
+export class ToolError extends Error {
+	constructor(
+		message: string,
+		readonly context?: Record<string, unknown>,
+	) {
+		super(message);
+		this.name = "ToolError";
+	}
+
+	/** Render error for LLM consumption. Override for custom formatting. */
+	render(): string {
+		return this.message;
+	}
+}
+
+/**
+ * Error entry for MultiError.
+ */
+export interface ErrorEntry {
+	message: string;
+	context?: string;
+}
+
+/**
+ * Error with multiple entries (e.g., multiple validation failures, batch errors).
+ */
+export class MultiError extends ToolError {
+	readonly errors: ErrorEntry[];
+
+	constructor(errors: ErrorEntry[]) {
+		super(errors.map((e) => e.message).join("; "));
+		this.name = "MultiError";
+		this.errors = errors;
+	}
+
+	render(): string {
+		if (this.errors.length === 1) {
+			const e = this.errors[0];
+			return e.context ? `${e.context}: ${e.message}` : e.message;
+		}
+		return this.errors.map((e) => (e.context ? `${e.context}: ${e.message}` : e.message)).join("\n");
+	}
+
+	static from(errors: Array<string | ErrorEntry>): MultiError {
+		return new MultiError(errors.map((e) => (typeof e === "string" ? { message: e } : e)));
+	}
+}
+
+/**
+ * Error thrown when a tool operation is aborted (e.g., via AbortSignal).
+ */
+export class ToolAbortError extends Error {
+	static readonly MESSAGE = "Operation aborted";
+
+	constructor(message: string = ToolAbortError.MESSAGE) {
+		super(message);
+		this.name = "ToolAbortError";
+	}
+}
+
+/**
+ * Throw ToolAbortError if the signal is aborted.
+ * Use this instead of signal?.throwIfAborted() to get consistent error types.
+ */
+export function throwIfAborted(signal?: AbortSignal): void {
+	if (signal?.aborted) {
+		const reason = signal.reason instanceof Error ? signal.reason : undefined;
+		throw reason instanceof ToolAbortError ? reason : new ToolAbortError();
+	}
+}
+
+/**
+ * Render an error for LLM consumption.
+ * Handles ToolError.render() and falls back to message/string.
+ */
+export function renderError(e: unknown): string {
+	if (e instanceof ToolError) {
+		return e.render();
+	}
+	if (e instanceof Error) {
+		return e.message;
+	}
+	return String(e);
+}

package/src/tools/tool-result.ts

@@ -0,0 +1,92 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { OutputSummary } from "$c/session/streaming-output";
+import type {
+	OutputMeta,
+	TruncationOptions,
+	TruncationSummaryOptions,
+	TruncationTextOptions,
+} from "$c/tools/output-meta";
+import { outputMeta } from "$c/tools/output-meta";
+import type { TruncationResult } from "./truncate";
+
+type ToolContent = Array<TextContent | ImageContent>;
+
+type DetailsWithMeta = { meta?: OutputMeta };
+
+export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
+	#details: TDetails;
+	#meta = outputMeta();
+	#content: ToolContent = [];
+
+	constructor(details?: TDetails) {
+		this.#details = details ?? ({} as TDetails);
+	}
+
+	text(text: string): this {
+		this.#content = [{ type: "text", text }];
+		return this;
+	}
+
+	content(content: ToolContent): this {
+		this.#content = content;
+		return this;
+	}
+
+	truncation(result: TruncationResult, options: TruncationOptions): this {
+		this.#meta.truncation(result, options);
+		return this;
+	}
+
+	truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this {
+		this.#meta.truncationFromSummary(summary, options);
+		return this;
+	}
+
+	truncationFromText(text: string, options: TruncationTextOptions): this {
+		this.#meta.truncationFromText(text, options);
+		return this;
+	}
+
+	limits(limits: { matchLimit?: number; resultLimit?: number; headLimit?: number; columnMax?: number }): this {
+		this.#meta.limits(limits);
+		return this;
+	}
+
+	sourceUrl(value: string): this {
+		this.#meta.sourceUrl(value);
+		return this;
+	}
+
+	sourcePath(value: string): this {
+		this.#meta.sourcePath(value);
+		return this;
+	}
+
+	sourceInternal(value: string): this {
+		this.#meta.sourceInternal(value);
+		return this;
+	}
+
+	diagnostics(summary: string, messages: string[]): this {
+		this.#meta.diagnostics(summary, messages);
+		return this;
+	}
+
+	done(): AgentToolResult<TDetails> {
+		const meta = this.#meta.get();
+		if (meta) {
+			this.#details.meta = meta;
+		}
+		const hasDetails = Object.entries(this.#details).some(([, value]) => value !== undefined);
+
+		return {
+			content: this.#content,
+			details: hasDetails ? this.#details : undefined,
+		};
+	}
+}
+
+export function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails> {
+	return new ToolResultBuilder(details);
+}

package/src/{core/tools → tools}/truncate.ts

@@ -2,14 +2,14 @@
  * Shared truncation utilities for tool outputs.
  *
  * Truncation is based on two independent limits - whichever is hit first wins:
- * - Line limit (default: 2000 lines)
+ * - Line limit (default: 4000 lines)
  * - Byte limit (default: 50KB)
  *
  * Never returns partial lines (except bash tail truncation edge case
  * and the read tool's long-line snippet fallback).
  */
 
-export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_LINES = 3000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
 

package/src/{core/tools → tools}/write.ts

@@ -9,17 +9,18 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/interactive/theme/theme";
-import writeDescription from "../../prompts/tools/write.md" with { type: "text" };
-import type { RenderResultOptions } from "../custom-tools/types";
-import { renderPromptTemplate } from "../prompt-templates";
-import type { ToolSession } from "../sdk";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
 	type WritethroughCallback,
 	writethroughNoop,
-} from "./lsp/index";
+} from "$c/lsp/index";
+import { getLanguageFromPath, highlightCode, type Theme } from "$c/modes/theme/theme";
+import writeDescription from "$c/prompts/tools/write.md" with { type: "text" };
+import type { ToolSession } from "$c/sdk";
+import { type OutputMeta, outputMeta } from "$c/tools/output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatDiagnostics, formatExpandHint, formatStatusIcon, replaceTabs, shortenPath } from "./render-utils";
 import type { RenderCallOptions } from "./renderers";
@@ -32,6 +33,7 @@ const writeSchema = Type.Object({
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {
 	diagnostics?: FileDiagnosticsResult;
+	meta?: OutputMeta;
 }
 
 const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
@@ -94,7 +96,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			const diagnostics = await this.writethrough(absolutePath, content, signal, undefined, batchRequest);
 
-			let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+			const resultText = `Successfully wrote ${content.length} bytes to ${path}`;
 			if (!diagnostics) {
 				return {
 					content: [{ type: "text", text: resultText }],
@@ -102,14 +104,14 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				};
 			}
 
-			const messages = diagnostics?.messages;
-			if (messages && messages.length > 0) {
-				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
-				resultText += messages.map((d) => `  ${d}`).join("\n");
-			}
 			return {
 				content: [{ type: "text", text: resultText }],
-				details: { diagnostics },
+				details: {
+					diagnostics,
+					meta: outputMeta()
+						.diagnostics(diagnostics.summary, diagnostics.messages ?? [])
+						.get(),
+				},
 			};
 		});
 	}

package/src/utils/changelog.ts

@@ -96,4 +96,4 @@ export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): C
 }
 
 // Re-export getChangelogPath from paths.ts for convenience
-export { getChangelogPath } from "../config";
+export { getChangelogPath } from "$c/config";

package/src/{core → utils}/file-mentions.ts

@@ -8,10 +8,10 @@
 
 import path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { FileMentionMessage } from "./messages";
-import { resolveReadPath } from "./tools/path-utils";
-import { formatAge } from "./tools/render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, truncateHead, truncateStringToBytesFromStart } from "./tools/truncate";
+import type { FileMentionMessage } from "$c/session/messages";
+import { resolveReadPath } from "$c/tools/path-utils";
+import { formatAge } from "$c/tools/render-utils";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead, truncateStringToBytesFromStart } from "$c/tools/truncate";
 
 /** Regex to match @filepath patterns in text */
 const FILE_MENTION_REGEX = /@([^\s@]+)/g;

package/src/utils/image-convert.ts

@@ -1,4 +1,4 @@
-import * as photon from "../vendor/photon";
+import * as photon from "$c/vendor/photon";
 
 /**
  * Convert image to PNG format for terminal display.