@oh-my-pi/pi-coding-agent 15.0.1 → 15.1.0

package/src/task/types.ts

@@ -1,7 +1,7 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
-import { type Static, type TSchema, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 
@@ -63,65 +63,65 @@ const assignmentDescriptionForContextDisabled =
 	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure, and include any background that would otherwise live in `context` since shared context is disabled in this mode.";
 
 const createTaskItemSchema = (contextEnabled: boolean) =>
-	Type.Object({
-		id: Type.String({
-			description: "CamelCase identifier, max 48 chars",
-			maxLength: 48,
-		}),
-		description: Type.String({
-			description: "Short one-liner for UI display only — not seen by the subagent",
-		}),
-		assignment: Type.String({
-			description: contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled,
-		}),
+	z.object({
+		id: z.string().max(48).describe("CamelCase identifier, max 48 chars"),
+		description: z.string().describe("Short one-liner for UI display only — not seen by the subagent"),
+		assignment: z
+			.string()
+			.describe(contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
 export const taskItemSchema = createTaskItemSchema(true);
-export type TaskItem = Static<typeof taskItemSchema>;
+export type TaskItem = z.infer<typeof taskItemSchema>;
 
 const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }) => {
 	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(options.simpleMode);
 	const itemSchema = createTaskItemSchema(contextEnabled);
-	const properties: Record<string, TSchema> = {
-		agent: Type.String({ description: "Agent type for all tasks in this batch" }),
-		tasks: Type.Array(itemSchema, {
-			description: contextEnabled
-				? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
-				: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
-		}),
-	};
+
+	let schema = z.object({
+		agent: z.string().describe("Agent type for all tasks in this batch"),
+		tasks: z
+			.array(itemSchema)
+			.describe(
+				contextEnabled
+					? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
+					: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
+			),
+	});
 
 	if (contextEnabled) {
-		properties.context = Type.Optional(
-			Type.String({
-				description:
+		schema = schema.extend({
+			context: z
+				.string()
+				.optional()
+				.describe(
 					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
-			}),
-		);
+				),
+		});
 	}
 
 	if (customSchemaEnabled) {
-		properties.schema = Type.Optional(
-			Type.String({
-				description:
+		schema = schema.extend({
+			schema: z
+				.string()
+				.optional()
+				.describe(
 					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
-			}),
-		);
+				),
+		});
 	}
 
 	if (options.isolationEnabled) {
-		return Type.Object({
-			...properties,
-			isolated: Type.Optional(
-				Type.Boolean({
-					description: "Run in isolated environment; returns patches. Use when tasks edit overlapping files.",
-				}),
-			),
+		schema = schema.extend({
+			isolated: z
+				.boolean()
+				.optional()
+				.describe("Run in isolated environment; returns patches. Use when tasks edit overlapping files."),
 		});
 	}
 
-	return Type.Object(properties);
+	return schema;
 };
 
 export const taskSchema = createTaskSchema({ isolationEnabled: true, simpleMode: "default" });
@@ -141,6 +141,8 @@ const ALL_TASK_SCHEMAS = [
 
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
+/** Active task tool parameter schema for the current simple-mode / isolation flags */
+export type TaskToolSchemaInstance = DynamicTaskSchema;
 
 export function getTaskSchema(options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }): DynamicTaskSchema {
 	switch (options.simpleMode) {
@@ -219,6 +221,15 @@ export interface AgentProgress {
 	toolCount: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/**
+	 * Current per-turn context size: latest assistant message's `usage.totalTokens`.
+	 * This is the number to compare against `contextWindow` — what compaction
+	 * decides on, what the user typically reads as "how full is the context".
+	 * Distinct from `tokens`, which is a lifetime billing-volume counter.
+	 */
+	contextTokens?: number;
+	/** Model's context window in tokens, when known. Lets the UI render `<curr>/<window>` gauges. */
+	contextWindow?: number;
 	/** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
 	cost: number;
 	durationMs: number;
@@ -244,6 +255,10 @@ export interface SingleResult {
 	durationMs: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
+	contextTokens?: number;
+	/** Model's context window in tokens, when known. */
+	contextWindow?: number;
 	modelOverride?: string | string[];
 	error?: string;
 	aborted?: boolean;

package/src/tools/ask.ts

@@ -18,7 +18,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component, Container, Markdown, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -31,23 +31,23 @@ import { ToolAbortError } from "./tool-errors";
 // Types
 // =============================================================================
 
-const OptionItem = Type.Object({
-	label: Type.String({ description: "display label" }),
+const OptionItem = z.object({
+	label: z.string().describe("display label"),
 });
 
-const QuestionItem = Type.Object({
-	id: Type.String({ description: "question id", examples: ["auth", "cache"] }),
-	question: Type.String({ description: "question text" }),
-	options: Type.Array(OptionItem, { description: "available options" }),
-	multi: Type.Optional(Type.Boolean({ description: "allow multiple selections" })),
-	recommended: Type.Optional(Type.Number({ description: "recommended option index" })),
+const QuestionItem = z.object({
+	id: z.string().describe("question id"),
+	question: z.string().describe("question text"),
+	options: z.array(OptionItem).describe("available options"),
+	multi: z.boolean().describe("allow multiple selections").optional(),
+	recommended: z.number().describe("recommended option index").optional(),
 });
 
-const askSchema = Type.Object({
-	questions: Type.Array(QuestionItem, { description: "questions to ask", minItems: 1 }),
+const askSchema = z.object({
+	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
 });
 
-export type AskToolInput = Static<typeof askSchema>;
+export type AskToolInput = z.infer<typeof askSchema>;
 
 /** Result for a single question */
 export interface QuestionResult {

package/src/tools/ast-edit.ts

@@ -4,7 +4,7 @@ import { type AstReplaceChange, type AstReplaceFileChange, astEdit } from "@oh-m
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
@@ -33,21 +33,17 @@ import { queueResolveHandler } from "./resolve";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astEditOpSchema = Type.Object({
-	pat: Type.String({ description: "ast pattern", examples: ["oldFn($$$ARGS)"] }),
-	out: Type.String({ description: "replacement template", examples: ["newFn($$$ARGS)"] }),
+const astEditOpSchema = z.object({
+	pat: z.string().describe("ast pattern"),
+	out: z.string().describe("replacement template"),
 });
 
-const astEditSchema = Type.Object({
-	ops: Type.Array(astEditOpSchema, {
-		minItems: 1,
-		description: "rewrite ops",
-	}),
-	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to rewrite" }), {
-		minItems: 1,
-		description: "files, directories, globs, or internal URLs to rewrite",
-		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
-	}),
+const astEditSchema = z.object({
+	ops: z.array(astEditOpSchema).min(1).describe("rewrite ops"),
+	paths: z
+		.array(z.string().describe("file, directory, glob, or internal URL to rewrite"))
+		.min(1)
+		.describe("files, directories, globs, or internal URLs to rewrite"),
 });
 
 interface AstEditCallOptions {
@@ -174,7 +170,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof astEditSchema>,
+		params: z.infer<typeof astEditSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>,
 		_context?: AgentToolContext,

package/src/tools/ast-grep.ts

@@ -4,7 +4,7 @@ import { type AstFindMatch, astGrep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
@@ -32,14 +32,13 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astGrepSchema = Type.Object({
-	pat: Type.String({ description: "ast pattern", examples: ["console.log($$$)"] }),
-	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to search" }), {
-		minItems: 1,
-		description: "files, directories, globs, or internal URLs to search",
-		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
-	}),
-	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
+const astGrepSchema = z.object({
+	pat: z.string().describe("ast pattern"),
+	paths: z
+		.array(z.string().describe("file, directory, glob, or internal URL to search"))
+		.min(1)
+		.describe("files, directories, globs, or internal URLs to search"),
+	skip: z.number().default(0).describe("matches to skip").optional(),
 });
 
 async function runMultiTargetAstGrep(
@@ -129,7 +128,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof astGrepSchema>,
+		params: z.infer<typeof astGrepSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>,
 		_context?: AgentToolContext,

package/src/tools/bash-command-fixup.ts

@@ -0,0 +1,47 @@
+/**
+ * Conservative transforms applied to a bash command before execution.
+ *
+ * Two fixups are applied, each anchored to the end of a top-level segment
+ * (segments split on `;`, `&&`, `||`, and background `&`):
+ *
+ *  1. Trailing `| head [args]` / `| tail [args]` (and the `|&` variant) — these
+ *     pipes exist purely to limit output length. The harness already truncates
+ *     bash output and exposes the full result via an artifact, so they only
+ *     hide content the agent wanted.
+ *
+ *  2. A redundant trailing `2>&1` left on a segment that has no remaining pipe
+ *     or other redirect. The harness already merges stderr into stdout, so the
+ *     duplication is purely cosmetic — and often a leftover after fixup (1)
+ *     drops a downstream pipe.
+ *
+ * The heavy lifting (tokenization, quoting, heredoc handling, command
+ * substitution, nested compound commands) lives in Rust under
+ * `pi_shell::fixup`, driven by the real `brush-parser` AST. This module is a
+ * thin sync wrapper plus user-facing notice formatting.
+ */
+import { applyBashFixups as nativeApplyBashFixups } from "@oh-my-pi/pi-natives";
+
+export interface BashFixupResult {
+	/** Possibly-rewritten command. */
+	command: string;
+	/** Substrings that were stripped, in the order they were removed. */
+	stripped: string[];
+}
+
+/**
+ * Apply both fixups to a bash command. On any parse failure, multi-line input,
+ * or no-op transform, returns the input verbatim with `stripped: []`.
+ */
+export function applyBashFixups(command: string): BashFixupResult {
+	return nativeApplyBashFixups(command);
+}
+
+/**
+ * Human-readable notice for the fixups that fired. Mirrors the shape of
+ * `formatTimeoutClampNotice` so it can ride alongside the other bash notices.
+ */
+export function formatBashFixupNotice(stripped: readonly string[]): string | undefined {
+	if (!stripped.length) return undefined;
+	const quoted = stripped.map(s => `\`${s}\``).join(", ");
+	return `<system-warning>Stripped redundant ${quoted} — bash output is already truncated and stderr is already merged into stdout. NEVER use these patterns.</system-warning>`;
+}

package/src/tools/bash.ts

@@ -3,7 +3,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { $env, getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { AsyncJobManager } from "../async";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -17,10 +17,11 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
+import { applyBashFixups, formatBashFixupNotice } from "./bash-command-fixup";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
 import { expandInternalUrls, type InternalUrlExpansionOptions } from "./bash-skill-urls";
-import { formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
+import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatToolWorkingDirectory, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
@@ -43,30 +44,16 @@ async function saveBashOriginalArtifact(session: ToolSession, originalText: stri
 	}
 }
 
-const bashSchemaBase = Type.Object({
-	command: Type.String({ description: "command to execute", examples: ["ls -la", "echo hi"] }),
-	env: Type.Optional(
-		Type.Record(Type.String({ pattern: BASH_ENV_NAME_PATTERN.source }), Type.String(), {
-			description: "extra env vars",
-		}),
-	),
-	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 300 })),
-	cwd: Type.Optional(Type.String({ description: "working directory", examples: ["src/", "/tmp"] })),
-
-	pty: Type.Optional(
-		Type.Boolean({
-			description: "run in pty mode",
-		}),
-	),
+const bashSchemaBase = z.object({
+	command: z.string().describe("command to execute"),
+	env: z.record(z.string().regex(BASH_ENV_NAME_PATTERN), z.string()).optional().describe("extra env vars"),
+	timeout: z.number().default(300).describe("timeout in seconds").optional(),
+	cwd: z.string().describe("working directory").optional(),
+	pty: z.boolean().describe("run in pty mode").optional(),
 });
 
-const bashSchemaWithAsync = Type.Object({
-	...bashSchemaBase.properties,
-	async: Type.Optional(
-		Type.Boolean({
-			description: "run in background",
-		}),
-	),
+const bashSchemaWithAsync = bashSchemaBase.extend({
+	async: z.boolean().describe("run in background").optional(),
 });
 
 type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
@@ -245,6 +232,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly #asyncEnabled: boolean;
 	readonly #autoBackgroundEnabled: boolean;
 	readonly #autoBackgroundThresholdMs: number;
+	#bashFixupNoticeEmitted = false;
 
 	constructor(private readonly session: ToolSession) {
 		this.#asyncEnabled = this.session.settings.get("async.enabled");
@@ -291,7 +279,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	#buildCompletedResult(
 		result: BashResult | BashInteractiveResult,
 		timeoutSec: number,
-		options: { requestedTimeoutSec?: number; notices?: string[]; terminalId?: string } = {},
+		options: { requestedTimeoutSec?: number; notices?: readonly string[]; terminalId?: string } = {},
 	): AgentToolResult<BashToolDetails> {
 		const outputLines = [this.#formatResultOutput(result)];
 		const notices = options.notices?.filter(Boolean) ?? [];
@@ -314,7 +302,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		label: string,
 		previewText: string,
 		timeoutSec: number,
-		options: { requestedTimeoutSec?: number; notices?: string[] } = {},
+		options: { requestedTimeoutSec?: number; notices?: readonly string[] } = {},
 	): AgentToolResult<BashToolDetails> {
 		const details: BashToolDetails = {
 			timeoutSeconds: timeoutSec,
@@ -352,7 +340,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		timeoutMs: number;
 		timeoutSec: number;
 		requestedTimeoutSec?: number;
-		timeoutClampNotice?: string;
+		notices?: readonly string[];
 
 		resolvedEnv?: Record<string, string>;
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>;
@@ -392,7 +380,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					});
 					const finalResult = this.#buildCompletedResult(result, options.timeoutSec, {
 						requestedTimeoutSec: options.requestedTimeoutSec,
-						notices: [options.timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+						notices: options.notices ?? [],
 					});
 					const finalText = this.#extractTextResult(finalResult);
 					latestText = finalText;
@@ -483,6 +471,18 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		let command = rawCommand;
 		const env = normalizeBashEnv(rawEnv);
 
+		// Apply conservative bash fixups (strip trailing `| head|tail` and redundant
+		// `2>&1`). The helper is single-line only and refuses anything that could
+		// change semantics.
+		let bashFixups: string[] = [];
+		if (this.session.settings.get("bash.stripTrailingHeadTail")) {
+			const fixup = applyBashFixups(command);
+			if (fixup.stripped.length > 0) {
+				command = fixup.command;
+				bashFixups = fixup.stripped;
+			}
+		}
+
 		// Extract leading `cd <path> && ...` into cwd when the model ignores the cwd parameter.
 		// Constrained to a single line so a `&&` that sits on a later line of a multiline
 		// script can't pull the entire script into the "cwd" capture.
@@ -558,7 +558,14 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const requestedTimeoutSec = rawTimeout;
 		const timeoutSec = clampTimeout("bash", requestedTimeoutSec);
 		const timeoutMs = timeoutSec * 1000;
+		const pendingNotices: string[] = [];
 		const timeoutClampNotice = formatTimeoutClampNotice(requestedTimeoutSec, timeoutSec);
+		if (timeoutClampNotice) pendingNotices.push(timeoutClampNotice);
+		const bashFixupNotice = this.#bashFixupNoticeEmitted ? undefined : formatBashFixupNotice(bashFixups);
+		if (bashFixupNotice) {
+			pendingNotices.push(bashFixupNotice);
+			this.#bashFixupNoticeEmitted = true;
+		}
 
 		if (asyncRequested) {
 			if (!AsyncJobManager.instance()) {
@@ -570,7 +577,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				timeoutMs,
 				timeoutSec,
 				requestedTimeoutSec,
-				timeoutClampNotice,
+				notices: pendingNotices,
 
 				resolvedEnv,
 				onUpdate,
@@ -578,7 +585,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
 				requestedTimeoutSec,
-				notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+				notices: pendingNotices,
 			});
 		}
 
@@ -592,7 +599,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				timeoutMs,
 				timeoutSec,
 				requestedTimeoutSec,
-				timeoutClampNotice,
+				notices: pendingNotices,
 
 				resolvedEnv,
 				onUpdate,
@@ -601,7 +608,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			if (startBackgrounded) {
 				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
 					requestedTimeoutSec,
-					notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+					notices: pendingNotices,
 				});
 			}
 			const waitResult = await this.#waitForManagedBashJob(job, autoBackgroundWaitMs, signal);
@@ -621,7 +628,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			job.setBackgrounded(true);
 			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec, {
 				requestedTimeoutSec,
-				notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+				notices: pendingNotices,
 			});
 		}
 
@@ -722,7 +729,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 							};
 							return this.#buildCompletedResult(timedOutResult, timeoutSec, {
 								requestedTimeoutSec,
-								notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+								notices: pendingNotices,
 								terminalId: handle.terminalId,
 							});
 						}
@@ -778,7 +785,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 
 				const bridgeNotices: string[] = [];
 				if (finalOutput.truncated) bridgeNotices.push("(output truncated)");
-				if (timeoutClampNotice) bridgeNotices.push(timeoutClampNotice);
+				for (const notice of pendingNotices) bridgeNotices.push(notice);
 
 				return this.#buildCompletedResult(bridgeResult, timeoutSec, {
 					requestedTimeoutSec,
@@ -833,7 +840,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 		return this.#buildCompletedResult(result, timeoutSec, {
 			requestedTimeoutSec,
-			notices: [timeoutClampNotice].filter((notice): notice is string => Boolean(notice)),
+			notices: pendingNotices,
 		});
 	}
 }
@@ -960,8 +967,11 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 					const expanded = renderContext?.expanded ?? options.expanded;
 					const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
 
-					// Get output from context (preferred) or fall back to result content
-					const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
+					// Get output from context (preferred) or fall back to result content.
+					// Strip the LLM-facing notice appended by wrappedExecute so we don't
+					// double-print it alongside the styled warning line below.
+					const rawOutput = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
+					const output = stripOutputNotice(rawOutput, details?.meta);
 					const displayOutput = output.trimEnd();
 					const showingFullOutput = expanded && renderContext?.isFullOutput === true;
 

package/src/tools/browser/render.ts

@@ -11,7 +11,7 @@ import type { RenderResultOptions } from "../../extensibility/custom-tools/types
 import type { Theme } from "../../modes/theme/theme";
 import { Hasher, renderCodeCell, renderStatusLine } from "../../tui";
 import type { BrowserToolDetails } from "../browser";
-import { formatStyledTruncationWarning } from "../output-meta";
+import { formatStyledTruncationWarning, stripOutputNotice } from "../output-meta";
 import { replaceTabs, shortenPath } from "../render-utils";
 
 const BROWSER_DEFAULT_PREVIEW_LINES = 10;
@@ -195,7 +195,7 @@ export const browserToolRenderer = {
 		const details = result.details;
 		const action = details?.action ?? argsObj.action;
 		const isError = result.isError === true;
-		const output = extractTextOutput(result.content);
+		const output = stripOutputNotice(extractTextOutput(result.content), details?.meta);
 
 		if (action === "run") {
 			let component = renderRunCell(argsObj, details, options, output, isError, theme);