gentle-pi 4.0.0 → 4.2.0

package/extensions/gentle-todo.ts

@@ -1,9 +1,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Text, type Component, type TUI } from "@earendil-works/pi-tui";
+import { ScrollView, Text, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 import { appendSystemPromptOnce } from "../lib/append-system-prompt.ts";
 import { NativePointerRegion } from "../lib/native-pointer-region.ts";
 import { panelHeaderRow } from "../lib/shell-card.ts";
-import { sidebarPart } from "../lib/shell-sidebar.ts";
+import { sidebarPart, sidebarState } from "../lib/shell-sidebar.ts";
 import { invalidateSidebar } from "../lib/shell-sidebar-layout.ts";
 import {
 	applyTodo,
@@ -16,6 +16,7 @@ import {
 	TODO_TOOL_NAME,
 	todoCardTone,
 	todoPromptBlock,
+	todoStateMessage,
 	todoSummary,
 	type TodoParams,
 	type TodoState,
@@ -24,12 +25,18 @@ import {
 // Gentle Todo: the task list the model keeps while it works, drawn as a
 // Gentle Shell card above the editor. Three things keep it current that a
 // static tool description cannot: `write` replaces the whole list in one
-// call, every turn's system prompt carries the open tasks and the rules, and
-// a list that goes untouched while tasks stay open is marked stale for both
-// the human and the model.
+// call, each run's system prompt carries a byte-stable rules block while the
+// open tasks reach the model as a request-local trailing message (so list
+// changes never invalidate the cached prompt prefix, gentle-shell#1662), and
+// a list that goes untouched while tasks stay open is marked stale for the
+// human. Long runs also receive one request-local reminder after several
+// tool-use turns, without waking the agent or changing tasks.
 
 const WIDGET_KEY = "gentle-todo";
+const STATUS_ENUM = ["pending", "in_progress", "blocked", "done", "dropped"];
 const COLLAPSE_KEY_DEFAULT = "ctrl+shift+t";
+const REMIND_AFTER_TOOL_TURNS = 4;
+const TODO_REMINDER = "The todo plan has not been reviewed during several tool-use turns. Check whether it still matches the work performed and update tasks where needed. Do not mark work done without verification.";
 const TOOL_PARAMETERS = {
 	type: "object",
 	additionalProperties: false,
@@ -46,15 +53,15 @@ const TOOL_PARAMETERS = {
 				properties: {
 					id: { type: "integer", description: "Existing task id to keep." },
 					title: { type: "string", description: "Short imperative title, e.g. 'Write the parser'." },
-					status: { type: "string", enum: ["pending", "in_progress", "done"], description: "Defaults to pending." },
-					note: { type: "string", description: "What is happening right now, shown while in_progress, e.g. 'writing tests'." },
+					status: { type: "string", enum: STATUS_ENUM, description: "Defaults to pending. blocked: open but waiting on something outside the list; dropped: will not be done, on purpose." },
+					note: { type: "string", description: "What is happening right now, shown while in_progress, e.g. 'writing tests'; required for blocked, naming what it waits for, e.g. 'waiting for an admin'." },
 				},
 			},
 		},
 		id: { type: "integer", description: "Task id for update." },
 		title: { type: "string", description: "Title for add, or a new title for update." },
-		status: { type: "string", enum: ["pending", "in_progress", "done"], description: "Status for add or update." },
-		note: { type: "string", description: "Note for add or update." },
+		status: { type: "string", enum: STATUS_ENUM, description: "Status for add or update." },
+		note: { type: "string", description: "Note for add or update; required for blocked." },
 	},
 } as const;
 
@@ -73,12 +80,18 @@ export function todoCollapseKey(env: NodeJS.ProcessEnv = process.env): string |
 interface TodoSession {
 	state: TodoState;
 	turn: number;
+	/** Separate from the existing run-based card freshness. */
+	toolTurnsSinceWrite: number;
+	reminded: boolean;
+	wroteThisTurn: boolean;
 	collapsed: boolean;
 	/** A finished list stays on screen for the turn it finished in, then clears. */
 	clearOnNextTurn: boolean;
 	ui: ExtensionContext["ui"] | undefined;
 	host: { requestRender(): void } | undefined;
 	tui: TUI | undefined;
+	/** Resolve the visible host when the key is pressed, not when it renders. */
+	scrollTodo?: (lines: number) => void;
 }
 
 function sessionKey(ctx: ExtensionContext): string {
@@ -94,7 +107,7 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		const key = sessionKey(ctx);
 		let current = sessions.get(key);
 		if (!current) {
-			current = { state: emptyTodo(), turn: 0, collapsed: false, clearOnNextTurn: false, ui: undefined, host: undefined, tui: undefined };
+			current = { state: emptyTodo(), turn: 0, toolTurnsSinceWrite: 0, reminded: false, wroteThisTurn: false, collapsed: false, clearOnNextTurn: false, ui: undefined, host: undefined, tui: undefined };
 			sessions.set(key, current);
 		}
 		return current;
@@ -106,8 +119,20 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		current.host?.requestRender();
 	};
 
-	const todoCard = (current: TodoSession, theme: Parameters<typeof renderTodoCard>[1], scrollable: boolean, spacer: boolean): Component & { dispose(): void } => {
+	const todoCard = (current: TodoSession, theme: Parameters<typeof renderTodoCard>[1], spacer: boolean): Component & { dispose(): void; digest(): string; scrollBy(lines: number): void } => {
 		let hovered = false;
+		let body: string[] = [];
+		let collapsed = current.collapsed;
+		// Widgets are measured as leaves, so native layout cannot assign this
+		// body a viewport. Use native scroll state and explicitly slice its lines
+		// while keeping the collapse header and card footer outside the viewport.
+		const scroll = new ScrollView({ render: () => body, invalidate() {} }, { follow: "none", overscroll: "contain" });
+		const scrollBy = (lines: number) => {
+			if (current.collapsed) return;
+			scroll.scrollBy(lines);
+			if (current.tui) invalidateSidebar(current.tui);
+			current.host?.requestRender();
+		};
 		// The row the rendered card draws its header on: 0 for the outlined
 		// frame, 1 below the float panel's top padding row.
 		let headerRow = 0;
@@ -120,9 +145,25 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 					staleTurns: stale,
 					collapseKey,
 					hovered,
-					...(scrollable ? { scrollable: true } : {}),
+					scrollable: true,
 				});
-				return spacer && lines.length > 0 ? [...lines, ""] : lines;
+				if (collapsed !== current.collapsed) {
+					collapsed = current.collapsed;
+					scroll.scrollToStart();
+				}
+				// At most one third of the screen, capped at 16 rows. Read height
+				// on every render so a mobile resize immediately releases chat space.
+				const terminalRows = current.tui?.terminal?.rows ?? 48;
+				const height = Math.min(16, Math.floor(terminalRows / 3));
+				const bodyStart = headerRow === 1 ? 3 : 1;
+				body = lines.slice(bodyStart, -1);
+				const overflow = !current.collapsed && lines.length + Number(spacer) > height;
+				const room = Math.max(1, height - bodyStart - 1 - Number(spacer) - Number(overflow));
+				scroll.updateLayout(body.length, current.collapsed ? body.length : room, () => current.host?.requestRender());
+				const visible = scroll.render(width).slice(scroll.scrollTop, scroll.scrollTop + scroll.viewportHeight);
+				const output = [...lines.slice(0, bodyStart), ...visible, ...lines.slice(-1)];
+				if (overflow) output.push(theme.fg("muted", truncateToWidth(`↑↓ ${scroll.scrollTop + 1}–${scroll.scrollTop + visible.length}/${body.length} · ctrl+shift+↑/↓`, width)));
+				return spacer && output.length > 0 ? [...output, ""] : output;
 			},
 			invalidate() {
 				hovered = false;
@@ -148,8 +189,17 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 				toggle(current);
 				return { handled: true, render: true };
 			},
+			onWheel(event) {
+				if (current.collapsed || body.length <= scroll.viewportHeight) return undefined;
+				scrollBy(event.wheelDelta ?? 0);
+				return { handled: true, render: true };
+			},
 		});
 		return {
+			scrollBy,
+			// Sidebar caches must observe height-only resizes and local viewport
+			// changes, even when terminal width and task content stay the same.
+			digest: () => JSON.stringify([current.tui?.terminal?.rows, current.collapsed, current.turn, hovered, scroll.scrollTop]),
 			render: (width) => region.render(width),
 			handleMouse: (event) => region.handleMouse(event),
 			invalidate: () => region.invalidate(),
@@ -161,6 +211,7 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		if (current.tui) invalidateSidebar(current.tui);
 		if (!current.ui) return;
 		if (current.state.tasks.length === 0) {
+			current.scrollTodo = undefined;
 			current.ui.setWidget(WIDGET_KEY, undefined);
 			return;
 		}
@@ -168,7 +219,15 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		current.ui.setWidget(WIDGET_KEY, (tui, theme) => {
 			snapshot.host = tui;
 			snapshot.tui = tui;
-			return sidebarPart(tui, "todo", todoCard(snapshot, theme, false, true), todoCard(snapshot, theme, true, false));
+			const bottom = todoCard(snapshot, theme, true);
+			const rail = todoCard(snapshot, theme, false);
+			snapshot.scrollTodo = (lines) => {
+				// Cached rail lines do not re-render when a narrow→wide resize
+				// restores the sidebar. Select ownership from the live layout.
+				const state = tui.terminal ? sidebarState(tui) : undefined;
+				(state?.active && state.ownsHost?.() ? rail : bottom).scrollBy(lines);
+			};
+			return sidebarPart(tui, "todo", bottom, rail);
 		});
 	};
 
