@diegopetrucci/pi-extensions 0.1.19 → 0.1.21

package/README.md

@@ -8,9 +8,10 @@ A collection of [pi](https://github.com/earendil-works/pi-mono) agent extensions
 - [`librarian`](./extensions/librarian): Adds a GitHub research scout that asks whether to use an opt-in local repo checkout cache under the OS user cache directory, with cached repos expiring after 30 days of non-use.
 - [`minimal-footer`](./extensions/minimal-footer): Replaces pi's built-in footer with a minimal configurable two-line layout: branch/repo on the first line, context/model on the second, optional `DUMB ZONE`, plus OpenAI Codex 5-hour and 7-day usage when available.
 - [`notify`](./extensions/notify): Sends configurable terminal, desktop, bell, and sound notifications when pi finishes and is ready for input.
+- [`openai-fast`](./extensions/openai-fast): Adds `/fast` to enable OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4 and GPT-5.5 by injecting the priority service tier.
 - [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, covers pi’s built-in providers with hardcoded rankings, sets reasoning to xhigh by default, and shows live status while running.
 - [`permission-gate`](./extensions/permission-gate): Prompts for confirmation before dangerous bash commands like `rm -rf`, `sudo`, and `chmod 777`.
-- [`quiet-tools`](./extensions/quiet-tools): Renders collapsed built-in tool rows as quiet one-line previews without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
+- [`quiet-tools`](./extensions/quiet-tools): Renders collapsed built-in tool rows as a one-line invocation plus an expand hint without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
 
 (For the full list of pi extensions I use, [check out my dotfiles](https://github.com/diegopetrucci/dot/blob/main/.pi/agent/settings.json).)
 
@@ -25,7 +26,7 @@ pi install npm:@diegopetrucci/pi-extensions
 Or pin the GitHub package to this release:
 
 ```bash
-pi install git:github.com/diegopetrucci/pi-extensions@v0.1.19
+pi install git:github.com/diegopetrucci/pi-extensions@v0.1.21
 ```
 
 Or a specific extension:

package/extensions/openai-fast/README.md

@@ -0,0 +1,95 @@
+# openai-fast
+
+A pi extension that enables OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4 and GPT-5.5.
+
+When active, the extension injects this into eligible OpenAI Codex request payloads:
+
+```json
+{
+  "service_tier": "priority"
+}
+```
+
+The user-facing feature is OpenAI Codex **Fast mode**. The wire value is `priority` because current Codex clients map Fast mode to the OpenAI priority service tier.
+
+## Eligibility
+
+Fast mode is only injected when all of these are true:
+
+- The current provider is `openai-codex`.
+- The current API is `openai-codex-responses`.
+- The current model is `gpt-5.4` or `gpt-5.5`.
+- The provider is using ChatGPT OAuth/subscription auth, not API-key auth.
+- The request payload does not already include `service_tier`.
+
+## Commands
+
+```text
+/fast status
+/fast on
+/fast off
+/fast auto
+/fast toggle
+```
+
+`/fast on` and `/fast off` are temporary session/runtime overrides. Use `/fast auto` to reload and follow config defaults again.
+
+The extension defaults to off so installing the full collection does not accidentally spend Fast-mode credits.
+
+## Config
+
+Optional global config:
+
+```text
+~/.pi/agent/extensions/openai-fast.json
+```
+
+Optional project config:
+
+```text
+.pi/openai-fast.json
+```
+
+Project config overrides global config.
+
+```json
+{
+  "enabled": false,
+  "showStatus": true
+}
+```
+
+- `enabled`: default Fast-mode state when there is no session override.
+- `showStatus`: show a compact `fast` status when Fast mode is active for the current model.
+
+## Install
+
+### Standalone npm package
+
+```bash
+pi install npm:@diegopetrucci/pi-openai-fast
+```
+
+### Collection package
+
+```bash
+pi install npm:@diegopetrucci/pi-extensions
+```
+
+### GitHub package
+
+```bash
+pi install git:github.com/diegopetrucci/pi-extensions
+```
+
+Then reload pi:
+
+```text
+/reload
+```
+
+## Notes
+
+- This extension intentionally does not affect API-key OpenAI models.
+- Pi may only account Fast-mode cost correctly when the backend reports `service_tier: "priority"` in the streamed response. The extension does not patch usage totals to avoid double-counting.
+- If pi adds first-class service-tier support later, this extension skips payloads that already contain `service_tier`.

package/extensions/openai-fast/index.ts

@@ -0,0 +1,292 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	getAgentDir,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+const EXTENSION_ID = "openai-fast";
+const PROVIDER_ID = "openai-codex";
+const API_ID = "openai-codex-responses";
+const FAST_SERVICE_TIER = "priority";
+const SUPPORTED_MODELS = new Set(["gpt-5.4", "gpt-5.5"]);
+const COMMANDS = ["status", "on", "off", "auto", "toggle"];
+
+const DEFAULT_CONFIG: OpenAIFastConfig = {
+	enabled: false,
+	showStatus: true,
+};
+
+type FastOverride = "auto" | "on" | "off";
+
+type OpenAIFastConfig = {
+	/** Default Fast-mode state when there is no session override. */
+	enabled: boolean;
+	/** Show a compact `fast` status when Fast mode is active for the current model. */
+	showStatus: boolean;
+};
+
+type SessionState = {
+	config: OpenAIFastConfig;
+	override: FastOverride;
+	lastInjectedAt?: number;
+	lastInjectedModel?: string;
+};
+
+type RecursivePartial<T> = {
+	[P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+
+type PayloadRecord = Record<string, unknown>;
+
+type Eligibility = {
+	eligible: boolean;
+	modelKey: string;
+	reason?: string;
+};
+
+function readConfigFile(path: string): RecursivePartial<OpenAIFastConfig> {
+	if (!existsSync(path)) return {};
+
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return isPayloadRecord(parsed) ? (parsed as RecursivePartial<OpenAIFastConfig>) : {};
+	} catch (error) {
+		console.error(`Warning: Could not parse ${path}: ${error}`);
+		return {};
+	}
+}
+
+function normalizeBoolean(value: unknown, fallback: boolean): boolean {
+	return typeof value === "boolean" ? value : fallback;
+}
+
+function mergeConfig(
+	base: OpenAIFastConfig,
+	overrides: RecursivePartial<OpenAIFastConfig>,
+): OpenAIFastConfig {
+	return {
+		enabled: normalizeBoolean(overrides.enabled, base.enabled),
+		showStatus: normalizeBoolean(overrides.showStatus, base.showStatus),
+	};
+}
+
+function findProjectConfigPath(cwd: string): string {
+	let current = cwd;
+	while (true) {
+		const candidate = join(current, ".pi", "openai-fast.json");
+		if (existsSync(candidate)) return candidate;
+
+		const parent = dirname(current);
+		if (parent === current) return join(cwd, ".pi", "openai-fast.json");
+		current = parent;
+	}
+}
+
+function loadConfig(cwd: string): OpenAIFastConfig {
+	const globalConfig = readConfigFile(join(getAgentDir(), "extensions", "openai-fast.json"));
+	const projectConfig = readConfigFile(findProjectConfigPath(cwd));
+	return mergeConfig(mergeConfig(DEFAULT_CONFIG, globalConfig), projectConfig);
+}
+
+function isPayloadRecord(payload: unknown): payload is PayloadRecord {
+	return typeof payload === "object" && payload !== null && !Array.isArray(payload);
+}
+
+function modelKey(ctx: ExtensionContext): string {
+	const model = ctx.model;
+	return model ? `${model.provider}/${model.id}` : "no-model";
+}
+
+function isFastEnabled(state: SessionState): boolean {
+	if (state.override === "on") return true;
+	if (state.override === "off") return false;
+	return state.config.enabled;
+}
+
+function describeMode(state: SessionState): string {
+	if (state.override === "on") return "on (session override)";
+	if (state.override === "off") return "off (session override)";
+	return state.config.enabled ? "on (config default)" : "off (config default)";
+}
+
+function getEligibility(ctx: ExtensionContext): Eligibility {
+	const model = ctx.model;
+	if (!model) {
+		return { eligible: false, modelKey: "no-model", reason: "no model is selected" };
+	}
+
+	const key = `${model.provider}/${model.id}`;
+	if (model.provider !== PROVIDER_ID) {
+		return {
+			eligible: false,
+			modelKey: key,
+			reason: `current provider is ${model.provider}, not ${PROVIDER_ID}`,
+		};
+	}
+
+	if (model.api !== API_ID) {
+		return {
+			eligible: false,
+			modelKey: key,
+			reason: `current API is ${model.api}, not ${API_ID}`,
+		};
+	}
+
+	if (!SUPPORTED_MODELS.has(model.id)) {
+		return {
+			eligible: false,
+			modelKey: key,
+			reason: "Fast mode is only enabled for gpt-5.4 and gpt-5.5",
+		};
+	}
+
+	if (!ctx.modelRegistry.isUsingOAuth(model)) {
+		return {
+			eligible: false,
+			modelKey: key,
+			reason: "ChatGPT OAuth auth is required; API-key auth is intentionally not used",
+		};
+	}
+
+	return { eligible: true, modelKey: key };
+}
+
+function updateStatus(ctx: ExtensionContext, state: SessionState): void {
+	if (!ctx.hasUI) return;
+	if (!state.config.showStatus) {
+		ctx.ui.setStatus(EXTENSION_ID, undefined);
+		return;
+	}
+
+	const eligibility = getEligibility(ctx);
+	ctx.ui.setStatus(
+		EXTENSION_ID,
+		isFastEnabled(state) && eligibility.eligible ? "fast" : undefined,
+	);
+}
+
+function getStatusMessage(ctx: ExtensionContext, state: SessionState): string {
+	const enabled = isFastEnabled(state);
+	const eligibility = getEligibility(ctx);
+	const active = enabled && eligibility.eligible;
+	const injected = state.lastInjectedAt
+		? ` Last injected for ${state.lastInjectedModel ?? "unknown model"} ${Math.max(0, Math.round((Date.now() - state.lastInjectedAt) / 1000))}s ago.`
+		: "";
+
+	if (active) {
+		return `OpenAI Fast mode is ${describeMode(state)} and active for ${eligibility.modelKey}; requests will use service_tier=${FAST_SERVICE_TIER}.${injected}`;
+	}
+
+	if (enabled) {
+		return `OpenAI Fast mode is ${describeMode(state)}, but inactive for ${eligibility.modelKey}: ${eligibility.reason}.${injected}`;
+	}
+
+	return `OpenAI Fast mode is ${describeMode(state)}. Current model: ${eligibility.modelKey}.${injected}`;
+}
+
+function injectFastServiceTier(
+	payload: unknown,
+	ctx: ExtensionContext,
+	state: SessionState,
+): PayloadRecord | undefined {
+	if (!isFastEnabled(state)) return undefined;
+	if (!getEligibility(ctx).eligible) return undefined;
+	if (!isPayloadRecord(payload)) return undefined;
+	if (payload.model !== ctx.model?.id) return undefined;
+	if ("service_tier" in payload) return undefined;
+
+	state.lastInjectedAt = Date.now();
+	state.lastInjectedModel = modelKey(ctx);
+	return {
+		...payload,
+		service_tier: FAST_SERVICE_TIER,
+	};
+}
+
+export default function openAIFastExtension(pi: ExtensionAPI) {
+	const states = new WeakMap<object, SessionState>();
+
+	function getState(ctx: ExtensionContext): SessionState {
+		let state = states.get(ctx.sessionManager);
+		if (!state) {
+			state = {
+				config: loadConfig(ctx.cwd),
+				override: "auto",
+			};
+			states.set(ctx.sessionManager, state);
+		}
+		return state;
+	}
+
+	pi.on("session_start", (_event, ctx) => {
+		const state: SessionState = {
+			config: loadConfig(ctx.cwd),
+			override: "auto",
+		};
+		states.set(ctx.sessionManager, state);
+		updateStatus(ctx, state);
+	});
+
+	pi.on("model_select", (_event, ctx) => {
+		updateStatus(ctx, getState(ctx));
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		const state = getState(ctx);
+		const nextPayload = injectFastServiceTier(event.payload, ctx, state);
+		updateStatus(ctx, state);
+		return nextPayload;
+	});
+
+	pi.registerCommand("fast", {
+		description: "Manage OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4/GPT-5.5",
+		getArgumentCompletions: (prefix) => {
+			const normalized = prefix.trim().toLowerCase();
+			const matches = COMMANDS.filter((command) => command.startsWith(normalized));
+			return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+		},
+		handler: async (args, ctx) => {
+			const state = getState(ctx);
+			const action = args.trim().toLowerCase() || "status";
+
+			if (action === "on" || action === "enable") {
+				state.override = "on";
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			if (action === "off" || action === "disable") {
+				state.override = "off";
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			if (action === "auto" || action === "default") {
+				state.override = "auto";
+				state.config = loadConfig(ctx.cwd);
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			if (action === "toggle") {
+				state.override = isFastEnabled(state) ? "off" : "on";
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			if (action === "status") {
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			ctx.ui.notify("Usage: /fast on | off | auto | toggle | status", "warning");
+		},
+	});
+}

package/extensions/openai-fast/openai-fast.example.json

@@ -0,0 +1,4 @@
+{
+  "enabled": false,
+  "showStatus": true
+}

package/extensions/openai-fast/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@diegopetrucci/pi-openai-fast",
+  "version": "0.1.0",
+  "description": "A pi extension that enables OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4 and GPT-5.5 by injecting the priority service tier.",
+  "keywords": ["pi-package", "pi", "openai", "codex", "fast"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegopetrucci/pi-extensions.git",
+    "directory": "extensions/openai-fast"
+  },
+  "files": [
+    "index.ts",
+    "openai-fast.example.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/extensions/quiet-tools/README.md

@@ -2,7 +2,7 @@
 
 A pi extension that makes collapsed built-in tool rows much quieter in the TUI.
 
-When enabled, collapsed tool output renders as one output line plus an inline hidden-line count and `Ctrl+O` expand hint. Expanding with `Ctrl+O` still shows pi's full rendered output.
+When enabled, each collapsed tool row renders as one invocation line plus a separate `(Ctrl+O to expand)` hint line. Tool output is hidden until expanded. Expanding with `Ctrl+O` still shows pi's full rendered output.
 
 `quiet-tools` only changes the visual renderer. It does not truncate, summarize, or rewrite the actual tool results sent to the model.
 
@@ -16,7 +16,7 @@ When enabled, collapsed tool output renders as one output line plus an inline hi
 - `edit`
 - `write`
 
-For `edit` and `write`, the collapsed call preview is also shortened so large diffs or file contents do not fill the TUI. Expanding restores pi's normal renderer.
+For every covered tool, the collapsed invocation is truncated to a single visual line so long paths, commands, diffs, or file contents do not fill the TUI. Expanding restores pi's normal renderer.
 
 ## Commands
 
@@ -61,3 +61,4 @@ Then reload pi:
 - It reuses pi's built-in implementations and preserves `shellPath`, `shellCommandPrefix`, and image autoresize settings when they are available from settings files.
 - If another extension also overrides built-in tool execution, pi's extension load order determines which override wins.
 - It affects assistant-invoked tool rows. User `!`/`!!` bash commands are rendered by a separate pi component and keep pi's default preview behavior.
+- Pi renders image attachments outside tool result renderers, so inline image display for image reads is still controlled by pi's image settings.

package/extensions/quiet-tools/index.ts

@@ -1,3 +1,5 @@
+import { homedir } from "node:os";
+
 import {
 	createBashToolDefinition,
 	createEditToolDefinition,
@@ -6,19 +8,15 @@ import {
 	createLsToolDefinition,
 	createReadToolDefinition,
 	createWriteToolDefinition,
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	formatSize,
 	keyHint,
 	SettingsManager,
 	type ExtensionAPI,
 	type ToolDefinition as PiToolDefinition,
 	type ToolsOptions,
 } from "@earendil-works/pi-coding-agent";
-import { Box, Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
 
-const COLLAPSED_PREVIEW_LINES = 1;
-const QUIET_CALL_TOOL_NAMES = new Set(["edit", "write"]);
+const QUIET_CALL_TOOL_NAMES = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
 
 type ToolDefinition = PiToolDefinition<any, any, any>;
 type ToolRenderCall = NonNullable<ToolDefinition["renderCall"]>;
@@ -34,208 +32,195 @@ type TimerRenderState = {
 	interval?: ReturnType<typeof setInterval>;
 };
 
-type TruncationLike = {
-	truncated?: boolean;
-	truncatedBy?: "lines" | "bytes";
-	firstLineExceedsLimit?: boolean;
-	outputLines?: number;
-	totalLines?: number;
-	maxBytes?: number;
-	maxLines?: number;
-};
+class QuietLinesRenderComponent extends Container {
+	private linesRenderer: ((width: number) => string[]) | undefined;
+
+	setLinesRenderer(linesRenderer: (width: number) => string[]): void {
+		this.linesRenderer = linesRenderer;
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		return this.linesRenderer?.(width).filter((line) => line) ?? [];
+	}
+}
 
-class QuietResultRenderComponent extends Container {}
+class QuietCallRenderComponent extends QuietLinesRenderComponent {}
+class QuietResultRenderComponent extends QuietLinesRenderComponent {}
 
-function sanitizePreviewText(text: string): string {
+function sanitizeInlineText(text: string): string {
 	return text
 		.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
 		.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+		.replace(/[\r\n\t]+/g, " ")
 		.replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "");
 }
 
-function getTextOutput(result: ToolRenderResultParams[0]): string {
-	return sanitizePreviewText(
-		result.content
-			.filter((content) => content.type === "text")
-			.map((content) => content.text ?? "")
-			.join("\n")
-			.trim(),
-	);
+function str(value: unknown): string | null {
+	if (typeof value === "string") return sanitizeInlineText(value);
+	if (value == null) return "";
+	return null;
 }
 
-function visibleLength(text: string): number {
-	return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").length;
+function asRecord(args: unknown): Record<string, unknown> | undefined {
+	return args && typeof args === "object" ? (args as Record<string, unknown>) : undefined;
 }
 
-function plural(count: number, singular: string): string {
-	return `${count} ${singular}${count === 1 ? "" : "s"}`;
+function firstStringArg(args: unknown, names: string[]): string | null {
+	const record = asRecord(args);
+	if (!record) return "";
+	for (const name of names) {
+		if (Object.prototype.hasOwnProperty.call(record, name)) {
+			return str(record[name]);
+		}
+	}
+	return "";
 }
 
-function formatDuration(ms: number): string {
-	return `${(ms / 1000).toFixed(1)}s`;
+function numberArg(args: unknown, name: string): number | undefined {
+	const value = asRecord(args)?.[name];
+	return typeof value === "number" ? value : undefined;
 }
 
-function renderCollapsedLine(line: string, hiddenLines: number, theme: RenderTheme, width: number): string {
-	if (width <= 0) return "";
-
-	const styledLine = theme.fg("toolOutput", line);
-	if (hiddenLines <= 0) {
-		return truncateToWidth(styledLine, width, "...");
-	}
+function invalidArgText(theme: RenderTheme): string {
+	return theme.fg("error", "[invalid arg]");
+}
 
-	const hint = theme.fg(
-		"muted",
-		`  ... ${plural(hiddenLines, "more line")} (${keyHint("app.tools.expand", "to expand")})`,
-	);
-	const hintWidth = visibleLength(hint);
-	if (hintWidth + 8 > width) {
-		return truncateToWidth(`${styledLine}${hint}`, width, "...");
-	}
+function shortenPath(path: string): string {
+	const home = homedir();
+	return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
 
-	return `${truncateToWidth(styledLine, width - hintWidth, "...")}${hint}`;
+function formatToolTitle(toolName: string, theme: RenderTheme): string {
+	return theme.fg("toolTitle", theme.bold(toolName));
 }
 
-function formatLimitWarning(label: string, count: unknown): string | undefined {
-	return typeof count === "number" ? `${count} ${label} limit` : undefined;
+function formatPathArg(args: unknown, theme: RenderTheme, placeholder = "..."): string {
+	const path = firstStringArg(args, ["file_path", "path"]);
+	if (path === null) return invalidArgText(theme);
+	return path ? theme.fg("accent", shortenPath(path)) : theme.fg("toolOutput", placeholder);
 }
 
-function getTruncationWarnings(result: ToolRenderResultParams[0]): string[] {
-	const details = result.details as
-		| {
-				truncation?: TruncationLike;
-				fullOutputPath?: string;
-				matchLimitReached?: number;
-				resultLimitReached?: number;
-				entryLimitReached?: number;
-				linesTruncated?: boolean;
-		  }
-		| undefined;
-	const truncation = details?.truncation;
-	const warnings: string[] = [];
-
-	if (details?.fullOutputPath) {
-		warnings.push(`Full output: ${details.fullOutputPath}`);
-	}
+function formatReadLineRange(args: unknown, theme: RenderTheme): string {
+	const offset = numberArg(args, "offset");
+	const limit = numberArg(args, "limit");
+	if (offset === undefined && limit === undefined) return "";
+	const startLine = offset ?? 1;
+	const endLine = limit !== undefined ? startLine + limit - 1 : "";
+	return theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+}
 
-	if (truncation?.truncated) {
-		if (truncation.firstLineExceedsLimit) {
-			warnings.push(`First line exceeds ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-		} else if (truncation.truncatedBy === "lines") {
-			warnings.push(
-				`Truncated: showing ${truncation.outputLines ?? "some"} of ${truncation.totalLines ?? "?"} lines (${truncation.maxLines ?? DEFAULT_MAX_LINES} line limit)`,
-			);
-		} else {
-			warnings.push(
-				`Truncated: ${truncation.outputLines ?? "some"} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
-			);
-		}
-	}
+function formatQuietReadCall(args: unknown, theme: RenderTheme): string {
+	return `${formatToolTitle("read", theme)} ${formatPathArg(args, theme)}${formatReadLineRange(args, theme)}`;
+}
 
-	const matchLimitWarning = formatLimitWarning("matches", details?.matchLimitReached);
-	if (matchLimitWarning) warnings.push(matchLimitWarning);
+function formatQuietBashCall(args: unknown, theme: RenderTheme): string {
+	const command = str(asRecord(args)?.command);
+	const timeout = numberArg(args, "timeout");
+	const commandDisplay = command === null
+		? invalidArgText(theme)
+		: command
+			? theme.fg("toolTitle", theme.bold(command))
+			: theme.fg("toolOutput", "...");
+	const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+	return `${theme.fg("toolTitle", theme.bold("$"))} ${commandDisplay}${timeoutSuffix}`;
+}
 
-	const resultLimitWarning = formatLimitWarning("results", details?.resultLimitReached);
-	if (resultLimitWarning) warnings.push(resultLimitWarning);
+function formatSearchPath(rawPath: string | null, theme: RenderTheme): string {
+	return rawPath === null ? invalidArgText(theme) : shortenPath(rawPath || ".");
+}
 
-	const entryLimitWarning = formatLimitWarning("entries", details?.entryLimitReached);
-	if (entryLimitWarning) warnings.push(entryLimitWarning);
+function formatQuietGrepCall(args: unknown, theme: RenderTheme): string {
+	const pattern = str(asRecord(args)?.pattern);
+	const rawPath = str(asRecord(args)?.path);
+	const glob = str(asRecord(args)?.glob);
+	const limit = numberArg(args, "limit");
+	let text = `${formatToolTitle("grep", theme)} ${
+		pattern === null ? invalidArgText(theme) : theme.fg("accent", `/${pattern || ""}/`)
+	}${theme.fg("toolOutput", ` in ${formatSearchPath(rawPath, theme)}`)}`;
+	if (glob) text += theme.fg("toolOutput", ` (${glob})`);
+	if (glob === null) text += ` ${invalidArgText(theme)}`;
+	if (limit !== undefined) text += theme.fg("toolOutput", ` limit ${limit}`);
+	return text;
+}
 
-	if (details?.linesTruncated) warnings.push("Some lines truncated");
+function formatQuietFindCall(args: unknown, theme: RenderTheme): string {
+	const pattern = str(asRecord(args)?.pattern);
+	const rawPath = str(asRecord(args)?.path);
+	const limit = numberArg(args, "limit");
+	let text = `${formatToolTitle("find", theme)} ${
+		pattern === null ? invalidArgText(theme) : theme.fg("accent", pattern || "")
+	}${theme.fg("toolOutput", ` in ${formatSearchPath(rawPath, theme)}`)}`;
+	if (limit !== undefined) text += theme.fg("toolOutput", ` (limit ${limit})`);
+	return text;
+}
 
-	return warnings;
+function formatQuietLsCall(args: unknown, theme: RenderTheme): string {
+	const rawPath = str(asRecord(args)?.path);
+	const limit = numberArg(args, "limit");
+	let text = `${formatToolTitle("ls", theme)} ${
+		rawPath === null ? invalidArgText(theme) : theme.fg("accent", shortenPath(rawPath || "."))
+	}`;
+	if (limit !== undefined) text += theme.fg("toolOutput", ` (limit ${limit})`);
+	return text;
 }
 
-function syncElapsedTimer(options: ToolRenderResultParams[1], context: ToolRenderContext): TimerRenderState {
-	const state = context.state as TimerRenderState;
+function formatQuietPathOnlyCall(toolName: "edit" | "write", args: unknown, theme: RenderTheme): string {
+	return `${formatToolTitle(toolName, theme)} ${formatPathArg(args, theme)}`;
+}
 
-	if (state.startedAt !== undefined && options.isPartial && !state.interval) {
-		state.interval = setInterval(() => context.invalidate(), 1000);
+function formatQuietCallLine(toolName: string, args: unknown, theme: RenderTheme): string {
+	switch (toolName) {
+		case "bash":
+			return formatQuietBashCall(args, theme);
+		case "edit":
+			return formatQuietPathOnlyCall("edit", args, theme);
+		case "find":
+			return formatQuietFindCall(args, theme);
+		case "grep":
+			return formatQuietGrepCall(args, theme);
+		case "ls":
+			return formatQuietLsCall(args, theme);
+		case "read":
+			return formatQuietReadCall(args, theme);
+		case "write":
+			return formatQuietPathOnlyCall("write", args, theme);
+		default:
+			return formatToolTitle(toolName, theme);
 	}
+}
+
+function formatExpandHint(theme: RenderTheme): string {
+	return `${theme.fg("muted", "(")}${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+}
 
-	if (!options.isPartial || context.isError) {
+function markToolTiming(options: ToolRenderResultParams[1], context: ToolRenderContext): void {
+	const state = context.state as TimerRenderState;
+
+	if ((!options.isPartial || context.isError) && state.startedAt !== undefined) {
 		state.endedAt ??= Date.now();
-		if (state.interval) {
-			clearInterval(state.interval);
-			state.interval = undefined;
-		}
 	}
 
-	return state;
+	if ((!options.isPartial || context.isError) && state.interval) {
+		clearInterval(state.interval);
+		state.interval = undefined;
+	}
 }
 
 function renderQuietCollapsedResult(
-	result: ToolRenderResultParams[0],
+	_result: ToolRenderResultParams[0],
 	options: ToolRenderResultParams[1],
-	theme: RenderTheme,
+	_theme: RenderTheme,
 	context: ToolRenderContext,
-): Container {
-	const state = syncElapsedTimer(options, context);
+): QuietResultRenderComponent {
+	markToolTiming(options, context);
 	const component = context.lastComponent instanceof QuietResultRenderComponent
 		? context.lastComponent
 		: new QuietResultRenderComponent();
-	component.clear();
-
-	const output = getTextOutput(result);
-	const outputLines = output ? output.split("\n") : [];
-
-	if (outputLines.length > 0) {
-		const firstLine = outputLines[0] ?? "";
-		const hiddenLines = Math.max(0, outputLines.length - COLLAPSED_PREVIEW_LINES);
-		component.addChild({
-			render: (width) => [renderCollapsedLine(firstLine, hiddenLines, theme, width)],
-			invalidate: () => undefined,
-		});
-	} else if (options.isPartial) {
-		component.addChild(new Text(theme.fg("muted", "Running..."), 0, 0));
-	}
-
-	const warnings = getTruncationWarnings(result);
-	if (warnings.length > 0) {
-		component.addChild(new Text(theme.fg("warning", `[${warnings.join(". ")}]`), 0, 0));
-	}
-
-	if (state.startedAt !== undefined && options.isPartial) {
-		component.addChild(new Text(theme.fg("muted", `Elapsed ${formatDuration(Date.now() - state.startedAt)}`), 0, 0));
-	}
-
-	component.invalidate();
+	component.setLinesRenderer(() => []);
 	return component;
 }
 
-function getPathArg(args: unknown): string | undefined {
-	if (!args || typeof args !== "object") return undefined;
-	const values = args as { path?: unknown; file_path?: unknown };
-	return typeof values.file_path === "string"
-		? values.file_path
-		: typeof values.path === "string"
-			? values.path
-			: undefined;
-}
-
-function formatQuietEditCall(args: unknown, theme: ToolRenderCallParams[1]): string {
-	const path = getPathArg(args);
-	const edits = args && typeof args === "object" && Array.isArray((args as { edits?: unknown }).edits)
-		? (args as { edits: unknown[] }).edits.length
-		: undefined;
-	const editSummary = typeof edits === "number" && edits > 0 ? `${plural(edits, "edit block")} hidden` : "preview hidden";
-	return `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", path ?? "...")}${theme.fg(
-		"muted",
-		`  ... ${editSummary} (${keyHint("app.tools.expand", "to expand")})`,
-	)}`;
-}
-
-function formatQuietWriteCall(args: unknown, theme: ToolRenderCallParams[1]): string {
-	const path = getPathArg(args);
-	const content = args && typeof args === "object" ? (args as { content?: unknown }).content : undefined;
-	const contentSummary = typeof content === "string"
-		? `${plural(content.split("\n").length, "line")}, ${formatSize(Buffer.byteLength(content, "utf8"))} hidden`
-		: "content hidden";
-	return `${theme.fg("toolTitle", theme.bold("write"))} ${theme.fg("accent", path ?? "...")}${theme.fg(
-		"muted",
-		`  ... ${contentSummary} (${keyHint("app.tools.expand", "to expand")})`,
-	)}`;
-}
-
 function renderQuietCall(
 	toolName: string,
 	base: ToolDefinition,
@@ -243,27 +228,29 @@ function renderQuietCall(
 	theme: ToolRenderCallParams[1],
 	context: ToolRenderCallParams[2],
 ) {
-	if (context.expanded || !QUIET_CALL_TOOL_NAMES.has(toolName)) {
-		return base.renderCall?.(args, theme, context) ?? new Text(theme.fg("toolTitle", theme.bold(toolName)), 0, 0);
+	const state = context.state as TimerRenderState;
+	if (context.executionStarted && state.startedAt === undefined) {
+		state.startedAt = Date.now();
+		state.endedAt = undefined;
 	}
 
-	if (toolName === "edit") {
-		const component = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1);
-		const bgColor = context.isError
-			? "toolErrorBg"
-			: context.executionStarted && !context.isPartial
-				? "toolSuccessBg"
-				: "toolPendingBg";
-		component.setBgFn((text) => theme.bg(bgColor, text));
-		component.clear();
-		component.addChild(new Text(formatQuietEditCall(args, theme), 0, 0));
-		component.invalidate();
-		return component;
+	if (context.expanded || !QUIET_CALL_TOOL_NAMES.has(toolName)) {
+		const delegateContext = context.lastComponent instanceof QuietCallRenderComponent
+			? { ...context, lastComponent: undefined }
+			: context;
+		return base.renderCall?.(args, theme, delegateContext) ?? new Text(theme.fg("toolTitle", theme.bold(toolName)), 0, 0);
 	}
 
-	const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-	text.setText(formatQuietWriteCall(args, theme));
-	return text;
+	const component = context.lastComponent instanceof QuietCallRenderComponent
+		? context.lastComponent
+		: new QuietCallRenderComponent();
+	const line = formatQuietCallLine(toolName, args, theme);
+	const hint = formatExpandHint(theme);
+	component.setLinesRenderer((width) => [
+		truncateToWidth(line, width, "..."),
+		truncateToWidth(hint, width, "..."),
+	]);
+	return component;
 }
 
 function createQuietToolDefinition(base: ToolDefinition): ToolDefinition {
@@ -334,7 +321,7 @@ export default function quietToolsExtension(pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("quiet-tools", {
-		description: "Toggle compact collapsed previews for built-in tool rows",
+		description: "Toggle one-line collapsed invocations for built-in tool rows",
 		getArgumentCompletions: (prefix) => {
 			const commands = ["on", "off", "toggle", "status"];
 			const query = prefix.trim().toLowerCase();
@@ -347,7 +334,7 @@ export default function quietToolsExtension(pi: ExtensionAPI) {
 			if (action === "on" || action === "enable") {
 				enabled = true;
 				registerTools(ctx.cwd);
-				ctx.ui.notify("Quiet tool previews enabled: collapsed built-in tool rows show one-line output.", "info");
+				ctx.ui.notify("Quiet tool previews enabled: collapsed built-in tool rows show a one-line invocation plus an expand hint.", "info");
 				return;
 			}
 
@@ -363,7 +350,7 @@ export default function quietToolsExtension(pi: ExtensionAPI) {
 				registerTools(ctx.cwd);
 				ctx.ui.notify(
 					enabled
-						? "Quiet tool previews enabled: collapsed built-in tool rows show one-line output."
+						? "Quiet tool previews enabled: collapsed built-in tool rows show a one-line invocation plus an expand hint."
 						: "Quiet tool previews disabled: restored pi's standard built-in tool renderers.",
 					"info",
 				);
@@ -372,7 +359,7 @@ export default function quietToolsExtension(pi: ExtensionAPI) {
 
 			if (action === "status") {
 				ctx.ui.notify(
-					`Quiet tool previews are ${enabled ? "enabled" : "disabled"}. Collapsed preview lines: ${enabled ? COLLAPSED_PREVIEW_LINES : "pi default"}. Model-visible tool results are unchanged.`,
+					`Quiet tool previews are ${enabled ? "enabled" : "disabled"}. Collapsed tool rows ${enabled ? "show a one-line invocation and hide output until expanded" : "use pi's default rendering"}. Model-visible tool results are unchanged.`,
 					"info",
 				);
 				return;

package/extensions/quiet-tools/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-quiet-tools",
-  "version": "0.1.0",
-  "description": "A pi extension that visually compacts collapsed built-in tool output in the TUI without changing tool results sent to the model.",
+  "version": "0.1.1",
+  "description": "A pi extension that visually compacts collapsed built-in tool rows in the TUI without changing tool results sent to the model.",
   "keywords": ["pi-package", "pi", "tools", "terminal", "tui"],
   "license": "MIT",
   "repository": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.19",
-  "description": "A collection of pi extensions, including a GitHub librarian with opt-in local repo checkout caching, a minimal custom footer, an Amp-style oracle, a 200k context cap for auto-compaction, a local HTML context inspector, quiet one-line collapsed tool previews, a permission gate for dangerous bash commands, confirm-before-destructive session actions, and terminal notifications when pi is ready for input.",
+  "version": "0.1.21",
+  "description": "A collection of pi extensions, including a GitHub librarian with opt-in local repo checkout caching, a minimal custom footer, an Amp-style oracle, a 200k context cap for auto-compaction, a local HTML context inspector, OpenAI Codex Fast mode controls, quiet one-line collapsed invocation previews, a permission gate for dangerous bash commands, confirm-before-destructive session actions, and terminal notifications when pi is ready for input.",
   "keywords": ["pi-package", "pi", "terminal", "agent"],
   "license": "MIT",
   "repository": {
@@ -36,7 +36,8 @@
       "./extensions/quiet-tools/index.ts",
       "./extensions/permission-gate/index.ts",
       "./extensions/confirm-destructive/index.ts",
-      "./extensions/notify/index.ts"
+      "./extensions/notify/index.ts",
+      "./extensions/openai-fast/index.ts"
     ],
     "image": "https://raw.githubusercontent.com/diegopetrucci/pi-extensions/main/assets/oracle-preview.svg"
   }