@oh-my-pi/pi-coding-agent 12.18.1 → 12.19.0

package/src/task/parallel.ts

@@ -82,3 +82,35 @@ export async function mapWithConcurrencyLimit<T, R>(
 
 	return { results, aborted: signal?.aborted ?? false };
 }
+
+/**
+ * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ */
+export class Semaphore {
+	#max: number;
+	#current = 0;
+	#queue: Array<() => void> = [];
+
+	constructor(max: number) {
+		this.#max = Math.max(1, max);
+	}
+
+	async acquire(): Promise<void> {
+		if (this.#current < this.#max) {
+			this.#current++;
+			return;
+		}
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#queue.push(resolve);
+		return promise;
+	}
+
+	release(): void {
+		const next = this.#queue.shift();
+		if (next) {
+			next();
+		} else {
+			this.#current--;
+		}
+	}
+}

package/src/task/render.ts

@@ -7,6 +7,7 @@
 import path from "node:path";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
+import { formatNumber } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import {
@@ -14,7 +15,6 @@ import {
 	formatDuration,
 	formatMoreItems,
 	formatStatusIcon,
-	formatTokens,
 	replaceTabs,
 	truncateToWidth,
 } from "../tools/render-utils";
@@ -518,13 +518,19 @@ function renderAgentProgress(
 			const taskPreview = truncateToWidth(progress.task, 40);
 			statusLine += ` ${theme.fg("muted", taskPreview)}`;
 		}
-		statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
+		if (progress.toolCount > 0) {
+			statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
+		}
 		if (progress.tokens > 0) {
-			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
+			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(progress.tokens)} tokens`)}`;
 		}
 	} else if (progress.status === "completed") {
-		statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
-		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
+		if (progress.toolCount > 0) {
+			statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
+		}
+		if (progress.tokens > 0) {
+			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(progress.tokens)} tokens`)}`;
+		}
 	}
 
 	lines.push(statusLine);
