@diegopetrucci/pi-extensions 0.1.20 → 0.1.22

package/README.md

@@ -5,9 +5,10 @@ A collection of [pi](https://github.com/earendil-works/pi-mono) agent extensions
 - [`confirm-destructive`](./extensions/confirm-destructive): Confirms before destructive session actions like clear, switch, and fork.
 - [`context-cap`](./extensions/context-cap): Caps effective model context windows at 200k tokens by default so pi avoids the `dumb zone`; toggle temporarily with `/context-cap`.
 - [`context-inspector`](./extensions/context-inspector): Adds `/context`, a local self-contained HTML dashboard that breaks down where the current session context is going, with category overview, top offenders, and drilldown search.
-- [`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.
+- [`librarian`](./extensions/librarian): Adds a GitHub research scout with a local repo checkout cache enabled by default under the OS user cache directory, toggleable with `/librarian-cache`, 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 a one-line invocation plus an expand hint without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
@@ -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.20
+pi install git:github.com/diegopetrucci/pi-extensions@v0.1.22
 ```
 
 Or a specific extension:

package/extensions/librarian/README.md

@@ -1,8 +1,8 @@
 # librarian
 
-A pi GitHub research scout inspired by `pi-librarian`, with an opt-in local checkout cache.
+A pi GitHub research scout inspired by `pi-librarian`, with a local checkout cache enabled by default.
 
-When the `librarian` tool runs, it asks whether to cache/reuse repository checkouts locally. If you say no, cancel, time out, or run without UI, it uses GitHub API/search and temporary fetched files only.
+When the `librarian` tool runs, it can cache/reuse repository checkouts locally. Use `/librarian-cache off` to force GitHub API/search and temporary fetched files only, or `/librarian-cache on` to re-enable cached local checkouts.
 
 ## Install
 
@@ -35,10 +35,21 @@ Then reload pi:
 - Tool name: `librarian`
 - Uses a restricted subagent with `bash` and `read`
 - Uses `gh` for GitHub search/API access
-- Asks on each call whether to use cached local checkouts
-- Defaults to no checkout/cache
+- Uses cached local checkouts by default
+- Toggle cache behavior for future calls with `/librarian-cache on | off | toggle | status`
 - Cached repos are removed lazily after 30 days without use
 
+## Commands
+
+```text
+/librarian-cache status
+/librarian-cache off
+/librarian-cache on
+/librarian-cache toggle
+```
+
+The command works in interactive mode, RPC mode, and print/JSON mode. It writes a global preference to `~/.pi/agent/extensions/librarian.json`, so separate non-UI invocations use the same setting. In non-UI modes, command feedback is written to stderr so stdout remains usable for normal output or JSON events.
+
 ## Cache location
 
 macOS:

package/extensions/librarian/index.ts

@@ -25,11 +25,14 @@ const CACHE_TTL_DAYS = 30;
 const CACHE_TTL_MS = CACHE_TTL_DAYS * 24 * 60 * 60 * 1000;
 const CACHE_METADATA_FILE = ".pi-librarian-cache.json";
 const CACHE_MARKER_FILE = ".pi-librarian-cache-used";
+const CACHE_CONFIG_FILE = "librarian.json";
 
 type LibrarianStatus = "running" | "done" | "error" | "aborted";
 
 type CacheMode = "disabled" | "enabled";
 
+const DEFAULT_CACHE_MODE: CacheMode = "enabled";
+
 type ToolCall = {
 	id: string;
 	name: string;
@@ -252,30 +255,67 @@ async function cleanupExpiredCache(cacheRoot: string): Promise<{ deleted: number
 	}
 }
 
-async function askForCache(ctx: ExtensionContext, cacheRoot: string): Promise<{ enabled: boolean; reason: string }> {
-	if (!ctx.hasUI) return { enabled: false, reason: "no UI available; using GitHub API/temp files only" };
+function getCacheConfigPath(): string {
+	return path.join(getAgentDir(), "extensions", CACHE_CONFIG_FILE);
+}
+
+function parseCacheMode(value: unknown): CacheMode | undefined {
+	if (value === "enabled" || value === "on" || value === true) return "enabled";
+	if (value === "disabled" || value === "off" || value === false) return "disabled";
+	return undefined;
+}
 
+async function readCachePreference(): Promise<CacheMode> {
 	try {
-		const enabled = await ctx.ui.confirm(
-			"Librarian repo cache",
-			[
-				"Cache/reuse local GitHub repo checkouts for this Librarian call?",
-				"",
-				`Cache directory: ${cacheRoot}`,
-				`Repos unused for ${CACHE_TTL_DAYS} days are removed lazily on future Librarian calls.`,
-				"",
-				"Choose No to use GitHub API and temporary fetched files only.",
-			].join("\n"),
-			{ timeout: 30_000 },
+		const raw = await fs.readFile(getCacheConfigPath(), "utf8");
+		const parsed = JSON.parse(raw) as {
+			cacheMode?: unknown;
+			cacheEnabled?: unknown;
+			cache?: { mode?: unknown; enabled?: unknown };
+		};
+		return (
+			parseCacheMode(parsed.cacheMode) ??
+			parseCacheMode(parsed.cache?.mode) ??
+			parseCacheMode(parsed.cacheEnabled) ??
+			parseCacheMode(parsed.cache?.enabled) ??
+			DEFAULT_CACHE_MODE
 		);
+	} catch {
+		return DEFAULT_CACHE_MODE;
+	}
+}
 
-		return enabled
-			? { enabled: true, reason: "user opted into cached local checkouts" }
-			: { enabled: false, reason: "user declined or prompt timed out" };
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return { enabled: false, reason: `cache prompt failed (${message}); using GitHub API/temp files only` };
+async function writeCachePreference(preference: CacheMode): Promise<void> {
+	const configPath = getCacheConfigPath();
+	const config = {
+		cacheMode: preference,
+		cacheEnabled: preference === "enabled",
+		updatedAt: new Date().toISOString(),
+	};
+
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+function resolveCacheDecision(preference: CacheMode): { enabled: boolean; reason: string } {
+	if (preference === "enabled") {
+		return { enabled: true, reason: "cache preference enabled; using cached local checkouts" };
+	}
+
+	return { enabled: false, reason: "cache preference disabled; using GitHub API/temp files only" };
+}
+
+function formatCachePreference(preference: CacheMode): string {
+	return preference === "enabled" ? "on" : "off";
+}
+
+function notifyCommand(ctx: ExtensionContext, message: string, type: "info" | "warning" | "error" = "info"): void {
+	if (ctx.hasUI) {
+		ctx.ui.notify(message, type);
+		return;
 	}
+
+	console.error(message);
 }
 
 function resolveToolPath(cwd: string, rawPath: string): string {
@@ -438,13 +478,81 @@ function isAbortLikeError(error: unknown): boolean {
 }
 
 export default function librarianExtension(pi: ExtensionAPI) {
+	let cachePreference: CacheMode = DEFAULT_CACHE_MODE;
+
+	pi.on("session_start", async () => {
+		cachePreference = await readCachePreference();
+	});
+
+	pi.registerCommand("librarian-cache", {
+		description: "Toggle Librarian local checkout cache for future librarian calls",
+		getArgumentCompletions: (prefix) => {
+			const commands = ["on", "off", "toggle", "status"];
+			const query = prefix.trim().toLowerCase();
+			const matches = commands.filter((command) => command.startsWith(query));
+			return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+		},
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase() || "status";
+			const cacheRoot = getUserCacheReposRoot();
+			const configPath = getCacheConfigPath();
+
+			const setPreference = async (mode: CacheMode): Promise<string | undefined> => {
+				cachePreference = mode;
+				try {
+					await writeCachePreference(mode);
+					return undefined;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return `Preference changed for this process, but could not save ${configPath}: ${message}`;
+				}
+			};
+
+			const formatSetMessage = (mode: CacheMode, warning?: string): string => {
+				const main = mode === "enabled"
+					? `Librarian cache enabled. Future librarian calls will reuse local checkouts under ${cacheRoot}.`
+					: "Librarian cache disabled. Future librarian calls will use GitHub API/search and temporary fetched files only.";
+				return warning ? `${main} ${warning}` : main;
+			};
+
+			if (action === "on" || action === "enable") {
+				const warning = await setPreference("enabled");
+				notifyCommand(ctx, formatSetMessage("enabled", warning), warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "off" || action === "disable") {
+				const warning = await setPreference("disabled");
+				notifyCommand(ctx, formatSetMessage("disabled", warning), warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "toggle") {
+				const next = cachePreference === "enabled" ? "disabled" : "enabled";
+				const warning = await setPreference(next);
+				notifyCommand(ctx, formatSetMessage(next, warning), warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "status") {
+				notifyCommand(
+					ctx,
+					`Librarian cache is ${formatCachePreference(cachePreference)}. Cache directory: ${cacheRoot}. Config: ${configPath}. Repos unused for ${CACHE_TTL_DAYS} days are removed lazily.`,
+				);
+				return;
+			}
+
+			notifyCommand(ctx, "Usage: /librarian-cache on | off | toggle | status", "warning");
+		},
+	});
+
 	pi.registerTool({
 		name: "librarian",
 		label: "Librarian",
 		description:
-			"GitHub research scout for coding and personal-assistant tasks. Use when the answer likely lives in GitHub repos, exact repo/path locations are unknown, or you'd otherwise do exploratory gh search/tree probes plus local rg/read inspection. Librarian asks whether to use an optional 30-day local checkout cache, otherwise it behaves like API-only pi-librarian.",
+			"GitHub research scout for coding and personal-assistant tasks. Use when the answer likely lives in GitHub repos, exact repo/path locations are unknown, or you'd otherwise do exploratory gh search/tree probes plus local rg/read inspection. Librarian uses an optional 30-day local checkout cache by default; toggle it with /librarian-cache.",
 		promptSnippet:
-			"Research GitHub repositories with evidence-first path and line citations; optionally ask the user to cache local repo checkouts.",
+			"Research GitHub repositories with evidence-first path and line citations; local checkout cache is enabled by default and user-toggleable with /librarian-cache.",
 		promptGuidelines: [
 			"Use librarian when the answer likely requires exploratory GitHub repository search or line-cited evidence from external repos.",
 			"Do not use librarian for files already present in the current workspace unless the user asks for external GitHub research.",
@@ -472,7 +580,7 @@ export default function librarianExtension(pi: ExtensionAPI) {
 			await fs.mkdir(path.join(workspace, "repos"), { recursive: true });
 
 			const cacheRoot = getUserCacheReposRoot();
-			const cacheDecision = await askForCache(ctx, cacheRoot);
+			const cacheDecision = resolveCacheDecision(cachePreference);
 			if (cacheDecision.enabled) await fs.mkdir(cacheRoot, { recursive: true });
 			const cleanup = cacheDecision.enabled ? await cleanupExpiredCache(cacheRoot) : { deleted: 0, errors: [] };
 

package/extensions/librarian/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-librarian",
   "version": "0.1.0",
-  "description": "A pi GitHub research scout that can optionally cache local repo checkouts under the user's OS cache directory.",
+  "description": "A pi GitHub research scout with a toggleable local repo checkout cache under the user's OS cache directory.",
   "keywords": ["pi-package", "pi", "github", "research", "subagent", "cache"],
   "license": "MIT",
   "repository": {

package/extensions/openai-fast/README.md

@@ -0,0 +1,96 @@
+# 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
+/fast status
+/fast on
+/fast off
+/fast auto
+/fast toggle
+```
+
+Run `/fast` without arguments to pick an action from a menu. `/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,302 @@
+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);
+			let action = args.trim().toLowerCase();
+
+			if (!action) {
+				if (!ctx.hasUI) {
+					action = "status";
+				} else {
+					const selection = await ctx.ui.select("OpenAI Fast mode", COMMANDS);
+					if (!selection) return;
+					action = selection;
+				}
+			}
+
+			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.1",
+  "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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.20",
-  "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 invocation 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.22",
+  "description": "A collection of pi extensions, including a GitHub librarian with toggleable 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"
   }