@@ -183,6 +242,8 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 			"Mark a task in_progress before starting it and done right after finishing it; keep exactly one task in_progress.",
 			"Prefer write with the complete list whenever the plan changes; keep ids of tasks that already exist.",
 			"Never mark a task done while tests fail or the work is partial; add a task for the blocker instead.",
+			"Mark a task blocked with a note naming what it waits for only when that is outside the list (a person, another team, an authorization); a prerequisite in the list is ordering, so keep the task pending. Return it to pending once the condition holds.",
+			"When the plan changes, mark tasks it made obsolete dropped, never done; dropped tasks no longer count as open.",
 		],
 		parameters: TOOL_PARAMETERS,
 		executionMode: "sequential",
@@ -200,6 +261,11 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 			if (!result.error) {
 				current.state = result.state;
 				current.clearOnNextTurn = false;
+				if (params.action !== "list") {
+					current.toolTurnsSinceWrite = 0;
+					current.reminded = false;
+					current.wroteThisTurn = true;
+				}
 				if (current.tui) invalidateSidebar(current.tui);
 			}
 			return {
@@ -218,6 +284,15 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		});
 	}
 
+	// Pi binds ctrl+shift+up/down to prompt navigation (tui.altScreen.*Prompt) and
+	// alt+up/down to dequeue and model reordering; alt+shift+up/down are free.
+	for (const [key, lines] of [["alt+shift+up", -3], ["alt+shift+down", 3]] as const) {
+		pi.registerShortcut(key, {
+			description: `Scroll the Todo list ${lines < 0 ? "up" : "down"}`,
+			handler: async (ctx) => session(ctx).scrollTodo?.(lines),
+		});
+	}
+
 	pi.on("session_start", (_event, ctx) => {
 		const current = session(ctx);
 		// A list that was already finished when the session was left is history,
@@ -225,6 +300,9 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 		const replayed = replayTodo(ctx.sessionManager.getBranch());
 		current.state = replayed.tasks.length > 0 && todoSummary(replayed).open === 0 ? { ...replayed, tasks: [] } : replayed;
 		current.turn = ctx.sessionManager.getBranch().filter((entry) => (entry as { type?: string }).type === "message" && (entry as { message?: { role?: string } }).message?.role === "user").length;
+		current.toolTurnsSinceWrite = 0;
+		current.reminded = false;
+		current.wroteThisTurn = false;
 		current.ui = ctx.hasUI ? ctx.ui : undefined;
 		show(current);
 	});
