@diegopetrucci/pi-extensions 0.1.62 → 0.1.63

package/README.md

@@ -13,8 +13,9 @@ A collection of [pi](https://pi.dev) agent extensions I made. (btw, [I am also b
 
 ### Providers
 
-- [`claude-fast`](./extensions/claude-fast): Adds `/claude-fast` to enable Anthropic Claude Fast mode for supported Claude Opus models by injecting `speed: "fast"`.
-- [`openai-fast`](./extensions/openai-fast): Adds `/fast` to enable OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4, GPT-5.5, and GPT-5.6 Codex variants by injecting the priority service tier.
+- [`claude-fast`](./extensions/claude-fast): Standalone-only provider-specific alternative that adds `/claude-fast` for supported Anthropic Claude Opus models.
+- [`fast`](./extensions/fast): Adds one `/fast` toggle that enables the provider-specific Fast mode for the currently selected supported OpenAI Codex or Anthropic Claude model.
+- [`openai-fast`](./extensions/openai-fast): Standalone-only provider-specific alternative that adds `/fast` for ChatGPT-auth GPT-5.4, GPT-5.5, and GPT-5.6 Codex variants.
 
 ### UI
 

package/extensions/claude-fast/README.md

@@ -2,6 +2,8 @@
 
 A pi extension that enables Anthropic Claude Fast mode for supported Claude Opus models.
 
+This package is standalone-only and is not auto-loaded by the `@diegopetrucci/pi-extensions` collection package. The collection uses the unified [`fast`](../fast) extension instead.
+
 When active, the extension injects this into eligible Anthropic request payloads:
 
 ```json

package/extensions/claude-fast/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-claude-fast",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "A pi extension that enables Anthropic Claude Fast mode for supported Claude Opus models by injecting speed=fast.",
   "keywords": [
     "pi-package",

package/extensions/dynamic-context-pruning/README.md

@@ -230,19 +230,32 @@ never required to exist. Full shape, with defaults:
 
 Notes:
 
-- `thresholds.minCharsSaved` is reserved for a future minimum-size filter and
-  is **not** currently enforced by the pipeline; the net-benefit gate's
-  break-even math is what actually decides whether a prune applies.
+- `thresholds.minCharsSaved` is a minimum-size floor enforced against fresh
+  **automatic** strategy proposals only, before the net-benefit gate runs: a
+  text-only candidate whose raw character savings (original text chars minus
+  placeholder chars) fall below this value is dropped up front and never
+  reaches gate or batch consideration. A tool-result candidate containing one
+  or more image blocks bypasses this raw-text floor (images do not receive
+  synthetic character counts) and is evaluated by the existing token-based
+  net-benefit gate. Manual prunes (`/prune`) and already-persisted/replayed
+  decisions always bypass this floor, same as the gate. Set to `0` to disable
+  filtering entirely. This is independent of the net-benefit gate's
+  break-even math (`gate.*`), which is a separate, later check on whatever
+  survives this floor.
 - `gate.breakEvenThresholdByState` lets `idle` vs `mid_loop` agent states use
   different thresholds; both default to `gate.breakEvenThreshold`. Real
-  mid-loop/idle detection isn't wired through yet, so this always evaluates as
-  `idle` in v1 — the field exists so the seam is ready once that lands. The
-  representative-corpus benchmark (see [Roadmap](#roadmap)) shows `mid_loop`
-  candidates carry ~all realized net benefit and `idle` candidates carry ~none
-  at r=0.1, which argues for a stricter `idle` default — but since every live
-  evaluation runs as `idle` today, defaulting it stricter would silently
-  disable most automatic pruning. Both states are intentionally kept at
-  parity until real agent-state detection lands; that's a follow-up ticket.
+  mid-loop/idle detection is wired through the `context` event handler
+  (pe-zy4s): the state is classified straight from the message payload —
+  `idle` if the most recent relevant message is a user message (this is the
+  first LLM call of the turn), `mid_loop` if it's an assistant message or a
+  tool result (the agent is iterating mid-turn). The representative-corpus
+  benchmark (see [Roadmap](#roadmap)) was re-derived against this same
+  runtime-observable definition and found the state-split REVERSED from an
+  earlier turn-end-based analysis: at r=0.1, `idle` candidates now carry
+  essentially all the realized net benefit and `mid_loop` candidates carry
+  essentially none. Since `idle` is not the worthless state under this
+  definition, both states are kept at parity (`22`/`22`) rather than forcing
+  a stricter default in either direction.
 - `gate.breakEvenThreshold`'s default of `22` is calibrated from the
   representative-corpus benchmark at `cachedPriceRatio` r=0.1 (aggressive
   prompt caching, the common case) — see [Roadmap](#roadmap) for the full
@@ -296,8 +309,46 @@ Options:
 - `--ratio R`: cached-price ratio(s) to model; repeatable and/or
   comma-separated (e.g. `--ratio 0.1,0.2`). Default: `0.1`.
 - `--json`: emit a full machine-readable JSON dump instead of aligned text.
+- `--simulate-compression`: additionally SIMULATE v2-style range compression
+  (docs/v2-design.md §1/§4 go/no-go evidence) alongside — never mixed into —
+  the deterministic results. See below.
+- `--sim-summary-fraction F`: summary size as a fraction of range tokens;
+  repeatable/comma-separated (e.g. `--sim-summary-fraction 0.1,0.15,0.3`).
+  Default: `0.15`.
+- `--sim-summary-min-tokens N`: floor on summary tokens regardless of
+  fraction. Default: `200`.
+- `--sim-summarizer-cost-mult M`: relative per-token price of the summarizer
+  call vs. the main model. Default: `1.0` (same per-token price; a
+  deliberate simplification that ignores summarizer latency/availability).
+- `--sim-min-range-tokens N`: minimum contiguous range size to be
+  considered. Default: `2000`.
 - `--help`: print usage.
 
+### Compression-simulation mode (`--simulate-compression`)
+
+This is a v2 go/no-go evidence generator that does **not** require building
+v2: it identifies plausible v2-style `compress` (range mode) opportunities —
+contiguous spans of complete, non-recent, non-protected messages, never
+splitting a toolCall/toolResult pair — during the same replay pass, and
+models the outcome:
+
+```text
+summaryTokens      = max(fraction * rangeTokens, summaryMinTokens)
+oneTimeCost        = cacheBustPenalty(earliest range position)
+                       + summarizerCostMult * (rangeTokens + summaryTokens)
+recurringSaving     = r * (rangeTokens - summaryTokens)
+realizedNetBenefit  = actualRemainingCalls * recurringSaving - oneTimeCost
+```
+
+Each distinct range is recorded once, at the earliest call boundary where it
+first exists and meets `--sim-min-range-tokens`; ranges never overlap. The
+same auto-expanding break-even threshold sweep as the deterministic
+strategies runs against this separate SIMULATED population, reported
+side-by-side with (but never combined with) the deterministic results — the
+two populations are computed **independently**; a simulated range may fully
+contain deterministic candidates, and no overlap/interaction between the two
+is modeled or netted out.
+
 With no positional paths, it defaults to every `*.jsonl` file found
 recursively under `~/.pi/agent/sessions`.
 
@@ -387,6 +438,22 @@ realized benefit across the whole 1,390-session corpus is only ~20.6k
 token-units — economically marginal, on the order of pennies. Savings only
 become material at weaker caching, r>=0.25.
 
+**pe-zy4s update (2026-07-08): this idle/mid_loop split used a turn-END
+definition** ("idle" = this call IS the turn's final assistant message, only
+knowable in hindsight via replay) **that was never runtime-observable.** Once
+real runtime agent-state detection landed (turn-START definition: "idle" =
+this is the FIRST LLM call of a turn; see the config-notes bullet above), the
+benchmark's candidate labeling was aligned to that same definition and
+re-derived on the representative corpus (460 gate-eligible candidates on the
+current `~/.the-last-harness/agent/sessions` corpus). The split **reverses**:
+at r=0.1, `idle` (T=22, ~20.6k realized net benefit) now carries essentially
+all the value, and `mid_loop` (T=1, ~0 realized net benefit) carries
+essentially none. Per the decision rule (stricter idle default only if idle
+is shown ~worthless), this evidence does **not** support a stricter idle
+default — parity (`22`/`22`) is kept. The table above is retained as the
+historical turn-END-definition record; it no longer reflects how the runtime
+classifies agent state.
+
 **This reframes, rather than weakens, the case for v2.** Small deterministic
 removals (dedupe/error-purge/superseded-file-ops) structurally cannot beat
 the cache-bust penalty at r=0.1 — there just isn't enough single-message

package/extensions/dynamic-context-pruning/index.ts

@@ -165,10 +165,16 @@ export interface PruneProtections {
 
 export interface PruneThresholds {
 	/**
-	 * Minimum characters a prune must remove to be worth persisting. Reserved
-	 * for a future minimum-size filter; NOT used by the net-benefit gate
-	 * (see `PruneGateConfig`/`gate`), which uses break-even token math instead.
-	 * Not enforced by this pipeline yet.
+	 * Minimum raw text characters a fresh AUTOMATIC prune proposal must remove
+	 * (original text chars minus placeholder chars) to be considered at all
+	 * (pe-qdzb). Enforced by `runDynamicContextPruningPipeline` BEFORE the
+	 * net-benefit gate (see `PruneGateConfig`/`gate`, which uses break-even token
+	 * math and is a separate, later check): text-only candidates below this floor
+	 * are dropped up front and never reach gate/batch consideration. Image-bearing
+	 * tool-result candidates bypass this raw-text floor (images receive no
+	 * synthetic character count) and proceed to the token-based gate. Manual
+	 * prunes and already-persisted/replayed decisions always bypass this floor,
+	 * same as the gate. A value of 0 disables the floor (no filtering).
 	 */
 	minCharsSaved: number;
 }
@@ -194,19 +200,42 @@ export type GateMode = "on" | "off" | "always-apply";
  * making tool calls) vs idle (waiting on the user). Both states default to
  * the same threshold today.
  *
- * pe-c5n9 evidence update: the representative-corpus benchmark shows
- * mid_loop candidates carry ~all realized net benefit while idle candidates
- * carry ~none (literally 0 at r=0.1). That would argue for a stricter idle
- * default. However, the only live runtime caller (the `context` event
- * handler below) does not yet perform real mid-loop/idle detection — it
- * always passes agentState:"idle". Defaulting idle to a much stricter
- * threshold today would therefore silently disable most automatic pruning
- * for everyone (100% of live evaluations run as "idle"), which is a far
- * bigger behavior change than a threshold recalibration. So the per-state
- * split is intentionally left at parity for now; a follow-up ticket should
- * wire real agent-state detection through `ctx` and then apply the
- * idle-vs-mid_loop split (idle stricter, mid_loop at DEFAULT_BREAK_EVEN_THRESHOLD)
- * once mid_loop is actually reachable.
+ * pe-c5n9 evidence (turn-END definition, since superseded -- see below):
+ * the representative-corpus benchmark showed mid_loop candidates carrying
+ * ~all realized net benefit while idle candidates carried ~none. That would
+ * have argued for a stricter idle default. However, the only live runtime
+ * caller (the `context` event handler below) did not yet perform real
+ * mid-loop/idle detection at the time, so no default change was made.
+ *
+ * pe-zy4s update (2026-07-08): real runtime mid_loop/idle detection is now
+ * wired through the `context` event handler (`classifyAgentStateFromMessages`),
+ * using a turn-START definition (idle = this is the first LLM call of a turn;
+ * mid_loop = the agent already made a call or received a tool result this
+ * turn) -- see that function's doc comment for the exact runtime-observable
+ * semantics. The benchmark's candidate labeling was aligned to this SAME
+ * definition (retiring the old turn-END definition above, which was never
+ * runtime-observable), and the state-split was re-derived on the
+ * representative corpus (~/.the-last-harness/agent/sessions, 460 candidates)
+ * under it.
+ *
+ * The result REVERSES the earlier (turn-END) finding: at r=0.1 the
+ * turn-START "idle" population (calls made at the start of a turn) carries
+ * essentially ALL the realized net benefit (idle-optimal T=22, total realized
+ * net benefit ~20,594 token-units), while "mid_loop" carries essentially NONE
+ * (mid_loop-optimal T=1, total realized net benefit ~0.0 -- i.e. no mid_loop
+ * candidate is ever worth accepting at r=0.1 under this definition). This is
+ * the OPPOSITE of what the pe-c5n9 evidence (measured under the old,
+ * non-runtime-observable turn-END definition) suggested.
+ *
+ * Per the pe-zy4s decision rule (stricter idle default only if idle itself is
+ * shown to be ~worthless): idle is NOT worthless here -- it is the ONLY state
+ * carrying value at r=0.1 -- so no state-conditioned strictness is justified
+ * in either direction. The per-state split is therefore kept at PARITY
+ * (`breakEvenThresholdByState: { idle: DEFAULT_BREAK_EVEN_THRESHOLD, mid_loop:
+ * DEFAULT_BREAK_EVEN_THRESHOLD }`), both config-overridable. A future ticket
+ * could consider a stricter mid_loop default given this evidence, but that is
+ * a new, unreviewed direction outside this ticket's authorized decision rule
+ * and is left for a follow-up.
  */
 export type AgentState = "idle" | "mid_loop";
 
@@ -397,6 +426,41 @@ export function estimateTokensForContent(content: string | (MinimalTextContent |
 
 export type TokenEstimator = (text: string) => number;
 
+/**
+ * Classify the agent's current state from the message payload alone (pe-zy4s):
+ * this is the runtime-observable definition used both by the live `context`
+ * event handler and (via re-export) by the offline benchmark, so the two can
+ * never drift apart.
+ *
+ * Walk backwards from the end of `messages`, skipping any message that is
+ * neither `user`, `assistant`, nor `toolResult` (e.g. system-role bookkeeping
+ * entries). The first such message found determines the state:
+ *  - `user` (a plain user turn message) => "idle": this call is the FIRST LLM
+ *    call of a turn, i.e. the decision is being made from a turn-start state.
+ *  - `assistant` or `toolResult` (mid-chain) => "mid_loop": the agent is
+ *    iterating (already made at least one call this turn, or is reacting to a
+ *    tool result).
+ *  - No such message found (empty history, or system-only) => "idle" (safe
+ *    default: nothing suggests an in-progress loop).
+ *
+ * The benchmark (scripts/benchmark.mjs) reclassifies its candidate labels to
+ * this SAME definition (pe-zy4s), reusing this function directly, so the
+ * defaults below rest on evidence measured with the exact definition the
+ * runtime observes. (An earlier turn-end-based benchmark definition -- "idle"
+ * meant "this IS the turn's last assistant message", only knowable in
+ * hindsight -- has been retired: the runtime cannot know in advance whether a
+ * call is a turn's last one, so that definition was never runtime-observable.)
+ */
+export function classifyAgentStateFromMessages(messages: MinimalMessage[]): AgentState {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const role = messages[i].role;
+		if (role === "user") return "idle";
+		if (role === "assistant" || role === "toolResult") return "mid_loop";
+		// Any other role (e.g. "system") is skipped: keep walking further back.
+	}
+	return "idle";
+}
+
 /** Resolve which break-even threshold applies for a given agent state (pe-s2ho state-conditioning hook). */
 export function resolveBreakEvenThreshold(gateConfig: PruneGateConfig, agentState: AgentState): number {
 	const override = gateConfig.breakEvenThresholdByState[agentState];
@@ -892,6 +956,20 @@ function contentTextLength(content: (MinimalTextContent | MinimalImageContent)[]
 	return content.reduce((sum, block) => (block.type === "text" ? sum + block.text.length : sum), 0);
 }
 
+/** Return true when a decision targets a tool result containing one or more images. */
+function isImageBearingToolResultTarget(
+	messages: MinimalMessage[],
+	decision: PruneDecisionRecord,
+	pairIndex?: Map<string, ToolCallPairIndices>,
+): boolean {
+	if (decision.kind !== "tool_result_content" || decision.correlation.type !== "toolCallId") return false;
+	const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
+	if (pair.resultIndex === undefined) return false;
+	const target = messages[pair.resultIndex];
+	if (target?.role !== "toolResult") return false;
+	return (target as MinimalToolResultMessage).content.some((block) => block.type === "image");
+}
+
 export interface ApplyResult {
 	applied: boolean;
 	charsRemoved: number;
@@ -1050,6 +1128,55 @@ export function estimateDecisionSavings(
 	return undefined;
 }
 
+/**
+ * Estimate the character savings of a single decision (pe-qdzb), i.e. the
+ * same before/after delta basis as `estimateDecisionSavings` but measured in
+ * raw characters rather than estimated tokens. Used by the pipeline to
+ * enforce `thresholds.minCharsSaved` against fresh automatic proposals
+ * *before* they reach the net-benefit gate. Returns undefined under the same
+ * conditions as `estimateDecisionSavings` (target absent / would not apply).
+ * Mirrors `estimateDecisionSavings`'s `Math.max(0, ...)` clamp, so a
+ * decision whose placeholder text would be LONGER than the original content
+ * (negative savings) is reported as 0 chars saved, not a negative number.
+ */
+export function estimateDecisionCharsSaved(
+	messages: MinimalMessage[],
+	decision: PruneDecisionRecord,
+	pairIndex?: Map<string, ToolCallPairIndices>,
+): number | undefined {
+	if (decision.correlation.type !== "toolCallId") return undefined;
+	const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
+
+	// Same non-mutating preview approach as `estimateDecisionSavings`.
+	const preview = messages.slice();
+	const result = applyPruneDecision(preview, decision, pairIndex);
+	if (!result.applied) return undefined;
+
+	if (decision.kind === "tool_result_content") {
+		if (pair.resultIndex === undefined) return undefined;
+		const before = messages[pair.resultIndex] as MinimalToolResultMessage;
+		const after = preview[pair.resultIndex] as MinimalToolResultMessage;
+		const charsBefore = contentTextLength(before.content);
+		const charsAfter = contentTextLength(after.content);
+		return Math.max(0, charsBefore - charsAfter);
+	}
+
+	if (decision.kind === "tool_call_input") {
+		if (pair.assistantIndex === undefined || pair.toolCallBlockIndex === undefined) return undefined;
+		const beforeBlock = (messages[pair.assistantIndex] as MinimalAssistantMessage).content[
+			pair.toolCallBlockIndex
+		] as MinimalToolCallContent;
+		const afterBlock = (preview[pair.assistantIndex] as MinimalAssistantMessage).content[
+			pair.toolCallBlockIndex
+		] as MinimalToolCallContent;
+		const charsBefore = JSON.stringify(beforeBlock.arguments ?? {}).length;
+		const charsAfter = JSON.stringify(afterBlock.arguments ?? {}).length;
+		return Math.max(0, charsBefore - charsAfter);
+	}
+
+	return undefined;
+}
+
 /**
  * Cache-aware cost model (pe-s2ho ticket NOTES, binding over the looser prose
  * in the ticket body): prompt caches are prefix-based, so pruning at message
@@ -1877,7 +2004,29 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
 	// against the pre-mutation `messages` clone, before the apply loop below
 	// mutates anything.
 	const freshManual = dedupedFresh.filter((decision) => decision.source === "manual");
-	const freshAutomatic = dedupedFresh.filter((decision) => decision.source !== "manual");
+	const freshAutomaticUnfiltered = dedupedFresh.filter((decision) => decision.source !== "manual");
+
+	// Minimum-size floor (pe-qdzb): drop fresh automatic proposals whose
+	// character savings (original content chars minus placeholder chars) fall
+	// below `thresholds.minCharsSaved`, BEFORE gate evaluation so dropped
+	// candidates never consume batch/earliest-position gate consideration.
+	// Applies to automatic proposals only; manual (`freshManual` above) and
+	// already-persisted decisions (`input.persistedDecisions`, applied later)
+	// bypass this floor entirely, same as the net-benefit gate. Tool-result
+	// candidates containing images also bypass this raw-text floor because
+	// images have no character count; their token savings still go through the
+	// existing net-benefit gate. A floor of 0 (the config default before
+	// pe-c5n9's DEFAULT_MIN_CHARS_SAVED constant was introduced) is a no-op:
+	// every non-negative delta clears it.
+	const minCharsSaved = input.config.thresholds.minCharsSaved;
+	const freshAutomatic =
+		minCharsSaved <= 0
+			? freshAutomaticUnfiltered
+			: freshAutomaticUnfiltered.filter((decision) => {
+					if (isImageBearingToolResultTarget(messages, decision, pairIndex)) return true;
+					const charsSaved = estimateDecisionCharsSaved(messages, decision, pairIndex);
+					return charsSaved !== undefined && charsSaved >= minCharsSaved;
+				});
 
 	// Collapse fresh AUTOMATIC candidates that target the same (kind,
 	// correlation) down to a single decision (pe-j7sb). Two strategies (e.g.
@@ -2360,9 +2509,10 @@ export default function dynamicContextPruningExtension(pi: ExtensionAPI) {
 			persistedDecisions,
 			knownIdempotencyKeys,
 			restoredIdempotencyKeys,
-			// Real mid-loop/idle agent-state detection lands in a follow-up ticket;
-			// "idle" is the safe default until it's wired through ctx.
-			agentState: "idle",
+			// Real mid-loop/idle agent-state detection (pe-zy4s): derived straight from
+			// the message payload via classifyAgentStateFromMessages -- see its doc
+			// comment for the exact runtime-observable definition.
+			agentState: classifyAgentStateFromMessages(event.messages as unknown as MinimalMessage[]),
 			cwd: ctx.sessionManager.getCwd(),
 		});
 

package/extensions/dynamic-context-pruning/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-dynamic-context-pruning",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "A pi extension that dynamically prunes stale context to keep sessions lean.",
   "keywords": [

package/extensions/fast/.pi-fleet-tested-version

@@ -0,0 +1 @@
+0.83.0

package/extensions/fast/README.md

@@ -0,0 +1,119 @@
+# fast
+
+A pi extension that provides one `/fast` toggle for supported OpenAI Codex and Anthropic Claude models. It selects the provider-specific Fast-mode request shape from the currently selected model.
+
+For eligible OpenAI Codex models it injects:
+
+```json
+{
+  "service_tier": "priority"
+}
+```
+
+For eligible Anthropic Claude models it injects:
+
+```json
+{
+  "speed": "fast"
+}
+```
+
+It also adds the required Anthropic beta header value:
+
+```text
+anthropic-beta: fast-mode-2026-02-01
+```
+
+## Eligibility
+
+OpenAI Fast mode requires all of the following:
+
+- Provider `openai-codex`.
+- API `openai-codex-responses`.
+- Model `gpt-5.4`, `gpt-5.5`, `gpt-5.6-sol`, `gpt-5.6-terra`, or `gpt-5.6-luna`.
+- ChatGPT OAuth/subscription auth, not API-key auth.
+- No existing `service_tier` field in the request payload.
+
+Anthropic Fast mode requires all of the following:
+
+- Provider `anthropic`.
+- API `anthropic-messages`.
+- Model `claude-opus-4-6`, `claude-opus-4-7`, or `claude-opus-4-8`.
+- No existing `speed` field in the request payload.
+
+Anthropic Fast mode supports both API-key and Claude Code OAuth access when the account has access to the research preview.
+
+## Commands
+
+```text
+/fast
+```
+
+Run `/fast` to toggle Fast mode for the current session/runtime. The enabled state follows model changes: switching between eligible OpenAI and Anthropic models automatically changes the request format without resetting the toggle. The footer shows `fast` only while the selected model is eligible and Fast mode is enabled.
+
+The extension defaults to off so installing the full collection does not accidentally spend Fast-mode credits.
+
+## Config
+
+Optional global config:
+
+```text
+~/<pi-config-dir>/agent/extensions/fast.json
+```
+
+Optional project config:
+
+```text
+<project>/<pi-config-dir>/fast.json
+```
+
+Here `<pi-config-dir>` is Pi's runtime config directory name (`CONFIG_DIR_NAME`; `.pi` by default). Project config overrides global config after Pi reports that the project is trusted.
+
+```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 selected model.
+
+The unified extension intentionally does not read `openai-fast.json` or `claude-fast.json`; those files belong to the provider-specific standalone packages and may contain conflicting defaults.
+
+## Install
+
+### Standalone npm package
+
+```bash
+pi install npm:@diegopetrucci/pi-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
+```
+
+## Legacy provider-specific packages
+
+The collection package loads this unified extension instead of `openai-fast` and `claude-fast`. Both provider-specific packages remain available as standalone alternatives. Do not load them together with this extension: independent Fast-mode state and duplicate `/fast` registrations can produce conflicting behavior.
+
+## Notes
+
+- Anthropic Fast mode has separate rate limits, costs more than standard speed, and does not share prompt-cache prefixes with standard-speed requests.
+- OpenAI Fast mode intentionally does not affect API-key models.
+- Existing `speed` and `service_tier` fields are never overwritten.
+- Cost accounting still depends on the provider reporting the effective tier in its streamed response.

package/extensions/fast/fast.example.json

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

package/extensions/fast/index.ts

@@ -0,0 +1,383 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	CONFIG_DIR_NAME,
+	getAgentDir,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+const EXTENSION_ID = "fast";
+const ANTHROPIC_PROVIDER_ID = "anthropic";
+const ANTHROPIC_API_ID = "anthropic-messages";
+const ANTHROPIC_FAST_SPEED = "fast";
+const ANTHROPIC_FAST_BETA = "fast-mode-2026-02-01";
+const CLAUDE_CODE_OAUTH_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
+const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const ANTHROPIC_SUPPORTED_MODELS = new Set(["claude-opus-4-6", "claude-opus-4-7", "claude-opus-4-8"]);
+
+const OPENAI_PROVIDER_ID = "openai-codex";
+const OPENAI_API_ID = "openai-codex-responses";
+const OPENAI_FAST_SERVICE_TIER = "priority";
+const OPENAI_SUPPORTED_MODELS = new Set([
+	"gpt-5.4",
+	"gpt-5.5",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-5.6-luna",
+]);
+
+const DEFAULT_CONFIG: FastConfig = {
+	enabled: false,
+	showStatus: true,
+};
+
+type FastOverride = "auto" | "on" | "off";
+type FastProvider = "anthropic" | "openai";
+
+type FastConfig = {
+	/** 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: FastConfig;
+	override: FastOverride;
+	lastInjectedAt?: number;
+	lastInjectedModel?: string;
+};
+
+type ProjectConfigContext = {
+	cwd: string;
+	isProjectTrusted?: () => boolean;
+};
+
+type RecursivePartial<T> = {
+	[P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+
+type PayloadRecord = Record<string, unknown>;
+
+type AnthropicHeaderCompat = {
+	forceAdaptiveThinking?: boolean;
+	supportsEagerToolInputStreaming?: boolean;
+};
+
+type Eligibility = {
+	eligible: boolean;
+	modelKey: string;
+	provider?: FastProvider;
+	reason?: string;
+};
+
+function readConfigFile(path: string): RecursivePartial<FastConfig> {
+	if (!existsSync(path)) return {};
+
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return isPayloadRecord(parsed) ? (parsed as RecursivePartial<FastConfig>) : {};
+	} 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: FastConfig, overrides: RecursivePartial<FastConfig>): FastConfig {
+	return {
+		enabled: normalizeBoolean(overrides.enabled, base.enabled),
+		showStatus: normalizeBoolean(overrides.showStatus, base.showStatus),
+	};
+}
+
+function canReadProjectConfig(ctx: ProjectConfigContext): boolean {
+	return typeof ctx.isProjectTrusted === "function" && ctx.isProjectTrusted();
+}
+
+function findProjectConfigPath(cwd: string): string {
+	let current = cwd;
+	while (true) {
+		const candidate = join(current, CONFIG_DIR_NAME, "fast.json");
+		if (existsSync(candidate)) return candidate;
+
+		const parent = dirname(current);
+		if (parent === current) return join(cwd, CONFIG_DIR_NAME, "fast.json");
+		current = parent;
+	}
+}
+
+function loadConfig(ctx: ProjectConfigContext): FastConfig {
+	const globalConfig = readConfigFile(join(getAgentDir(), "extensions", "fast.json"));
+	const projectConfig = canReadProjectConfig(ctx) ? readConfigFile(findProjectConfigPath(ctx.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 === ANTHROPIC_PROVIDER_ID) {
+		if (model.api !== ANTHROPIC_API_ID) {
+			return {
+				eligible: false,
+				modelKey: key,
+				reason: `current API is ${model.api}, not ${ANTHROPIC_API_ID}`,
+			};
+		}
+
+		if (!ANTHROPIC_SUPPORTED_MODELS.has(model.id)) {
+			return {
+				eligible: false,
+				modelKey: key,
+				reason: "Fast mode is only enabled for Claude Opus 4.6, 4.7, and 4.8",
+			};
+		}
+
+		return { eligible: true, modelKey: key, provider: "anthropic" };
+	}
+
+	if (model.provider === OPENAI_PROVIDER_ID) {
+		if (model.api !== OPENAI_API_ID) {
+			return {
+				eligible: false,
+				modelKey: key,
+				reason: `current API is ${model.api}, not ${OPENAI_API_ID}`,
+			};
+		}
+
+		if (!OPENAI_SUPPORTED_MODELS.has(model.id)) {
+			return {
+				eligible: false,
+				modelKey: key,
+				reason: "Fast mode is not enabled for this OpenAI Codex model",
+			};
+		}
+
+		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, provider: "openai" };
+	}
+
+	return {
+		eligible: false,
+		modelKey: key,
+		reason: `current provider ${model.provider} does not support this extension's Fast mode`,
+	};
+}
+
+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) {
+		const wireSetting =
+			eligibility.provider === "anthropic"
+				? `speed=${ANTHROPIC_FAST_SPEED}`
+				: `service_tier=${OPENAI_FAST_SERVICE_TIER}`;
+		return `Fast mode is ${describeMode(state)} and active for ${eligibility.modelKey}; requests will use ${wireSetting}.${injected}`;
+	}
+
+	if (enabled) {
+		return `Fast mode is ${describeMode(state)}, but inactive for ${eligibility.modelKey}: ${eligibility.reason}.${injected}`;
+	}
+
+	return `Fast mode is ${describeMode(state)}. Current model: ${eligibility.modelKey}.${injected}`;
+}
+
+function splitBetaHeader(value: string | null | undefined): string[] {
+	return (value ?? "")
+		.split(",")
+		.map((part) => part.trim())
+		.filter(Boolean);
+}
+
+async function isAnthropicOAuth(ctx: ExtensionContext): Promise<boolean> {
+	try {
+		const resolution = await ctx.modelRegistry.getProviderAuth(ANTHROPIC_PROVIDER_ID);
+		const apiKey = resolution?.auth.apiKey;
+		if (typeof apiKey === "string") return apiKey.includes("sk-ant-oat");
+	} catch {
+		// Fall back to the synchronous registry snapshot below.
+	}
+
+	return ctx.model ? ctx.modelRegistry.isUsingOAuth(ctx.model) : false;
+}
+
+function getAnthropicProviderBetas(ctx: ExtensionContext, hasActiveTools: boolean): string[] {
+	const model = ctx.model;
+	if (!model) return [];
+	const compat = model.compat as AnthropicHeaderCompat | undefined;
+
+	const betas: string[] = [];
+	if (hasActiveTools && compat?.supportsEagerToolInputStreaming === false) {
+		betas.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+	}
+	if (compat?.forceAdaptiveThinking !== true) {
+		betas.push(INTERLEAVED_THINKING_BETA);
+	}
+	return betas;
+}
+
+async function injectAnthropicFastHeader(
+	headers: Record<string, string | null>,
+	ctx: ExtensionContext,
+	state: SessionState,
+	hasActiveTools: boolean,
+): Promise<void> {
+	if (!isFastEnabled(state)) return;
+	const eligibility = getEligibility(ctx);
+	if (!eligibility.eligible || eligibility.provider !== "anthropic") return;
+
+	const matchingKeys = Object.keys(headers).filter((name) => name.toLowerCase() === "anthropic-beta");
+	const existing = matchingKeys.flatMap((name) => splitBetaHeader(headers[name]));
+	const matchingModelEntries = Object.entries(ctx.model?.headers ?? {}).filter(
+		([name]) => name.toLowerCase() === "anthropic-beta",
+	);
+	const modelBetas = matchingModelEntries.flatMap(([, value]) => splitBetaHeader(value));
+	const providerBetas = getAnthropicProviderBetas(ctx, hasActiveTools);
+	const oauthBetas = (await isAnthropicOAuth(ctx)) ? CLAUDE_CODE_OAUTH_BETAS : [];
+	const next = Array.from(
+		new Set([...modelBetas, ...existing, ...oauthBetas, ...providerBetas, ANTHROPIC_FAST_BETA]),
+	);
+
+	for (const key of matchingKeys) delete headers[key];
+	const outputKey = matchingModelEntries.at(-1)?.[0] ?? "anthropic-beta";
+	headers[outputKey] = next.join(",");
+}
+
+function injectFastPayload(
+	payload: unknown,
+	ctx: ExtensionContext,
+	state: SessionState,
+): PayloadRecord | undefined {
+	if (!isFastEnabled(state)) return undefined;
+	const eligibility = getEligibility(ctx);
+	if (!eligibility.eligible || !eligibility.provider) return undefined;
+	if (!isPayloadRecord(payload)) return undefined;
+	if (payload.model !== ctx.model?.id) return undefined;
+
+	if (eligibility.provider === "anthropic") {
+		if ("speed" in payload) return undefined;
+		state.lastInjectedAt = Date.now();
+		state.lastInjectedModel = eligibility.modelKey;
+		return { ...payload, speed: ANTHROPIC_FAST_SPEED };
+	}
+
+	if ("service_tier" in payload) return undefined;
+	state.lastInjectedAt = Date.now();
+	state.lastInjectedModel = eligibility.modelKey;
+	return { ...payload, service_tier: OPENAI_FAST_SERVICE_TIER };
+}
+
+export default function fastExtension(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),
+				override: "auto",
+			};
+			states.set(ctx.sessionManager, state);
+		}
+		return state;
+	}
+
+	pi.on("session_start", (_event, ctx) => {
+		const state: SessionState = {
+			config: loadConfig(ctx),
+			override: "auto",
+		};
+		states.set(ctx.sessionManager, state);
+		updateStatus(ctx, state);
+	});
+
+	pi.on("model_select", (_event, ctx) => {
+		updateStatus(ctx, getState(ctx));
+	});
+
+	pi.on("before_provider_headers", async (event, ctx) => {
+		const hasActiveTools = typeof pi.getActiveTools === "function" && pi.getActiveTools().length > 0;
+		await injectAnthropicFastHeader(event.headers, ctx, getState(ctx), hasActiveTools);
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		const state = getState(ctx);
+		const nextPayload = injectFastPayload(event.payload, ctx, state);
+		updateStatus(ctx, state);
+		return nextPayload;
+	});
+
+	pi.registerCommand("fast", {
+		description: "Toggle Fast mode for supported OpenAI Codex and Anthropic Claude models",
+		getArgumentCompletions: () => null,
+		handler: async (args, ctx) => {
+			const state = getState(ctx);
+			const action = args.trim();
+
+			if (!action) {
+				state.override = isFastEnabled(state) ? "off" : "on";
+				updateStatus(ctx, state);
+				ctx.ui.notify(getStatusMessage(ctx, state), "info");
+				return;
+			}
+
+			ctx.ui.notify("Usage: /fast", "warning");
+		},
+	});
+}

package/extensions/fast/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@diegopetrucci/pi-fast",
+  "version": "0.1.0",
+  "description": "A pi extension that enables Fast mode for supported OpenAI Codex and Anthropic Claude models based on the currently selected model.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "openai",
+    "anthropic",
+    "fast"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegopetrucci/pi-extensions.git",
+    "directory": "extensions/fast"
+  },
+  "files": [
+    "index.ts",
+    "fast.example.json",
+    "README.md",
+    ".pi-fleet-tested-version"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}

package/extensions/openai-fast/README.md

@@ -2,6 +2,8 @@
 
 A pi extension that enables OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4, GPT-5.5, and GPT-5.6 Codex variants (`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`).
 
+This package is standalone-only and is not auto-loaded by the `@diegopetrucci/pi-extensions` collection package. The collection uses the unified [`fast`](../fast) extension instead.
+
 When active, the extension injects this into eligible OpenAI Codex request payloads:
 
 ```json

package/extensions/openai-fast/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-openai-fast",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "A pi extension that enables OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4, GPT-5.5, and GPT-5.6 Codex variants by injecting the priority service tier.",
   "keywords": [
     "pi-package",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.62",
+  "version": "0.1.63",
   "description": "A collection of pi extensions and skills for annotation UIs, context management, workflow audits, contrarian review, review-comment triage, notifications, brrr push alerts, safety guards, GitHub research, repo-local knowledge, todos, tool rendering, model/provider helpers, and Xiaohei-style article illustrations.",
   "keywords": [
     "pi-package",
@@ -45,7 +45,6 @@
       "./extensions/annotate-git-diff/index.ts",
       "./extensions/annotate-last-message/index.ts",
       "./extensions/brrr/index.ts",
-      "./extensions/claude-fast/index.ts",
       "./extensions/code-reviewer/index.ts",
       "./extensions/confirm-destructive/index.ts",
       "./extensions/context-cap/index.ts",
@@ -53,12 +52,12 @@
       "./extensions/contrarian/index.ts",
       "./extensions/dirty-repo-guard/index.ts",
       "./extensions/dynamic-context-pruning/index.ts",
+      "./extensions/fast/index.ts",
       "./extensions/gnosis/index.ts",
       "./extensions/inline-bash/index.ts",
       "./extensions/librarian/index.ts",
       "./extensions/minimal-footer/index.ts",
       "./extensions/notify/index.ts",
-      "./extensions/openai-fast/index.ts",
       "./extensions/oracle/index.ts",
       "./extensions/permission-gate/index.ts",
       "./extensions/quiet-tools/index.ts",