@oh-my-pi/pi-coding-agent 13.11.0 → 13.12.0

package/src/session/streaming-output.ts

@@ -36,16 +36,14 @@ export interface OutputSinkOptions {
 
 export interface TruncationResult {
 	content: string;
-	truncated: boolean;
-	truncatedBy: "lines" | "bytes" | null;
+	truncated?: boolean;
+	truncatedBy?: "lines" | "bytes";
 	totalLines: number;
 	totalBytes: number;
-	outputLines: number;
-	outputBytes: number;
-	lastLinePartial: boolean;
-	firstLineExceedsLimit: boolean;
-	maxLines: number;
-	maxBytes: number;
+	outputLines?: number;
+	outputBytes?: number;
+	lastLinePartial?: boolean;
+	firstLineExceedsLimit?: boolean;
 }
 
 export interface TruncationOptions {
@@ -206,26 +204,10 @@ export function truncateLine(
 // =============================================================================
 
 /** Shared helper to build a no-truncation result. */
-function noTruncResult(
-	content: string,
-	totalLines: number,
-	totalBytes: number,
-	maxLines: number,
-	maxBytes: number,
-): TruncationResult {
-	return {
-		content,
-		truncated: false,
-		truncatedBy: null,
-		totalLines,
-		totalBytes,
-		outputLines: totalLines,
-		outputBytes: totalBytes,
-		lastLinePartial: false,
-		firstLineExceedsLimit: false,
-		maxLines,
-		maxBytes,
-	};
+export function noTruncResult(content: string, totalLines?: number, totalBytes?: number): TruncationResult {
+	if (totalLines == null) totalLines = countNewlines(content) + 1;
+	if (totalBytes == null) totalBytes = Buffer.byteLength(content, "utf-8");
+	return { content, totalLines, totalBytes };
 }
 
 /**
@@ -244,7 +226,7 @@ export function truncateHead(content: string, options: TruncationOptions = {}):
 	const totalLines = countNewlines(content) + 1;
 
 	if (totalLines <= maxLines && totalBytes <= maxBytes) {
-		return noTruncResult(content, totalLines, totalBytes, maxLines, maxBytes);
+		return noTruncResult(content, totalLines, totalBytes);
 	}
 
 	let includedLines = 0;
@@ -283,8 +265,6 @@ export function truncateHead(content: string, options: TruncationOptions = {}):
 					outputBytes: 0,
 					lastLinePartial: false,
 					firstLineExceedsLimit: true,
-					maxLines,
-					maxBytes,
 				};
 			}
 			break;
@@ -307,8 +287,6 @@ export function truncateHead(content: string, options: TruncationOptions = {}):
 					outputBytes: 0,
 					lastLinePartial: false,
 					firstLineExceedsLimit: true,
-					maxLines,
-					maxBytes,
 				};
 			}
 			break;
@@ -335,8 +313,6 @@ export function truncateHead(content: string, options: TruncationOptions = {}):
 		outputBytes: bytesUsed,
 		lastLinePartial: false,
 		firstLineExceedsLimit: false,
-		maxLines,
-		maxBytes,
 	};
 }
 
@@ -354,7 +330,7 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
 	const totalLines = countNewlines(content) + 1;
 
 	if (totalLines <= maxLines && totalBytes <= maxBytes) {
-		return noTruncResult(content, totalLines, totalBytes, maxLines, maxBytes);
+		return noTruncResult(content, totalLines, totalBytes);
 	}
 
 	let includedLines = 0;
@@ -396,8 +372,6 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
 					outputBytes: tail.bytes,
 					lastLinePartial: true,
 					firstLineExceedsLimit: false,
-					maxLines,
-					maxBytes,
 				};
 			}
 			break;
@@ -420,8 +394,6 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
 					outputBytes: tail.bytes,
 					lastLinePartial: true,
 					firstLineExceedsLimit: false,
-					maxLines,
-					maxBytes,
 				};
 			}
 			break;
@@ -447,8 +419,6 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
 		outputBytes: bytesUsed,
 		lastLinePartial: false,
 		firstLineExceedsLimit: false,
-		maxLines,
-		maxBytes,
 	};
 }
 
@@ -693,7 +663,7 @@ export function formatTailTruncationNotice(
 	if (!truncation.truncated) return "";
 
 	const { fullOutputPath, originalContent, suffix = "" } = options;
-	const startLine = truncation.totalLines - truncation.outputLines + 1;
+	const startLine = truncation.totalLines - (truncation.outputLines ?? truncation.totalLines) + 1;
 	const endLine = truncation.totalLines;
 	const fullOutputPart = fullOutputPath ? `. Full output: ${fullOutputPath}` : "";
 
@@ -705,11 +675,9 @@ export function formatTailTruncationNotice(
 			const lastLine = lastNl === -1 ? originalContent : originalContent.substring(lastNl + 1);
 			lastLineSizePart = ` (line is ${formatBytes(Buffer.byteLength(lastLine, "utf-8"))})`;
 		}
-		notice = `[Showing last ${formatBytes(truncation.outputBytes)} of line ${endLine}${lastLineSizePart}${fullOutputPart}${suffix}]`;
-	} else if (truncation.truncatedBy === "lines") {
-		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}${fullOutputPart}${suffix}]`;
+		notice = `[Showing last ${formatBytes(truncation.outputBytes ?? truncation.totalBytes)} of line ${endLine}${lastLineSizePart}${fullOutputPart}${suffix}]`;
 	} else {
-		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatBytes(truncation.maxBytes)} limit)${fullOutputPart}${suffix}]`;
+		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}${fullOutputPart}${suffix}]`;
 	}
 
 	return `\n\n${notice}`;
@@ -727,13 +695,8 @@ export function formatHeadTruncationNotice(
 
 	const startLineDisplay = options.startLine ?? 1;
 	const totalFileLines = options.totalFileLines ?? truncation.totalLines;
-	const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+	const endLineDisplay = startLineDisplay + (truncation.outputLines ?? truncation.totalLines) - 1;
 	const nextOffset = endLineDisplay + 1;
-
-	const notice =
-		truncation.truncatedBy === "lines"
-			? `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`
-			: `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatBytes(truncation.maxBytes)} limit). Use offset=${nextOffset} to continue]`;
-
+	const notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
 	return `\n\n${notice}`;
 }

package/src/slash-commands/builtin-registry.ts

@@ -465,6 +465,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "btw",
+		description: "Ask an ephemeral side question using the current session context",
+		inlineHint: "<question>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const question = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleBtwCommand(question);
+		},
+	},
 	{
 		name: "background",
 		aliases: ["bg"],

package/src/system-prompt.ts

@@ -447,22 +447,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills = prepResult.value.skills;
 	}
 
-	const now = new Date();
-	const date = now.toLocaleDateString("en-CA", {
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-	});
-	const dateTime = now.toLocaleString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric",
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		timeZoneName: "short",
-	});
+	const date = new Date().toISOString().slice(0, 10);
+	const dateTime = date;
+	const promptCwd = resolvedCwd.replace(/\\/g, "/");
 
 	// Build tool metadata for system prompt rendering
 	// Priority: explicit list > tools map > defaults
@@ -504,7 +491,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		rules: rules ?? [],
 		date,
 		dateTime,
-		cwd: resolvedCwd,
+		cwd: promptCwd,
 		intentTracing: !!intentField,
 		intentField: intentField ?? "",
 		eagerTasks,

package/src/task/agents.ts

@@ -53,7 +53,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			name: "task",
 			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
 			spawns: "*",
-			model: "default",
+			model: "pi/task",
 			thinkingLevel: Effort.Medium,
 		},
 		template: taskMd,

package/src/task/executor.ts

@@ -1243,7 +1243,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		exitCode,
 		output: truncatedOutput,
 		stderr,
-		truncated,
+		truncated: Boolean(truncated),
 		durationMs: Date.now() - startTime,
 		tokens: progress.tokens,
 		modelOverride,

package/src/task/index.ts

@@ -20,7 +20,7 @@ import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import type { ToolSession } from "..";
-import { isDefaultModelAlias } from "../config/model-resolver";
+import { resolveAgentModelPatterns } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Theme } from "../modes/theme/theme";
 import planModeSubagentPrompt from "../prompts/system/plan-mode-subagent.md" with { type: "text" };
@@ -507,14 +507,15 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			: agent;
 
 		// Apply per-agent model override from settings (highest priority)
-		const agentModelOverrides = this.session.settings.get("task.agentModelOverrides") as Record<string, string>;
+		const agentModelOverrides = this.session.settings.get("task.agentModelOverrides");
 		const settingsModelOverride = agentModelOverrides[agentName];
-		const effectiveAgentModel = isDefaultModelAlias(effectiveAgent.model) ? undefined : effectiveAgent.model;
-		const modelOverride =
-			settingsModelOverride ??
-			effectiveAgentModel ??
-			this.session.getActiveModelString?.() ??
-			this.session.getModelString?.();
+		const modelOverride = resolveAgentModelPatterns({
+			settingsOverride: settingsModelOverride,
+			agentModel: effectiveAgent.model,
+			settings: this.session.settings,
+			activeModelPattern: this.session.getActiveModelString?.(),
+			fallbackModelPattern: this.session.getModelString?.(),
+		});
 		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
 		// Output schema priority: agent frontmatter > params > inherited from parent session

package/src/tools/browser.ts

@@ -526,6 +526,17 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		const proxy = process.env.PUPPETEER_PROXY;
 		if (proxy) {
 			launchArgs.push(`--proxy-server=${proxy}`);
+			// Chrome (since v72) bypasses proxies for localhost by default. When PUPPETEER_PROXY_BYPASS_LOOPBACK
+			// is true, add <-loopback> so traffic to localhost reaches the proxy (e.g. for mitmdump/auth capture).
+			const bypassLoopback = process.env.PUPPETEER_PROXY_BYPASS_LOOPBACK?.toLowerCase();
+			if (
+				bypassLoopback === "true" ||
+				bypassLoopback === "1" ||
+				bypassLoopback === "yes" ||
+				bypassLoopback === "on"
+			) {
+				launchArgs.push("--proxy-bypass-list=<-loopback>");
+			}
 		}
 		const ignoreCert = process.env.PUPPETEER_PROXY_IGNORE_CERT_ERRORS?.toLowerCase();
 		if (ignoreCert === "true" || ignoreCert === "1" || ignoreCert === "yes" || ignoreCert === "on") {

package/src/tools/exit-plan-mode.ts

@@ -77,6 +77,12 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 			}
 		}
 
+		if (!planExists) {
+			throw new ToolError(
+				`Plan file not found at ${state.planFilePath}. Write the finalized plan to ${state.planFilePath} before calling exit_plan_mode.`,
+			);
+		}
+
 		return {
 			content: [{ type: "text", text: "Plan ready for approval." }],
 			details: {

package/src/tools/fetch.ts

@@ -1159,7 +1159,7 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 			finalUrl: result.finalUrl,
 			contentType: result.contentType,
 			method: result.method,
-			truncated: result.truncated || needsArtifact,
+			truncated: Boolean(result.truncated || needsArtifact),
 			notes: result.notes,
 		};
 

package/src/tools/output-meta.ts

@@ -14,7 +14,7 @@ import type {
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
-import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import { type OutputSummary, type TruncationResult, truncateTail } from "../session/streaming-output";
 import { formatBytes, wrapBrackets } from "./render-utils";
 import { renderError } from "./tool-errors";
 
@@ -117,26 +117,28 @@ export class OutputMetaBuilder {
 		if (!result.truncated) return this;
 
 		const { direction, startLine = 1, totalFileLines, artifactId } = options;
+		const outputLines = result.outputLines ?? result.totalLines;
+		const outputBytes = result.outputBytes ?? result.totalBytes;
+		const truncatedBy: "lines" | "bytes" = result.truncatedBy === "lines" ? "lines" : "bytes";
 
 		let shownStart: number;
 		let shownEnd: number;
 
 		if (direction === "tail") {
-			shownStart = result.totalLines - result.outputLines + 1;
+			shownStart = result.totalLines - outputLines + 1;
 			shownEnd = result.totalLines;
 		} else {
 			shownStart = startLine;
-			shownEnd = startLine + result.outputLines - 1;
+			shownEnd = startLine + outputLines - 1;
 		}
 
 		this.#meta.truncation = {
 			direction,
-			truncatedBy: result.truncatedBy!,
+			truncatedBy,
 			totalLines: totalFileLines ?? result.totalLines,
 			totalBytes: result.totalBytes,
-			outputLines: result.outputLines,
-			outputBytes: result.outputBytes,
-			maxBytes: result.maxBytes,
+			outputLines,
+			outputBytes,
 			shownRange: { start: shownStart, end: shownEnd },
 			artifactId,
 			nextOffset: direction === "head" ? shownEnd + 1 : undefined,
@@ -315,7 +317,7 @@ export function outputMeta(): OutputMetaBuilder {
 // =============================================================================
 
 export function formatFullOutputReference(artifactId: string): string {
-	return `Full output: artifact://${artifactId}`;
+	return `Read artifact://${artifactId} for full output`;
 }
 
 export function formatTruncationMetaNotice(truncation: TruncationMeta): string {
@@ -432,6 +434,95 @@ function appendOutputNotice(
 
 const kUnwrappedExecute = Symbol("OutputMeta.UnwrappedExecute");
 
+// =============================================================================
+// Centralized artifact spill for large tool results
+// =============================================================================
+
+/** Text content above this byte threshold gets saved to an artifact. */
+const RESULT_ARTIFACT_THRESHOLD = 50 * 1024; // 50KB
+
+/** When spilling, keep this many bytes of tail in the result sent to the LLM. */
+const RESULT_ARTIFACT_TAIL_BYTES = 20 * 1024; // 20KB
+
+/** When spilling, keep at most this many lines of tail. */
+const RESULT_ARTIFACT_TAIL_LINES = 500;
+
+/**
+ * If the tool result text exceeds RESULT_ARTIFACT_THRESHOLD, save the full
+ * output as a session artifact and replace the content with a tail-truncated
+ * version plus an artifact reference. Skips when the tool already saved its
+ * own artifact (e.g. bash/python via OutputSink).
+ */
+async function spillLargeResultToArtifact(
+	result: AgentToolResult,
+	toolName: string,
+	context: AgentToolContext | undefined,
+): Promise<AgentToolResult> {
+	const sessionManager = context?.sessionManager;
+	if (!sessionManager) return result;
+
+	// Skip if tool already saved an artifact
+	const existingMeta = (result.details as { meta?: OutputMeta } | undefined)?.meta;
+	if (existingMeta?.truncation?.artifactId) return result;
+
+	// Measure total text content
+	const textParts: string[] = [];
+	for (const block of result.content) {
+		if (block.type === "text" && block.text) {
+			textParts.push(block.text);
+		}
+	}
+	if (textParts.length === 0) return result;
+
+	const fullText = textParts.length === 1 ? textParts[0] : textParts.join("\n");
+	const totalBytes = Buffer.byteLength(fullText, "utf-8");
+	if (totalBytes <= RESULT_ARTIFACT_THRESHOLD) return result;
+
+	// Save full output as artifact
+	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
+	if (!artifactId) return result;
+
+	// Truncate to tail
+	const truncated = truncateTail(fullText, {
+		maxBytes: RESULT_ARTIFACT_TAIL_BYTES,
+		maxLines: RESULT_ARTIFACT_TAIL_LINES,
+	});
+
+	// Replace text blocks with single tail-truncated block, keep images
+	const newContent: (TextContent | ImageContent)[] = [];
+	for (const block of result.content) {
+		if (block.type !== "text") {
+			newContent.push(block);
+		}
+	}
+	newContent.push({ type: "text", text: truncated.content });
+
+	// Build truncation meta
+	const outputLines = truncated.outputLines ?? truncated.totalLines;
+	const outputBytes = truncated.outputBytes ?? truncated.totalBytes;
+	const shownStart = truncated.totalLines - outputLines + 1;
+	const truncationMeta: TruncationMeta = {
+		direction: "tail",
+		truncatedBy: truncated.truncatedBy ?? "bytes",
+		totalLines: truncated.totalLines,
+		totalBytes: truncated.totalBytes,
+		outputLines,
+		outputBytes,
+		maxBytes: RESULT_ARTIFACT_TAIL_BYTES,
+		shownRange: { start: shownStart, end: truncated.totalLines },
+		artifactId,
+	};
+
+	const newMeta: OutputMeta = { ...(existingMeta ?? {}), truncation: truncationMeta };
+	const newDetails = { ...(result.details ?? {}), meta: newMeta };
+
+	return { ...result, content: newContent, details: newDetails };
+}
+
+// =============================================================================
+// Tool wrapper
+// =============================================================================
+
 async function wrappedExecute(
 	this: AgentTool & { [kUnwrappedExecute]: AgentToolExecFn },
 	toolCallId: string,
@@ -443,8 +534,12 @@ async function wrappedExecute(
 	const originalExecute = this[kUnwrappedExecute];
 
 	try {
+		let result = await originalExecute.call(this, toolCallId, params, signal, onUpdate, context);
+
+		// Spill large results to artifact, truncate to tail
+		result = await spillLargeResultToArtifact(result, this.name, context);
+
 		// Append notices from meta
-		const result = await originalExecute.call(this, toolCallId, params, signal, onUpdate, context);
 		const meta = (result.details as { meta?: OutputMeta } | undefined)?.meta;
 		if (meta) {
 			return {

package/src/tools/read.ts

@@ -16,6 +16,7 @@ import type { ToolSession } from "../sdk";
 import {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
+	noTruncResult,
 	type TruncationResult,
 	truncateHead,
 	truncateHeadBytes,
@@ -592,15 +593,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const truncation: TruncationResult = {
 				content: selectedContent,
 				truncated: wasTruncated,
-				truncatedBy: stoppedByByteLimit ? "bytes" : wasTruncated ? "lines" : null,
+				truncatedBy: stoppedByByteLimit ? "bytes" : wasTruncated ? "lines" : undefined,
 				totalLines: totalSelectedLines,
 				totalBytes: totalSelectedBytes,
 				outputLines: collectedLines.length,
 				outputBytes: collectedBytes,
 				lastLinePartial: false,
 				firstLineExceedsLimit,
-				maxLines: DEFAULT_MAX_LINES,
-				maxBytes: DEFAULT_MAX_BYTES,
 			};
 
 			const shouldAddHashLines = displayMode.hashLines;
@@ -687,8 +686,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
 		const internalRouter = this.session.internalRouter!;
 
-		const displayMode = resolveFileDisplayMode(this.session);
-
 		// Check if URL has query extraction (agent:// only)
 		let parsed: URL;
 		try {
@@ -716,7 +713,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return toolResult(details).text(resource.content).sourceInternal(url).done();
 		}
 
-		// Apply pagination similar to file reading
+		// Apply pagination similar to file reading.
 		const allLines = resource.content.split("\n");
 		const totalLines = allLines.length;
 
@@ -733,9 +730,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				.done();
 		}
 
+		const ignoreLimits = scheme === "skill";
 		let selectedContent: string;
 		let userLimitedLines: number | undefined;
-		if (limit !== undefined) {
+		if (limit !== undefined && !ignoreLimits) {
 			const endLine = Math.min(startLine + limit, allLines.length);
 			selectedContent = allLines.slice(startLine, endLine).join("\n");
 			userLimitedLines = endLine - startLine;
@@ -743,14 +741,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			selectedContent = allLines.slice(startLine).join("\n");
 		}
 
-		// Apply truncation
-		const truncation = truncateHead(selectedContent);
-
-		const shouldAddHashLines = displayMode.hashLines;
-		const shouldAddLineNumbers = shouldAddHashLines ? false : displayMode.lineNumbers;
-		const formatText = (text: string, startNum: number): string => {
-			return formatTextWithMode(text, startNum, shouldAddHashLines, shouldAddLineNumbers);
-		};
+		const truncation: TruncationResult = ignoreLimits
+			? noTruncResult(selectedContent)
+			: truncateHead(selectedContent);
 
 		let outputText: string;
 		let truncationInfo:
@@ -762,13 +755,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
 			const snippet = truncateHeadBytes(firstLine, DEFAULT_MAX_BYTES);
 
-			if (shouldAddHashLines) {
-				outputText = `[Line ${startLineDisplay} is ${formatBytes(
-					firstLineBytes,
-				)}, exceeds ${formatBytes(DEFAULT_MAX_BYTES)} limit. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`;
-			} else {
-				outputText = formatText(snippet.text, startLineDisplay);
-			}
+			outputText = snippet.text;
 			if (snippet.text.length === 0) {
 				outputText = `[Line ${startLineDisplay} is ${formatBytes(
 					firstLineBytes,
@@ -780,7 +767,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				options: { direction: "head", startLine: startLineDisplay, totalFileLines: totalLines },
 			};
 		} else if (truncation.truncated) {
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 			details.truncation = truncation;
 			truncationInfo = {
 				result: truncation,
@@ -790,11 +777,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const remaining = allLines.length - (startLine + userLimitedLines);
 			const nextOffset = startLine + userLimitedLines + 1;
 
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 			outputText += `\n\n[${remaining} more lines in resource. Use offset=${nextOffset} to continue]`;
 			details.truncation = truncation;
 		} else {
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 		}
 
 		const resultBuilder = toolResult(details).text(outputText).sourceInternal(url);
@@ -924,7 +911,7 @@ export const readToolRenderer = {
 		}
 		if (truncation) {
 			if (fallback?.firstLineExceedsLimit) {
-				let warning = `First line exceeds ${formatBytes(fallback.maxBytes ?? DEFAULT_MAX_BYTES)} limit`;
+				let warning = `First line exceeds ${formatBytes(fallback.outputBytes ?? fallback.totalBytes)} limit`;
 				if (truncation.artifactId) {
 					warning += `. ${formatFullOutputReference(truncation.artifactId)}`;
 				}