pi-quiet-activity 1.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin Vargas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# Quiet Activity
+
+A global Pi extension that reduces an agent run to one activity indicator and the final answer.
+
+![Quiet Activity showing live working status in Pi](https://raw.githubusercontent.com/kevinvargasl/pi-quiet-activity/main/assets/pi-quiet-activity-demo.gif)
+
+## Quiet mode
+
+While the agent works, the activity line follows the current operation:
+
+```text
+User: Do this.
+Working
+Reading abc.ts...
+Writing 1234.csv...
+Calling MCP context7/resolve-library-id...
+```
+
+Built-in file, shell, search, web, MCP, task, and question tools receive concise labels. MCP proxy calls include the server and tool when those fields are available. Unknown tools display `Using <tool-name>...`. Long details are normalized to one line and truncated. Terminal control sequences are removed, and common credentials in commands or URLs are redacted.
+
+The TUI hides:
+
+- thinking/reasoning blocks
+- intermediate assistant narration attached to tool-using turns
+- all built-in and extension tool calls/results
+- the final answer while it is still streaming
+
+When the agent settles, the working line disappears and a compact elapsed time appears in dimmed text before the finalized answer, such as `Worked for 45s`, `Worked for 1m 23s`, or `Worked for 2h 12m`. The extension does not add anything to the footer.
+
+![Elapsed time displayed before the final answer](https://raw.githubusercontent.com/kevinvargasl/pi-quiet-activity/main/assets/elapsed-time-message.png)
+
+Some models, including Claude Opus 5 through GitHub Copilot, can put useful details in a tool-calling turn and finish with only a short phrase. Quiet mode now asks the model to repeat those details in a self-contained final response. Rendering stays display-only. Tool execution and saved session data are unchanged, but the extra instruction is part of the model's system prompt while quiet mode is enabled in the TUI.
+
+## Toggle
+
+Press:
+
+```text
+F9
+```
+
+This shortcut is not assigned by Pi's default keybindings and works in Windows and macOS terminals. On a Mac keyboard configured to use the top row for media controls, press `Fn+F9`. It toggles between quiet mode and Pi's normal transcript. A brief notification reports only whether quiet activity is enabled or disabled; no permanent footer indicator is added. The setting persists across restarts in:
+
+```text
+~/.pi/agent/extension-data/quiet-activity/config.json
+```
+
+You can also use:
+
+```text
+/quiet-activity
+/quiet-activity on
+/quiet-activity off
+/quiet-activity toggle
+/quiet-activity status
+```
+
+## Installation
+
+Install the latest release from npm:
+
+```bash
+pi install npm:pi-quiet-activity
+```
+
+To pin this release:
+
+```bash
+pi install npm:pi-quiet-activity@1.3.1
+```
+
+To try the current main branch without installing it:
+
+```bash
+pi -e git:github.com/kevinvargasl/pi-quiet-activity
+```
+
+Run `/reload` in an existing Pi session after installation, or restart Pi.
+
+## Compatibility
+
+The extension patches Pi's exported `AssistantMessageComponent` and `ToolExecutionComponent` render methods for the current TUI session. It restores the original methods during session shutdown/reload.
+
+Renderer extensions that patch the same component prototypes may conflict. Turning quiet mode off restores normal rendering through whatever renderer was active when this extension loaded.

package/activity/display.ts

@@ -0,0 +1,57 @@
+import type {
+	ExtensionContext,
+	ToolExecutionEndEvent,
+	ToolExecutionStartEvent,
+} from "@earendil-works/pi-coding-agent";
+import { toolActivityLabel } from "./labels.ts";
+
+export interface ActivityDisplay {
+	reset(ctx: ExtensionContext): void;
+	clear(): void;
+	start(event: ToolExecutionStartEvent, ctx: ExtensionContext): void;
+	end(event: ToolExecutionEndEvent, ctx: ExtensionContext): void;
+	refresh(ctx: ExtensionContext): void;
+	restore(ctx: ExtensionContext): void;
+}
+
+export function createActivityDisplay(
+	isEnabled: () => boolean,
+): ActivityDisplay {
+	const active = new Map<string, string>();
+
+	function text(): string {
+		const activity = Array.from(active.values()).at(-1);
+		if (!activity) return "Working";
+		return `${activity}${activity.endsWith("...") ? "" : "..."}`;
+	}
+
+	function refresh(ctx: ExtensionContext): void {
+		if (ctx.mode !== "tui") return;
+		ctx.ui.setWorkingMessage(isEnabled() ? text() : undefined);
+		ctx.ui.setWorkingVisible(true);
+	}
+
+	return {
+		reset(ctx) {
+			active.clear();
+			refresh(ctx);
+		},
+		clear: () => active.clear(),
+		start(event, ctx) {
+			active.delete(event.toolCallId);
+			active.set(event.toolCallId, toolActivityLabel(event.toolName, event.args));
+			refresh(ctx);
+		},
+		end(event, ctx) {
+			active.delete(event.toolCallId);
+			refresh(ctx);
+		},
+		refresh,
+		restore(ctx) {
+			active.clear();
+			if (ctx.mode !== "tui") return;
+			ctx.ui.setWorkingMessage();
+			ctx.ui.setWorkingVisible(true);
+		},
+	};
+}

package/activity/labels.ts

@@ -0,0 +1,154 @@
+const MAX_DETAIL_LENGTH = 72;
+const ANSI_SEQUENCE =
+	/\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/g;
+const CONTROL_CHARACTERS =
+	/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u202A-\u202E\u2066-\u2069]/g;
+const BEARER_TOKEN = /\b(Bearer)\s+[A-Za-z0-9._~+/=-]+/gi;
+const SENSITIVE_ASSIGNMENT =
+	/\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password|passwd|pwd)(\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s&]+)/gi;
+const SENSITIVE_FLAG =
+	/(--?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password|passwd|pwd)\b(?:=|\s)+)(?:"[^"]*"|'[^']*'|[^\s]+)/gi;
+
+type ToolArguments = Record<string, unknown>;
+
+interface ActivitySpec {
+	action: string;
+	fallback: string;
+	keys: readonly string[];
+}
+
+const ACTIVITY_SPECS: Record<string, ActivitySpec> = {
+	read: {
+		action: "Reading",
+		fallback: "Reading a file",
+		keys: ["path", "file"],
+	},
+	write: {
+		action: "Writing",
+		fallback: "Writing a file",
+		keys: ["path", "file"],
+	},
+	edit: {
+		action: "Editing",
+		fallback: "Editing a file",
+		keys: ["path", "file"],
+	},
+	bash: { action: "Running", fallback: "Running a command", keys: ["command"] },
+	grep: {
+		action: "Searching files for",
+		fallback: "Searching files",
+		keys: ["query", "pattern"],
+	},
+	search: {
+		action: "Searching files for",
+		fallback: "Searching files",
+		keys: ["query", "pattern"],
+	},
+	find: {
+		action: "Finding",
+		fallback: "Finding files",
+		keys: ["pattern", "query", "path"],
+	},
+	web_search: {
+		action: "Searching the web for",
+		fallback: "Searching the web",
+		keys: ["query", "queries"],
+	},
+	source_check: {
+		action: "Checking",
+		fallback: "Checking sources",
+		keys: ["claim"],
+	},
+	fetch_content: {
+		action: "Fetching",
+		fallback: "Fetching content",
+		keys: ["url", "urls"],
+	},
+	mcp_call: {
+		action: "Calling",
+		fallback: "Calling an MCP tool",
+		keys: ["tool", "toolName", "name", "server"],
+	},
+};
+
+const STATIC_LABELS: Record<string, string> = {
+	get_search_content: "Reading search results",
+	todo: "Updating tasks",
+	ask_user_question: "Preparing a question",
+};
+
+function asArguments(value: unknown): ToolArguments {
+	return typeof value === "object" && value !== null
+		? (value as ToolArguments)
+		: {};
+}
+
+function shorten(value: string): string {
+	const oneLine = value
+		.replace(ANSI_SEQUENCE, "")
+		.replace(CONTROL_CHARACTERS, "")
+		.replace(/\s+/g, " ")
+		.replace(BEARER_TOKEN, "$1 [redacted]")
+		.replace(SENSITIVE_ASSIGNMENT, "$1$2[redacted]")
+		.replace(SENSITIVE_FLAG, "$1[redacted]")
+		.trim();
+	return oneLine.length <= MAX_DETAIL_LENGTH
+		? oneLine
+		: `${oneLine.slice(0, MAX_DETAIL_LENGTH - 3)}...`;
+}
+
+function firstString(value: unknown): string | undefined {
+	if (typeof value === "string" && value.trim()) return shorten(value);
+	if (!Array.isArray(value)) return undefined;
+	const match = value.find(
+		(item): item is string => typeof item === "string" && Boolean(item.trim()),
+	);
+	return match ? shorten(match) : undefined;
+}
+
+function findDetail(
+	args: ToolArguments,
+	keys: readonly string[],
+): string | undefined {
+	for (const key of keys) {
+		const value = firstString(args[key]);
+		if (value) return value;
+	}
+	return undefined;
+}
+
+function formatSpec(spec: ActivitySpec, args: ToolArguments): string {
+	const value = findDetail(args, spec.keys);
+	return value ? `${spec.action} ${value}` : spec.fallback;
+}
+
+function mcpActivityLabel(args: ToolArguments): string {
+	const server = findDetail(args, ["server", "serverName"]);
+	const tool = findDetail(args, ["tool", "toolName"]);
+	if (tool) return `Calling MCP ${server ? `${server}/${tool}` : tool}`;
+	if (server) return `Using MCP ${server}`;
+
+	const search = findDetail(args, ["search"]);
+	if (search) return `Searching MCP for ${search}`;
+
+	const target = findDetail(args, ["describe", "instructions", "name"]);
+	return target ? `Inspecting MCP ${target}` : "Using MCP";
+}
+
+export function toolActivityLabel(toolName: string, rawArgs: unknown): string {
+	const name = toolName.toLowerCase();
+	const staticLabel = STATIC_LABELS[name];
+	if (staticLabel) return staticLabel;
+
+	const args = asArguments(rawArgs);
+	if (name === "mcp") return mcpActivityLabel(args);
+
+	const spec = ACTIVITY_SPECS[name];
+	if (spec) return formatSpec(spec, args);
+
+	if (name.startsWith("mcp_")) {
+		const target = findDetail(args, ["tool", "toolName", "name"]);
+		return target ? `Calling ${target}` : `Calling ${shorten(toolName)}`;
+	}
+	return `Using ${shorten(toolName)}`;
+}

