@oh-my-pi/pi-coding-agent 3.21.0 → 3.25.0

package/src/core/sdk.ts

@@ -18,7 +18,7 @@
  * const session = await createAgentSession({
  *   model: myModel,
  *   getApiKey: async () => process.env.MY_KEY,
- *   tools: [readTool, bashTool],
+ *   toolNames: ["read", "bash", "edit", "write"], // Filter tools
  *   extensions: [],
  *   skills: [],
  *   sessionFile: false,
@@ -55,7 +55,7 @@ import {
 	loadExtensionFromFactory,
 	type ToolDefinition,
 	wrapRegisteredTools,
-	wrapToolsWithExtensions,
+	wrapToolWithExtensions,
 } from "./extensions/index";
 import { logger } from "./logger";
 import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp/index";
@@ -75,48 +75,34 @@ import { time } from "./timings";
 import { createToolContextStore } from "./tools/context";
 import { getGeminiImageTools } from "./tools/gemini-image";
 import {
-	allTools,
-	applyBashInterception,
-	baseCodingToolNames,
-	bashTool,
-	codingTools,
-	createAllTools,
+	BUILTIN_TOOLS,
 	createBashTool,
-	createCodingTools,
 	createEditTool,
 	createFindTool,
 	createGitTool,
 	createGrepTool,
 	createLsTool,
-	createReadOnlyTools,
 	createReadTool,
-	createRulebookTool,
+	createTools,
 	createWriteTool,
-	editTool,
 	filterRulebookRules,
-	findTool,
 	getWebSearchTools,
-	gitTool,
-	grepTool,
-	lsTool,
-	readOnlyTools,
-	readTool,
 	setPreferredImageProvider,
 	setPreferredWebSearchProvider,
 	type Tool,
-	type ToolName,
+	type ToolSession,
 	warmupLspServers,
-	writeTool,
 } from "./tools/index";
 import { createTtsrManager } from "./ttsr";
 
 // Types
-
 export interface CreateAgentSessionOptions {
 	/** Working directory for project-local discovery. Default: process.cwd() */
 	cwd?: string;
 	/** Global config directory. Default: ~/.omp/agent */
 	agentDir?: string;
+	/** Spawns to allow. Default: "*" */
+	spawns?: string;
 
 	/** Auth storage for credentials. Default: discoverAuthStorage(agentDir) */
 	authStorage?: AuthStorage;
@@ -133,8 +119,6 @@ export interface CreateAgentSessionOptions {
 	/** System prompt. String replaces default, function receives default and returns final. */
 	systemPrompt?: string | ((defaultPrompt: string) => string);
 
-	/** Built-in tools to use. Default: all coding tools (read, bash, edit, write, grep, find, ls, lsp, notebook, output, task, web_fetch, web_search) */
-	tools?: Tool[];
 	/** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
 	customTools?: (CustomTool | ToolDefinition)[];
 	/** Inline extensions (merged with discovery). */
@@ -163,7 +147,12 @@ export interface CreateAgentSessionOptions {
 	enableMCP?: boolean;
 
 	/** Tool names explicitly requested (enables disabled-by-default tools) */
-	explicitTools?: string[];
+	toolNames?: string[];
+
+	/** Output schema for structured completion (subagents) */
+	outputSchema?: unknown;
+	/** Whether to include the complete tool by default */
+	requireCompleteTool?: boolean;
 
 	/** Session manager. Default: SessionManager.create(cwd) */
 	sessionManager?: SessionManager;
@@ -208,21 +197,11 @@ export type { FileSlashCommand } from "./slash-commands";
 export type { Tool } from "./tools/index";
 
 export {
-	// Pre-built tools (use process.cwd())
-	readTool,
-	bashTool,
-	editTool,
-	writeTool,
-	grepTool,
-	findTool,
-	gitTool,
-	lsTool,
-	codingTools,
-	readOnlyTools,
-	allTools as allBuiltInTools,
-	// Tool factories (for custom cwd)
-	createCodingTools,
-	createReadOnlyTools,
+	// Tool factories
+	BUILTIN_TOOLS,
+	createTools,
+	type ToolSession,
+	// Individual tool factories (for custom usage)
 	createReadTool,
 	createBashTool,
 	createEditTool,
@@ -426,7 +405,6 @@ function customToolToDefinition(tool: CustomTool): ToolDefinition {
 		label: tool.label,
 		description: tool.description,
 		parameters: tool.parameters,
-		hidden: tool.hidden,
 		execute: (toolCallId, params, onUpdate, ctx, signal) =>
 			tool.execute(toolCallId, params, onUpdate, createCustomToolContext(ctx), signal),
 		onSession: tool.onSession ? (event, ctx) => tool.onSession?.(event, createCustomToolContext(ctx)) : undefined,
@@ -509,7 +487,7 @@ function createCustomToolsExtension(tools: CustomTool[]): ExtensionFactory {
  *   model: myModel,
  *   getApiKey: async () => process.env.MY_KEY,
  *   systemPrompt: 'You are helpful.',
- *   tools: [readTool, bashTool],
+ *   tools: codingTools({ cwd: process.cwd() }),
  *   skills: [],
  *   sessionManager: SessionManager.inMemory(),
  * });
@@ -630,30 +608,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
 	time("discoverContextFiles");
 
-	const sessionContext = {
+	const toolSession: ToolSession = {
+		cwd,
+		hasUI: options.hasUI ?? false,
+		rulebookRules,
+		eventBus,
+		outputSchema: options.outputSchema,
+		requireCompleteTool: options.requireCompleteTool,
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
+		getSessionSpawns: () => options.spawns ?? "*",
+		settings: settingsManager,
 	};
-	const allBuiltInToolsMap = await createAllTools(cwd, sessionContext, {
-		lspFormatOnWrite: settingsManager.getLspFormatOnWrite(),
-		lspDiagnosticsOnWrite: settingsManager.getLspDiagnosticsOnWrite(),
-		lspDiagnosticsOnEdit: settingsManager.getLspDiagnosticsOnEdit(),
-		editFuzzyMatch: settingsManager.getEditFuzzyMatch(),
-		readAutoResizeImages: settingsManager.getImageAutoResize(),
-	});
-	time("createAllTools");
 
-	// Determine which tools to include based on settings
-	let baseToolNames = options.tools
-		? options.tools.map((t) => t.name).filter((n): n is ToolName => n in allBuiltInToolsMap)
-		: [...baseCodingToolNames];
-
-	// Filter out git tool if disabled in settings
-	if (!settingsManager.getGitToolEnabled()) {
-		baseToolNames = baseToolNames.filter((name) => name !== "git");
-	}
-
-	const initialActiveToolNames: ToolName[] = baseToolNames;
-	const initialActiveBuiltInTools = initialActiveToolNames.map((name) => allBuiltInToolsMap[name]);
+	const builtinTools = await createTools(toolSession, options.toolNames);
+	time("createAllTools");
 
 	// Discover MCP tools from .mcp.json files
 	let mcpManager: MCPManager | undefined;
@@ -840,61 +808,30 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		hasQueuedMessages: () => session.queuedMessageCount > 0,
 	}));
 
+	// All built-in tools are active (conditional tools like git/ask return null from factory if disabled)
 	const toolRegistry = new Map<string, AgentTool>();
-	for (const [name, tool] of Object.entries(allBuiltInToolsMap)) {
-		toolRegistry.set(name, tool as AgentTool);
+	for (const tool of builtinTools) {
+		toolRegistry.set(tool.name, tool as AgentTool);
 	}
-	for (const tool of wrappedExtensionTools as AgentTool[]) {
+	for (const tool of wrappedExtensionTools) {
 		toolRegistry.set(tool.name, tool);
 	}
-
-	let activeToolsArray: Tool[] = [...initialActiveBuiltInTools, ...wrappedExtensionTools];
-
-	if (rulebookRules.length > 0) {
-		activeToolsArray.push(createRulebookTool(rulebookRules));
-	}
-
-	if (options.explicitTools) {
-		const explicitSet = new Set(options.explicitTools);
-		activeToolsArray = activeToolsArray.filter((tool) => !tool.hidden || explicitSet.has(tool.name));
-	} else {
-		activeToolsArray = activeToolsArray.filter((tool) => !tool.hidden);
-	}
-	time("combineTools");
-
-	if (settingsManager.getBashInterceptorEnabled()) {
-		activeToolsArray = applyBashInterception(activeToolsArray);
-	}
-	time("applyBashInterception");
-
-	let wrappedToolRegistry: Map<string, AgentTool> | undefined;
 	if (extensionRunner) {
-		activeToolsArray = wrapToolsWithExtensions(activeToolsArray as AgentTool[], extensionRunner);
-		const allRegistryTools = Array.from(toolRegistry.values());
-		const wrappedAllTools = wrapToolsWithExtensions(allRegistryTools, extensionRunner);
-		wrappedToolRegistry = new Map<string, AgentTool>();
-		for (const tool of wrappedAllTools) {
-			wrappedToolRegistry.set(tool.name, tool);
+		for (const tool of toolRegistry.values()) {
+			toolRegistry.set(tool.name, wrapToolWithExtensions(tool, extensionRunner));
 		}
 	}
+	time("combineTools");
 
-	const rebuildSystemPrompt = (toolNames: string[]): string => {
-		const validToolNames = toolNames.filter((n): n is ToolName => n in allBuiltInToolsMap);
-		const extraToolDescriptions = toolNames
-			.filter((name) => !(name in allBuiltInToolsMap))
-			.map((name) => {
-				const tool = toolRegistry.get(name);
-				if (!tool) return null;
-				return { name, description: tool.description || tool.label || "Custom tool" };
-			})
-			.filter((tool): tool is { name: string; description: string } => tool !== null);
+	const rebuildSystemPrompt = (toolNames: string[], tools: Map<string, AgentTool>): string => {
+		toolContextStore.setToolNames(toolNames);
 		const defaultPrompt = buildSystemPromptInternal({
 			cwd,
 			skills,
 			contextFiles,
-			rulebookRules,
-			selectedTools: validToolNames,
-			extraToolDescriptions,
+			tools,
+			toolNames,
+			rules: rulebookRules,
 			skillsSettings: settingsManager.getSkillsSettings(),
 		});
 
@@ -906,9 +843,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				cwd,
 				skills,
 				contextFiles,
-				rulebookRules,
-				selectedTools: validToolNames,
-				extraToolDescriptions,
+				tools,
+				toolNames,
+				rules: rulebookRules,
 				skillsSettings: settingsManager.getSkillsSettings(),
 				customPrompt: options.systemPrompt,
 			});
@@ -916,7 +853,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return options.systemPrompt(defaultPrompt);
 	};
 
-	const systemPrompt = rebuildSystemPrompt(initialActiveToolNames);
+	const systemPrompt = rebuildSystemPrompt(Array.from(toolRegistry.keys()), toolRegistry);
 	time("buildSystemPrompt");
 
 	const promptTemplates = options.promptTemplates ?? (await discoverPromptTemplates(cwd, agentDir));
@@ -936,7 +873,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			systemPrompt,
 			model,
 			thinkingLevel,
-			tools: activeToolsArray,
+			tools: Array.from(toolRegistry.values()),
 		},
 		convertToLlm,
 		transformContext: extensionRunner
@@ -984,7 +921,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		customCommands: customCommandsResult.commands,
 		skillsSettings: settingsManager.getSkillsSettings(),
 		modelRegistry,
-		toolRegistry: wrappedToolRegistry ?? toolRegistry,
+		toolRegistry,
 		rebuildSystemPrompt,
 		ttsrManager,
 	});

package/src/core/session-manager.ts

@@ -698,6 +698,13 @@ async function truncateForPersistence<T>(obj: T, key?: string): Promise<T> {
 		let changed = false;
 		const result: Record<string, unknown> = {};
 		for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+			// Strip transient/redundant properties that shouldn't be persisted
+			// - partialJson: streaming accumulator for tool call JSON parsing
+			// - jsonlEvents: raw subprocess streaming events (already saved to artifact files)
+			if (k === "partialJson" || k === "jsonlEvents") {
+				changed = true;
+				continue;
+			}
 			const newV = await truncateForPersistence(v, k);
 			result[k] = newV;
 			if (newV !== v) changed = true;

package/src/core/system-prompt.ts

@@ -256,10 +256,10 @@ export function loadSystemPromptFiles(options: LoadContextFilesOptions = {}): st
 export interface BuildSystemPromptOptions {
 	/** Custom system prompt (replaces default). */
 	customPrompt?: string;
-	/** Tools to include in prompt. Default: [read, bash, edit, write] */
-	selectedTools?: ToolName[];
-	/** Extra tool descriptions to include in prompt (non built-in tools). */
-	extraToolDescriptions?: Array<{ name: string; description: string }>;
+	/** Tools to include in prompt. */
+	tools?: Map<string, { description: string; label: string }>;
+	/** Tool names to include in prompt. */
+	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
 	/** Skills settings for discovery. */
@@ -271,21 +271,21 @@ export interface BuildSystemPromptOptions {
 	/** Pre-loaded skills (skips discovery if provided). */
 	skills?: Skill[];
 	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
-	rulebookRules?: Rule[];
+	rules?: Rule[];
 }
 
 /** Build the system prompt with tools, guidelines, and context */
 export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): string {
 	const {
 		customPrompt,
-		selectedTools,
-		extraToolDescriptions = [],
+		tools,
 		appendSystemPrompt,
 		skillsSettings,
+		toolNames,
 		cwd,
 		contextFiles: providedContextFiles,
 		skills: providedSkills,
-		rulebookRules,
+		rules: rulebookRules,
 	} = options;
 	const resolvedCwd = cwd ?? process.cwd();
 	const resolvedCustomPrompt = resolvePromptInput(customPrompt, "system prompt");
@@ -311,6 +311,9 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	// Resolve context files: use provided or discover
 	const contextFiles = providedContextFiles ?? loadProjectContextFiles({ cwd: resolvedCwd });
 
+	// Build tools list based on selected tools
+	const toolsList = toolNames?.map((name) => `- ${name}: ${toolDescriptions[name as ToolName]}`).join("\n") ?? "";
+
 	// Resolve skills: use provided or discover
 	const skills =
 		providedSkills ??
@@ -335,9 +338,11 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		}
 
 		// Append custom tool descriptions if provided
-		if (extraToolDescriptions.length > 0) {
-			prompt += "\n\n# Additional Tools\n\n";
-			prompt += extraToolDescriptions.map((tool) => `- ${tool.name}: ${tool.description}`).join("\n");
+		if (tools && tools.size > 0) {
+			prompt += "\n\n# Tools\n\n";
+			prompt += Array.from(tools.entries())
+				.map(([name, { description }]) => `- ${name}: ${description}`)
+				.join("\n");
 		}
 
 		// Append git context if in a git repo
@@ -347,8 +352,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		}
 
 		// Append skills section (only if read tool is available)
-		const customPromptHasRead = !selectedTools || selectedTools.includes("read");
-		if (customPromptHasRead && skills.length > 0) {
+		if (tools?.has("read") && skills.length > 0) {
 			prompt += formatSkillsForPrompt(skills);
 		}
 
@@ -369,25 +373,16 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const docsPath = getDocsPath();
 	const examplesPath = getExamplesPath();
 
-	// Build tools list based on selected tools
-	const tools = selectedTools || (["read", "bash", "edit", "write"] as ToolName[]);
-	const builtInToolsList = tools.map((t) => `- ${t}: ${toolDescriptions[t]}`).join("\n");
-	const extraToolsList =
-		extraToolDescriptions.length > 0
-			? extraToolDescriptions.map((tool) => `- ${tool.name}: ${tool.description}`).join("\n")
-			: "";
-	const toolsList = [builtInToolsList, extraToolsList].filter(Boolean).join("\n");
-
 	// Generate anti-bash rules (returns null if not applicable)
-	const antiBashSection = generateAntiBashRules(tools);
+	const antiBashSection = generateAntiBashRules(Array.from(tools?.keys() ?? []));
 
 	// Build guidelines based on which tools are actually available
 	const guidelinesList: string[] = [];
 
-	const hasBash = tools.includes("bash");
-	const hasEdit = tools.includes("edit");
-	const hasWrite = tools.includes("write");
-	const hasRead = tools.includes("read");
+	const hasBash = tools?.has("bash");
+	const hasEdit = tools?.has("edit");
+	const hasWrite = tools?.has("write");
+	const hasRead = tools?.has("read");
 
 	// Read-only mode notice (no bash, edit, or write)
 	if (!hasBash && !hasEdit && !hasWrite) {
@@ -454,12 +449,6 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		}
 	}
 
-	// Append custom tool descriptions if provided
-	if (extraToolDescriptions.length > 0) {
-		prompt += "\n\n# Additional Tools\n\n";
-		prompt += extraToolDescriptions.map((tool) => `- ${tool.name}: ${tool.description}`).join("\n");
-	}
-
 	// Append git context if in a git repo
 	const gitContext = loadGitContext(resolvedCwd);
 	if (gitContext) {

package/src/core/tools/ask.ts

@@ -22,6 +22,7 @@ import { Type } from "@sinclair/typebox";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
 import askDescription from "../../prompts/tools/ask.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
+import type { ToolSession } from "./index";
 import { formatErrorMessage, formatMeta } from "./render-utils";
 
 // =============================================================================
@@ -67,7 +68,10 @@ function getDoneOptionLabel(): string {
 // Tool Implementation
 // =============================================================================
 
-export function createAskTool(_cwd: string): AgentTool<typeof askSchema, AskToolDetails> {
+export function createAskTool(session: ToolSession): null | AgentTool<typeof askSchema, AskToolDetails> {
+	if (!session.hasUI) {
+		return null;
+	}
 	return {
 		name: "ask",
 		label: "Ask",
@@ -193,8 +197,14 @@ export function createAskTool(_cwd: string): AgentTool<typeof askSchema, AskTool
 	};
 }
 
-/** Default ask tool using process.cwd() - for backwards compatibility (no UI) */
-export const askTool = createAskTool(process.cwd());
+/** Default ask tool - returns null when no UI */
+export const askTool = createAskTool({
+	cwd: process.cwd(),
+	hasUI: false,
+	rulebookRules: [],
+	getSessionFile: () => null,
+	getSessionSpawns: () => "*",
+});
 
 // =============================================================================
 // TUI Renderer
@@ -225,10 +235,7 @@ export const askToolRenderer = {
 				const opt = args.options[i];
 				const isLast = i === args.options.length - 1;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg(
-					"dim",
-					uiTheme.checkbox.unchecked,
-				)} ${uiTheme.fg("muted", opt.label)}`;
+				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${uiTheme.fg("muted", opt.label)}`;
 			}
 		}
 

package/src/core/tools/bash-interceptor.ts

@@ -80,13 +80,13 @@ const forbiddenPatterns: Array<{
  * @param availableTools Set of tool names that are available
  * @returns InterceptionResult indicating if the command should be blocked
  */
-export function checkBashInterception(command: string, availableTools: Set<string>): InterceptionResult {
+export function checkBashInterception(command: string, availableTools: string[]): InterceptionResult {
 	// Normalize command for pattern matching
 	const normalizedCommand = command.trim();
 
 	for (const { pattern, tool, message } of forbiddenPatterns) {
 		// Only block if the suggested tool is actually available
-		if (!availableTools.has(tool)) {
+		if (!availableTools.includes(tool)) {
 			continue;
 		}
 
@@ -106,8 +106,8 @@ export function checkBashInterception(command: string, availableTools: Set<strin
  * Check if a command is a simple directory listing that should use `ls` tool.
  * Only applies to bare `ls` without complex flags.
  */
-export function checkSimpleLsInterception(command: string, availableTools: Set<string>): InterceptionResult {
-	if (!availableTools.has("ls")) {
+export function checkSimpleLsInterception(command: string, availableTools: string[]): InterceptionResult {
+	if (!availableTools.includes("ls")) {
 		return { block: false };
 	}
 

package/src/core/tools/bash.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+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";
@@ -6,6 +6,8 @@ import type { Theme } from "../../modes/interactive/theme/theme";
 import bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
 import { executeBash } from "../bash-executor";
 import type { RenderResultOptions } from "../custom-tools/types";
+import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
+import type { ToolSession } from "./index";
 import { formatBytes, wrapBrackets } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
 
@@ -19,7 +21,7 @@ export interface BashToolDetails {
 	fullOutputPath?: string;
 }
 
-export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
+export function createBashTool(session: ToolSession): AgentTool<typeof bashSchema> {
 	return {
 		name: "bash",
 		label: "Bash",
@@ -30,12 +32,25 @@ export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
 			{ command, timeout }: { command: string; timeout?: number },
 			signal?: AbortSignal,
 			onUpdate?,
+			ctx?: AgentToolContext,
 		) => {
+			// Check interception if enabled and available tools are known
+			if (session.settings?.getBashInterceptorEnabled()) {
+				const interception = checkBashInterception(command, ctx?.toolNames ?? []);
+				if (interception.block) {
+					throw new Error(interception.message);
+				}
+				const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
+				if (lsInterception.block) {
+					throw new Error(lsInterception.message);
+				}
+			}
+
 			// Track output for streaming updates
 			let currentOutput = "";
 
 			const result = await executeBash(command, {
-				cwd,
+				cwd: session.cwd,
 				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
 				signal,
 				onChunk: (chunk) => {
@@ -92,9 +107,6 @@ export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
 	};
 }
 
-/** Default bash tool using process.cwd() - for backwards compatibility */
-export const bashTool = createBashTool(process.cwd());
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================
@@ -183,9 +195,7 @@ export const bashToolRenderer = {
 					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
 				} else {
 					warnings.push(
-						`Truncated: ${truncation.outputLines} lines shown (${formatBytes(
-							truncation.maxBytes ?? DEFAULT_MAX_BYTES,
-						)} limit)`,
+						`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
 					);
 				}
 			}