@@ -242,14 +320,41 @@ export default function gentleTodo(pi: ExtensionAPI, env: NodeJS.ProcessEnv = pr
 			current.clearOnNextTurn = false;
 			show(current);
 		}
-		const block = todoPromptBlock(current.state, staleTurns(current.state, current.turn));
-		if (!block) return undefined;
 		// gentle-shell#1485: pi-claude-bridge drops a handler-returned
-		// systemPrompt, so the open-tasks block goes through appendSystemPrompt.
-		appendSystemPromptOnce(event.systemPromptOptions, block);
+		// systemPrompt, so the rules block goes through appendSystemPrompt. It is
+		// the same bytes on every turn, list or no list (gentle-shell#1662).
+		appendSystemPromptOnce(event.systemPromptOptions, todoPromptBlock());
 		return undefined;
 	});
 
+	pi.on("turn_end", (event, ctx) => {
+		const current = session(ctx);
+		// A turn containing a valid todo write is already reconciled. Failed
+		// writes and list reads deliberately do not refresh this counter.
+		if (!current.wroteThisTurn && event.message.role === "assistant" && event.message.content.some((part) => part.type === "toolCall")) {
+			current.toolTurnsSinceWrite += 1;
+		}
+		current.wroteThisTurn = false;
+	});
+
+	pi.on("context", (event, ctx) => {
+		const current = session(ctx);
+		// Context transforms are request-local: no transcript entry, UI
+		// notification, continuation or provider-specific wake is needed. The
+		// current list trails the transcript (gentle-shell#1662), then the
+		// one-shot reminder when it is due.
+		const trailing: Array<{ role: "custom"; customType: string; content: string; display: false; timestamp: number }> = [];
+		const state = todoStateMessage(current.state);
+		if (state !== undefined) trailing.push({ role: "custom", customType: "gentle-todo-state", content: state, display: false, timestamp: Date.now() });
+		const actionable = current.state.tasks.some((task) => task.status === "pending" || task.status === "in_progress");
+		if (!current.reminded && current.toolTurnsSinceWrite >= REMIND_AFTER_TOOL_TURNS && actionable) {
+			current.reminded = true;
+			trailing.push({ role: "custom", customType: "gentle-todo-reminder", content: TODO_REMINDER, display: false, timestamp: Date.now() });
+		}
+		if (trailing.length === 0) return undefined;
+		return { messages: [...event.messages, ...trailing] };
+	});
+
 	pi.on("tool_execution_end", (event, ctx) => {
 		if (event.toolName !== TODO_TOOL_NAME) return;
 		show(session(ctx));

package/extensions/history/index.ts

@@ -37,7 +37,7 @@ import {
   type TuiMouseEvent,
   truncateToWidth,
 } from "@earendil-works/pi-tui";
-import { gentlePiConfigHome } from "../../lib/agent-home.ts";
+import { bundledGentlePiAgentHome, gentlePiConfigHome } from "../../lib/agent-home.ts";
 import {
   historyCaptureEnabled,
   historyCaptureEnvOverride,
@@ -1316,14 +1316,19 @@ export default function promptHistoryExtension(
 ): void {
   const env = deps.env ?? process.env;
   const configHome = deps.gentlePiConfigHome ?? gentlePiConfigHome(env);
-  // Per-prompt gate: re-read so a Customize toggle applies live.
-  const capturing = () => captureEnabled(env, configHome);
-  const root = deps.root ?? PI_HISTORY_ROOT;
+  // Per-prompt gate: re-read so a Customize toggle applies live. A delegated
+  // child never captures: its prompt is a delegation brief, not user history,
+  // and the parent owns the store's init and GC (gentle-shell#1690).
+  const capturing = () => env.GENTLE_PI_AGENTS_CHILD !== "1" && captureEnabled(env, configHome);
+  // S9: a bundled Gentle Shell keeps the whole store in the agent home Pi runs
+  // with; everywhere else it stays under ~/.pi/agent, where existing ones live.
+  const bundledAgentDir = bundledGentlePiAgentHome(env);
+  const root = deps.root ?? (bundledAgentDir === undefined ? PI_HISTORY_ROOT : join(bundledAgentDir, "history"));
   const cwd = deps.cwd ?? process.cwd();
   const instanceId = deps.instanceId ?? randomUUID();
   const now = deps.now ?? Date.now;
-  const agentDir = deps.agentDir ?? AGENT_DIR;
-  const sessionsRoot = deps.sessionsRoot ?? SESSIONS_ROOT;
+  const agentDir = deps.agentDir ?? bundledAgentDir ?? AGENT_DIR;
+  const sessionsRoot = deps.sessionsRoot ?? (bundledAgentDir === undefined ? SESSIONS_ROOT : join(bundledAgentDir, "sessions"));
   let writerState: SessionWriterState | null = null;
 
   /**

package/extensions/pi-pretty.ts

@@ -1,5 +1,14 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { shellEnabled } from "../lib/shell-bar.ts";
+import {
+	createBashToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { bundledGentlePiAgentHome } from "../lib/agent-home.ts";
+import { keepNativeWorkingRow, shellEnabled } from "../lib/shell-bar.ts";
 import {
 	mergeDisabledTools,
 	PI_PRETTY_SUPPRESSED_TOOL_NAMES,
@@ -26,12 +35,37 @@ async function loadPiPrettyExtension(): Promise<PiPrettyExtension> {
 	);
 }
 
+// S9: pi-pretty keeps its FFF database under deps.sdk.getAgentDir(), falling
+// back to $HOME/.pi/agent whatever agent home Pi runs with. In a bundled
+// Gentle Shell it gets the agent home; a deps.sdk also replaces the host tool
+// factories it would otherwise import, so the same five come along. Elsewhere,
+// and for a host that already passes its own sdk, Pi's deps stay unchanged.
+function withAgentHome(deps: unknown, env: NodeJS.ProcessEnv): unknown {
+	const agentHome = bundledGentlePiAgentHome(env);
+	const given = (deps ?? {}) as { sdk?: unknown };
+	if (agentHome === undefined || given.sdk !== undefined) return deps;
+	return {
+		...given,
+		sdk: {
+			createReadToolDefinition,
+			createBashToolDefinition,
+			createLsToolDefinition,
+			createFindToolDefinition,
+			createGrepToolDefinition,
+			getAgentDir: () => agentHome,
+		},
+	};
+}
+
 export default async function gentlePiPrettyExtension(
 	pi: unknown,
 	deps?: unknown,
 	bundled?: PiPrettyExtension,
 	env: NodeJS.ProcessEnv = process.env,
 ): Promise<unknown> {
+	// gentle-shell#1690: a delegated child has no transcript to prettify, and
+	// the upstream fallback would start its own file indexing in every child.
+	if (env.GENTLE_PI_AGENTS_CHILD === "1") return undefined;
 	if (quietToolsEnabled()) {
 		process.env.PRETTY_DISABLE_TOOLS = mergeDisabledTools(
 			process.env.PRETTY_DISABLE_TOOLS,
@@ -39,6 +73,7 @@ export default async function gentlePiPrettyExtension(
 		);
 	}
 	const extension = bundled ?? await loadPiPrettyExtension();
+	deps = withAgentHome(deps, env);
 	if (!shellEnabled(env)) return extension(pi, deps);
 	const api = pi as ExtensionAPI;
 	// Scope interception to this bundled dependency, never to the shared host UI.
@@ -77,8 +112,9 @@ export default async function gentlePiPrettyExtension(
 	// GentlePromptEditor already carries the live working state in its frame.
 	// Hide Pi's separate loader row to avoid repeating Thinking above the input;
 	// transcript thinking blocks remain untouched as historical reasoning markers.
+	// Inside Herdr the row stays: its native Pi detection reads it.
 	api.on("session_start", (_event, ctx) => {
-		if (ctx.mode === "tui") ctx.ui.setWorkingVisible(false);
+		if (ctx.mode === "tui" && !keepNativeWorkingRow(env)) ctx.ui.setWorkingVisible(false);
 	});
 	api.on("session_shutdown", (_event, ctx) => {
 		if (ctx.mode !== "tui") return;

package/extensions/quiet-tools.ts

@@ -12,12 +12,14 @@ import { Text, type Component } from "@earendil-works/pi-tui";
 import { homedir } from "node:os";
 import { isAbsolute } from "node:path";
 import { resolveGentleAiDevBinaryOverride, type GentleAiDevBinaryOverride } from "../lib/gentle-ai-binary.ts";
+import { CARD_CONTENT, cardContent } from "../lib/card-content-policy.ts";
 import { GentleAiElapsedTimingLedger } from "../lib/gentle-ai-elapsed-store.ts";
 import { quietToolsEnabled } from "../lib/quiet-tools-config.ts";
 import { registerCompactCodemode } from "../lib/codemode-renderer.ts";
+import { offerBuiltinCodemodeOptOut, type BuiltinCodemodeOptOutOptions } from "../lib/builtin-codemode-optout.ts";
 import { getGentleAiRenderState, renderGentleAiLifecycleCall, renderGentleAiResult, type GentleAiRenderContext } from "../lib/gentle-ai-renderer.ts";
 import {
-	CARD_TONE, cardAwaitingResult, cardBottom, cardInnerWidth, cardLine, cardRunningLine, cardTopRows, floatRows, markCardResult,
+	CARD_TONE, cardAwaitingResult, cardBottom, cardInnerWidth, cardLine, cardRunningLine, cardStyle, cardTopRows, floatRows, markCardResult,
 	type CardRowContext, type CardTheme,
 } from "../lib/shell-card.ts";
 import { sanitizeTerminalText, stripAnsi } from "../lib/terminal-theme.ts";
@@ -55,6 +57,11 @@ const COLLAPSED_COUNT_LABELS: Partial<Record<QuietToolName, string>> = {
 	ls: "entries",
 };
 
+// Cards that show only the command while the Card content preference is
+// minimal: their results stay one expand key away and never add rows to the
+// transcript view.
+const COMMAND_ONLY_TOOLS: ReadonlySet<QuietToolName> = new Set(["read", "bash", "grep", "find", "ls", "edit", "write"]);
+
 const COLLAPSED_TAIL_LINE_LIMIT = 10;
 const PREVIEW_LINE_LIMIT = 3;
 
@@ -423,7 +430,10 @@ export function formatToolResultOutput(
 ): string {
 	const text = safeText(extractTextContent(result));
 	if (expanded) {
-		const detail = expandedResultText(toolName, result, text);
+		// Write results only acknowledge the operation; the body lives in the call args.
+		const detail = toolName === "write" && !isError && typeof args?.content === "string" && args.content.length > 0
+			? safeText(args.content)
+			: expandedResultText(toolName, result, text);
 		return detail ? `\n${detail}` : "";
 	}
 	if (isError) {
@@ -470,7 +480,9 @@ interface ToolRenderContextLike {
 	lastComponent?: unknown;
 	state?: unknown;
 	cwd?: string;
-	[key: string]: unknown;
+	expanded?: boolean;
+	toolCallId?: string;
+	durationMs?: number;
 }
 
 function formatToolCall(toolName: QuietToolName, args: Record<string, unknown>, theme: ThemeLike): string {
@@ -482,7 +494,9 @@ function formatToolCall(toolName: QuietToolName, args: Record<string, unknown>,
 		case "bash": {
 			const command = safeText(asString(args.command, "..."));
 			const timeout = typeof args.timeout === "number" ? theme.fg("muted", ` (timeout ${args.timeout}s)`) : "";
-			return `${theme.fg("toolTitle", theme.bold(`bash $ ${command}`))}${timeout}`;
+			// Minimal cards title bash with the bare command; the card glyph supplies the `$` prompt.
+			const title = cardContent() === CARD_CONTENT.MINIMAL ? command : `bash $ ${command}`;
+			return `${theme.fg("toolTitle", theme.bold(title))}${timeout}`;
 		}
 		case "grep": {
 			let text = `${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", `/${safeText(asString(args.pattern))}/`)} in ${safeText(shortenPath(args.path) || ".")}`;
@@ -568,7 +582,23 @@ function toolTone(pending: boolean, failed: boolean): ToolTone {
 	return pending ? CARD_TONE.WARNING : CARD_TONE.SUCCESS;
 }
 
+/** One settled frame per component: bounded memory, including all card chrome. */
+class ToolCardRows {
+	private frame?: { width: number; style: ReturnType<typeof cardStyle>; running: boolean; lines: string[] };
+
+	render(width: number, running: boolean, build: () => string[]): string[] {
+		const style = cardStyle();
+		if (this.frame?.width === width && this.frame.style === style && this.frame.running === running) return this.frame.lines;
+		const lines = build();
+		this.frame = { width, style, running, lines };
+		return lines;
+	}
+
+	invalidate(): void { this.frame = undefined; }
+}
+
 class ToolCardTop implements Component {
+	private readonly rows = new ToolCardRows();
 	private readonly header: () => string;
 	private readonly glyph: string;
 	private readonly tone: ToolTone;
@@ -590,41 +620,44 @@ class ToolCardTop implements Component {
 		const target = Math.max(0, Math.floor(width));
 		if (target === 0) return [];
 		const running = this.row !== undefined && cardAwaitingResult(this.row);
-		return floatRows(this.tone, this.theme, target, (inner) => ({
+		return this.rows.render(target, running, () => floatRows(this.tone, this.theme, target, (inner) => ({
 			head: cardTopRows({ title: this.header(), glyph: this.glyph, body: [], tone: this.tone }, this.theme, inner, this.hint),
 			body: running ? [cardRunningLine(this.tone, this.theme, inner)] : undefined,
 			bottom: running ? cardBottom(this.tone, this.theme, inner) : undefined,
-		}));
+		})));
 	}
 
-	invalidate(): void {}
+	invalidate(): void { this.rows.invalidate(); }
 }
 
 class ToolCardBody implements Component {
+	private readonly rows = new ToolCardRows();
 	private readonly inner: () => Component;
 	private readonly tone: ToolTone;
 	private readonly theme: CardTheme;
 
-	constructor(inner: () => Component, tone: ToolTone, theme: CardTheme) {
+	private readonly cacheable: boolean;
+
+	constructor(inner: () => Component, tone: ToolTone, theme: CardTheme, cacheable = true) {
 		this.inner = inner;
 		this.tone = tone;
 		this.theme = theme;
+		this.cacheable = cacheable;
 	}
 
 	/** Renders the inner component between the card sides and closes the frame, even when the result has no rows. */
 	render(width: number): string[] {
 		const target = Math.max(0, Math.floor(width));
 		if (target === 0) return [];
-		return floatRows(this.tone, this.theme, target, (inner) => ({
+		const build = () => floatRows(this.tone, this.theme, target, (inner) => ({
 			body: this.inner().render(cardInnerWidth(inner)).map((line) => cardLine(line.trimEnd(), this.tone, this.theme, inner)),
 			bottom: cardBottom(this.tone, this.theme, inner),
 			afterHeading: true,
 		}));
+		return this.cacheable ? this.rows.render(target, false, build) : build();
 	}
 
-	invalidate(): void {
-		// Content is rebuilt with the current theme at render time.
-	}
+	invalidate(): void { this.rows.invalidate(); }
 }
 
 function shouldRenderPreviewTail(
@@ -649,11 +682,15 @@ function hasImageContent(result: AgentToolResult<unknown>): boolean {
 	return result.content.some((content) => content.type === "image");
 }
 
-function sanitizedRenderContext(context: ToolRenderContextLike | undefined): ToolRenderContextLike {
+function isRenderArgs(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function sanitizedRenderContext(context: (Omit<ToolRenderContextLike, "args"> & { args?: unknown }) | undefined): ToolRenderContextLike {
 	if (!context) return { args: {} };
 	return {
 		...context,
-		args: sanitizedArgs(context.args),
+		args: sanitizedArgs(isRenderArgs(context.args) ? context.args : undefined),
 		cwd: typeof context.cwd === "string" ? safeText(context.cwd) : context.cwd,
 	};
 }
@@ -685,7 +722,7 @@ function gentleAiRenderTransition(
 	return { directResult: false };
 }
 
-/** Rendering-only factory; Bash renderers are not attached to production native Bash. */
+/** Rendering-only factory; the default export attaches the Bash renderers to native Bash through pi.registerToolRenderer, so execution and schema stay pi's. */
 export function createQuietToolRenderer(
 	toolName: QuietToolName,
 	resolveOverride: GentleAiDevBinaryOverrideResolver = () => undefined,
@@ -702,7 +739,7 @@ export function createQuietToolRenderer(
 		renderShell: "self",
 		renderCall(args, theme, context) {
 			const callArgs = args as Record<string, unknown>;
-			const renderContext = sanitizedRenderContext(context as ToolRenderContextLike | undefined);
+			const renderContext = sanitizedRenderContext(context);
 			const operationPath = toolName === "bash"
 				? gentleAiRenderTransition(callArgs, renderContext, commandArguments()).operationPath
 				: undefined;
@@ -718,12 +755,15 @@ export function createQuietToolRenderer(
 		},
 		/** Builds the card component for this render pass; collapsed cards delegate to the wrapped-line cache keyed by the tool result object. */
 		renderResult(result, options, theme, context) {
-			const renderContext = context as ToolRenderContextLike | undefined;
+			const renderContext = context ? sanitizedRenderContext(context) : undefined;
 			markCardResult(renderContext?.state);
 			const cacheKey = typeof result === "object" && result !== null ? result : undefined;
 			const safeResult = sanitizedResult(result);
 			const text = safeText(extractTextContent(safeResult));
-			const isError = renderContext?.isError ?? options.isError ?? false;
+			// Current Pi carries errors on the context. Older renderer callers
+			// supplied them on options; keep that structural fallback for those hosts.
+			const legacyError = "isError" in options && options.isError === true;
+			const isError = renderContext?.isError ?? legacyError;
 			const directResult = toolName === "bash" && gentleAiRenderTransition(
 				renderContext?.args,
 				renderContext,
@@ -734,7 +774,14 @@ export function createQuietToolRenderer(
 				return renderGentleAiResult(safeResult, { expanded: options.expanded, isPartial: options.isPartial, isError }, theme, renderContext ? withElapsedTiming(renderContext as GentleAiRenderContext) : undefined);
 			}
 			const resultTone = toolTone(options.isPartial === true, isError);
-			const carded = (component: () => Component): Component => new ToolCardBody(component, resultTone, theme);
+			const carded = (component: () => Component, cacheable = options.isPartial !== true): Component => new ToolCardBody(component, resultTone, theme, cacheable);
+			// Under the minimal Card content preference, every quiet tool draws
+			// the command alone while collapsed; the expand key still reveals
+			// the full result. Failures keep their bounded error tail so a red
+			// card always says why. The default preference keeps the previews.
+			if (COMMAND_ONLY_TOOLS.has(toolName) && !options.expanded && !isError && cardContent() === CARD_CONTENT.MINIMAL) {
+				return carded(() => new Text("", 0, 0));
+			}
 			if (options.isPartial) {
 				if (options.expanded) return carded(() => new Text(`${theme.fg("warning", partialLabel(toolName, text))}\n${theme.fg("muted", text)}`, 0, 0));
 				const visible = lastOutputLines(text, PREVIEW_LINE_LIMIT);
@@ -749,7 +796,7 @@ export function createQuietToolRenderer(
 					options,
 					theme,
 					sanitizedRenderContext(renderContext) as any,
-				));
+				), false);
 			}
 			let output = formatToolResultOutput(toolName, safeResult, {
 				expanded: options.expanded,
@@ -789,11 +836,24 @@ function registerQuietTool(pi: ExtensionAPI, toolName: RegisteredToolName, resol
 	});
 }
 
-export default function quietTools(pi: ExtensionAPI, resolveOverride: GentleAiDevBinaryOverrideResolver = () => resolveGentleAiDevBinaryOverride()): ReturnType<ExtensionFactory> {
+export default function quietTools(
+	pi: ExtensionAPI,
+	resolveOverride: GentleAiDevBinaryOverrideResolver = () => resolveGentleAiDevBinaryOverride(),
+	codemodeOptOut: Omit<BuiltinCodemodeOptOutOptions, "effectiveExtensions"> = {},
+): ReturnType<ExtensionFactory> {
 	if (!quietToolsEnabled()) return;
 	let elapsedTiming: GentleAiElapsedTimingLedger | undefined;
+	let codemodeOptOutOffered = false;
 	pi.on("session_start", (_event, ctx) => {
 		elapsedTiming = new GentleAiElapsedTimingLedger(ctx.sessionManager, pi);
+		// The compact codemode below displaces Pi's builtin, which makes Pi warn
+		// at startup. Offer the settings opt-out once per process, detached so
+		// the dialog never holds up startup; the offer itself never throws.
+		if (codemodeOptOutOffered) return;
+		codemodeOptOutOffered = true;
+		let effectiveExtensions: unknown;
+		try { effectiveExtensions = pi.getSettings().extensions; } catch { /* Fall back to the settings file alone. */ }
+		void offerBuiltinCodemodeOptOut(ctx, { ...codemodeOptOut, effectiveExtensions });
 	});
 	// Only bash calls that render as gentle-ai cards carry a durable duration;
 	// every other quiet tool keeps its plain renderer and writes no entries.
@@ -812,5 +872,15 @@ export default function quietTools(pi: ExtensionAPI, resolveOverride: GentleAiDe
 	for (const toolName of Object.keys(TOOL_CREATORS) as RegisteredToolName[]) {
 		registerQuietTool(pi, toolName, resolveOverride, () => elapsedTiming);
 	}
+	// Native Bash keeps pi's execution and schema; only its drawing becomes a
+	// Gentle card while the Card content preference is minimal, so quiet bash
+	// rows match the other tools. The resolver API is newer than this
+	// package's pinned pi types, so it is probed structurally; hosts without it
+	// — and the default content preference — keep pi's native bash rendering.
+	const host = pi as typeof pi & { registerToolRenderer?: (resolver: (toolName: string, next: () => unknown) => unknown) => void };
+	if (typeof host.registerToolRenderer === "function") {
+		host.registerToolRenderer((toolName, next) =>
+			toolName === "bash" && cardContent() === CARD_CONTENT.MINIMAL ? createQuietToolRenderer("bash", resolveOverride, () => elapsedTiming) : next());
+	}
 	return registerCompactCodemode(pi);
 }