package/activity/timer.ts

@@ -0,0 +1,14 @@
+export function formatElapsedTime(elapsedMs: number): string {
+	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	if (totalMinutes < 60) {
+		const seconds = totalSeconds % 60;
+		return seconds === 0 ? `${totalMinutes}m` : `${totalMinutes}m ${seconds}s`;
+	}
+
+	const hours = Math.floor(totalMinutes / 60);
+	const minutes = totalMinutes % 60;
+	return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
+}

package/index.ts

@@ -0,0 +1,184 @@
+import type {
+	AgentStartEvent,
+	BeforeAgentStartEvent,
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+	SessionShutdownEvent,
+	SessionStartEvent,
+	ToolExecutionEndEvent,
+	ToolExecutionStartEvent,
+} from "@earendil-works/pi-coding-agent";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	createActivityDisplay,
+	type ActivityDisplay,
+} from "./activity/display.ts";
+import { formatElapsedTime } from "./activity/timer.ts";
+import {
+	createQuietRenderPatcher,
+	type QuietRenderPatcher,
+} from "./render/index.ts";
+
+const SHORTCUT = "f9";
+const FINAL_RESPONSE_INSTRUCTION =
+	"Quiet activity hides text from assistant turns that call tools. After tool use finishes, provide a self-contained final response. Repeat any result or explanation the user needs from earlier tool-calling turns.";
+const CONFIG_PATH = join(
+	process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"),
+	"extension-data",
+	"quiet-activity",
+	"config.json",
+);
+
+type QuietMode = "enabled" | "disabled";
+
+interface QuietState {
+	mode: { current: QuietMode };
+	activity: ActivityDisplay;
+	renderer: QuietRenderPatcher;
+	startedAt?: number;
+}
+
+function loadMode(): QuietMode {
+	try {
+		const config = JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as {
+			enabled?: unknown;
+		};
+		return config.enabled === false ? "disabled" : "enabled";
+	} catch {
+		return "enabled";
+	}
+}
+
+function saveMode(mode: QuietMode): boolean {
+	try {
+		mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`${JSON.stringify({ enabled: mode === "enabled" }, null, 2)}\n`,
+			"utf8",
+		);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function createState(): QuietState {
+	const mode = { current: loadMode() };
+	const isEnabled = () => mode.current === "enabled";
+	return {
+		mode,
+		activity: createActivityDisplay(isEnabled),
+		renderer: createQuietRenderPatcher(isEnabled),
+	};
+}
+
+function changeMode(
+	state: QuietState,
+	mode: QuietMode,
+	ctx: ExtensionContext,
+): void {
+	state.mode.current = mode;
+	state.renderer.refresh();
+	state.activity.refresh(ctx);
+
+	const saved = saveMode(mode);
+	ctx.ui.notify(`Quiet activity ${mode}.`, saved ? "info" : "warning");
+	if (!saved) ctx.ui.notify(`Could not save ${CONFIG_PATH}`, "warning");
+}
+
+function toggle(state: QuietState, ctx: ExtensionContext): void {
+	changeMode(
+		state,
+		state.mode.current === "enabled" ? "disabled" : "enabled",
+		ctx,
+	);
+}
+
+function handleCommand(
+	state: QuietState,
+	args: string,
+	ctx: ExtensionContext,
+): void {
+	switch (args.trim().toLowerCase() || "toggle") {
+		case "status":
+			ctx.ui.notify(
+				`Quiet activity is ${state.mode.current}. Toggle: ${SHORTCUT}`,
+			);
+			return;
+		case "on":
+			changeMode(state, "enabled", ctx);
+			return;
+		case "off":
+			changeMode(state, "disabled", ctx);
+			return;
+		case "toggle":
+			toggle(state, ctx);
+			return;
+		default:
+			ctx.ui.notify("Usage: /quiet-activity [on|off|toggle|status]", "warning");
+	}
+}
+
+function register(pi: ExtensionAPI, state: QuietState): void {
+	pi.registerShortcut(SHORTCUT, {
+		description: "Toggle quiet activity / normal agent output",
+		handler: (ctx: ExtensionContext) => toggle(state, ctx),
+	});
+	pi.registerCommand("quiet-activity", {
+		description:
+			"Control final-answer-only agent display: on, off, toggle, or status",
+		handler: (args: string, ctx: ExtensionCommandContext): Promise<void> => {
+			handleCommand(state, args, ctx);
+			return Promise.resolve();
+		},
+	});
+	pi.on("session_start", (_event: SessionStartEvent, ctx: ExtensionContext) => {
+		if (ctx.mode === "tui") state.renderer.install();
+		state.activity.reset(ctx);
+	});
+	pi.on(
+		"before_agent_start",
+		(event: BeforeAgentStartEvent, ctx: ExtensionContext) => {
+			if (ctx.mode !== "tui" || state.mode.current !== "enabled") return;
+			return {
+				systemPrompt: `${event.systemPrompt}\n\n${FINAL_RESPONSE_INSTRUCTION}`,
+			};
+		},
+	);
+	pi.on("agent_start", (_event: AgentStartEvent, ctx: ExtensionContext) => {
+		state.startedAt = Date.now();
+		state.activity.reset(ctx);
+	});
+	pi.on(
+		"tool_execution_start",
+		(event: ToolExecutionStartEvent, ctx: ExtensionContext) =>
+			state.activity.start(event, ctx),
+	);
+	pi.on(
+		"tool_execution_end",
+		(event: ToolExecutionEndEvent, ctx: ExtensionContext) =>
+			state.activity.end(event, ctx),
+	);
+	pi.on("agent_settled", (_event, ctx) => {
+		state.activity.clear();
+		if (state.startedAt === undefined) return;
+		const elapsed = formatElapsedTime(Date.now() - state.startedAt);
+		state.renderer.finish(ctx.ui.theme.fg("dim", `Worked for ${elapsed}`));
+		state.startedAt = undefined;
+	});
+	pi.on(
+		"session_shutdown",
+		(_event: SessionShutdownEvent, ctx: ExtensionContext) => {
+			state.activity.restore(ctx);
+			state.renderer.uninstall();
+		},
+	);
+}
+
+export default function quietActivityExtension(pi: ExtensionAPI): void {
+	register(pi, createState());
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "pi-quiet-activity",
+  "version": "1.3.1",
+  "description": "Final-answer-only interactive mode with live activity labels for Pi.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "quiet-mode"
+  ],
+  "author": "Kevin Vargas",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kevinvargasl/pi-quiet-activity.git"
+  },
+  "homepage": "https://github.com/kevinvargasl/pi-quiet-activity#readme",
+  "bugs": {
+    "url": "https://github.com/kevinvargasl/pi-quiet-activity/issues"
+  },
+  "files": [
+    "index.ts",
+    "activity",
+    "render",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/kevinvargasl/pi-quiet-activity/main/assets/pi-quiet-activity-demo.gif"
+  },
+  "scripts": {
+    "test": "node --experimental-strip-types tests/run-smoke.mjs",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm test && npm run typecheck"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2"
+  }
+}