@@ -744,7 +750,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 		theme,
 	)}`;
 	if (result.tokens > 0) {
-		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
+		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(result.tokens)} tokens`)}`;
 	}
 	statusLine += `${theme.sep.dot}${theme.fg("dim", formatDuration(result.durationMs))}`;
 
@@ -882,7 +888,9 @@ export function renderResult(
 
 			const lines: string[] = [];
 
-			if (isPartial && details.progress) {
+			const shouldRenderProgress =
+				Boolean(details.progress && details.progress.length > 0) && (isPartial || details.results.length === 0);
+			if (shouldRenderProgress && details.progress) {
 				details.progress.forEach((progress, i) => {
 					const isLast = i === details.progress!.length - 1;
 					lines.push(...renderAgentProgress(progress, isLast, expanded, theme, spinnerFrame));

package/src/task/types.ts

@@ -193,4 +193,9 @@ export interface TaskToolDetails {
 	usage?: Usage;
 	outputPaths?: string[];
 	progress?: AgentProgress[];
+	async?: {
+		state: "running" | "completed" | "failed";
+		jobId: string;
+		type: "task";
+	};
 }

package/src/tools/ask.ts

@@ -24,7 +24,7 @@ import { type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
 import { renderStatusLine } from "../tui";
 import type { ToolSession } from ".";
-import { ToolUIKit } from "./render-utils";
+import { formatErrorMessage, formatMeta, formatTitle } from "./render-utils";
 
 // =============================================================================
 // Types
@@ -75,8 +75,6 @@ export interface AskToolDetails {
 
 const OTHER_OPTION = "Other (type your own)";
 const RECOMMENDED_SUFFIX = " (Recommended)";
-/** Default timeout in milliseconds (used when settings unavailable) */
-const _DEFAULT_ASK_TIMEOUT_MS = 30000;
 
 function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
@@ -381,8 +379,7 @@ interface AskRenderArgs {
 
 export const askToolRenderer = {
 	renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const ui = new ToolUIKit(uiTheme);
-		const label = ui.title("Ask");
+		const label = formatTitle("Ask", uiTheme);
 
 		// Multi-part questions
 		if (args.questions && args.questions.length > 0) {
@@ -417,14 +414,14 @@ export const askToolRenderer = {
 
 		// Single question
 		if (!args.question) {
-			return new Text(ui.errorMessage("No question provided"), 0, 0);
+			return new Text(formatErrorMessage("No question provided", uiTheme), 0, 0);
 		}
 
 		let text = `${label} ${uiTheme.fg("accent", args.question)}`;
 		const meta: string[] = [];
 		if (args.multi) meta.push("multi");
 		if (args.options?.length) meta.push(`options:${args.options.length}`);
-		text += ui.meta(meta);
+		text += formatMeta(meta, uiTheme);
 
 		if (args.options?.length) {
 			for (let i = 0; i < args.options.length; i++) {

package/src/tools/bash-interactive.ts

@@ -13,8 +13,7 @@ import type { Terminal as XtermTerminalType } from "@xterm/headless";
 import xterm from "@xterm/headless";
 import type { Theme } from "../modes/theme/theme";
 import { OutputSink, type OutputSummary } from "../session/streaming-output";
-import { getStateIcon } from "../tui";
-import { replaceTabs } from "./render-utils";
+import { formatStatusIcon, replaceTabs } from "./render-utils";
 
 export interface BashInteractiveResult extends OutputSummary {
 	exitCode: number | undefined;
@@ -235,10 +234,10 @@ class BashInteractiveOverlayComponent implements Component {
 		}
 		const statusIcon =
 			this.#state === "running"
-				? getStateIcon("running", this.uiTheme)
+				? formatStatusIcon("running", this.uiTheme)
 				: this.#state === "complete" && this.#exitCode === 0
-					? getStateIcon("success", this.uiTheme)
-					: getStateIcon("warning", this.uiTheme);
+					? formatStatusIcon("success", this.uiTheme)
+					: formatStatusIcon("warning", this.uiTheme);
 		const title = this.uiTheme.fg("accent", "Console");
 		const statusBadge = `${this.uiTheme.fg("dim", this.uiTheme.format.bracketLeft)}${this.#stateText()}${this.uiTheme.fg("dim", this.uiTheme.format.bracketRight)}`;
 		const prefix = `${statusIcon} ${title} `;

package/src/tools/bash.ts

@@ -5,13 +5,14 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { $env, isEnoent } from "@oh-my-pi/pi-utils";
 import { getProjectDir } from "@oh-my-pi/pi-utils/dirs";
-import { type Static, Type } from "@sinclair/typebox";
+import { Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import type { Theme } from "../modes/theme/theme";
 import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
+import { DEFAULT_MAX_BYTES, TailBuffer } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
@@ -19,17 +20,15 @@ import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-intera
 import { checkBashInterception } from "./bash-interceptor";
 import { applyHeadTail } from "./bash-normalize";
 import { expandInternalUrls } from "./bash-skill-urls";
-import type { OutputMeta } from "./output-meta";
-import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
+import { formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
-import { formatBytes, replaceTabs, wrapBrackets } from "./render-utils";
+import { replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
-import { DEFAULT_MAX_BYTES } from "./truncate";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
-const bashSchema = Type.Object({
+const bashSchemaBase = Type.Object({
 	command: Type.String({ description: "Command to execute" }),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 300)" })),
 	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
@@ -37,10 +36,33 @@ const bashSchema = Type.Object({
 	tail: Type.Optional(Type.Number({ description: "Return only last N lines of output" })),
 });
 
-export type BashToolInput = Static<typeof bashSchema>;
+const bashSchemaWithAsync = Type.Object({
+	...bashSchemaBase.properties,
+	async: Type.Optional(
+		Type.Boolean({
+			description: "Run in background; returns immediately with a job ID. Result delivered as follow-up.",
+		}),
+	),
+});
+
+type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
+
+export interface BashToolInput {
+	command: string;
+	timeout?: number;
+	cwd?: string;
+	head?: number;
+	tail?: number;
+	async?: boolean;
+}
 
 export interface BashToolDetails {
 	meta?: OutputMeta;
+	async?: {
+		state: "running" | "completed" | "failed";
+		jobId: string;
+		type: "bash";
+	};
 }
 
 export interface BashToolOptions {}
@@ -57,26 +79,61 @@ function isInteractiveResult(result: BashResult | BashInteractiveResult): result
  *
  * Executes bash commands with optional timeout and working directory.
  */
-export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
+export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly name = "bash";
 	readonly label = "Bash";
 	readonly description: string;
-	readonly parameters = bashSchema;
+	readonly parameters: BashToolSchema;
 	readonly concurrency = "exclusive";
+	readonly #asyncEnabled: boolean;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(bashDescription);
+		this.#asyncEnabled = this.session.settings.get("async.enabled");
+		this.parameters = this.#asyncEnabled ? bashSchemaWithAsync : bashSchemaBase;
+		this.description = renderPromptTemplate(bashDescription, { asyncEnabled: this.#asyncEnabled });
+	}
+
+	#formatResultOutput(result: BashResult | BashInteractiveResult, headLines?: number, tailLines?: number): string {
+		let outputText = normalizeResultOutput(result);
+		const headTailResult = applyHeadTail(outputText, headLines, tailLines);
+		if (headTailResult.applied) {
+			outputText = headTailResult.text;
+		}
+		if (!outputText) {
+			outputText = "(no output)";
+		}
+		return outputText;
+	}
+
+	#buildResultText(result: BashResult | BashInteractiveResult, timeoutSec: number, outputText: string): string {
+		if (result.cancelled) {
+			throw new ToolError(normalizeResultOutput(result) || "Command aborted");
+		}
+		if (isInteractiveResult(result) && result.timedOut) {
+			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
+		}
+		if (result.exitCode === undefined) {
+			throw new ToolError(`${outputText}\n\nCommand failed: missing exit status`);
+		}
+		if (result.exitCode !== 0) {
+			throw new ToolError(`${outputText}\n\nCommand exited with code ${result.exitCode}`);
+		}
+		return outputText;
 	}
 
 	async execute(
 		_toolCallId: string,
-		{ command: rawCommand, timeout: rawTimeout = 300, cwd, head, tail }: BashToolInput,
+		{ command: rawCommand, timeout: rawTimeout = 300, cwd, head, tail, async: asyncRequested = false }: BashToolInput,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
 	): Promise<AgentToolResult<BashToolDetails>> {
 		let command = rawCommand;
 
+		if (asyncRequested && !this.#asyncEnabled) {
+			throw new ToolError("Async bash execution is disabled. Enable async.enabled to use async mode.");
+		}
+
 		// Only apply explicit head/tail params from tool input.
 		const headLines = head;
 		const tailLines = tail;
@@ -113,13 +170,64 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		const timeoutSec = Math.max(1, Math.min(3600, rawTimeout));
 		const timeoutMs = timeoutSec * 1000;
 
+		if (asyncRequested) {
+			const manager = this.session.asyncJobManager;
+			if (!manager) {
+				throw new ToolError("Async job manager unavailable for this session.");
+			}
+			const label = command.length > 120 ? `${command.slice(0, 117)}...` : command;
+			const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);
+			const jobId = manager.register(
+				"bash",
+				label,
+				async ({ jobId, signal: runSignal, reportProgress }) => {
+					const artifactsDir = this.session.getArtifactsDir?.();
+					const extraEnv = artifactsDir ? { ARTIFACTS: artifactsDir } : undefined;
+					const { path: artifactPath, id: artifactId } =
+						(await this.session.allocateOutputArtifact?.("bash")) ?? {};
+					try {
+						const result = await executeBash(command, {
+							cwd: commandCwd,
+							sessionKey: this.session.getSessionId?.() ?? undefined,
+							timeout: timeoutMs,
+							signal: runSignal,
+							env: extraEnv,
+							artifactPath,
+							artifactId,
+							onChunk: chunk => {
+								tailBuffer.append(chunk);
+								void reportProgress(tailBuffer.text(), { async: { state: "running", jobId, type: "bash" } });
+							},
+						});
+						const outputText = this.#formatResultOutput(result, headLines, tailLines);
+						const finalText = this.#buildResultText(result, timeoutSec, outputText);
+						await reportProgress(finalText, { async: { state: "completed", jobId, type: "bash" } });
+						return finalText;
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						await reportProgress(message, { async: { state: "failed", jobId, type: "bash" } });
+						throw error;
+					}
+				},
+				{
+					onProgress: (text, details) => {
+						onUpdate?.({ content: [{ type: "text", text }], details: details ?? {} });
+					},
+				},
+			);
+			return {
+				content: [{ type: "text", text: `Background job ${jobId} started: ${label}` }],
+				details: { async: { state: "running", jobId, type: "bash" } },
+			};
+		}
+
 		// Track output for streaming updates (tail only)
-		const tailBuffer = createTailBuffer(DEFAULT_MAX_BYTES);
+		const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);
 
 		// Set up artifacts environment and allocation
 		const artifactsDir = this.session.getArtifactsDir?.();
 		const extraEnv = artifactsDir ? { ARTIFACTS: artifactsDir } : undefined;
-		const { artifactPath, artifactId } = await allocateOutputArtifact(this.session, "bash");
+		const { path: artifactPath, id: artifactId } = (await this.session.allocateOutputArtifact?.("bash")) ?? {};
 
 		const usePty =
 			this.session.settings.get("bash.virtualTerminal") === "on" &&
@@ -163,15 +271,8 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		if (isInteractiveResult(result) && result.timedOut) {
 			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
 		}
-		// Apply head/tail filtering if specified
-		let outputText = normalizeResultOutput(result);
-		const headTailResult = applyHeadTail(outputText, headLines, tailLines);
-		if (headTailResult.applied) {
-			outputText = headTailResult.text;
-		}
-		if (!outputText) {
-			outputText = "(no output)";
-		}
+
+		const outputText = this.#formatResultOutput(result, headLines, tailLines);
 		const details: BashToolDetails = {};
 		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
 		if (result.exitCode === undefined) {
@@ -232,9 +333,6 @@ function formatBashCommand(args: BashRenderArgs, _uiTheme: Theme): string {
 	return displayWorkdir ? `${prompt} cd ${displayWorkdir} && ${command}` : `${prompt} ${command}`;
 }
 
-// Preview line limit when not expanded (matches tool-execution behavior)
-export const BASH_PREVIEW_LINES = 10;
-
 export const bashToolRenderer = {
 	renderCall(args: BashRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const cmdText = formatBashCommand(args, uiTheme);
@@ -256,7 +354,6 @@ export const bashToolRenderer = {
 		const isError = result.isError === true;
 		const header = renderStatusLine({ icon: isError ? "error" : "success", title: "Bash" }, uiTheme);
 		const details = result.details;
-		const truncation = details?.meta?.truncation;
 		const outputBlock = new CachedOutputBlock();
 
 		return {
@@ -281,21 +378,8 @@ export const bashToolRenderer = {
 							)
 						: undefined;
 				let warningLine: string | undefined;
-				if (truncation && !showingFullOutput) {
-					const warnings: string[] = [];
-					if (truncation?.artifactId) {
-						warnings.push(`Full output: artifact://${truncation.artifactId}`);
-					}
-					if (truncation.truncatedBy === "lines") {
-						warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-					} else {
-						warnings.push(
-							`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.outputBytes)} limit)`,
-						);
-					}
-					if (warnings.length > 0) {
-						warningLine = uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme));
-					}
+				if (details?.meta?.truncation && !showingFullOutput) {
+					warningLine = formatStyledTruncationWarning(details.meta, uiTheme) ?? undefined;
 				}
 
 				const outputLines: string[] = [];

package/src/tools/cancel-job.ts

@@ -0,0 +1,93 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { type Static, Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import cancelJobDescription from "../prompts/tools/cancel-job.md" with { type: "text" };
+import type { ToolSession } from "./index";
+
+const cancelJobSchema = Type.Object({
+	job_id: Type.String({ description: "Background job ID" }),
+});
+
+type CancelJobParams = Static<typeof cancelJobSchema>;
+
+export interface CancelJobToolDetails {
+	status: "cancelled" | "not_found" | "already_completed";
+	jobId: string;
+}
+
+export class CancelJobTool implements AgentTool<typeof cancelJobSchema, CancelJobToolDetails> {
+	readonly name = "cancel_job";
+	readonly label = "CancelJob";
+	readonly description: string;
+	readonly parameters = cancelJobSchema;
+
+	constructor(private readonly session: ToolSession) {
+		this.description = renderPromptTemplate(cancelJobDescription);
+	}
+
+	static createIf(session: ToolSession): CancelJobTool | null {
+		if (!session.settings.get("async.enabled")) return null;
+		return new CancelJobTool(session);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: CancelJobParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<CancelJobToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<CancelJobToolDetails>> {
+		const manager = this.session.asyncJobManager;
+		if (!manager) {
+			return {
+				content: [
+					{ type: "text", text: "Async execution is disabled; no background jobs are available to cancel." },
+				],
+				details: {
+					status: "not_found",
+					jobId: params.job_id,
+				},
+			};
+		}
+
+		const existing = manager.getJob(params.job_id);
+		if (!existing) {
+			return {
+				content: [{ type: "text", text: `Background job not found: ${params.job_id}` }],
+				details: {
+					status: "not_found",
+					jobId: params.job_id,
+				},
+			};
+		}
+
+		if (existing.status !== "running") {
+			return {
+				content: [{ type: "text", text: `Background job ${params.job_id} is already ${existing.status}.` }],
+				details: {
+					status: "already_completed",
+					jobId: params.job_id,
+				},
+			};
+		}
+
+		const cancelled = manager.cancel(params.job_id);
+		if (!cancelled) {
+			return {
+				content: [{ type: "text", text: `Background job ${params.job_id} is already completed.` }],
+				details: {
+					status: "already_completed",
+					jobId: params.job_id,
+				},
+			};
+		}
+
+		return {
+			content: [{ type: "text", text: `Cancelled background job ${params.job_id}.` }],
+			details: {
+				status: "cancelled",
+				jobId: params.job_id,
+			},
+		};
+	}
+}

package/src/tools/fetch.ts

@@ -3,13 +3,14 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { htmlToMarkdown } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { ptree } from "@oh-my-pi/pi-utils";
+import { ptree, truncate } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { parse as parseHtml } from "node-html-parser";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import fetchDescription from "../prompts/tools/fetch.md" with { type: "text" };
+import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { ensureTool } from "../utils/tools-manager";
@@ -19,12 +20,10 @@ import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/type
 import { convertWithMarkitdown, fetchBinary } from "../web/scrapers/utils";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
-import type { OutputMeta } from "./output-meta";
-import { allocateOutputArtifact } from "./output-utils";
-import { formatExpandHint } from "./render-utils";
+import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
+import { formatExpandHint, getDomain } from "./render-utils";
 import { ToolAbortError } from "./tool-errors";
 import { toolResult } from "./tool-result";
-import { DEFAULT_MAX_BYTES, truncateHead } from "./truncate";
 
 // =============================================================================
 // Types and Constants
@@ -900,10 +899,10 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 		};
 
 		if (needsArtifact) {
-			const { artifactPath, artifactId: allocatedId } = await allocateOutputArtifact(this.session, "fetch");
+			const { path: artifactPath, id } = (await this.session.allocateOutputArtifact?.("fetch")) ?? {};
 			if (artifactPath) {
 				await Bun.write(artifactPath, buildOutput(result.content));
-				artifactId = allocatedId;
+				artifactId = id;
 			}
 		}
 
@@ -942,23 +941,6 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 // TUI Rendering
 // =============================================================================
 
-/** Truncate text to max length with ellipsis */
-function truncate(text: string, maxLen: number, ellipsis: string): string {
-	if (text.length <= maxLen) return text;
-	const sliceLen = Math.max(0, maxLen - ellipsis.length);
-	return `${text.slice(0, sliceLen)}${ellipsis}`;
-}
-
-/** Extract domain from URL */
-function getDomain(url: string): string {
-	try {
-		const u = new URL(url);
-		return u.hostname.replace(/^www\./, "");
-	} catch {
-		return url;
-	}
-}
-
 /** Count non-empty lines */
 function countNonEmptyLines(text: string): number {
 	return text.split("\n").filter(l => l.trim()).length;
@@ -1029,9 +1011,7 @@ export function renderFetchResult(
 	metadataLines.push(`${uiTheme.fg("muted", "Chars:")} ${charCount}`);
 	if (truncated) {
 		metadataLines.push(uiTheme.fg("warning", `${uiTheme.status.warning} Output truncated`));
-		if (truncation?.artifactId) {
-			metadataLines.push(uiTheme.fg("warning", `Full output: artifact://${truncation.artifactId}`));
-		}
+		if (truncation?.artifactId) metadataLines.push(formatStyledArtifactReference(truncation.artifactId, uiTheme));
 	}
 	if (hasNotes) {
 		metadataLines.push(`${uiTheme.fg("muted", "Notes:")} ${details.notes.join("; ")}`);

package/src/tools/find.ts

@@ -11,6 +11,7 @@ import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import findDescription from "../prompts/tools/find.md" with { type: "text" };
+import { type TruncationResult, truncateHead } from "../session/streaming-output";
 import {
 	Ellipsis,
 	Hasher,
@@ -22,12 +23,11 @@ import {
 } from "../tui";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
-import type { OutputMeta } from "./output-meta";
+import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
-import { type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
 	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', 'src/**/*.json', 'lib/*.tsx'" }),
@@ -506,7 +506,7 @@ export const findToolRenderer = {
 		if (limits?.resultLimit) truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
 		if (truncation) truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
 		const artifactId = truncation && "artifactId" in truncation ? truncation.artifactId : undefined;
-		if (artifactId) truncationReasons.push(`full output: artifact://${artifactId}`);
+		if (artifactId) truncationReasons.push(formatFullOutputReference(artifactId));
 
 		const extraLines: string[] = [];
 		if (truncationReasons.length > 0) {