package/render/assistant.ts

@@ -0,0 +1,208 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+
+type AssistantRender = typeof AssistantMessageComponent.prototype.render;
+type AssistantUpdate = typeof AssistantMessageComponent.prototype.updateContent;
+type EnabledCheck = () => boolean;
+
+const ELAPSED_METADATA = Symbol.for("pi-quiet-activity.elapsed");
+
+interface RenderState {
+	originalMessage: AssistantMessage;
+	renderedMessage: AssistantMessage;
+	isStreaming: boolean;
+	elapsed?: string;
+}
+
+interface RuntimeState {
+	hasToolCalls: boolean;
+	isStreaming: boolean;
+	lastMessage?: AssistantMessage;
+	[ELAPSED_METADATA]?: string;
+}
+
+type ElapsedMessage = AssistantMessage & {
+	[ELAPSED_METADATA]?: string;
+};
+
+interface RenderMethods {
+	render: AssistantRender;
+	update: AssistantUpdate;
+}
+
+interface PatchState {
+	components: Map<AssistantMessageComponent, RenderState>;
+	originals?: RenderMethods;
+	patches?: RenderMethods;
+}
+
+function getRuntimeState(component: AssistantMessageComponent): RuntimeState {
+	// SAFETY: Pi's AssistantMessageComponent owns these runtime fields; the symbol
+	// metadata is private to this extension and does not overlap Pi's properties.
+	return component as unknown as RuntimeState;
+}
+
+function getMessageElapsed(message?: AssistantMessage): string | undefined {
+	return (message as ElapsedMessage | undefined)?.[ELAPSED_METADATA];
+}
+
+function getElapsed(component: AssistantMessageComponent): string | undefined {
+	const runtime = getRuntimeState(component);
+	return runtime[ELAPSED_METADATA] ?? getMessageElapsed(runtime.lastMessage);
+}
+
+function setElapsed(
+	component: AssistantMessageComponent,
+	message: AssistantMessage,
+	elapsed: string,
+): void {
+	getRuntimeState(component)[ELAPSED_METADATA] = elapsed;
+	(message as ElapsedMessage)[ELAPSED_METADATA] = elapsed;
+}
+
+export interface AssistantRenderPatch {
+	install(): void;
+	refresh(): void;
+	finish(elapsed: string): void;
+	uninstall(): void;
+}
+
+function removeThinking(message: AssistantMessage): AssistantMessage {
+	if (!message.content.some((part) => part.type === "thinking")) return message;
+	return {
+		...message,
+		content: message.content.filter((part) => part.type !== "thinking"),
+	};
+}
+
+function shouldHide(
+	state: PatchState,
+	isEnabled: EnabledCheck,
+	component: AssistantMessageComponent,
+): boolean {
+	if (!isEnabled()) return false;
+	const runtime = getRuntimeState(component);
+	const isStreaming =
+		state.components.get(component)?.isStreaming ?? runtime.isStreaming;
+	return isStreaming || runtime.hasToolCalls;
+}
+
+function createPatches(
+	state: PatchState,
+	isEnabled: EnabledCheck,
+	originals: RenderMethods,
+): RenderMethods {
+	return {
+		update: function updateContent(
+			this: AssistantMessageComponent,
+			...args: Parameters<AssistantUpdate>
+		): void {
+			const [message, requestedStreaming] = args;
+			const runtime = getRuntimeState(this);
+			const previous = state.components.get(this);
+			const originalMessage =
+				message === previous?.renderedMessage ? previous.originalMessage : message;
+			const isStreaming = requestedStreaming ?? runtime.isStreaming;
+			const renderedMessage = isEnabled()
+				? removeThinking(originalMessage)
+				: originalMessage;
+
+			state.components.set(this, {
+				originalMessage,
+				renderedMessage,
+				isStreaming,
+				elapsed: previous?.elapsed ?? getElapsed(this),
+			});
+			originals.update.call(this, renderedMessage, isStreaming);
+		},
+		render: function render(
+			this: AssistantMessageComponent,
+			...args: Parameters<AssistantRender>
+		): string[] {
+			if (shouldHide(state, isEnabled, this)) return [];
+			const lines = originals.render.call(this, ...args);
+			const elapsed = state.components.get(this)?.elapsed ?? getElapsed(this);
+			return isEnabled() && elapsed ? [elapsed, ...lines] : lines;
+		},
+	};
+}
+
+function finish(state: PatchState, elapsed: string): void {
+	const entries = Array.from(state.components.entries());
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const [component, renderState] = entries[index];
+		const runtime = getRuntimeState(component);
+		if (renderState.isStreaming || runtime.hasToolCalls) continue;
+		renderState.elapsed = elapsed;
+		setElapsed(component, renderState.originalMessage, elapsed);
+		state.originals?.update.call(
+			component,
+			renderState.renderedMessage,
+			renderState.isStreaming,
+		);
+		return;
+	}
+}
+
+function install(state: PatchState, isEnabled: EnabledCheck): void {
+	if (state.originals) return;
+
+	const prototype = AssistantMessageComponent.prototype;
+	const originals = {
+		render: prototype.render,
+		update: prototype.updateContent,
+	};
+	const patches = createPatches(state, isEnabled, originals);
+	state.originals = originals;
+	state.patches = patches;
+	prototype.updateContent = patches.update;
+	prototype.render = patches.render;
+}
+
+function refresh(state: PatchState, isEnabled: EnabledCheck): void {
+	const update = state.originals?.update;
+	if (!update) return;
+
+	for (const [component, renderState] of state.components) {
+		renderState.renderedMessage = isEnabled()
+			? removeThinking(renderState.originalMessage)
+			: renderState.originalMessage;
+		update.call(component, renderState.renderedMessage, renderState.isStreaming);
+	}
+}
+
+function uninstall(state: PatchState): void {
+	const { originals, patches } = state;
+	if (!originals || !patches) return;
+
+	try {
+		for (const [component, renderState] of state.components) {
+			originals.update.call(
+				component,
+				renderState.originalMessage,
+				renderState.isStreaming,
+			);
+		}
+	} finally {
+		const prototype = AssistantMessageComponent.prototype;
+		if (prototype.updateContent === patches.update)
+			prototype.updateContent = originals.update;
+		if (prototype.render === patches.render) prototype.render = originals.render;
+
+		state.components.clear();
+		state.originals = undefined;
+		state.patches = undefined;
+	}
+}
+
+export function createAssistantRenderPatch(
+	isEnabled: EnabledCheck,
+): AssistantRenderPatch {
+	const state: PatchState = { components: new Map() };
+	return {
+		install: () => install(state, isEnabled),
+		refresh: () => refresh(state, isEnabled),
+		finish: (elapsed) => finish(state, elapsed),
+		uninstall: () => uninstall(state),
+	};
+}

package/render/index.ts

@@ -0,0 +1,29 @@
+import { createAssistantRenderPatch } from "./assistant.ts";
+import { createToolRenderPatch } from "./tool.ts";
+
+export interface QuietRenderPatcher {
+	install(): void;
+	refresh(): void;
+	finish(elapsed: string): void;
+	uninstall(): void;
+}
+
+export function createQuietRenderPatcher(
+	isEnabled: () => boolean,
+): QuietRenderPatcher {
+	const assistant = createAssistantRenderPatch(isEnabled);
+	const tool = createToolRenderPatch(isEnabled);
+
+	return {
+		install() {
+			assistant.install();
+			tool.install();
+		},
+		refresh: () => assistant.refresh(),
+		finish: (elapsed) => assistant.finish(elapsed),
+		uninstall() {
+			assistant.uninstall();
+			tool.uninstall();
+		},
+	};
+}

package/render/tool.ts

@@ -0,0 +1,37 @@
+import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+
+type ToolRender = typeof ToolExecutionComponent.prototype.render;
+
+export interface ToolRenderPatch {
+	install(): void;
+	uninstall(): void;
+}
+
+export function createToolRenderPatch(
+	isEnabled: () => boolean,
+): ToolRenderPatch {
+	let original: ToolRender | undefined;
+	let patch: ToolRender | undefined;
+
+	return {
+		install() {
+			if (original) return;
+			const prototype = ToolExecutionComponent.prototype;
+			original = prototype.render;
+			patch = function render(
+				this: ToolExecutionComponent,
+				...args: Parameters<ToolRender>
+			): string[] {
+				return isEnabled() ? [] : (original?.call(this, ...args) ?? []);
+			};
+			prototype.render = patch;
+		},
+		uninstall() {
+			if (original && patch && ToolExecutionComponent.prototype.render === patch) {
+				ToolExecutionComponent.prototype.render = original;
+			}
+			original = undefined;
+			patch = undefined;
+		},
+	};
+}